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

#Startseite (für alle Versuchsgruppen)
class Start(Page):
    form_model = 'player'

    def is_displayed(self):
        return self.round_number == 1

    # Nach Verlassen der Startseite werden die später benötigten Zeiten generiert
    def before_next_page(self):
        self.participant.vars['MaxDauerZeit'] = time.time() + 30 * 60
        self.participant.vars['DauerAnzahl'] = time.time() + 15 * 60
        self.participant.vars['Startzeit'] = time.time()


import time

# Aufgabenseite der Versuchsgruppe Anzahl (bestehend aus Anzahl und AnzahlPeer)
class Anzahl(Page):
    form_model = 'player'
    form_fields = ['count']
    timer_text = 'Verbleibende Bearbeitungszeit:'

    def get_timeout_seconds(self):
        return self.participant.vars['DauerAnzahl'] - time.time()

    def is_displayed(self):
        return self.get_timeout_seconds() > 3 and (self.participant.vars['treatment'] == "Anzahl" or self.participant.vars['treatment'] == "AnzahlPeer")

    def vars_for_template(self):
        return dict(
            eintrag=self.session.vars[self.round_number + 200]
        )

    def js_vars(self):
        return dict(
            current_round_correct_answer=self.session.vars[self.round_number],
            round_number = self.round_number
        )

    # Vor Erreichen der Bezahlseite werden die Methoden check_count(), count_correct_rounds() aufgerufen. Außerdem
    # wird die tatsächlich benötigte Zeit berechnet.
    def before_next_page(self):
        self.player.check_count()
        self.player.count_correct_rounds()
        self.player.RichtigeZeit = time.time()-self.participant.vars['Startzeit']
        self.participant.vars['TatsächlichDauerZeit']= int(round(time.time()-self.participant.vars['Startzeit'] , 0))



# Aufgabenseite der Versuchsgruppe Zeit (bestehend aus Zeit und ZeitPeer)
class Zeit(Page):
    form_model = 'player'
    form_fields = ['count']

    def get_timeout_seconds(self):
        return self.participant.vars['MaxDauerZeit'] - time.time()

    # Wenn 30 Aufgaben bearbeitet wurden, wird die Seite nicht mehr angezeigt und die Spieler:innen gelangen auf die Bezahlseite
    def is_displayed(self):
       if self.round_number == 1:
            return self.get_timeout_seconds() > 3 and (self.participant.vars['treatment'] == "Zeit" or self.participant.vars['treatment'] == "ZeitPeer")
       if self.round_number > 30:
           return False
       else:
            return self.get_timeout_seconds() > 3 and (self.participant.vars['treatment'] == "Zeit" or self.participant.vars['treatment'] == "ZeitPeer")

    def vars_for_template(self):
            return dict(
                eintrag=self.session.vars[self.round_number + 200]
            )

    def js_vars(self):
        return dict(
            current_round_correct_answer=self.session.vars[self.round_number],
            round_number=self.round_number
        )

    # Vor Erreichen der Bezahlseite werden die Methoden check_count() und count_correct_rounds() aufgerufen. Außerdem
    # wird die tatsächlich benötigte Zeit berechnet.
    def before_next_page(self):
        self.player.check_count()
        self.player.count_correct_rounds()
        self.player.RichtigeZeit = time.time()-self.participant.vars['Startzeit']
        self.participant.vars['TatsächlichDauerZeit']= int(round(time.time()-self.participant.vars['Startzeit'],0))



# Wartseite für Versuchsgruppe ZeitPeer, falls eine/einer der beiden Proband:innen früher mit der Bearbeitung der
# 30 Aufgaben fertig ist, so dass beide gleichzeitig auf die Bezahlseite gelangen
class MyWaitPage (WaitPage):
    template_name = 'Anzahl/MyWaitPage.html'
    def is_displayed(self):
        return self.round_number == Constants.num_rounds and (self.participant.vars['treatment'] == "ZeitPeer")



#In der letzten Fassung des Experiments nicht mehr verwendete Seite für Feedback nach jeder Runde (Das Feedback wird nun
# auf der jeweiligen Aufgabenseite gezeigt)
class ZwischenErgebnis(Page):
    def get_timeout_seconds1(self):
        return self.participant.vars['MaxDauerZeit'] - time.time()

    def get_timeout_seconds2(self):
        return self.participant.vars['DauerAnzahl'] - time.time()

    def is_displayed(self):
        if (self.participant.vars['treatment'] == "Zeit" or self.participant.vars['treatment'] == "ZeitPeer"):
            return (self.round_number <= 30) and (self.get_timeout_seconds1() > 3)
        if (self.participant.vars['treatment'] == "Anzahl" or self.participant.vars['treatment'] == "AnzahlPeer"):
            return self.get_timeout_seconds2() > 3

    def vars_for_template(self):
        return dict(
            player=self.player
        )



# In der letzten Fassung des Experiments nicht mehr verwendete Seite, die die Ergebnisse aus allen Runden zusammenfasst
class Results(Page):
    def is_displayed(self):
        return self.round_number == Constants.num_rounds

    def vars_for_template(self):
        return dict(
            number_of_rounds_played=self.round_number,
            total_payoff=sum([p.payoff for p in self.player.in_all_rounds()]),
            player_in_all_rounds=self.player.in_all_rounds(),
        )



# Bezahlseite der Versuchsgruppe Anzahl
class BezahlungAnzahl(Page):
    def is_displayed(self):
        return self.round_number == Constants.num_rounds and (self.participant.vars['treatment'] == "Anzahl" or self.participant.vars['treatment'] == "AnzahlPeer")

    form_model = 'player'
    form_fields = ['ergebnisAnzahl']

    def before_next_page(self):
        self.player.bezahlung()



#Bezahlseite der Versuchsgruppe Zeit
class BezahlungZeit(Page):
    def is_displayed(self):
        return self.round_number == Constants.num_rounds and (self.participant.vars['treatment'] == "Zeit" or self.participant.vars['treatment'] == "ZeitPeer")
    
    form_model = 'player'
    form_fields = ['ergebnisZeit']

    def before_next_page(self):
        self.player.bezahlung()



# Fragebogen (für alle Versuchsgruppen)
class Fragebogen(Page):
    form_model = 'player'
    form_fields = ['alter','geschlecht','religion','risikoavers','believeBetrug','beschäftigung']
    def is_displayed(self):
        return self.round_number == Constants.num_rounds


# Methode zum Berechnen der Ausprägungen der Dimensionen des Big Five Persönlichkeitstests
def combine_score(positive, negative):
    return 3 + (positive - negative) / 2


#Seite des Big Five Persönlichkeitstests
class BigFive(Page):
    form_model = 'player'
    form_fields = ['q1', 'q2', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8', 'q9', 'q10']



    def is_displayed(self):
        return self.round_number == Constants.num_rounds


    def before_next_page(self):
        self.player.extraversion = combine_score(self.player.q6, self.player.q1)
        self.player.verträglichkeit = combine_score(self.player.q2, self.player.q7)
        self.player.gewissenhaftigkeit = combine_score(self.player.q8, self.player.q3)
        self.player.neurotizismus = combine_score(self.player.q9, self.player.q4)
        self.player.offenheit = combine_score(self.player.q10, self.player.q5)



# Endseite, auf der Teilnehmer:innen ihre Auszahlung in Euro sehen.
class Ende(Page):
    def is_displayed(self):
        return self.round_number == Constants.num_rounds



# ZwischenErgebnis und Results in Durchführung nicht verwendet
page_sequence = [
    Start,
    Anzahl,
    Zeit,
    #ZwischenErgebnis,
    MyWaitPage,
    BezahlungAnzahl,
    BezahlungZeit,
    Fragebogen,
    BigFive,
    #Results,
    Ende
]