import itertools
import time

from otree.api import *


class Constants(BaseConstants):
    name_in_url = "war_of_attrition2"
    players_per_group = 2
    num_rounds = 2

    len = 100
    starting_money = 100
    payout_stay = -1
    payout_opp_quits = 80

    time_list = [0]


class Subsession(BaseSubsession):
    def creating_session(self):
        self.group_randomly()


class Group(BaseGroup):
    p1_exit = models.BooleanField(initial=False)
    p2_exit = models.BooleanField(initial=False)

    p1_action = models.FloatField()
    p2_action = models.FloatField()

    p1_payout = models.FloatField(initial=100)
    p2_payout = models.FloatField(initial=100)

    flag = models.FloatField(initial=1)

    game_ended = models.BooleanField(initial=False)
    game_started = models.BooleanField(initial=False)

    game_started_at = models.StringField(initial=0)
    game_ended_at = models.StringField(initial=0)

    last_payout_update = models.StringField(initial="0")

    len_round = models.FloatField(initial=0)


def get_state(group: Group):
    return dict(
        p1_payout=group.p1_payout,
        p2_payout=group.p2_payout,
        game_ended=group.game_ended,
    )


class Player(BasePlayer):
    test_p1 = models.IntegerField()
    # Necessary variables for Questions
    payoff_test = models.IntegerField(
        label="Wie hoch ist deine sekündliche Auszahlung wenn beide Spieler im Spiel bleiben?")
    payoff_final = models.IntegerField(
        label="Wie hoch ist die finale Auszahlung wenn du im Spiel bleibst und dein Gegner aussteigt?")
    len_test = models.IntegerField(
        label="Wie lange dauert eine Spielrunde maximal?")
    com_test = models.IntegerField(
        label="Wie lange dauert die Blockade der Austrittsoption an wenn ein Spieler das Commitment verwendet?"
    )

    # Variable to examine the amount of right answers
    right_answers = models.IntegerField(inital=0)


class Button(Page):

    @staticmethod
    def js_vars(player: Player):
        return dict(my_id=player.id_in_group)

    @staticmethod
    def live_method(player: Player, action):
        group = player.group

        if action:
            # if-Sequence to check whether there was only an update
            if action == "UPDATE":
                update_payout(group)

                if group.p1_payout <= 0:
                    group.game_ended = True
                    group.game_ended_at = str(time.time_ns())
                    group.len_round = (int(group.game_ended_at) - int(group.game_started_at)) / 1000000000
                    return {0: "timeout"}
            # if-Sequence for P1
            elif action == "p1_exit":
                group.p1_exit = True
                update_payout(group)
                group.p2_payout = group.p2_payout + 80
                group.p1_payout = round(group.p1_payout)
                group.p2_payout = round(group.p2_payout)
                group.game_ended = True
                group.game_ended_at = str(time.time_ns())
                group.len_round = (int(group.game_ended_at) - int(group.game_started_at)) / 1000000000
                return {0: "p1_exit"}

            # if-Sequence for P2
            elif action == "p2_exit":
                group.p2_exit = True
                update_payout(group)
                group.p1_payout = group.p1_payout + 80
                group.p1_payout = round(group.p1_payout)
                group.p2_payout = round(group.p2_payout)
                group.game_ended = True
                group.game_ended_at = str(time.time_ns())
                group.len_round = (int(group.game_ended_at) - int(group.game_started_at)) / 1000000000
                return {0: "p2_exit"}

        return {0: get_state(group)}


class Results(Page):
    @staticmethod
    def before_next_page(player, timeout_happened):
        if player.id_in_group == 1:
            update_payout(player.group)


class Treatment(Page):
    pass


def update_payout(group: Group):
    if group.game_started == False or group.game_ended == True:
        return

    now = time.time_ns()

    last_payout_update = group.last_payout_update

    group.last_payout_update = str(now)

    last_payout_update_parsed = int(last_payout_update)

    nanos = now - last_payout_update_parsed

    seconds = nanos / 1000000000

    group.p1_payout = group.p1_payout + (Constants.payout_stay * seconds)

    group.p2_payout = group.p2_payout + (Constants.payout_stay * seconds)


class WaitToStart(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        # Time as a floating point number expressed in nanoseconds since the epoch
        group.last_payout_update = str(time.time_ns())
        # Time as a floating point number expressed in seconds since the epoch
        group.game_started = True
        group.game_started_at = str(time.time_ns())
        update_payout(group)


class ShuffleWaitPage(WaitPage):
    wait_for_all_groups = True

    @staticmethod
    def after_all_players_arrive(subsession):
        subsession.group_randomly()


page_sequence = [
    ShuffleWaitPage,
    WaitToStart,
    Button,
    Results
]


def custom_export(players):
    # header row
    yield ['session',
           'participant_code',
           'id_in_group',
           "Rundenlänge",
           'p1_payout',
           'p2_payout']

    # for loop to get a row for each player

    for p in players:
        participant = p.participant
        session = p.session
        yield [session.code,
               participant.code,
               p.id_in_group,
               p.group.len_round,
               p.group.p1_payout,
               p.group.p2_payout]