from otree.api import *


doc = """
Your app description
"""



class C(BaseConstants):
    NAME_IN_URL = 'WB_Norm_Appropriateness_Part2'
    PLAYERS_PER_GROUP = 2
    NUM_ROUNDS = 1
    #wenn XXX_ROLE legt otree automatische player variable role an
    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
    TREATMENTS_NAMES = ['Control', 'T1', 'T2', 'T3'] #T1: message wb/non embezzle; T2: message remaining silent/ embezzle; T3: message wb + non-embezzle + remaining silent + embezzle
    TEAM_PAYOFF = cu(1.5)
    SOLO_PAYOFF = cu(1.2)


class Subsession(BaseSubsession):
    TREATMENT = models.StringField(initial='Control')
    matched_new = models.BooleanField(initial=False)


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    my_wrongdoing = models.BooleanField(initial=False)
    my_wb = models.BooleanField(initial=False)
    playertype = models.StringField()
    Spieler1 = models.BooleanField(initial=False)
    second_task_together = models.BooleanField(initial=False)

    # Spieler A
    TeamDecision_A_Player1 = models.BooleanField(
        label='',
        choices=[
            [True, 'Accept Player 2 as a team member'],
            [False, 'Not build a team with Player 2']
        ],
        widget=widgets.RadioSelectHorizontal

    )

    # Spieler B
    TeamDecision_B_Player1 = models.BooleanField(
        label='',
        choices=[
            [True, 'Accept Player 2 as a team member'],
            [False, 'Not build a team with Player 2']
        ],
        widget=widgets.RadioSelectHorizontal

    )




def find_transition_index(array):
    for i,element in enumerate(array):
        if not isinstance(element, list):
            return i
    return -1
def creating_session(subsession):
    subsession.TREATMENT = 'Control' #damit es nicht Null

    if 'wb_treatment' in subsession.session.config:
        subsession.TREATMENT = subsession.session.config['wb_treatment']

    subsession.matched_new = False
    subsession.session.second_time_counting = True

#sobald 4 Spieler da sind, soll gestartet werden
def group_by_arrival_time_method(subsession, waiting_players):
    a_players = [p for p in waiting_players if p.participant.playertype == 'A']
    b_players = [p for p in waiting_players if p.participant.playertype == 'B']
    new_group_id = find_transition_index(subsession.get_group_matrix())
    if len(a_players) >= 2:
        print('A group created')

        return [a_players[0], a_players[1]]

    if len(b_players) >= 2:
        print('B group created')

        return [b_players[0], b_players[1]]

    #subsession.session.vars['mymatrix'] = subsession.get_group_matrix()
    print('not enough players yet to create a group')

#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.playertype = player.participant.vars['playertype'] #nochmals zur Sicherheit
        #player.role = player.playertype #nochmals zur Sicherheit
        player.participant.vars['spieler'] = 'Spieler2'
        player.participant.vars['group_id'] = player.group.id_in_subsession #notwendig für WB_Norm_Appropriateness
        player.my_wrongdoing = player.participant.vars['player_embezzle'] #daten holen von Entscheidung
        player.my_wb = player.participant.vars['player_wb'] #Daten holen von Entscheidung
        if player.id_in_group==1:
            player.Spieler1=True
            player.participant.vars['spieler'] = 'Spieler1'

def rememberGroupForCounting(group):
    for player in group.get_players():
        player.participant.matched_before = group.id_in_subsession
# PAGES
class MyPage(Page):
    pass


class ResultsWaitPage(WaitPage):
    pass


class Results(Page):
    pass

class GroupMatchingPart2(WaitPage):
    group_by_arrival_time = True
    body_text = "Wait until the group gets matched and the roles assigned"


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

        return dict(
            body_text="Please wait until the roles in your group get assigned."
        )

#für Spieler A und B
class Decision_S1A(Page):
    form_model = 'player'
    form_fields = ['TeamDecision_A_Player1']
    def is_displayed (player:Player):
        return player.Spieler1 and player.playertype==C.A_ROLE
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] ##2er gruppen ist nur der
        action_Part_I = 'In Part I of the experiment, Player 2 decided to keep part of the donation budget.'
        if (player2.my_wrongdoing==False):
            action_Part_I = 'In Part I of the experiment, Player 2 decided to transfer the full donation budget.'

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

class Decision_S1B(Page):
    form_model = 'player'
    form_fields = ['TeamDecision_B_Player1']
    def is_displayed (player:Player):
        return player.Spieler1 and player.playertype==C.B_ROLE
    @staticmethod
    def vars_for_template(player: Player):
        player2 = player.get_others_in_group()[0] ##2er gruppen ist nur der andere
        action_Part_I = 'In Part I of the experiment, Player 2 decided to report the group partner.'
        if (player2.my_wb == False):
            action_Part_I = 'In Part I of the experiment, Player 2 decided to overlook the decision of the group partner.'

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

# Variablen setzen wenn Spieler*in 1 entschieden hat
class Process_Decision(WaitPage):
    def after_all_players_arrive(group: Group):
        player1 = group.get_players()[0]
        player2 = group.get_players()[1]

        if player1.playertype == C.A_ROLE:
            player1.second_task_together = player2.second_task_together = player1.TeamDecision_A_Player1
        else:  # B-Players
            player1.second_task_together = player2.second_task_together = player1.TeamDecision_B_Player1


        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="Please wait until your group can continue."
        )


#Ergebnis anzeigen was Spieler*in entschieden hat
class ResultDecision(Page):
    @staticmethod
    def vars_for_template(player: Player):

        return dict(
            myrole1=player.Spieler1,
            together = player.second_task_together,

        )

class BeforeNextApp(WaitPage):
    @staticmethod
    def after_all_players_arrive(group):
        for p in group.get_players():
            p.participant.matched_before = group.id_in_subsession

    @staticmethod
    def is_displayed(player):
        return player.round_number == C.NUM_ROUNDS
#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 not player.Spieler1



page_sequence = [GroupMatchingPart2, RoleMatchingPart2, Decision_S1A,Decision_S1B, Info_S2, Process_Decision, ResultDecision, BeforeNextApp]