from otree.api import Currency as c, currency_range
from ._builtin import Page, WaitPage
from .models import Constants
import random


class Exeriment_ID(Page):
    form_model = "player"
    form_fields = ["Experiment_ID"]


class Instructions(Page):
    pass


class Instructions_Wait(WaitPage):
    def after_all_players_arrive(self):
        print("-------------------------------------------------------------------")
        print(
            "A new session has started, and everyone has read the generell instructions"
        )
        print("-------------------------------------------------------------------")
        pass


class Task1_Instructions(Page):
    pass


class Task1_Instructions_Wait(WaitPage):
    def after_all_players_arrive(self):
        pass

class Task1_solved(Page):
    form_model = "player"
    form_fields = ["Nsolved1NEW"]

    def before_next_page(self):
        player = self.player
        player.payout_round1 = player.Nsolved1NEW * Constants.Win_rate_Self_tournament / 2
        pass


class Task1_Wait(WaitPage):
    def after_all_players_arrive(self):
        print("Another groups has finished Task 1")
        pass


class Task2_Instructions(Page):
    pass


class Task2_Instructions_Wait(WaitPage):
    def after_all_players_arrive(self):
        pass


class Task2_solved(Page):
    form_model = "player"
    form_fields = ["Nsolved2NEW"]

    def before_next_page(self):
        # moved into task2_wait to determin all calculation for task2
        pass


class Task2_Wait(WaitPage):
    def after_all_players_arrive(self):
        print("Another groups has finished Task 2")
        if Constants.players_per_group > 2:
            print(
                "Error: Fehleinstellung: More than 2 players in group -> coinflip fehlergebnis für alle anderen"
            )

        # lets do one coinflip for all...
        p1 = self.group.get_player_by_id(1)
        p1.coinflip_if_equal_task2 = random.randint(0, 1)
        p2 = self.group.get_player_by_id(2)

        # coinflip des anderen Spielers invertieren
        if p1.coinflip_if_equal_task2:
            p2.coinflip_if_equal_task2 = 0
        else:
            p2.coinflip_if_equal_task2 = 1

        # when jedoch coinflip ausgeschaltet
        if Constants.coinflip == 0:
            p1.coinflip_if_equal_task2 = 0.5
            p2.coinflip_if_equal_task2 = 0.5

        # Gegnerische Werte notieren:
        # Constante compete_against_current muss 1 um gegen die aktuellen werte des gegners zu gehen
        # ansonsten geht es gegen vorhergehene werte
        if Constants.compete_against_current == 1:
            p1.OpponentSolved2 = p2.Nsolved2NEW
            p2.OpponentSolved2 = p1.Nsolved2NEW
        else:
           p1.OpponentSolved2 = p2.Nsolved1NEW
           p2.OpponentSolved2 = p1.Nsolved1NEW

        # payouts berechnen (Vorwert = -1) next should select payout as solved * tournament rate if won, what if equal, 0 if lost
        if p1.Nsolved2NEW > p1.OpponentSolved2:
            p1.payout_round2 = p1.Nsolved2NEW * Constants.Win_rate_Self_tournament
        elif p1.Nsolved2NEW == p1.OpponentSolved2:
            p1.payout_round2 = (
                p1.Nsolved2NEW
                * Constants.Win_rate_Self_tournament
                * p1.coinflip_if_equal_task2
            )
	    # Da jetzt der Coinflip tatsächlich relevant wird passen wir die Texte an:
            # TExt kann nach Chinesisch übersetzt werden hier aber dann auch unten!!!
            if Constants.coinflip == 0:
                p1.Coinflip_task2 = "Equal - Pot splits 50:50"
            elif p1.coinflip_if_equal_task2 == 1:
                p1.Coinflip_task2 = "You won Coinflip."
            else:
                p1.Coinflip_task2 = "You lost Coinflip"
        else:
            p1.payout_round2 = 0

        if p2.Nsolved2NEW > p2.OpponentSolved2:
            p2.payout_round2 = p2.Nsolved2NEW * Constants.Win_rate_Self_tournament
        elif p2.Nsolved2NEW == p2.OpponentSolved2:
            p2.payout_round2 = (
                p2.Nsolved2NEW
                * Constants.Win_rate_Self_tournament
                * p2.coinflip_if_equal_task2
            )
            # Da jetzt der Coinflip tatsächlich relevant wird passen wir die Texte an:
            # TExt kann nach Chinesisch übersetzt werden hier aber dann auch unten!!!
            if Constants.coinflip == 0:
                p2.Coinflip_task2 = "Equal - Pot splits 50:50"
            elif p2.coinflip_if_equal_task2 == 1:
                p2.Coinflip_task2 = "You won Coinflip."
            else:
                p2.Coinflip_task2 = "You lost Coinflip"
        else:
            p2.payout_round2 = 0

class Task3_Instructions(Page):
     form_model = "player"
     form_fields = ["Choice"]   




class Choice_For_Task3(Page):


    def before_next_page(self):

        if self.player.Choice == "2":
            self.player.Choice_boolean_is_tournament = True
        elif self.player.Choice == "1":
            self.player.Choice_boolean_is_tournament = False
        else:
            print(
                " Error in task Choice for task3! Value is not one of the two allowed Values, or Values have been changed but not in the code"
            )

        pass


class Task3_Instructions_Wait(WaitPage):
    def after_all_players_arrive(self):
        pass


class Task3_solved(Page):
    form_model = "player"
    form_fields = ["Nsolved3NEW"]


class WaitPageResults(WaitPage):
    wait_for_all_groups = True

    def after_all_players_arrive(self):

        print("All groups have finished Task3")

        if Constants.players_per_group > 2:
            print(
                "Error: Fehleinstellung: More than 2 players in group -> coinflip fehlergebnis für alle anderen"
            )

        # Alle Gruppen landen hier gleichzeitg wir müssen alle Gruppen durchgehen:
        # DAHER EINZUG ÜBER ALLES WEITERE!!!
        for party in self.subsession.get_groups():
            print("Another groups has finished Task 2")

            # lets do one coinflip for all IN CURRENT GROUP
            p1 = party.get_player_by_id(1)
            p1.coinflip_if_equal_task3 = random.randint(0, 1)
            p2 = party.get_player_by_id(2)

            # coinflip des anderen Spielers invertieren
            if p1.coinflip_if_equal_task3:
                p2.coinflip_if_equal_task3 = 0
            else:
                p2.coinflip_if_equal_task3 = 1
	    
            # when jedoch coinflip ausgeschaltet
            if Constants.coinflip == 0:
                p1.coinflip_if_equal_task3 = 0.5
                p2.coinflip_if_equal_task3 = 0.5


            # Gegnerische Werte notieren:
            # Constante compete_against_current muss 1 um gegen die aktuellen werte des gegners zu gehen
            # ansonsten geht es gegen vorhergehene werte
            if Constants.compete_against_current == 1:
                 p1.OpponentSolved3 = p2.Nsolved3NEW
                 p2.OpponentSolved3 = p1.Nsolved3NEW
            else:
                 p1.OpponentSolved3 = p2.Nsolved2NEW
                 p2.OpponentSolved3 = p1.Nsolved2NEW

            # payouts berechnen
            # if choice piecerate like task1
            if p1.Choice == "1":
                p1.payout_round3 = p1.Nsolved3NEW * Constants.Win_rate_Piecerate
            if p2.Choice == "1":
                p2.payout_round3 = p2.Nsolved3NEW * Constants.Win_rate_Piecerate

            # bei tournament wahl genau dasselbe wie unter task 2 aber nur für den der das auch gewählt hat
            if p1.Choice == "2":
                if p1.Nsolved3NEW > p1.OpponentSolved3:
                    p1.payout_round3 = p1.Nsolved3NEW * Constants.Win_rate_Self_tournament
                elif p1.Nsolved3NEW == p1.OpponentSolved3:
                    p1.payout_round3 = (
                        p1.Nsolved3NEW
                        * Constants.Win_rate_Self_tournament
                        * p1.coinflip_if_equal_task3
                    )
                    # Da jetzt der Coinflip tatsächlich relevant wird passen wir die Texte an:
                    # TExt kann nach Chinesisch übersetzt werden hier aber dann auch unten!!!
                    if Constants.coinflip == 0:
                        p1.Coinflip_task3 = "Equal - Pot splits 50:50"
                    elif p1.coinflip_if_equal_task3 == 1:
                        p1.Coinflip_task3 = "You won Coinflip."
                    else:
                        p1.Coinflip_task3 = "You lost Coinflip"
                else:
                    p1.payout_round3 = 0
                  
            if p2.Choice == "2":
                if p2.Nsolved3NEW > p2.OpponentSolved3:
                    p2.payout_round3 = p2.Nsolved3NEW * Constants.Win_rate_Self_tournament
                elif p2.Nsolved3NEW == p2.OpponentSolved3:
                    p2.payout_round3 = (
                        p2.Nsolved3NEW
                        * Constants.Win_rate_Self_tournament
                        * p2.coinflip_if_equal_task3
                    )
                    # Da jetzt der Coinflip tatsächlich relevant wird passen wir die Texte an:
                    # TExt kann nach Chinesisch übersetzt werden hier aber dann auch unten!!!
                    if Constants.coinflip == 0:
                        p2.Coinflip_task3 = "Equal - Pot splits 50:50"
                    elif p2.coinflip_if_equal_task3 == 1:
                        p2.Coinflip_task3 = "You won Coinflip."
                    else:
                        p2.Coinflip_task3 = "You lost Coinflip"
                else:
                    p2.payout_round3 = 0
                pass
                    
            # Select wish round gets payed
            p1.paying_round = random.randint(1, Constants.num_tasks)
            p2.paying_round = random.randint(1, Constants.num_tasks)

            if p1.paying_round == 1:
                p1.participant.payoff=p1.payout_round1
            if p1.paying_round == 2:
                p1.participant.payoff=p1.payout_round2
            if p1.paying_round == 3:
                p1.participant.payoff = p1.payout_round3

            if p2.paying_round == 1:
                p2.participant.payoff=p2.payout_round1
            if p2.paying_round == 2:
                p2.participant.payoff=p2.payout_round2
            if p2.paying_round == 3:
               p2.participant.payoff = p2.payout_round3

            # Here endet die Forschleife
        pass


class Compensation(Page):
    pass


page_sequence = [
    Exeriment_ID,    
    Instructions,
    Instructions_Wait,
    Task1_Instructions,
    Task1_Instructions_Wait,
    Task1_solved,
    Task1_Wait,
    Task2_Instructions,
    Task2_Instructions_Wait,
    Task2_solved,
    Task2_Wait,
    Task3_Instructions,
    Choice_For_Task3,
    Task3_Instructions_Wait,
    Task3_solved,
    WaitPageResults,
    Compensation,
]