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


import json



class Instruction (Page):
    form_model = 'player'

    form_fields = ['q1','q2','q3', 'q4']
    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):
        return {
            'read' : self.player.read,
            'outside_option': self.subsession.outside_option,
            'tot_matches': self.subsession.tot_matches-1
        }

class Instruction2 (Page):
    def is_displayed(self):
        return self.subsession.round_number == 1
    def vars_for_template(self):
        return {
            'tot_matches': self.subsession.tot_matches-1
        }

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

class Usher (Page):
    def is_displayed(self):
        return self.subsession.round_number <= self.subsession.tot_matches

    def vars_for_template(self):
        return dict(
            roundnum = self.subsession.round_number - 1,
            role = self.player.roles
        )

# class Buyer_page(Page):
#     live_method = "live_seller_actions"
#
#     def is_displayed(self):
#         return self.player.roles =="Buyer"
#
#     def vars_for_template(self):
#         return dict(
#             roundnum = self.subsession.round_number - 1,
#         )



class Bargain_page(Page):
    live_method = "live_bargain"

    def is_displayed(self):
        return self.subsession.round_number <= self.subsession.tot_matches

    def vars_for_template(self):
        offer_dict = json.loads(self.group.seller_offers)
        if len(offer_dict)>0:
            latest_offer = int(offer_dict[str(len(offer_dict) - 1)])
        else:
            latest_offer = 0

        draw_dict = json.loads(self.group.lucky_draws)
        if len(draw_dict)>0:
            latest_draw = int(draw_dict[str(len(draw_dict) - 1)])
        else:
            latest_draw = 0


        guess_dict = json.loads(self.group.seller_guesses)
        if len(guess_dict)>0:
            guessed_max = int(guess_dict[str(len(guess_dict) - 1)]['max'])
            guessed_min = int(guess_dict[str(len(guess_dict) - 1)]['min'])
        else:
            guessed_max = 400
            guessed_min = 50

        value_B = 0
        for player in self.group.get_players():
            if player.roles == "Buyer":
                value_B = player.value

        prob_percent = int(round(self.subsession.prob_continuation**(len(offer_dict)+1),2)*100)
        if prob_percent < 10:
            prob_percent = "Less than 10%"
        return dict(
            random_initial = self.group.local_seed % 350 +50,
            matchnum = self.subsession.round_number - 1,
            roundnum= len(offer_dict)+1,
            prob_percent = prob_percent,
            p_value = self.player.value,
            bargain_stage = self.group.bargain_stage,
            latest_offer = latest_offer,
            B_value = value_B,
            guessed_min = guessed_min,
            guessed_max = guessed_max,
            latest_draw = (100-latest_draw)*3.6-36,
            outside_option = self.subsession.outside_option
        )

class ResultsWaitPage(WaitPage):
    def is_displayed(self):
        return self.subsession.round_number <= self.subsession.tot_matches
    pass


class Results(Page):
    def is_displayed(self):
        return self.subsession.round_number <= self.subsession.tot_matches


    def vars_for_template(self):
        offer_dict = json.loads(self.group.seller_offers)
        action_dict = json.loads(self.group.buyer_actions)
        iterround = [r for r in range(0, len(offer_dict) - 1)]
        rounds = [r for r in range(1, len(offer_dict))]
        Y_N = ["N", "Y"]

        value_B = 0;
        for player in self.group.get_players():
            if player.roles=="Buyer":
                value_B = player.value


        return dict(
                    match_num = self.subsession.round_number -1,
                    round_num=len(offer_dict),
                    iterround=iterround,
                    offer_dict=self.group.seller_offers,
                    action_dict=self.group.buyer_actions,
                    value_B = value_B,
                    match_gain = int(self.player.payoff)
                    )

import random
class Final_payment(Page):

    def cal_final_payoff(self,local_seed):
        local_random = random.Random(local_seed+self.player.id_in_group)
        chosen_round = local_random.randint(2, self.subsession.tot_matches)
        player = self.player.in_round(chosen_round)
        self.participant.payoff = player.payoff
        return self.participant.payoff, chosen_round-1

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


    def vars_for_template(self):
        final_payment, chosen_match = self.cal_final_payoff(self.group.local_seed)
        Bvalue_dict = {}
        AcOffer_dict = {}
        Outcome_dict = {}
        Earning_dict = {}

        for m in range(2,self.subsession.tot_matches+1):
            player = self.player.in_round(m)
            Earning_dict[m-1] = int(player.payoff)

            group = self.player.in_round(m).group
            for p in group.get_players():
                if p.roles == "Buyer":
                    Bvalue_dict[m-1]=p.value
            if group.bargain_stage =="accepted, end":
                Outcome_dict[m-1] = "Offer Accepted"
                offer_dict = json.loads(group.seller_offers)
                AcOffer_dict[m-1] = offer_dict[str(len(offer_dict)-1)]
            if group.bargain_stage ==  "rejected, end":
                Outcome_dict[m - 1] = "Match Terminated"
                AcOffer_dict[m - 1] = "N/A"
            if group.bargain_stage == "outside, end":
                Outcome_dict[m - 1] = "Outside Option Taken"
                AcOffer_dict[m - 1] = "N/A"


        return dict(final_payment = final_payment,
                    chosen_match = chosen_match,
                    total_payment = self.participant.payoff_plus_participation_fee(),
                    tot_match_num = self.subsession.tot_matches-1,
                    Bvalue_dict = Bvalue_dict,
                    AcOffer_dict = AcOffer_dict,
                    Outcome_dict = Outcome_dict,
                    Earning_dict = Earning_dict
                    )



page_sequence = [Instruction, Instruction2, PleaseWait, ResultsWaitPage,Usher, Bargain_page,  Results, Final_payment ]