from otree.api import *
c = cu

doc = ''
class C(BaseConstants):
    NAME_IN_URL = 'treatment_1'
    PLAYERS_PER_GROUP = 4
    NUM_ROUNDS = 10
    ENDOWMENT = 24
    THRESHOLD = 48
    BONUS = 96


class Subsession(BaseSubsession):
        pass
def creating_session(subsession: Subsession):
    session = subsession.session
    group = subsession.get_groups()
    for g in group:
        g.treatment_g = session.config['treatment']
        if g.treatment_g == 1:
            g.high_valuation = 24
            g.low_valuation = 24
            g.high_rule = 12
            g.low_rule = 12
        elif g.treatment_g == 2:
            g.high_valuation = 24
            g.low_valuation = 24
            g.high_rule = 16
            g.low_rule = 8
        elif g.treatment_g == 3:
            g.high_valuation = 32
            g.low_valuation = 16
            g.high_rule = 12
            g.low_rule = 12
        elif g.treatment_g == 4:
            g.high_valuation = 32
            g.low_valuation = 16
            g.high_rule = 16
            g.low_rule = 8
        elif g.treatment_g == 5:
            g.high_valuation = 24
            g.low_valuation = 24
            g.high_rule = 0
            g.low_rule = 0
        elif g.treatment_g == 6:
            g.high_valuation = 32
            g.low_valuation = 16
            g.high_rule = 0
            g.low_rule = 0
        players = g.get_players()
        for p in players:
            p.participant.treatment = g.treatment_g


class Group(BaseGroup):
    treatment_g = models.IntegerField()
    total_contribution = models.CurrencyField()
    threshold_hit = models.BooleanField(initial=False)
    high_rule = models.IntegerField()
    low_rule = models.IntegerField()
    high_valuation = models.IntegerField()
    low_valuation = models.IntegerField()

def set_types(group: Group):
    players = group.get_players()
    for p in players:
        ##p.variant = p.participant.variant
        if p.id_in_group <= C.PLAYERS_PER_GROUP/2:
            p.rule_type = group.low_rule
            p.valuation_type = group.low_valuation
        else:
            p.rule_type = group.high_rule
            p.valuation_type = group.high_valuation


"""def set_payoffs(group: Group):
    players = group.get_players()
    contributions = [p.contribution for p in players]
    group.total_contribution = int(sum(contributions))
    if group.total_contribution < C.THRESHOLD:
        group.threshold_hit = False
    else: 
        group.threshold_hit = True
    for p in players:
        p.rest = C.ENDOWMENT - p.contribution
        if group.threshold_hit == True:
            p.earning = p.valuation_type + C.ENDOWMENT - p.contribution
            p.result = p.valuation_type + C.ENDOWMENT - p.contribution
        else:
            p.earning = C.ENDOWMENT - p.contribution
            p.result = C.ENDOWMENT - p.contribution

        if p.round_number == 1:
            p.earning = int(p.earning)
            p.participant.earning = int(p.earning)
        else:
            p.earning = int(p.participant.earning + p.earning)
            p.participant.earning = int(p.participant.earning + p.earning)"""

def set_payoffs(group: Group):
    players = group.get_players()
    contributions = [p.contribution for p in players]
    group.total_contribution = int(sum(contributions))
    if group.total_contribution < C.THRESHOLD:
        group.threshold_hit = False
    else:
        group.threshold_hit = True
    for p in players:
        p.rest = C.ENDOWMENT - p.contribution
        if group.threshold_hit == True:
            p.earning = p.valuation_type + C.ENDOWMENT - p.contribution
            p.result = p.valuation_type + C.ENDOWMENT - p.contribution
        else:
            p.earning = C.ENDOWMENT - p.contribution
            p.result = C.ENDOWMENT - p.contribution
        p.earning = int(p.earning)
        if p.round_number == 1:
            p.participant.earning = int(p.earning)
        else:
            p.participant.earning = int(p.participant.earning + p.earning)
class Player(BasePlayer):
    contribution = models.IntegerField(label='Wie viel möchten Sie beitragen?', max=C.ENDOWMENT, min=0)
    rule_type = models.IntegerField()
    valuation_type = models.IntegerField()
    earning = models.IntegerField(initial=0)
    result = models.IntegerField(initial=0)
    rest = models.IntegerField(initial=0)



def custom_export(players):
    yield ['participant_code', 'id_in_group']
    for p in players:
        pp = p.participant
        yield [pp.code, p.id_in_group]


class TypeWaitPage(WaitPage):
    after_all_players_arrive = set_types



class Contribute(Page):
    form_model = 'player'
    form_fields = ['contribution']
    @staticmethod
    def vars_for_template(player: Player):
       #  group = player.group
        num = player.round_number

        return dict(
            round_num = int(num)
        )
class ResultsWaitPage(WaitPage):
    after_all_players_arrive = set_payoffs

class Results(Page):
    form_model = 'player'

    @staticmethod
    def vars_for_template(player: Player):
        group=player.group
        return dict(
            group_result=int(group.total_contribution),
            player_result=int(player.earning),
            #rest=int(C.ENDOWMENT - player.contribution)
        )


class FirstRound(Page):
    form_model = 'player'

    @staticmethod
    def vars_for_template(player: Player):
        group = player.group
        return dict(
            bonus=int(2 * C.THRESHOLD)
        )

    @staticmethod
    def is_displayed(player: Player):
        return player.round_number ==  1

        return True




page_sequence = [TypeWaitPage, FirstRound, Contribute, ResultsWaitPage, Results]