from otree.api import Currency as c, currency_range
from ._builtin import Page
from .models import Constants
import datetime, json, time
import random
import math

def per_sec():
    choice1 = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
    random.shuffle(choice1)
    return choice1

def per_move():
    choice2 = [0.1, 0.2, 0.5, 0.75, 1]
    random.shuffle(choice2)
    return choice2

class instructions1(Page):

    def vars_for_template(self):
        if self.round_number == 1:
            self.participant.vars['move'] = per_move()
            self.participant.vars['sec'] = per_sec()

        if self.round_number == 1:  #10
            return dict(
                min_num_of_moves=10,
                endowment=(10) * 0.5 + 10,
                per_move_ins=50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins= 10    #self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 2: #8
            return dict(
                min_num_of_moves=8,
                endowment=(8) * 0.5 + 10,
                per_move_ins=50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=10  # self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 3:  #10
            return dict(
                min_num_of_moves=10,
                endowment=(10) * 0.5 + 10,
                per_move_ins=50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=10  # self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 4:  #8
            return dict(
                min_num_of_moves=8,
                endowment=(8) * 0.5 + 10,
                per_move_ins=50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=10  # self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 5:  #10
            return dict(
                min_num_of_moves=10,
                endowment=(10) * 0.5 + 10,
                per_move_ins=50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=10  # self.participant.vars['sec'][self.round_number - 1],
            )



    def before_next_page(self):
        self.participant.vars['sssss'] = time.time()


class Game1(Page):
    form_model = 'player'
    form_fields = ['puzzle_solved', 'total_payoff', 'time_spent', 'num_of_moves', 'min_num_of_moves', 'board_history',
                   'deduction_per_second', 'deduction_all_seconds', 'deduction_per_move', 'deduction_all_moves',
                   'time_between_moves', 'endowment', 'deduction_per_move_cents', 'deduction_per_second_cents']

    timeout_seconds = 1500
    timer_text = 'Time Left to Next Deduction:'

    def before_next_page(self):
        if self.player.puzzle_solved == 1:
            self.player.time_spent = math.floor(time.time() - self.participant.vars['sssss'])
            self.player.total_payoff = round((self.player.endowment - (self.player.time_spent // 10 * self.player.deduction_per_second)
                                       - (self.player.deduction_per_move * self.player.num_of_moves)),2)
            self.player.deduction_all_moves = self.player.deduction_per_move * self.player.num_of_moves
            self.player.deduction_all_seconds = self.player.time_spent // 10 * self.player.deduction_per_second

            if self.player.total_payoff <0:
                self.player.total_payoff = 0
            else:
                self.player.total_payoff = self.player.total_payoff

            self.player.deduction_all_seconds = round((self.player.time_spent // 10 * self.player.deduction_per_second), 2)
            self.player.deduction_all_moves = self.player.deduction_per_move * self.player.num_of_moves

        if self.timeout_happened:
            self.player.time_spent = self.timeout_seconds
            self.player.total_payoff = self.player.endowment - (self.timeout_seconds / 10 * self.player.deduction_per_second)\
                                       - (self.player.deduction_per_move * self.player.num_of_moves)

            if self.player.total_payoff <0:
                self.player.total_payoff = 0
            else:
                self.player.total_payoff = self.player.total_payoff

            self.player.deduction_all_seconds = round((self.timeout_seconds / 10 * self.player.deduction_per_second),2)

    def vars_for_template(self) -> dict:
        if self.round_number == 1:
            return dict(
                min_num_of_moves=10,
                endowment=(10) * 0.5 + 10,
                per_move_ins=0.50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins= 0.10    #self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 2:
            return dict(
                min_num_of_moves=8,
                endowment=(8) * 0.5 + 10,
                per_move_ins=0.50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=0.10  # self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 3:
            return dict(
                min_num_of_moves=10,
                endowment=(10) * 0.5 + 10,
                per_move_ins=0.50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=0.10  # self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 4:
            return dict(
                min_num_of_moves=8,
                endowment=(8) * 0.5 + 10,
                per_move_ins=0.50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=0.10  # self.participant.vars['sec'][self.round_number - 1],
            )

        if self.round_number == 5:
            return dict(
                min_num_of_moves=10,
                endowment=(10) * 0.5 + 10,
                per_move_ins=0.50,  # self.participant.vars['move'][self.round_number - 1],
                per_10sec_ins=0.10  # self.participant.vars['sec'][self.round_number - 1],
            )

    def js_vars(self):
        if self.round_number == 1:  # 10 steps
            return {
                'timeout': self.timeout_seconds,
                'game_id': self.round_number,
                'per_move': 0.50,  # self.participant.vars['move'][self.round_number - 1],
                'per_move_cents': 50,
                'per_10sec': 0.10,#self.participant.vars['sec'][self.round_number - 1],
                'per_10sec_cents': 10,
                'endowment': (10) * 0.5 + 10,
                'min_num_of_moves': 10,
                'player_id': self.player.id,
                'the_player': self.player.id == 1,
                'board': [
                    [None, 1, 2],
                    [4, 5, 6],
                    [7, 3, 8],
                ]
            }

        if self.round_number == 2:  # 8 steps
            return {
                'timeout': self.timeout_seconds,
                'game_id': self.round_number,
                'per_move': 0.50,  # self.participant.vars['move'][self.round_number - 1],
                'per_move_cents': 50,
                'per_10sec': 0.10,#self.participant.vars['sec'][self.round_number - 1],
                'per_10sec_cents': 10,
                'endowment': (8) * 0.5 + 10,
                'min_num_of_moves': 8,
                'player_id': self.player.id,
                'the_player': self.player.id == 1,
                'board': [
                    [4, 1, 3],
                    [7, None, 6],
                    [5, 2, 8],
                ]
            }

        if self.round_number == 3:  # 10 steps
            return {
                'timeout': self.timeout_seconds,
                'game_id': self.round_number,
                'per_move': 0.50,  # self.participant.vars['move'][self.round_number - 1],
                'per_move_cents': 50,
                'per_10sec': 0.10,#self.participant.vars['sec'][self.round_number - 1],
                'per_10sec_cents': 10,
                'endowment': (10) * 0.5 + 10,
                'min_num_of_moves': 10,
                'player_id': self.player.id,
                'the_player': self.player.id == 1,
                'board': [
                    [3, 4, 5],
                    [1, None, 2],
                    [7, 8, 6],
                ]
            }

        if self.round_number == 4:  # 8 steps
            return {
                'timeout': self.timeout_seconds,
                'game_id': self.round_number,
                'per_move': 0.50,  # self.participant.vars['move'][self.round_number - 1],
                'per_move_cents': 50,
                'per_10sec': 0.10,#self.participant.vars['sec'][self.round_number - 1],
                'per_10sec_cents': 10,
                'endowment': (8) * 0.5 + 10,
                'min_num_of_moves': 8,
                'player_id': self.player.id,
                'the_player': self.player.id == 1,
                'board': [
                    [1, 6, 2],
                     [4, 5, 3],
                     [7, 8, None],
                ]
            }

        if self.round_number == 5:  # 10 steps
            return {
                'timeout': self.timeout_seconds,
                'game_id': self.round_number,
                'per_move': 0.50,  # self.participant.vars['move'][self.round_number - 1],
                'per_move_cents': 50,
                'per_10sec': 0.10,#self.participant.vars['sec'][self.round_number - 1],
                'per_10sec_cents': 10,
                'endowment': (10) * 0.5 + 10,
                'min_num_of_moves': 10,
                'player_id': self.player.id,
                'the_player': self.player.id == 1,
                'board': [
                    [5, 2, 3],
                     [1, None, 4],
                     [7, 8, 6],
                ]
            }




def paying_round(self):
    choice3 = random.randint(1, Constants.num_rounds)
    return choice3


class Results(Page):
    form_model = 'player'
    form_fields = ['paying_round', 'final_payoff']

    def vars_for_template(self):

        if self.round_number == 1:
            self.participant.vars['paying_round'] = paying_round(self)

        if self.round_number < self.participant.vars['paying_round']:
            self.participant.vars['final_payoff'] = 0
            self.participant.vars['final_move'] = 0
            self.participant.vars['final_time'] = 0
            self.participant.vars['final_endow'] = 0

        else:
            self.participant.vars['final_payoff'] = self.player.in_round(self.participant.vars['paying_round']).total_payoff
            self.participant.vars['final_move'] = self.player.in_round(self.participant.vars['paying_round']).num_of_moves
            self.participant.vars['final_time'] = self.player.in_round(self.participant.vars['paying_round']).time_spent
            self.participant.vars['final_endow'] = self.player.in_round(self.participant.vars['paying_round']).endowment

        return dict(
            paying_round=self.participant.vars['paying_round'],
            final_payoff=self.participant.vars['final_payoff'],
            final_move=self.participant.vars['final_move'],
            final_time=self.participant.vars['final_time'],
            player_in_all_rounds=self.player.in_all_rounds(),
            player_in_previous_round=self.player.in_previous_rounds(),
            endowment=self.participant.vars['final_endow'],
            payoff=self.participant.vars['final_payoff'],
        )






    def js_vars(self):
        return {
            'paying_round': self.participant.vars['paying_round'],
            'final_payoff': self.participant.vars['final_payoff']
        }


page_sequence = [instructions1,
                 Game1, Results,
                 ]