from otree.api import *
import time

doc = """
I modified a one-shot PD to have multiple repeated coordination games
"""


class C(BaseConstants):
    NAME_IN_URL = 'stag'
    PLAYERS_PER_GROUP = 2
    NUM_ROUNDS = 10
    PAYOFF_A = 25
    PAYOFF_B = 35
    PAYOFF_C = 0
    PAYOFF_D = 0


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    cooperate = models.BooleanField(
        choices=[[True, 'A'], [False, 'B']],
        doc="""This player's decision""",
        widget=widgets.RadioSelect,
    )
    # input_button = models.CharField()
    number = models.IntegerField()
    comprehension = models.IntegerField(label="")
    comprehension2 = models.IntegerField(label="")
    decision_time = models.IntegerField()
    game_payoff_Stag = models.IntegerField()

    def record_decision_time(self):
        self.decision_time = int(time.time()) - self.participant.vars['start_time']  # records DT
        self.participant.vars['start_time'] = int(time.time())  # updates start time

    def record_game_payoff(self):
        all_players = self.in_all_rounds()
        combined_payoff = 0
        for temp_player in all_players:
            combined_payoff += temp_player.payoff
        self.participant.vars['game_payoff_Stag'] = int(combined_payoff)
        self.game_payoff_Stag = int(combined_payoff)

# FUNCTIONS
def set_payoffs(group: Group):
    for p in group.get_players():
        set_payoff(p)


def other_player(player: Player):
    return player.get_others_in_group()[0]


def set_payoff(player: Player):
    payoff_matrix = {
        (False, True): C.PAYOFF_A,
        (True, True): C.PAYOFF_B,
        (False, False): C.PAYOFF_A,
        (True, False): C.PAYOFF_C,
    }
    other = other_player(player)
    player.payoff = payoff_matrix[(player.cooperate, other.cooperate)]


# PAGES
class Game_Introduction(Page):
    def is_displayed(self):
        return self.round_number == 1

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

class Comprehension1(Page):
    def is_displayed(self):
        return self.round_number == 1
    form_model = 'player'
    form_fields = ['comprehension']

    @staticmethod
    def error_message(player: Player, values):
        solutions = dict(comprehension=66)

        if values != solutions:
            return "Por favor, inténtalo de nuevo."

class Comprehension2(Page):
    def is_displayed(self):
        return self.round_number == 1
    form_model = 'player'
    form_fields = ['comprehension2']

    @staticmethod
    def error_message(player: Player, values):
        solutions = dict(comprehension2=105)

        if values != solutions:
            return "Por favor, inténtalo de nuevo."

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

    def before_next_page(player, timeout_happened):
         player.participant.vars['start_time'] = int(time.time())

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

    def before_next_page(player, timeout_happened):
         player.participant.vars['start_time'] = int(time.time())

class Decision(Page):
    form_model = 'player'
    form_fields = ['cooperate']
    # timeout_seconds = 40

    def vars_for_template(self):

        # specify info for progress bar
        total = C.NUM_ROUNDS
        page = self.subsession.round_number
        progress = page / total * 100

        return {
            'page': page,
            'total': total,
            'progress': progress,}

    def before_next_page(player, timeout_happened):
        player.record_decision_time()
        player.record_game_payoff()
        player.game_payoff_Stag = int(player.participant.vars['game_payoff_Stag'])

class ResultsWaitPage(WaitPage):
    after_all_players_arrive = set_payoffs


class Results(Page):
    @staticmethod
    def vars_for_template(player: Player):
        opponent = other_player(player)
        return dict(
            opponent=opponent,
            same_choice=player.cooperate == opponent.cooperate,
            my_decision=player.field_display('cooperate'),
            opponent_decision=opponent.field_display('cooperate'),
        )

class Probabilities(Page):
    def is_displayed(self):
        return self.round_number != C.NUM_ROUNDS
    form_model = 'player'
    form_fields = ["number"]

class CombinedResults(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == C.NUM_ROUNDS
    @staticmethod
    def vars_for_template(player: Player):
        all_players = player.in_all_rounds()
        combined_payoff = 0
        for temp_player in all_players:
            combined_payoff += temp_player.payoff
        return {
            "combined_payoff": combined_payoff
        }

    def before_next_page(player, timeout_happened):
        player.record_game_payoff()

page_sequence = [FirstPage, Decision, ResultsWaitPage, Results, Probabilities, CombinedResults]