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

import random
import itertools


doc = """
This is a one-shot "Prisoner's Dilemma". Two players are asked separately
whether they want to cooperate or defect. Their choices directly determine the
payoffs.
"""


class Constants(BaseConstants):
    name_in_url = 'prisoner'
    players_per_group = 2
    num_rounds = 1

    #instructions_template = 'prisoner/instructions.html'


    #=========================================
    #payoffs for high condition
    #=========================================
    # payoff if 1 player defects and the other cooperates""",
    betray_payoff_high = c(400)
    betrayed_payoff_high = c(0)

    # payoff if both players cooperate or both defect
    both_cooperate_payoff_high = c(200)
    both_defect_payoff_high = c(100)


    #=========================================
    #payoffs for low conditoin
    #=========================================
    # payoff if 1 player defects and the other cooperates""",
    betray_payoff_low = c(300)
    betrayed_payoff_low = c(0)

    # payoff if both players cooperate or both defect
    both_cooperate_payoff_low = c(200)
    both_defect_payoff_low = c(100)



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):
    def set_payoffs(self):
        for p in self.get_players():
            p.set_payoff()


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

        #initializing payoffs
        both_cooperate_payoff = 0
        betrayed_payoff = 0
        betray_payoff = 0
        both_defect_payoff = 0

        #if PD is in high temptation condition
        if treatment == "high_temptation":
            both_cooperate_payoff = Constants.both_cooperate_payoff_high
            betrayed_payoff = Constants.betrayed_payoff_high
            betray_payoff = Constants.betray_payoff_high
            both_defect_payoff = Constants.both_defect_payoff_high
       
        #if PD is in low temptation conditoin
        else:
            both_cooperate_payoff = Constants.both_cooperate_payoff_low
            betrayed_payoff = Constants.betrayed_payoff_low
            betray_payoff = Constants.betray_payoff_low
            both_defect_payoff = Constants.both_defect_payoff_low

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

        self.payoff = payoff_matrix[self.decision][self.other_player().decision]