import random

from otree.api import *


doc = """
Your app description
"""
def creating_session(subsession):
    subsession.TREATMENT = 'Control' #damit es nicht Null ist
    if 'wb_treatment' in subsession.session.config:
        subsession.TREATMENT = subsession.session.config['wb_treatment']
    subsession.matched_new = False

    for p in subsession.get_players():
        if p.role==C.A_ROLE:
            p.participant.vars['playertype'] = 'A'
        else:
            p.participant.vars['playertype'] = 'B'

        p.playertype = p.participant.vars['playertype']

class C(BaseConstants):
    NAME_IN_URL = 'whistleblowing'
    PLAYERS_PER_GROUP = 2
    NUM_ROUNDS = 1
    A_ROLE = 'A'
    B_ROLE = 'B'

    ## Definition : Gruppe1 A B & Gruppe2 A B werden zu
    ## Spieler1 G1A Spieler2 G2A
    ## Spieler1 G1B Spieler2 G2B
    Player_1 = 1
    Player_2 = 2

    DONATION_BUDGET = cu(5)
    EMBEZZLE_BUDGET = cu(2)
    PENALTY_BUDGET_A = cu(2)
    PENALTY_BUDGET_B = cu(1)
    ESTIMATE_CORRECT_BUDGET = cu(1) # wenn jemand bei der Einschätzung richtig liegt

    DONATION_AFTER_EMBEZZLING = DONATION_BUDGET - EMBEZZLE_BUDGET ## nur für die anzeige

    DONATION_DECISION_A = __name__ + '/donation_a.html'
    DONATION_DECISION_B = __name__ + '/donation_b.html'

    DONATION_FORWARDED = __name__ + '/decision_forward.html'
    DONATION_SILENCED = __name__ + '/decision_silenced.html'
    DONATION_REPORTED = __name__ + '/decision_report.html'

    TREATMENTS_NAMES = ['Control','T1','T2']
class Subsession(BaseSubsession):
    amount_possible_donations = models.IntegerField(initial=0)
    amount_real_donations = models.IntegerField(initial=0)
    amount_embezzling_tries = models.IntegerField(initial=0)
    amount_embezzling_succeeds = models.FloatField(initial=0)
    ## hier noch die anzahl
    TREATMENT = models.StringField(initial='Control')
    total_donation = models.FloatField(initial=0.0)
    ##Mehrheit embezzle/non embezzle und wb/non-wb
    #for Role A: tie=0, embezzle= 1, non-embezzle= 2
    #for Role B: tie=0, wb = 1, non-wb=2
    #both initial = -1
    majority_A = models.IntegerField (initial=-1)
    majority_B = models.IntegerField(initial=-1)
    matched_new = models.BooleanField (initial=False)

    #für T2: ob Mehrheit WB/nonWB oder Embez/nonEmbez macht
    majority_AT2 = models.IntegerField(initial=-1)
    majority_BT2 = models.IntegerField(initial=-1)





class Group(BaseGroup):
    donation_amount = models.CurrencyField(initial=cu(0))


class Player(BasePlayer):
    FirstPartA = models.BooleanField(initial=False)
    #für die fixe Rollenzuweisung
    playertype = models.StringField()
    donation_b_silence = models.BooleanField(
        label="",
        choices=[
            [False, "Das Verhalten von Spieler*in A melden"],
            [True, "Stillschweigend über das Verhalten von Spieler*in A hinwegsehen"]
        ],
        widget=widgets.RadioSelectHorizontal
    )
    donation_a = models.BooleanField(
        label="",
        choices = [
                [True, 'Das vollständige Spendenbudget an GoAhead weiterleiten'],
                [False, 'Einen Teil des Spendenbudgets einbehalten']
        ],
        widget=widgets.RadioSelectHorizontal
    )

    honesty_A = models.IntegerField(
        label="Unabhängig von Ihrem (vorherigen) Verhalten, geben Sie hier bitte an, was für Sie persönlich das moralisch richtige Verhalten wäre:",
        choices=[
            [1, 'Das vollständige Spendenbudget an GoAhead weiterleiten'],
            [2, 'Einen Teil des Spendenbudgets einbehalten'],
        ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
    )
    majority_view_honesty_A = models.IntegerField(
        label="Geben Sie an, was Sie denken, was die Mehrheit der Teilnehmenden in der Rolle „Spieler*in A“ bei der vorangegangenen Frage angegeben haben. Wenn Ihre Einschätzung bei dieser Frage korrekt ist, erhalten Sie eine zusätzliche Auszahlung von 1 Taler.",
        choices=[
            [1, 'Das vollständige Spendenbudget an GoAhead weiterleiten'],
            [2, 'Einen Teil des Spendenbudgets einbehalten']
        ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
    )

    wb_B = models.IntegerField(
        label="Unabhängig von Ihrem (vorherigen) Verhalten, geben Sie hier bitte an, was für Sie persönlich das moralisch richtige Verhalten wäre:",
    choices=[
        [1, 'Das Verhalten von Spieler*in A melden'],
        [2, 'Stillschweigend über das Verhalten von Spieler*in A hinwegsehen'],
    ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
)
    majority_view_wb_B = models.IntegerField(
        label="Geben Sie an, was Sie denken, was die Mehrheit der Teilnehmenden in der Rolle „Spieler*in B“ bei der vorangegangenen Frage angegeben haben. Wenn Ihre Einschätzung bei dieser Frage korrekt ist, erhalten Sie eine zusätzliche Auszahlung von 1 Taler.",
        choices=[
            [1, 'Das Verhalten von Spieler*in A melden'],
            [2, 'Stillschweigend über das Verhalten von Spieler*in A hinwegsehen']
        ],
        widget=widgets.RadioSelectHorizontal,
        initial = -1
    )
    #deskriptive Norm für T0 und T1 ohne zusätzliches Geld
    majority_action_A = models.IntegerField(
        label="Unabhängig davon, was  glauben Sie, wie hat sich die Mehrheit der Spieler*in A verhalten?",
        choices=[
            [1, 'Das vollständige Spendenbudget an GoAhead weiterzuleiten'],
            [2, 'Einen Teil des Spendenbudgets einzubehalten']
        ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
    )
    majority_action_B = models.IntegerField(
        label="Unabhängig davon, was  glauben Sie, wie hat sich die Mehrheit der Spieler*in B verhalten?",
        choices=[
            [1, 'Das Verhalten von Spieler*in A zu melden'],
            [2, 'Stillschweigend über das Verhalten von Spieler*in A hinwegzusehen']
        ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
    )

    #T2
    majority_view_honesty_AT2 = models.IntegerField(
        label="Geben Sie an, was Sie denken, wie sich die Mehrheit der Teilnehmenden in der Rolle 'Spieler*in A' in dieser Sitzung bei der Entscheidung über das Spendenbudget verhalten hat. Wenn Ihre Einschätzung bei dieser Frage korrekt ist, erhalten Sie eine zusätzliche Auszahlung von 1 Taler.",
        choices=[
            [1, 'Das vollständige Spendenbudget an GoAhead weiterleiten'],
            [2, 'Einen Teil des Spendenbudgets einbehalten']
        ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
    )
    majority_view_wb_BT2 = models.IntegerField(
        label="Geben Sie an, was Sie denken, wie sich die Mehrheit der Teilnehmenden in der Rolle 'Spieler*in B' in dieser Sitzung bezüglich der Entscheidung von Spieler*in A verhalten hat. Wenn Ihre Einschätzung bei dieser Frage korrekt ist, erhalten Sie eine zusätzliche Auszahlung von 1 Taler.",
        choices=[
            [1, 'Das Verhalten von Spieler*in A melden'],
            [2, 'Stillschweigend über das Verhalten von Spieler*in A hinwegsehen']
        ],
        widget=widgets.RadioSelectHorizontal,
        initial=-1
    )

    second_task_together = models.BooleanField(
        label="Ihre Entscheidung",
        choices=[
            [True, 'Die nachfolgende Aufgabe als Team bearbeiten'],
            [False,'Die nachfolgende Aufgabe einzeln bearbeiten']
        ]

    )

    #Strategie Methode
    #Spieler A
    DecA_embezzle = models.IntegerField(
        label='Wie entscheiden Sie Sich, wenn Spieler*in 2 im ersten Teil des Experiments einen Teil der Spende einbehalten hat?',
        initial=-1,
        choices=[
            [1, 'Die nachfolgende Aufgabe als Team bearbeiten'],
            [0, 'Die nachfolgende Aufgabe alleine bearbeiten']
        ],
        widget=widgets.RadioSelectHorizontal

    )
    DecA_nonembezzle = models.IntegerField(
        label='Wie entscheiden Sie Sich, wenn Spieler*in 2 im ersten Teil des Experiments den vollständigen Spendenbetrag weitergeleitet hat?',
        initial=-1,
        choices=[
            [1, 'Die nachfolgende Aufgabe als Team bearbeiten'],
            [0, 'Die nachfolgende Aufgabe alleine bearbeiten']
        ],
        widget=widgets.RadioSelectHorizontal

    )
    # Spieler B
    DecB_nonwb = models.IntegerField(
        label='Wie entscheiden Sie Sich, wenn Spieler*in 2 im ersten Teil des Experiments über die Entscheidung von Spieler*in A einen Teil des Spendenbudgets einzubehalten stillschweigend hinweggesehen hat?',
        initial=-1,
        choices=[
            [1, 'Die nachfolgende Aufgabe als Team bearbeiten'],
            [0, 'Die nachfolgende Aufgabe alleine bearbeiten']
        ],
        widget=widgets.RadioSelectHorizontal

    )
    DecB_wb = models.IntegerField(
        label='Wie entscheiden Sie Sich, wenn Spieler*in 2 im ersten Teil des Experiments die Entscheidung von Spieler*in A einen Teil des Spendenbudgets einzubehalten gemeldet hat?',
        initial=-1,
        choices=[
            [1, 'Die nachfolgende Aufgabe als Team bearbeiten'],
            [0, 'Die nachfolgende Aufgabe alleine bearbeiten']
        ],
        widget=widgets.RadioSelectHorizontal

    )
    #nur in control Treatment
    DecAB = models.IntegerField(
        label='Bitte treffen Sie nun Ihre Entscheidung:',
        initial=-1,
        choices=[
            [1, 'Die nachfolgende Aufgabe als Team bearbeiten'],
            [0, 'Die nachfolgende Aufgabe alleine bearbeiten']
        ],
        widget=widgets.RadioSelectHorizontal

    )
    Spieler1 = models.BooleanField(initial=False) #ob jemand Spieler 1 oder 2 wird
    team_embezzle = models.BooleanField(initial=False) ## Nur für eure Auswertung und das leichtere Überprüfen
    team_penalty = models.BooleanField(initial=False)
    estimate_correct = models.IntegerField (initial=-1)



def secondpart( p: Player, p2: Player):
    text = ""
    if p.FirstPartA:  # linke seite
        if p2.donation_a:
            text = "die Spende weiterzuleiten."
        else:
            text = "einen Teil der Spende einzubehalten."
    else:  ## rechte seite
        if p2.donation_b_silence:
            text = "über die Einbehaltung der Spende stillschweigend hinwegzusehen."
        else:
            text = "die Einbehaltung der Spende zu melden."
    return text


def rearrange_group_matrix(input_array):
    output_list =[]
    # Split the input array into two lists based on the first and second entries
    playerA = [inner_array[0] for inner_array in input_array]

    playerB = [inner_array[1] for inner_array in input_array]

    # Randomly group the entries of each player into pairs
    random.shuffle(playerA)
    random.shuffle(playerB)

    playerA_pairs = [[playerA[i], playerA[i + 1]] for i in range(0, len(playerA), 2)]
    playerB_pairs = [[playerB[i], playerB[i + 1]] for i in range(0, len(playerB), 2)]
   # print(playerB_pairs,playerA_pairs, [playerA_pairs,playerB_pairs])
    return playerA_pairs+playerB_pairs


def fill_control_variables_set_payoff(group:Group):
    ## Spieler 1 ist A , Spieler 2 ist B , wenn ihr später rnd zuordnung macht evtl nochmal anfassen
    ## falls dem so ist, die 0 & 1 unten durch die suche nach A und B tauschen
    ## index = 0 if group.get_player()[0].role == C.A_ROLE else 1
    ## und dann 0 und 1 durch index und 1-index ersetzen

    #determine who is who
    player1A = True
    if group.get_players()[0].role == C.B_ROLE:
        player1A = False
    embezzle = False
    report = True

    if player1A: #A Spieler ist an Stelle 0
        group.get_players()[0].donation_b_silence = group.get_players()[1].donation_b_silence
        group.get_players()[1].donation_a = group.get_players()[0].donation_a

        if group.get_players()[0].donation_a == False:
            embezzle=True
        if group.get_players()[0].donation_b_silence == True:
            report = False
    else: #B Spieler ist an Stelle 0
        group.get_players()[1].donation_b_silence = group.get_players()[0].donation_b_silence
        group.get_players()[0].donation_a = group.get_players()[1].donation_a
        if group.get_players()[0].donation_a==False:
            embezzle = True
        if group.get_players()[0].donation_b_silence == True:
            report = False

    group.donation_amount = C.DONATION_BUDGET
    for player in group.get_players():
        player.payoff = cu(0) ## kriegen erstmal nix
        player.team_embezzle = embezzle
        player.team_penalty = embezzle and report
        #um nullwerte zu vermeiden werden die Variablen beider Spieler belegt
        #if player.id_in_group == 1:
            #player.donation_b_silence = report
        #else: #ID ist 2
            #.donation_a=embezzle
        #print("Gruppe" + player.group + " , embezzle: " + embezzle + ", wb: " + report)
        ## nur zum zählen
        if embezzle and not report:
            player.subsession.amount_embezzling_succeeds += 1/2 ## wird ja 2mal gezählt
        ## HIER PAYOFF
        if embezzle: ## nur wenn unterschlagen wird passiert überhaupt was
            if report: ## und gemeldet
                player.payoff = -(C.PENALTY_BUDGET_A if player.role == C.A_ROLE else C.PENALTY_BUDGET_B)
            else: ## stillschweigend
                if player.role==C.A_ROLE:
                    player.payoff = C.EMBEZZLE_BUDGET
                    group.donation_amount -= C.EMBEZZLE_BUDGET
        #calculate total donation: maximum donation possible minus how many times of embezzlement
        player.session.total_donation = (len(player.subsession.get_groups()) * C.DONATION_BUDGET) - (player.subsession.amount_embezzling_succeeds * C.EMBEZZLE_BUDGET)
        #bonus für Einschätzungen ermitteln
        if not player.subsession.TREATMENT==C.TREATMENTS_NAMES[2]: #für control und T1
            if player.role == C.A_ROLE and player.estimate_correct==-1: #noch nicht berechnet
                player.participant.vars['playertype'] = 'A' #nochmals zur Sicherheit
                player.estimate_correct=0
                if player.majority_view_honesty_A==player.subsession.majority_A:
                    player.payoff += C.ESTIMATE_CORRECT_BUDGET
                    player.estimate_correct=1
            elif player.role == C.B_ROLE and player.estimate_correct==-1: #noch nicht für B berechnet
                player.participant.vars['playertype'] = 'B'  # nochmals zur Sicherheit
                player.estimate_correct=0
                if player.majority_view_wb_B == player.subsession.majority_B:
                    player.payoff +=C.ESTIMATE_CORRECT_BUDGET
                    player.estimate_correct=1
        else: #T2
            if player.role == C.A_ROLE and player.estimate_correct==-1: #noch nicht berechnet
                player.estimate_correct=0
                if player.majority_view_honesty_AT2==player.subsession.majority_AT2:
                    player.payoff += C.ESTIMATE_CORRECT_BUDGET
                    player.estimate_correct=1
            elif player.role == C.B_ROLE and player.estimate_correct==-1: #noch nicht für B berechnet
                player.estimate_correct=0
                if player.majority_view_wb_BT2 == player.subsession.majority_BT2:
                    player.payoff +=C.ESTIMATE_CORRECT_BUDGET
                    player.estimate_correct=1
        player.participant.estimate_correct = player.estimate_correct
# count majority vote if in according treatment
def countVotes (group: Group):
    if group.subsession.TREATMENT in C.TREATMENTS_NAMES:
        allplayers = group.subsession.get_players()
        counterA_embezzle = 0
        counterA_nonembezzle=0
        counterB_wb = 0
        counterB_nonwb=0
        numA_embezzle = 0
        numA_nonembezzle = 0
        numB_wb = 0
        numB_nonwb=0
        for p in allplayers:
            if p.role == C.A_ROLE: #A-players
                if p.honesty_A == 2:
                    counterA_embezzle = counterA_embezzle+1
                else:
                    counterA_nonembezzle = counterA_nonembezzle+1
                if p.donation_a:
                    numA_nonembezzle = numA_nonembezzle+1
                else:
                    numA_embezzle = numA_embezzle+1
            else: #B-players
                #p.role == C.B_ROLE:  # B-players
                if p.wb_B == 1:
                    counterB_wb = counterB_wb + 1
                else:
                    counterB_nonwb = counterB_nonwb + 1

                if p.donation_b_silence:
                    numB_nonwb_wb = numB_nonwb + 1
                else:
                    numB_wb = numB_wb + 1
        #majority ermitteln
        #role A
        if counterA_embezzle > counterA_nonembezzle:
            group.subsession.majority_A = 2
        elif counterA_embezzle < counterA_nonembezzle:
            group.subsession.majority_A = 1
        else:
            group.subsession.majority_A = 0

        if numA_embezzle > numA_nonembezzle:
            group.subsession.majority_AT2 = 2
        elif numA_embezzle<numA_nonembezzle:
            group.subsession.majority_AT2 = 1
        else:
            group.subsession.majority_AT2 = 0
        # role B
        if counterB_wb > counterB_nonwb:
            group.subsession.majority_B = 1
        elif counterB_wb < counterB_nonwb:
            group.subsession.majority_B = 2
        else:
            group.subsession.majority_B = 0

        if numB_wb > numB_nonwb:
            group.subsession.majority_BT2 = 1
        elif numB_wb < numB_nonwb:
            group.subsession.majority_BT2 = 2
        else:
            group.subsession.majority_BT2 = 0

#hier die Rollen Spieler 1 und 2 vergeben
def setSpielerRole (group:Group):
    #einfache Regel wenn ID=1 dann Spieler 1, sonst Spieler 2
    #aufrufen sobald die neuen Gruppen zusammengestellt wurden
    for player in group.get_players():
        player.participant.vars['spieler'] = 'Spieler2'
        if player.id_in_group==1:
            player.Spieler1=True
            player.participant.vars['spieler'] = 'Spieler1'





        # PAGES
class Donation_Decision_A(Page):
    form_model = 'player'
    form_fields = ['donation_a']
    @staticmethod
    def is_displayed(player: Player):
        if player.role == C.A_ROLE:
            player.FirstPartA = True ## nur zum speichern
        return player.role == C.A_ROLE

    def vars_for_template(player: Player):
        return dict(
            control=player.subsession.TREATMENT=='Control',
            t2=player.subsession.TREATMENT=='T2',
        )

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        ## zum zählen nur
        if player.role == C.A_ROLE:
            player.subsession.amount_possible_donations +=1
            if player.donation_a:
                player.subsession.amount_real_donations += 1
            else:
                player.subsession.amount_embezzling_tries += 1
class Donation_Decision_B(Page):
    form_model = 'player'
    form_fields = ['donation_b_silence']
    @staticmethod
    def is_displayed(player: Player):
        return player.role == C.B_ROLE
    def vars_for_template(player: Player):
        return dict(
            control=player.subsession.TREATMENT=='Control',
            t2=player.subsession.TREATMENT == 'T2',
        )

class Questionaire_A(Page):
    form_model = 'player'
    form_fields = ['honesty_A', 'majority_view_honesty_A', 'majority_action_A']
    @staticmethod
    def is_displayed(player: Player): #nur anzeigen in Control und T1
        return not player.subsession.TREATMENT == C.TREATMENTS_NAMES[2] and player.role == C.A_ROLE

class Questionaire_AT2(Page):
    form_model = 'player'
    form_fields = ['honesty_A', 'majority_view_honesty_AT2']
    @staticmethod
    def is_displayed(player: Player): #nur anzeigen in T2
        return player.subsession.TREATMENT == C.TREATMENTS_NAMES[2] and player.role == C.A_ROLE

class Questionaire_B(Page):
    form_model = 'player'
    form_fields = ['wb_B','majority_view_wb_B','majority_action_B']
    @staticmethod
    def is_displayed(player: Player):## Nur control und T1
        return not player.subsession.TREATMENT == C.TREATMENTS_NAMES[2]  and player.role == C.B_ROLE

class Questionaire_BT2(Page):
    form_model = 'player'
    form_fields = ['wb_B','majority_view_wb_BT2']
    @staticmethod
    def is_displayed(player: Player):## Nur T2
        return player.subsession.TREATMENT == C.TREATMENTS_NAMES[2]  and player.role == C.B_ROLE

class Donation_Payoff_Waitpage(WaitPage):
    ## Hier die ganze berechnung machen
    ##auf alle Gruppen warten und dann erst berechnung machen
    wait_for_all_groups = True
    @staticmethod
    def after_all_players_arrive(subsession: Subsession):
        for g in subsession.get_groups():
            countVotes(g)
            fill_control_variables_set_payoff(g)
    def vars_for_template(player: Player):
        return dict (
            body_text = 'Bitte warten Sie, bis Ihre(e) Teampartner*in ihre/seine Entscheidung und Einschätzungen eingegeben hat.',
        )

class Intermediate_Result(Page):
    @staticmethod
    def vars_for_template(player: Player):
        return dict(
            donated = player.donation_a,
            silenced = player.donation_b_silence, ##für jeden player donation_a und donation_b_silence gespeichert, daher einfach übergeben
            myroleA = player.role==C.A_ROLE,
            #mycorrect = player.estimate_correct kommunizieren wir erst ganz am Ende des Experiments
        )



class GroupMatchingPart2(WaitPage):
    wait_for_all_groups = True
    #def after_all_players_arrive(group: Group):
       # if group.get_players()[0].id_in_group == 1 and group.id_in_subsession == 1:
          #  group.subsession.set_group_matrix(rearrange_group_matrix(group.subsession.get_group_matrix()))
    def after_all_players_arrive(subsession: Subsession):
        if subsession.matched_new == False:
            print(subsession.get_group_matrix())
            subsession.set_group_matrix(rearrange_group_matrix(subsession.get_group_matrix()))
            #for p in subsession.get_players():
                #p.role=p.participant.vars['playertype'] funzt net
            #subsession.group_randomly(fixed_id_in_group=True)
            print(subsession.get_group_matrix())
            subsession.session.vars['mymatrix'] = subsession.get_group_matrix()
            subsession.matched_new=True


class RoleMatchingPart2(WaitPage): #nachdem neue 2er Gruppen zusammgengestellt wurden, Spieler 1 und 2 zuordnen
    @staticmethod
    def after_all_players_arrive(group: Group):
        setSpielerRole(group)
    def vars_for_template(player: Player):

        return dict(
            body_text="Bitte warten Sie, bis die neuen Gruppen und Rollen zusammengestellt werden."
        )

class Part2_Info(Page):
    @staticmethod
    def is_displayed(player: Player):
        return True
    def vars_for_template(player: Player):
        return dict(
            control=player.subsession.TREATMENT == 'Control'
        )


#Ergebnis anzeigen was Spieler*in entschieden hat
class ResultDecision(Page):
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] #ist nur einer
        local_decision = False
        if player2.playertype == C.A_ROLE:
            local_decision=player2.donation_a
        else:
            local_decision=player2.donation_b_silence

        return dict(
            myrole1=player.Spieler1,
            together = player.second_task_together,
            mytypeA = player.playertype==C.A_ROLE,
            otherDec = local_decision,
            control = player.subsession.TREATMENT=='Control'
        )

#Variablen setzen wenn Spieler*in 1 entschieden hat
class Decision_Con(WaitPage):
    def after_all_players_arrive(group: Group):
            player1 = group.get_players()[0]
            player2 = group.get_players()[1]
            if not player1.subsession.TREATMENT=='Control': #Treatments T1 und T2
                if player1.playertype==C.A_ROLE:
                    if player2.donation_a == False:
                        player1.second_task_together = player2.second_task_together = bool(player1.DecA_embezzle)
                    else:
                        player1.second_task_together = player2.second_task_together = bool(player1.DecA_nonembezzle)
                else: #B-Players
                    if player2.donation_b_silence == False:
                        player1.second_task_together = player2.second_task_together = bool(player1.DecB_wb)
                    else:
                        player1.second_task_together = player2.second_task_together = bool(player1.DecB_nonwb)
            else: #Treatment Control
                player1.second_task_together = player2.second_task_together = bool(player1.DecAB)

            player1.participant.count_numbers_together = player1.second_task_together
            player1.session.second_time_counting = True
            player1.session.params['second_time_counting'] = True
            player2.participant.count_numbers_together = player2.second_task_together
            player2.session.second_time_counting = True #braucht man eigentlich nicht mehr weil es eine session variable ist, aber zur Sicherheit
            player2.session.params['second_time_counting'] = True

    def vars_for_template(player: Player):

        return dict(
            body_text="Bitte warten Sie, bis in allen Teams die jeweiligen Entscheidungen getroffen wurden."
        )

#für Spieler A und B
class Decision_S1A(Page):
    form_model = 'player'
    form_fields = ['DecA_embezzle', 'DecA_nonembezzle']
    def is_displayed (player:Player):
        return player.Spieler1 and player.playertype==C.A_ROLE and not player.subsession.TREATMENT=='Control'
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] ##2er gruppen ist nur der andere

        return dict(
            control = player.subsession.TREATMENT,
            secondpart = secondpart(player,player2)
        )

class Decision_S1ACon(Page):
    form_model = 'player'
    form_fields = ['DecAB']
    def is_displayed (player:Player):
        return player.Spieler1 and player.playertype==C.A_ROLE and player.subsession.TREATMENT=='Control'
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] ##2er gruppen ist nur der andere

        return dict(
            control = player.subsession.TREATMENT,
            secondpart = secondpart(player,player2)
        )

class Decision_S1B(Page):
    form_model = 'player'
    form_fields = ['DecB_wb', 'DecB_nonwb']
    def is_displayed (player:Player):
        return player.Spieler1 and player.playertype==C.B_ROLE and not player.subsession.TREATMENT=='Control'
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] ##2er gruppen ist nur der andere

        return dict(
            control = player.subsession.TREATMENT,
            secondpart = secondpart(player,player2)
        )
    #brauchen wir nicht mehr: auch für Spieler A nicht mehr
   # def before_next_page(player: Player, timout_happened):
       # player2 = player.get_others_in_group()[0]
        #if player2.donation_b_silence==False:
         #   player.second_task_together=player2.second_task_together=bool (player.DecB_wb)
        #else:
         #   player.second_task_together = player2.second_task_together = bool(player.DecB_nonwb)
       # player.participant.count_numbers_together = player.second_task_together
        #player.session.second_time_counting = True
        #player2.participant.count_numbers_together = player2.second_task_together
        #player2.session.second_time_counting = True

class Decision_S1BCon(Page):
    form_model = 'player'
    form_fields = ['DecAB']
    def is_displayed (player:Player):
        return player.Spieler1 and player.playertype==C.B_ROLE and player.subsession.TREATMENT=='Control'
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] ##2er gruppen ist nur der andere

        return dict(
            control = player.subsession.TREATMENT,
            secondpart = secondpart(player,player2)
        )

#für Spieler 2
class Info_S2(Page):
    @staticmethod
    #def before_next_page(player: Player, timeout_happened):
        #player2 = player.get_others_in_group()[0] ##2er gruppe wieer
        #player.second_task_together = player2.second_task_together ##hier nur für eure auswertung
        #player.participant.count_numbers_together = player.second_task_together #abhängig von der entscheidung
        #player.session.second_time_counting = True
    def is_displayed(player: Player):
        return player.Spieler1==False

class Player_wait_stage(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        pass
    def vars_for_template(player: Player):
        return dict (body_text= "Bitte warten Sie bis die Rollen in Ihrem Team zugeordnet wurden.")



page_sequence = [Player_wait_stage, Donation_Decision_A, Donation_Decision_B, Questionaire_A,Questionaire_B, Questionaire_AT2,Questionaire_BT2,
                 Donation_Payoff_Waitpage,Intermediate_Result,Part2_Info,
                    GroupMatchingPart2,RoleMatchingPart2,Decision_S1A,Decision_S1ACon, Decision_S1B,Decision_S1BCon, Info_S2, Decision_Con, ResultDecision]