from otree.api import Currency as c, currency_range
from ._builtin import Page, WaitPage
from .models import Constants
import random
import numpy as np


class MultiplierExAnte(Page):
    form_model = 'player'

    def is_displayed(self):
        return self.player.id_in_group == 1

    def vars_for_template(self):
        r = self.round_number
        self.player.multiplier = self.participant.vars['multipliers'][r-1]
        return dict(multiplier=self.player.multiplier, round=self.round_number)

class Decision(Page):
    form_model = 'player'
    form_fields = ['answer1', 'answer2', 'answer3']

    def vars_for_template(self):
        # Again, there must be a better way!
        ref_player = self.player
        letters = Constants.Alphabet.copy()
        codes = [ref_player.code_A,
                 ref_player.code_B,
                 ref_player.code_C,
                 ref_player.code_D,
                 ref_player.code_E,
                 ref_player.code_F,
                 ref_player.code_G,
                 ref_player.code_H,
                 ref_player.code_I,
                 ref_player.code_J,
                 ref_player.code_K,
                 ref_player.code_L,
                 ref_player.code_M,
                 ref_player.code_N,
                 ref_player.code_O,
                 ref_player.code_P,
                 ref_player.code_Q,
                 ref_player.code_R,
                 ref_player.code_S,
                 ref_player.code_T,
                 ref_player.code_U,
                 ref_player.code_V,
                 ref_player.code_W,
                 ref_player.code_X,
                 ref_player.code_Y,
                 ref_player.code_Z]

        # Shuffle order
        d = list(zip(letters, codes))
        random.shuffle(d)
        letters, codes = zip(*d)
        return dict(let1=letters[:13], cod1=codes[:13],
                    let2=letters[13:], cod2=codes[13:],
                    round=self.round_number)

    def before_next_page(self):
        return self.player.determine_correct()

class MultiplierExPost(Page):
    form_model = 'player'

    def is_displayed(self):
        return self.player.id_in_group == 2 or self.player.id_in_group == 3

    def vars_for_template(self):
        r = self.round_number
        self.player.multiplier = self.participant.vars['multipliers'][r-1]
        return dict(multiplier=self.player.multiplier, round=self.round_number)

class Results(Page):

    def is_displayed(self):
        return self.round_number == Constants.num_rounds

    def vars_for_template(self):
        all_t = []
        total_t = 0
        all_p = []
        total_p = 0
        all_m = self.participant.vars['multipliers']
        for r in range(1, Constants.num_rounds + 1):
            # in round r:
            t = self.player.in_round(r).correct
            m = all_m[r - 1]
            p = m*t
            # append to lists:
            all_t = np.append(all_t,t)
            all_p = np.append(all_p,p)
            # add to total:
            total_t = total_t + t
            total_p = total_p + p
        return dict(all_points=all_p,
                    all_multipliers=all_m,
                    all_correct=all_t,
                    total_points=total_p,
                    total_correct=total_t,
                    average_multiplier=np.average(all_m))

    def before_next_page(self):
        total_t = 0 #total correct
        total_p = 0 #total points
        all_m = self.participant.vars['multipliers']
        for r in range(1, Constants.num_rounds + 1):
            t = self.player.in_round(r).correct
            m = all_m[r - 1]
            p = m*t
            total_t = total_t + t
            total_p = total_p + p
        self.participant.vars['total_correct'] = total_t
        self.participant.vars['total_points'] = total_p


page_sequence = [MultiplierExAnte,
                 Decision,
                 MultiplierExPost,
                 Results]