from otree.api import Currency as c, currency_range
from ._builtin import Page, WaitPage
from django.http import HttpResponseRedirect
from django.shortcuts import render
from .forms import UploadFileForm
from . import models
from django.http import JsonResponse
from django.db import connection
from pprint import pprint
import csv
import itertools


class Config(Page):
    form_model = models.Player
    form_fields = ['multiplier',
                   'startingPoint',
                   'numberOfGameSteps',
                   # 'numberOfChoices',
                   'pointToSubtract',
                   'waitingWindow']


class Start(Page):
    pass


class MyPage(Page):
    pass


class ResultsWaitPage(WaitPage):

    def after_all_players_arrive(self):
        pass


class Results(Page):
    pass


class ResultsData(Page):
    form_model = models.Player


page_sequence = [
    Config,
    Start,
    MyPage,
    Results
]


# urls.urlpatterns += url(r'^alien_calculation/$', pages.get_corresponding_fitness)

# print(urls.urlpatterns)


def get_corresponding_fitness(request):
    # getting the matching fitness to a received bitstring
    bsIn = request.GET.get('bitstring', None)
    landscape_in = request.GET.get('landscape', None)
    print(request)
    landcape_foreign_key = models.AlienGameLandscape.objects.get(landscape=landscape_in)
    fitness = models.FitnessData.objects.filter(alien_game_landscape=landcape_foreign_key).get(bitstring=bsIn).fitness
    data = {
        'fitness': fitness
    }

    # saving record to database
    player_id = request.GET.get('playerID', None)
    subsession_id = request.GET.get('subsessionID', None)
    # fitness_data_id = models.FitnessData.objects.get(bitstring=bsIn).bitstringID
    game_step_count = request.GET.get('gameStepCount', None)
    timestamp = request.GET.get('timestamp', None)

    player_ = models.Player.objects.get(id=player_id)
    subsession_ = models.Subsession.objects.get(id=subsession_id)
    fitness_data_ = models.FitnessData.objects.filter(alien_game_landscape=landcape_foreign_key).get(bitstring=bsIn)

    game_step_record = models.GameStep(player=player_,
                                       subsession=subsession_,
                                       fitnessData=fitness_data_,
                                       gameStepCount=game_step_count,
                                       timestamp=timestamp)
    game_step_record.save()

    # calculating step payoff and saving if it is larger, than the previous ones in this game round
    step_payoff = round((fitness * player_.multiplier * 100) / 100, 2)
    if player_.payoff < step_payoff:
        player_.payoff = step_payoff
        player_.save()
    print("MAX: " + player_.payoff.__str__())

    pprint(connection.queries)
    return JsonResponse(data)


def handle_uploaded_file(f):
    # with open(f.name, 'r') as csvfile:
    with f.read() as csvfile:
        semantic_scenario_description = f.name.split(".")[0]
        # checking the database for already existing scenario, and only updating if the uploaded DB is new
        query = models.AlienGameLandscape.objects.filter(landscape=semantic_scenario_description)
        if query.count() == 0:

            # adding new landscape to the AlienGameLandscape table
            alien_game_landscape = models.AlienGameLandscape(landscape=semantic_scenario_description)
            alien_game_landscape.save()

            # reader1, reader2 = itertools.tee(csv.reader(csvfile, delimiter=";"), 2)
            reader1, reader2 = csv.DictReader(csvfile)

            # getting the longest bitstring (bitstrings in uploaded file can miss leading zeroes...)
            max_length = 0
            header = True
            for row in reader1:
                if not header:
                    bitstring = row[1]
                    length = len(str(bitstring))
                    if length > max_length:
                        max_length = length
                        print("updated length: " + str(max_length))
                header = False

            header2 = True
            for row in reader2:
                if not header2:
                    bitstring_id = row[0]
                    bitstring = row[1]
                    fitness = row[2]

                    landscape_foreign_key = models.AlienGameLandscape.objects.get(
                        landscape=semantic_scenario_description)

                    print("{{{{ " + "{0:0>{width}}".format(bitstring, width=max_length))

                    bitstring_data_record = models.FitnessData(bitstringID=bitstring_id,
                                                               # bitstring=bitstring,
                                                               bitstring="{0:0>{width}}".format(bitstring, width=max_length),
                                                               fitness=fitness,
                                                               alien_game_landscape=landscape_foreign_key)

                    bitstring_data_record.save(force_insert=True)
                header2 = False


def upload_file(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        print(request.FILES)
        if form.is_valid():
            handle_uploaded_file(request.FILES['file'])
            return HttpResponseRedirect('testing/')
    else:
        form = UploadFileForm()
    return render(request, 'testing/FileUpload.html', {'form': form})


def show_results_data_page(request):
    return render(request, 'testing/ResultsData.html')