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

class ShuffleWaitPage(WaitPage):

    wait_for_all_groups = True

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

    def vars_for_template(self):
        return {
            'activeness': self.player.activeness,
            'altruism':self.player.expert_altruism,

        }

class control_1(Page):
    def is_displayed(self):
         return self.subsession.round_number == 1
    form_model = 'player'
    form_fields = ['expert_q1', 'client_q1']
    def vars_for_template(self):
        return {
            'activeness': self.player.activeness,
            #'altruism':self.player.expert_altruism,

        }
class control_2(Page):
    def is_displayed(self):
         return self.subsession.round_number == 1 and self.player.id_in_group == 1
    form_model = 'player'
    form_fields = ['expert_q2', 'expert_q3']
    def vars_for_template(self):
        return {
            #'activeness': self.player.activeness,
            'altruism':self.player.expert_altruism,

        }
class control_3(Page):
    def is_displayed(self):
         return self.subsession.round_number == 1
    form_model = 'player'
    form_fields = ['expert_q4', 'expert_q5', 'client_q2']
    def vars_for_template(self):
        return {
            'activeness': self.player.activeness,
            #'altruism':self.player.expert_altruism,

        }
# class control_4(Page):
#     def is_displayed(self):
#         return self.subsession.round_number == 1 and self.player.id_in_group == 1
#     form_model = 'player'
#     form_fields = ['expert_q5']

class get_problems(WaitPage):
    after_all_players_arrive = 'set_problems_and_signals'


class after_control_questions(Page):
    def is_displayed(self) -> bool:
        return self.subsession.round_number == 1

class after_instruction_waipage(WaitPage):  # this waitpage makes sure that the game starts after all subjects finish the control questions
    def is_displayed(self) -> bool:
        return self.subsession.round_number == 1
    wait_for_all_groups = True

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

    def vars_for_template(self):
        return {
            'round_number': self.round_number,
            'activeness': self.player.activeness,
            'altruism':self.player.expert_altruism,
            'altruism_contract':self.player.altruism_contract,
        }

    # form_model = "player"
    # form_fields = [
    #     'active1',
    #     'active2',
    # ]
    #
    # def before_next_page(self):
    #     # Determine which row is chosen for WTP table
    #     for p in self.subsession.get_players():
    #         if p.id_in_group == 2:
    #             # random_num = randint(1, 7)
    #             random_num = randint(1, 2)
    #             if random_num ==1:
    #                 p.activeness = p.active1
    #                 p.activeness_chosen = 1
    #             if random_num ==2:
    #                 p.activeness = p.active2
    #                 p.activeness_chosen = 2

class AWaitPage(WaitPage):
    def after_all_players_arrive(self):
        player1 = self.group.get_player_by_role('player1')
        player2 = self.group.get_player_by_role('player2')
        player1.activeness = player2.activeness


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

    form_model = "player"
    form_fields = ['precision_choice1']

    def vars_for_template(self):
        return {
            'round_number': self.round_number,
        }
    def precision_choice1_error_message(self, value):
        if value == None and self.player.id_in_group == 1:
            return 'Please make a choice'
    def before_next_page(self):
        player1 = self.group.get_player_by_role('player1')
        player2 = self.group.get_player_by_role('player2')
        player2.precision_choice1 = player1.precision_choice1
        # player1.diagnostic_cost1 = int(100 * (player1.precision_choice1 - 0.5) ** 2)
        # player2.diagnostic_cost1 = player1.diagnostic_cost1

class private_signal(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2 and self.player.activeness == 1

    def vars_for_template(self):
        return {
            'round_number':self.round_number,
            'private_signal_letter':self.player.private_signal_letter
        }


class communication_wait_page(WaitPage):
    wait_for_all_groups = True
    # after_all_players_arrive = 'my_page_timeout_seconds'
    # def after_all_players_arrive(self):
    #     for p in self.subsession.get_players():
    #         p.my_page_timeout_seconds()


class communication(Page):
    # def after_all_players_arrive(self):
    #     player1 = self.group.get_player_by_role('player1')
    #     player2 = self.group.get_player_by_role('player2')
    #     player2.precision_choice1 = player1.precision_choice1
    def get_timeout_seconds(self):
        if self.round_number == 1:
            return 180
        else:
            return 60
    def vars_for_template(self):
        return {
            'round_number': self.round_number,
            'private_signal': self.player.private_signal_letter,
            'precision_choice': "{:.0%}".format(self.player.precision_choice1)
                }
        # for p in self.group.get_players():
        #     if p.id_in_group == 1:
        #         return {
        #             #'diagnostic_result': self.player.diagnosis_letter1,
        #             #'recommended_solution': self.player.recommend_soln_letter1,
        #             'private_signal': self.player.private_signal_letter,
        #             'precision_choice': "{:.0%}".format(self.player.precision_choice1)
        #         }
        #     else:
        #         return {
        #             #'diagnostic_result': self.player.diagnosis_letter1,
        #             #'recommended_solution': self.player.recommend_soln_letter1,
        #             'private_signal': self.player.private_signal_letter,
        #             #'precision_choice': "{:.0%}".format(self.player.precision_choice1)
        #         }

class revision_decision(Page):
    def is_displayed(self):
        return self.player.id_in_group == 1
    form_model = "player"
    form_fields = ['revise']
    def revise_error_message(self, value):
        if value == None and self.player.id_in_group == 1:
            return 'Please make a choice'
    def vars_for_template(self):
        return {
            'round_number': self.round_number,
            'precision_choice1': "{:.0%}".format(self.player.precision_choice1)
        }
    def before_next_page(self):
        for p in self.group.get_players():
            p.diagnostic_cost = p.diagnostic_cost1
            p.precision_choice = p.precision_choice1

class precision_choice2_waitpage(WaitPage):
    # This wait page is for mapping from origianl choice to new choice if expert does not want to revise
    def is_displayed(self):
        for p in self.group.get_players():
            if p.id_in_group == 1:
                if self.player.revise == 1:
                    return True

    # def before_next_page(self):
    #     for p in self.group.get_players():
    #         p.diagnostic_cost = p.diagnostic_cost1
    #         p.precision_choice = p.precision_choice1

class precision_choice2(Page):
    def is_displayed(self):
        for p in self.group.get_players():
            if p.id_in_group == 1:
                if self.player.revise == 1:
                    return True

    form_model = "player"
    form_fields = ['precision_choice']

    def precision_choice_error_message(self, value):
        if value == None and self.player.id_in_group == 1:
            return 'Please make a choice'
    def vars_for_template(self):
        return {
            'round_number': self.round_number,
            'precision_choice1': "{:.0%}".format(self.player.precision_choice1)
        }

class diagnosis_wait_page_pre_wait2(WaitPage):
    wait_for_all_groups = True

class diagnosis_wait_page2(WaitPage):
    def after_all_players_arrive(self):
        for p in self.group.get_players():
            if p.id_in_group == 1:
                p.diagnostic_cost = round(100*(p.precision_choice - 0.5) ** 2)
                p.diagnostic_result = p.problem
                random_result = randint(1, 100)
                if p.precision_choice == 0.5:
                    if random_result <= 50:
                        p.diagnostic_result = p.problem
                    else:
                           p.diagnostic_result = abs(p.problem - 1)
                if p.precision_choice == 0.6:
                    if random_result <= 60:
                        p.diagnostic_result = p.problem
                    else:
                        p.diagnostic_result = abs(p.problem - 1)
                if p.precision_choice == 0.7:
                    if random_result <= 70:
                        p.diagnostic_result = p.problem
                    else:
                        p.diagnostic_result = abs(p.problem - 1)
                if p.precision_choice == 0.8:
                    if random_result <= 80:
                        p.diagnostic_result = p.problem
                    else:
                        p.diagnostic_result = abs(p.problem - 1)
                if p.precision_choice == 0.9:
                    if random_result <= 90:
                        p.diagnostic_result = p.problem
                    else:
                        p.diagnostic_result = abs(p.problem - 1)
                if p.precision_choice == 1:
                    p.diagnostic_result = p.problem

        player1 = self.group.get_player_by_role('player1')
        player2 = self.group.get_player_by_role('player2')
        #player2.problem = player1.problem
        player2.precision_choice = player1.precision_choice
        player2.diagnostic_result = player1.diagnostic_result
        player1.diagnosis_letter = "A"*(player1.diagnostic_result == 0) + "B"*(player1.diagnostic_result == 1)
        player2.diagnosis_letter = player1.diagnosis_letter
        player1.recommend_soln_letter = "A*"*(player1.diagnostic_result == 0) + "B*"*(player1.diagnostic_result == 1)
        player2.recommend_soln_letter = player1.recommend_soln_letter


class diagnostic_result(Page):
    wait_for_all_groups = True
    def vars_for_template(self):
        return {
            'precision': "{:.0%}".format(self.player.precision_choice),
            'diagnostic_result': self.player.diagnosis_letter,
            'recommended_solution': self.player.recommend_soln_letter,
            'private_signal': self.player.private_signal
        }

class choose_treatment(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2
    def vars_for_template(self):
        return {
            'precision': "{:.0%}".format(self.player.precision_choice),
            'diagnostic_result': self.player.diagnosis_letter,
            'private_signal': self.player.private_signal_letter,
            'recommend_solution': self.player.recommend_soln_letter,
            'activeness':self.player.activeness
        }

    form_model = "player"
    form_fields = ['treatment_choice', 'passive_guess', 'belief_precision']
    def treatment_choice_error_message(self, value):
        if value == None and self.player.id_in_group == 2 and self.player.activeness == 1:
            return 'Please make a choice'
    def belief_precision_error_message(self, value):
        if value == None and self.player.id_in_group == 2:
            return 'Please make a choice'
    def passive_guess_error_message(self, value):
        if value == None and self.player.id_in_group == 2 and self.player.activeness == 0:
            return 'Please make a choice'

class payoff_wait_page(WaitPage):

     after_all_players_arrive = 'set_payoffs'


class payoff(Page):

    def vars_for_template(self):
        return {
            'round_number': self.round_number,
            'payment_expert': self.player.payment,
            'payment_client': self.player.payment_temp,
            'recommended_solution': self.player.recommend_soln_letter,
            'actual_solution':self.player.treatment_final_letter,
            'problem':self.player.problem_letter,
            'cost':self.player.diagnostic_cost,
            # 'randomization_result':self.player.active_result_display,
            # 'randomization_cost': self.player.active_cost_display
            'altruism': self.player.expert_altruism,
            'altruism_payoff': self.player.altruism_payoff,
            'payment': self.player.payment
        }

class FinalPaymentWaitPage(WaitPage):
    wait_for_all_groups = True

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

    def after_all_players_arrive(self):
        for p in self.subsession.get_players():
            # for pr in p.in_all_rounds():
            #     p.final_payment = p.final_payment + pr.payment
            #
            # p.final_payment = Constants.initial_earning + (p.final_payment*Constants.exchange_rate)
            # p.participant.vars['final_payment'] = p.final_payment
            # p.payoff = p.final_payment
            p.final_payment = Constants.initial_earning + p.in_round(Constants.round_selected).payment * Constants.exchange_rate
            p.participant.vars['final_payment'] = p.final_payment
            p.participant.vars["round_selected"] = Constants.round_selected


page_sequence = [ShuffleWaitPage,
                 get_problems,
                 WTP,
                 instruction,
                 control_1,
                 control_2,
                 control_3,

                 after_control_questions,
                 after_instruction_waipage,
                 AWaitPage,
                 precision_choice,
                 #private_signal,
                 # diagnosis_wait_page_pre_wait,
                 # diagnosis_wait_page,
                 communication_wait_page,
                 communication,
                 revision_decision,
                 precision_choice2_waitpage,
                 precision_choice2,
                 diagnosis_wait_page_pre_wait2,
                 diagnosis_wait_page2,
                 choose_treatment,
                 payoff_wait_page,
                 payoff,
                 FinalPaymentWaitPage]