from otree.api import *

doc = """
Game of Nim. Players take turns adding a number. First to 15 wins.
"""


class Constants(BaseConstants):
    import csv
    import random

    name_in_url = 'race_game_one_player'
    players_per_group = None
    win_payoff = cu(10)
    lose_payoff = cu(0)
    with open('race_game_one_player/target.csv', 'r') as para:
        para = list(csv.DictReader(para))
        num_rounds = len(para)  # number of row

    round_order = list(range(1, num_rounds+1))
    # random.shuffle(round_order)


class Subsession(BaseSubsession):
    round_row = models.IntegerField(initial=0)
    target = models.IntegerField(initial=0)
    choice = models.IntegerField(initial=0)
    mode = models.StringField(initial='')


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    is_winner = models.BooleanField(initial=False)
    remain = models.IntegerField(initial=100)
    current_number = models.IntegerField(initial=0)
    whose_turn = models.IntegerField(initial=1)
    player_turn = models.IntegerField(initial=0)
    winner_id = models.IntegerField()
    game_over = models.BooleanField(initial=False)
    history = models.StringField(initial = '')
    start_timestamp = models.FloatField()
    end_timestamp = models.FloatField()
    count_player_turn = models.IntegerField(initial=0)
    count_com_turn = models.IntegerField(initial=0)

def creating_session(subsession):
    round_row = Constants.para[subsession.round_number - 1]
    print(round_row)
    subsession.target = int(round_row['target'])
    subsession.choice = int(round_row['choice'])
    subsession.mode = round_row['mode']
    if subsession.round_number <= 2:
        for player in subsession.get_players():
            player.player_turn = 1

def get_remain(player: Player):
    subsession = player.subsession
    remain = subsession.target - player.current_number
    return remain

def rational_race_game(player: Player, mode):
    import random
    subsession = player.subsession
    if mode == 'last_win':
        add = player.remain % (subsession.choice + 1)
    else:
        if player.remain == 1:
            add = 1
        else:
            add = (player.remain - 1) % (subsession.choice + 1)
    if add == 0:
        add = random.randint(1,subsession.choice)
    return add

def record_history(player: Player, number):
    player.history = player.history + str(number) + ','
    # return new_history

# PAGES
class Game(Page):
    form_model = 'player'
    form_fields = ['start_timestamp','end_timestamp']
    @staticmethod
    def js_vars(player: Player):
        subsession = player.subsession
        return dict(choice = subsession.choice)

    @staticmethod
    def live_method(player: Player, data):
        group = player.group
        subsession = player.subsession
        news = None
        number = 0
        if player.current_number > subsession.target:
            player.is_winner = 0
            player.game_over = True
            player.payoff = 0
        if player.count_player_turn - player.count_com_turn >=2:
            player.is_winner = 0
            player.game_over = True
            player.payoff = 0
        if (data):
            if data == 'computer_turn':
                player.count_com_turn +=1
                if player.current_number == 0:
                    import random
                    number = random.randint(1,2)
                    player.current_number += number
                else:
                    number = rational_race_game(player, subsession.mode)
                    player.current_number += number
                if player.current_number == subsession.target:
                    if subsession.mode == 'last_win':
                        player.is_winner = 0
                    else:
                        player.is_winner = 1
                        player.payoff = Constants.win_payoff
                    player.game_over = True
                player.player_turn = 1 - player.player_turn
            else:
                player.count_player_turn += 1
                number = data
                record_history(player, number)
                player.current_number += number
                if player.current_number == subsession.target:
                    if subsession.mode == 'last_win':
                        player.is_winner = 1
                        player.payoff = Constants.win_payoff
                    else:
                        player.is_winner = 0
                    player.game_over = True
                # else:
                player.player_turn = 1 - player.player_turn
            player.remain = get_remain(player)
            news = dict(player_turn = player.player_turn, number=number)
        else:
            news = None

        print(data)
        print('current number:', player.current_number)
        print('remain:', player.remain)
        print('count_com:', player.count_com_turn)
        print('count_player:', player.count_player_turn)
        print(news)
        print('=========================')

        return {
            player.id_in_group: dict(
                game_over=player.game_over,
                current_number=player.current_number,
                player_turn = player.player_turn,
                news=news,
                choice = subsession.choice,
                remain = player.remain,
            )
        }


class ResultsWaitPage(WaitPage):
    pass


class Results(Page):
    pass


page_sequence = [Game, Results]