from otree.api import *
c = cu

doc = 'Treatment Mean Rule'
class C(BaseConstants):
    NAME_IN_URL = 'T_D'
    PLAYERS_PER_GROUP = 4
    NUM_ROUNDS = 6
    TEILNAHMEKOSTEN = cu(10)
    PEAK_VERTEILUNG1_1 = 11
    PEAK_VERTEILUNG1_2 = 12
    PEAK_VERTEILUNG1_3 = 13
    PEAK_VERTEILUNG1_4 = 14
    PEAKS_1 = (5, 5, 25, 5, 30, 5)
    PEAKS_2 = (10, 30, 30, 10, 35, 7)
    PEAKS_3 = (90, 70, 70, 65, 90, 10)
    PEAKS_4 = (95, 95, 75, 70, 95, 25)
class Subsession(BaseSubsession):
    peak1 = models.IntegerField()
    peak2 = models.IntegerField()
    peak3 = models.IntegerField()
    peak4 = models.IntegerField()
    Partizipationskonstellation = models.IntegerField()
def strangermatching(subsession: Subsession):
    session = subsession.session
    subsession.group_randomly()
class Group(BaseGroup):
    Partizipation_Spieler1 = models.BooleanField()
    Partizipation_Spieler2 = models.BooleanField()
    Partizipation_Spieler3 = models.BooleanField()
    Partizipation_Spieler4 = models.BooleanField()
    Teilnehmeranzahl = models.IntegerField()
    Ergebnis = models.FloatField(initial=0)
    Ergebnis_CU = models.CurrencyField()
    Ergebnis_Int = models.IntegerField()
def Teilnahmeentscheidungen(group: Group):
    spieler1 = group.get_player_by_id(1) 
    group.Partizipation_Spieler1 = spieler1.Partizipationsentscheidung_1
    spieler1.Wirkliche_Partizipation = spieler1.Partizipationsentscheidung_1
    
    spieler2 = group.get_player_by_id(2) 
    group.Partizipation_Spieler2 = spieler2.Partizipationsentscheidung_2
    spieler2.Wirkliche_Partizipation = spieler2.Partizipationsentscheidung_2
    
    spieler3 = group.get_player_by_id(3) 
    group.Partizipation_Spieler3 = spieler3.Partizipationsentscheidung_3
    spieler3.Wirkliche_Partizipation = spieler3.Partizipationsentscheidung_3
    
    spieler4 = group.get_player_by_id(4) 
    group.Partizipation_Spieler4 = spieler4.Partizipationsentscheidung_4
    spieler4.Wirkliche_Partizipation = spieler4.Partizipationsentscheidung_4
    
    group.Teilnehmeranzahl = spieler1.Wirkliche_Partizipation + spieler2.Wirkliche_Partizipation + spieler3.Wirkliche_Partizipation + spieler4.Wirkliche_Partizipation
def Ergebnisse_Durchschnitt(group: Group):
    session = group.session
    subsession = group.subsession
    
    if group.Teilnehmeranzahl == 0:
        for player in group.get_players():
            player.payoff = 0
            group.Ergebnis = -1
    
    if group.Teilnehmeranzahl >0:      
    
        spieler1 = group.get_player_by_id(1)
        spieler2 = group.get_player_by_id(2)
        spieler3 = group.get_player_by_id(3)
        spieler4 = group.get_player_by_id(4)
        peak1 = C.PEAKS_1[subsession.round_number-1]
        peak2 = C.PEAKS_2[subsession.round_number-1]
        peak3 = C.PEAKS_3[subsession.round_number-1]
        peak4 = C.PEAKS_4[subsession.round_number-1]
    
        if spieler1.Wirkliche_Partizipation == 1:
            group.Ergebnis = group.Ergebnis + spieler1.Stimmabgabe
    
        if spieler2.Wirkliche_Partizipation == 1:
            group.Ergebnis = group.Ergebnis + spieler2.Stimmabgabe
    
        if spieler3.Wirkliche_Partizipation == 1:
            group.Ergebnis = group.Ergebnis + spieler3.Stimmabgabe
    
        if spieler4.Wirkliche_Partizipation == 1:
            group.Ergebnis = group.Ergebnis + spieler4.Stimmabgabe
    
        group.Ergebnis = group.Ergebnis / group.Teilnehmeranzahl            
    
        group.Ergebnis_CU = group.Ergebnis
        import math
        if group.Ergebnis_CU - math.floor(group.Ergebnis_CU) < 0.5:
            group.Ergebnis_Int = math.floor(group.Ergebnis_CU)
        if group.Ergebnis_CU - math.floor(group.Ergebnis_CU) >= 0.5:
            group.Ergebnis_Int = math.ceil(group.Ergebnis_CU)
    
        spieler1.payoff = 110 - abs(group.Ergebnis - peak1) - spieler1.Wirkliche_Partizipation * 10
    
        spieler2.payoff = 110 - abs(group.Ergebnis - peak2) - spieler2.Wirkliche_Partizipation * 10
    
        spieler3.payoff = 110 - abs(group.Ergebnis - peak3) - spieler3.Wirkliche_Partizipation * 10
    
        spieler4.payoff = 110 - abs(group.Ergebnis - peak4) - spieler4.Wirkliche_Partizipation * 10
    
        if abs(spieler1.Schaetzung - group.Ergebnis) <=5:
            spieler1.Bonus_Schaetzung = 5
        if abs(spieler1.Schaetzung - group.Ergebnis) >5:
            spieler1.Bonus_Schaetzung = 0
    
        if abs(spieler2.Schaetzung - group.Ergebnis) <=5:
            spieler2.Bonus_Schaetzung =  5
        if abs(spieler2.Schaetzung - group.Ergebnis) >5:
            spieler2.Bonus_Schaetzung =  0
    
        if abs(spieler3.Schaetzung - group.Ergebnis) <=5:
            spieler3.Bonus_Schaetzung =  5       
        if abs(spieler3.Schaetzung - group.Ergebnis) >5:
            spieler3.Bonus_Schaetzung =  0      
    
        if abs(spieler4.Schaetzung - group.Ergebnis) <=5:
            spieler4.Bonus_Schaetzung =  5        
        if abs(spieler4.Schaetzung - group.Ergebnis) >5:
            spieler4.Bonus_Schaetzung =  0          
    
def Runde_nicht_auszahlen(group: Group):
    session = group.session
    subsession = group.subsession
    spieler1 = group.get_player_by_id(1)
    spieler2 = group.get_player_by_id(2)
    spieler3 = group.get_player_by_id(3)
    spieler4 = group.get_player_by_id(4)
    
    spieler1.participant.payoff = spieler1.participant.payoff - spieler1.payoff
    spieler2.participant.payoff = spieler2.participant.payoff - spieler2.payoff
    spieler3.participant.payoff = spieler3.participant.payoff - spieler3.payoff
    spieler4.participant.payoff = spieler4.participant.payoff - spieler4.payoff
    
    if subsession.round_number == C.NUM_ROUNDS:
        import random
        spieler1.participant.ausgezahlte_runde = random.randint(1,C.NUM_ROUNDS)
        prev_player = spieler1.in_round(spieler1.participant.ausgezahlte_runde)
        spieler1.participant.payoff = spieler1.participant.payoff + prev_player.payoff
        spieler1.participant.auszahlung = prev_player.payoff
    
        spieler2.participant.ausgezahlte_runde = random.randint(1,C.NUM_ROUNDS)
        prev_player = spieler2.in_round(spieler2.participant.ausgezahlte_runde)
        spieler2.participant.payoff = spieler2.participant.payoff + prev_player.payoff
        spieler2.participant.auszahlung = prev_player.payoff
    
        spieler3.participant.ausgezahlte_runde = random.randint(1,C.NUM_ROUNDS)
        prev_player = spieler3.in_round(spieler3.participant.ausgezahlte_runde)
        spieler3.participant.payoff = spieler3.participant.payoff + prev_player.payoff
        spieler3.participant.auszahlung = prev_player.payoff
    
        spieler4.participant.ausgezahlte_runde = random.randint(1,C.NUM_ROUNDS)
        prev_player = spieler4.in_round(spieler4.participant.ausgezahlte_runde)
        spieler4.participant.payoff = spieler4.participant.payoff + prev_player.payoff
        spieler4.participant.auszahlung = prev_player.payoff
    
class Player(BasePlayer):
    Partizipationsentscheidung_1 = models.BooleanField(choices=[[True, 'Ja'], [False, 'Nein']], label='Möchten Sie an der Wahl teilnehmen, wenn Ihnen Peak 1 zugelost wird?')
    Partizipationsentscheidung_2 = models.BooleanField(choices=[[True, 'Ja'], [False, 'Nein']], label='Möchten Sie an der Wahl teilnehmen, wenn Ihnen Peak 2 zugelost wird?')
    Partizipationsentscheidung_3 = models.BooleanField(choices=[[True, 'Ja'], [False, 'Nein']], label='Möchten Sie an der Wahl teilnehmen, wenn Ihnen Peak 3 zugelost wird?')
    Partizipationsentscheidung_4 = models.BooleanField(choices=[[True, 'Ja'], [False, 'Nein']], label='Möchten Sie an der Wahl teilnehmen, wenn Ihnen Peak 4 zugelost wird?')
    Wirkliche_Partizipation = models.BooleanField()
    Stimmabgabe = models.FloatField(max=100, min=0)
    Schaetzung = models.FloatField(max=100, min=0)
    Endowment = models.CurrencyField(initial=110)
    Bonus_Schaetzung = models.IntegerField(initial=0)
class WaitPage_Stranger_Matching(WaitPage):
    wait_for_all_groups = True
    after_all_players_arrive = strangermatching
class Start(Page):
    form_model = 'player'
class Partizipationsentscheidung(Page):
    form_model = 'player'
    form_fields = ['Partizipationsentscheidung_1', 'Partizipationsentscheidung_2', 'Partizipationsentscheidung_3', 'Partizipationsentscheidung_4']
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        subsession = player.subsession
        peak1 = C.PEAKS_1[subsession.round_number-1]
        peak2 = C.PEAKS_2[subsession.round_number-1]
        peak3 = C.PEAKS_3[subsession.round_number-1]
        peak4 = C.PEAKS_4[subsession.round_number-1]
        
        return dict(
        peak1 = peak1,
        peak2 = peak2,
        peak3 = peak3,
        peak4 = peak4
        )
class Wait_Page_Post_Teilnahmeentscheidung(WaitPage):
    after_all_players_arrive = Teilnahmeentscheidungen
class Abstimmung_Teilnehmer(Page):
    form_model = 'player'
    form_fields = ['Stimmabgabe', 'Schaetzung']
    @staticmethod
    def is_displayed(player: Player):
        return player.Wirkliche_Partizipation == 1
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        subsession = player.subsession
        group = player.group
        peak1 = C.PEAKS_1[subsession.round_number-1]
        peak2 = C.PEAKS_2[subsession.round_number-1]
        peak3 = C.PEAKS_3[subsession.round_number-1]
        peak4 = C.PEAKS_4[subsession.round_number-1]
        Partizipationskonstellation = 1000 * group.Partizipation_Spieler1 + 100 * group.Partizipation_Spieler2 + 10 * group.Partizipation_Spieler3 + group.Partizipation_Spieler4
        
        return dict(
        peak1 = peak1,
        peak2 = peak2,
        peak3 = peak3,
        peak4 = peak4,
        Partizipationskonstellation = Partizipationskonstellation
        )
        
        
class Abstimmung_Enthaltung(Page):
    form_model = 'player'
    form_fields = ['Schaetzung']
    @staticmethod
    def is_displayed(player: Player):
        group = player.group
        return player.Wirkliche_Partizipation == 0 and group.Teilnehmeranzahl != 0
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        subsession = player.subsession
        group = player.group
        peak1 = C.PEAKS_1[subsession.round_number-1]
        peak2 = C.PEAKS_2[subsession.round_number-1]
        peak3 = C.PEAKS_3[subsession.round_number-1]
        peak4 = C.PEAKS_4[subsession.round_number-1]
        Partizipationskonstellation = 1000 * group.Partizipation_Spieler1 + 100 * group.Partizipation_Spieler2 + 10 * group.Partizipation_Spieler3 + group.Partizipation_Spieler4
        
        return dict(
        peak1 = peak1,
        peak2 = peak2,
        peak3 = peak3,
        peak4 = peak4,
        Partizipationskonstellation = Partizipationskonstellation
        )
class WaitPage_Post_Abstimmung(WaitPage):
    after_all_players_arrive = Ergebnisse_Durchschnitt
class Ergebnisse(Page):
    form_model = 'player'
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        subsession = player.subsession
        group = player.group
        import math 
        peak1 = C.PEAKS_1[subsession.round_number-1]
        peak2 = C.PEAKS_2[subsession.round_number-1]
        peak3 = C.PEAKS_3[subsession.round_number-1]
        peak4 = C.PEAKS_4[subsession.round_number-1]
        payoffbonus = player.payoff +5
        group.Ergebnis = math.floor(group.Ergebnis*100)/100
        
        return dict(
        peak1 = peak1,
        peak2 = peak2,
        peak3 = peak3,
        peak4 = peak4,
        payoffbonus = payoffbonus
        )
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.payoff = player.payoff + player.Bonus_Schaetzung
class WaitPage_nicht_direkt_auszahlen(WaitPage):
    after_all_players_arrive = Runde_nicht_auszahlen
page_sequence = [WaitPage_Stranger_Matching, Start, Partizipationsentscheidung, Wait_Page_Post_Teilnahmeentscheidung, Abstimmung_Teilnehmer, Abstimmung_Enthaltung, WaitPage_Post_Abstimmung, Ergebnisse, WaitPage_nicht_direkt_auszahlen]