from otree.api import (
    models,
    widgets,
    BaseConstants,
    BaseSubsession,
    BaseGroup,
    BasePlayer,
    Currency as c,
    currency_range,
)

import random
import itertools

author = 'Your name here'

doc = """
Your app description
"""


class Constants(BaseConstants):
    name_in_url = 'diss_exp_instructions_pd'
    players_per_group = None
    num_rounds = 1

    # # Initial amount allocated to RE condition participants
    # endowment = c(100)

    # payoff if 1 player defects and the other cooperates""",
    betrayer_payoff = c(4)
    betrayed_payoff = c(0)

    # payoff if both players cooperate or both defect
    both_cooperate_payoff = c(2)
    both_defect_payoff = c(1)

    #instructions template for PD
    pdinstructions = 'diss_exp_instructions_pd/pdinstructions_template.html'


class Subsession(BaseSubsession):
    def creating_session(self):
        
        #the two treatments
        treatments = itertools.cycle(['high_temptation', 'low_temptation'])

        #assigns players to treatments on a first-come-first-served basis (alternating)
        #(on MTurk, how the queue is formed is kinda random I guess)
        #ensures that everyone in a group (PD) is playing in the same treatment
        if self.round_number == 1:
            for g in self.get_groups():
                if 'treatment' in self.session.config:
                    treatment = self.session.config['treatment']
                    #if more than 2 players must add code for additional players
                    # NOTE: participant.vars is an ephemeral thing
                    #       whose value is more permanently stored 
                    #       in p[num].treatment = thing
                    p1 = g.get_player_by_id(1)
                    p1.participant.vars['treatment'] = treatment
                    p1.treatment = treatment
                    p2 = g.get_player_by_id(2)
                    p2.participant.vars['treatment'] = treatment
                    p2.treatment = treatment
                else:
                    treatment = next(treatments)
                    p1 = g.get_player_by_id(1)
                    p1.participant.vars['treatment'] = treatment
                    p1.treatment = treatment
                    p2 = g.get_player_by_id(2)
                    p2.participant.vars['treatment'] = treatment
                    p2.treatment = treatment
        else:
            for g in self.get_groups():
                p1 = g.get_player_by_id(1)
                treatment1 = p1.participant.vars['treatment']
                p1.treatment = treatment1
                p2 = g.get_player_by_id(2)
                treatment2 = p2.participant.vars['treatment']
                p2.treatment = treatment2


class Group(BaseGroup):
    # kept = models.CurrencyField(
    #     doc="""Amount dictator decided to keep for himself""",
    #     min=0,
    #     max=Constants.endowment,
    #     label="I will keep",
    # )

    def set_payoffs(self):
        for p in self.get_players():
            p.set_payoff()

    # def set_payoffs(self):
    #     p1 = self.get_player_by_id(1)
    #     p2 = self.get_player_by_id(2)
    #     p1.payoff = self.kept
    #     p2.payoff = Constants.endowment - self.kept


class Player(BasePlayer):
    
    treatment = models.StringField()

    #the choices an agent can make
    decision = models.StringField(
        choices=[['Cooperate', 'Cooperate'], ['Defect', 'Defect']],
        doc="""This player's decision""",
        widget=widgets.RadioSelect,
    )

    def other_player(self):
        return self.get_others_in_group()[0]

    def set_payoff(self):
        #players' treatment
        treatment = self.treatment
        id_in_group = self.id_in_group

        #initializing payoffs
        both_cooperate_payoff = Constants.both_cooperate_payoff
        betrayed_payoff = Constants.betrayed_payoff
        betrayer_payoff = Constants.betrayer_payoff
        both_defect_payoff = Constants.both_defect_payoff


        #payoffs based on decisions of both
        payoff_matrix = dict(
            Cooperate=dict(
                Cooperate=both_cooperate_payoff,
                Defect=betrayed_payoff,
            ),
            Defect=dict(
                Cooperate=betrayer_payoff, Defect=both_defect_payoff
            ),
        )

        #payoff from PD
        payoff_PD = payoff_matrix[self.decision][self.other_player().decision]


        #payoff from negotiated exchange
        ##initializing
        payoff_NE = 0
        ## if you made the offer
        if id_in_group == 1:
            payoff_NE = self.group.kept

        ## if you received the offer
        else:
            payoff_NE = Constants.endowment - self.group.kept

        self.payoff = payoff_NE + payoff_PD