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

num2words = {1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five',
             6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten',
             11: 'Eleven', 12: 'Twelve', 13: 'Thirteen', 14: 'Fourteen',
             15: 'Fifteen', 16: 'Sixteen', 17: 'Seventeen', 18: 'Eighteen',
             19: 'Nineteen', 20: 'Twenty', 30: 'Thirty', 40: 'Forty',
             50: 'Fifty', 60: 'Sixty', 70: 'Seventy', 80: 'Eighty',
             90: 'Ninety', 0: 'Zero'}


def n2w(n):
    try:
        w = num2words[n].lower()
        return w
    except KeyError:
        try:
            w = num2words[n - n % 10].lower() + "-" + num2words[n % 10].lower()
            return w
        except KeyError:
            return 'Number out of range'


class Instruction(Page):
    form_model = 'player'

    form_fields = ['q1', 'q2', 'q3', 'q4', 'q5']#,'cutOff']  # , 'q4b', 'q4c', 'q4d', 'q5a', 'q5b', 'q5c', 'q5d', 'q7', 'q8']

    def is_displayed(self):
        return self.subsession.round_number == 1

    def error_message(self, value):
        return self.player.set_error_message(value)

    live_method = "live_instruct"

    def vars_for_template(self):
        players = self.subsession.get_players()
        num_pairs = int((len(players) - self.subsession.num_FR) / 2)
        FR_prob = int(2 * self.subsession.num_FR / (len(players) + self.subsession.num_FR) * 100)
        TR_prob = 100 - FR_prob

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}
        if self.subsession.num_FR > 0:
            correct_answers = {"q1": 4,
                               "q2": 4,
                               "q3": 3,
                               "q4": 4,
                               "q5":1
                               }
        else:
            if self.subsession.sender_Mistake > 0:
                correct_answers = {"q1": 4,
                               "q2": 4,
                               "q3": 3,
                               "q4": 4,
                               "q5":1
                                   }
            else:
                correct_answers = {"q1": 4,
                               "q2": 4,
                               "q3": 3,
                               "q4": 4,
                               "q5":1
                                   }

        return {
            'read': self.player.read,
            'num_FR': self.subsession.num_FR,
            'num_pairs': num_pairs,
            'wnum_FR': n2w(self.subsession.num_FR),
            'wnum_pairs': n2w(num_pairs),
            'FR_prob': FR_prob,
            'TR_prob': TR_prob,
            'conflict': self.subsession.conflict,
            'conflictplus5': self.subsession.conflict + 5,
            'payoffs': payoffs,
            'typeO_prob': int(100 * self.subsession.typeO_prob),
            'typeI_prob': int(100 * (1 - self.subsession.typeO_prob)),
            'participation_fee': int(self.session.participation_fee),
            'solutions': correct_answers,
            'sender_Mistake': self.subsession.sender_Mistake,
            'SM_numerator': self.session.config['SM_numerator'],
            'SM_denominator': self.session.config['SM_denominator'],
            'SM_dmn': self.session.config['SM_denominator'] - self.session.config['SM_numerator'],
            'mistake_rate': int(round(self.subsession.sender_Mistake, 2) * 100),
            'one_mistake_rate': int(round(1 - self.subsession.sender_Mistake, 2) * 100),
        }


class PleaseWait(Page):
    def is_displayed(self):
        return self.subsession.round_number == 1


class Usher(Page):

    def is_displayed(self):
        return self.subsession.round_number < Constants.num_rounds

    def vars_for_template(self):
        players = self.subsession.get_players()
        FR_prob = int(2 * self.subsession.num_FR / (len(players) + self.subsession.num_FR) * 100)
        TR_prob = 100 - FR_prob

        pract_or_off = 'this practice round'
        round_num = self.subsession.round_number
        title = "Practice Round #" + str(self.subsession.round_number)

        return dict(
            roundnum=round_num,
            role=self.player.roles,
            FR_prob=FR_prob,
            TR_prob=TR_prob,
            pract_or_off=pract_or_off,
            title_text=title
        )


class SenderPage(Page):
    form_model = 'player'
    form_fields = ['message_sent']

    def is_displayed(self):
        return self.player.roles == 'S' and self.subsession.round_number < Constants.num_rounds

    def vars_for_template(self):
        title = "Pratice Round #" + str(self.subsession.round_number)
        round_num = self.subsession.round_number

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        return dict(
            roundnum=round_num,
            poison_type=self.player.type,
            typeO_prob=int(100 * self.subsession.typeO_prob),
            typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
            payoffs=payoffs,
            title_text=title,
            conflict=self.subsession.conflict,
            sender_Mistake=self.subsession.sender_Mistake,
            SM_numerator=self.session.config['SM_numerator'],
            SM_denominator=self.session.config['SM_denominator'],
            SM_dmn=self.session.config['SM_denominator'] - self.session.config['SM_numerator'],
            mistake_rate=int(round(self.subsession.sender_Mistake, 2) * 100),
            one_mistake_rate=int(round(1 - self.subsession.sender_Mistake, 2) * 100)
        )


class WaitS(WaitPage):
    template_name = 'antidote/WaitS.html'

    def is_displayed(self):
        return (
                       self.player.roles == 'FR' or self.player.roles == 'TR') and self.subsession.round_number < Constants.num_rounds

    def vars_for_template(self):
        prac_off = "Practice Round"
        title = "Pratice Round #" + str(self.subsession.round_number)
        round_num = self.subsession.round_number

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        return dict(body_text="Please wait for the message from S.",
                    title_text=title,
                    roundnum=round_num,
                    typeO_prob=int(100 * self.subsession.typeO_prob),
                    typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
                    payoffs=payoffs,
                    conflict=self.subsession.conflict
                    )


class ReceiverPage(Page):
    form_model = 'player'
    form_fields = ['action']

    def is_displayed(self):
        return (
                       self.player.roles == 'FR' or self.player.roles == 'TR') and self.subsession.round_number < Constants.num_rounds

    def vars_for_template(self):
        players = self.subsession.get_players()
        if self.player.roles == 'TR':
            local_random = random.Random(99)
            local_random.shuffle(players)
            player = players[self.player.pseudo_group - 1]
            if self.subsession.sender_Mistake == 0:
                self.player.message_received = player.message_sent
                self.player.message_sent = player.message_sent
                player.message_received = player.message_sent
            else:
                if player.message_sent == 1:
                    local_random = random.Random(self.subsession.local_seed + self.player.id_in_group)
                    draw = local_random.random()
                    if draw >= self.subsession.sender_Mistake:
                        self.player.message_received = player.message_sent
                        self.player.message_sent = player.message_sent
                        player.message_received = player.message_sent
                    else:
                        self.player.message_received = 1 - player.message_sent
                        self.player.message_sent = player.message_sent
                        player.message_received = 1 - player.message_sent
                else:
                    self.player.message_received = player.message_sent
                    self.player.message_sent = player.message_sent
                    player.message_received = player.message_sent

        if self.player.roles == 'FR':
            # This part ensures that FR received a random message from one of the S
            num_pairs = int((len(players) - self.subsession.num_FR) / 2)

            # local_random = random.Random(self.subsession.local_seed)
            local_random = random.Random(99)
            local_random.shuffle(players)
            index = self.subsession.num_FR + (self.subsession.local_seed + self.player.id_in_group) % num_pairs
            self.player.message_received = players[index].message_sent
            self.player.message_sent = players[index].message_sent

        title = "Pratice Round #" + str(self.subsession.round_number)
        round_num = self.subsession.round_number

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        if self.player.message_received == 0:
            message = "The Poison is TYPE 0."
        if self.player.message_received == 1:
            message = "The Poison is TYPE 1."

        return dict(
            message=message,
            body_text="Please wait for the message from S.",
            title_text=title,
            roundnum=round_num,
            typeO_prob=int(100 * self.subsession.typeO_prob),
            typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
            payoffs=payoffs,
            conflict=self.subsession.conflict
        )

    def before_next_page(self):
        self.player.payoff = 300 - 3 * (10 * self.player.type - self.player.action * 2) ** 2
        players = self.subsession.get_players()
        if self.player.roles == 'TR':
            local_random = random.Random(99)
            local_random.shuffle(players)
            player = players[self.player.pseudo_group - 1]
            player.action = self.player.action
            player.payoff = 300 - (self.subsession.conflict * 2 + 10 * player.type - player.action * 2) ** 2
        return


class WaitR(WaitPage):
    template_name = 'antidote/WaitR.html'

    def is_displayed(self):
        return self.player.roles == 'S' and self.subsession.round_number < Constants.num_rounds

    def vars_for_template(self):

        title = "Pratice Round #" + str(self.subsession.round_number)
        round_num = self.subsession.round_number

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        if self.player.message_sent == 0:
            message = "The Poison is TYPE 0."
        if self.player.message_sent == 1:
            message = "The Poison is TYPE 1."
        return dict(
            message=message,
            body_text="Please wait for the message from S.",
            title_text=title,
            roundnum=round_num,
            typeO_prob=int(100 * self.subsession.typeO_prob),
            typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
            payoffs=payoffs,
            conflict=self.subsession.conflict
        )


class Round0(Page):
    form_model = 'player'
    form_fields = ['action']

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

    def vars_for_template(self):
        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        return dict(
            typeO_prob=int(100 * self.subsession.typeO_prob),
            typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
            payoffs=payoffs,
            conflict=self.subsession.conflict,
            title_text="Round #0"
        )

    def before_next_page(self):
        self.player.payoff = 300 - 3 * (10 * self.player.type - self.player.action * 2) ** 2
        self.participant.vars['intro_payoff'] = self.player.payoff
        self.participant.vars['intro_action'] = self.player.action
        self.participant.vars['intro_type'] = self.player.type
        return


class ResultsWaitPage(WaitPage):
    pass


class Results(Page):

    def is_displayed(self):
        return self.subsession.round_number < Constants.num_rounds

    def vars_for_template(self):

        title = "Pratice Round #" + str(self.subsession.round_number)
        round_num = self.subsession.round_number

        if self.player.roles == 'S':
            if self.player.type == 0:
                hcol = 5
            else:
                hcol = 7
            lcolor = "#ffd099"
            hcolor = "#ffad4d"
        else:
            lcolor = "#b7d9fa"
            hcolor = "#407fbf"
            if self.player.type == 0:
                hcol = 2
            else:
                hcol = 4

        if self.player.message_sent == 0:
            message_S = "The Poison is TYPE 0."
        if self.player.message_sent == 1:
            message_S = "The Poison is TYPE 1."

        if self.player.message_received == 0:
            message_R = "The Poison is TYPE 0."
        if self.player.message_received == 1:
            message_R = "The Poison is TYPE 1."

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        return dict(
            prac_orS=True,
            action=self.player.action,
            hcol=hcol,
            lcolor=lcolor,
            hcolor=hcolor,
            title_text=title,
            roundnum=round_num,
            typeO_prob=int(100 * self.subsession.typeO_prob),
            typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
            payoffs=payoffs,
            earning=int(self.player.payoff),
            message_R=message_R,
            message_S=message_S,
            sender_Mistake=self.subsession.sender_Mistake

        )


class IntroWait(WaitPage):
    wait_for_all_groups = True

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


class Round0_Results(Page):

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

    def vars_for_template(self):

        title = "Round #0"
        round_num = self.subsession.round_number

        lcolor = "#b7d9fa"
        hcolor = "#407fbf"
        if self.player.type == 0:
            hcol = 2
        else:
            hcol = 4

        payoffs = dict()
        for action in range(0, 6):
            payoffs[action] = {'R0': 300 - 3 * (0 - action * 2) ** 2,
                               'R1': 300 - 3 * (10 - action * 2) ** 2,
                               'S0': 300 - (self.subsession.conflict * 2 + 0 - action * 2) ** 2,
                               'S1': 300 - (self.subsession.conflict * 2 + 10 - action * 2) ** 2}

        return dict(
            prac_orS=(self.subsession.round_number <= Constants.pract_rounds) or (self.player.roles == "S"),
            action=self.player.action,
            hcol=hcol,
            lcolor=lcolor,
            hcolor=hcolor,
            title_text=title,
            roundnum=round_num,
            typeO_prob=int(100 * self.subsession.typeO_prob),
            typeI_prob=int(100 * (1 - self.subsession.typeO_prob)),
            payoffs=payoffs,
            earning=int(self.player.payoff),
        )


class Offround_start(Page):
    def is_displayed(self):
        return self.subsession.round_number == Constants.num_rounds

    def vars_for_template(self):
        prac_off = "Practice Round"
        if self.subsession.round_number > Constants.pract_rounds:
            prac_off = "Official Round"
        title = "Round #" + str(self.subsession.round_number - Constants.pract_rounds) + ": " + prac_off

        return dict(
            title_text=title,
        )


class Instruction_Over(WaitPage):
    template_name = 'ECR_instructions/templates/ECR_instructions/PostInstructionWaitPage.html'


page_sequence = [Instruction, PleaseWait, Instruction_Over]  # , Usher, SenderPage, WaitS, ReceiverPage, WaitR, ResultsWaitPage, Results,
# Round0, Round0_Results, Offround_start, IntroWait]