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

def get_word_list():
    with open("valid_words.txt", "r") as word_file:
        word_list = [i.strip() for i in word_file.read().split('\n')]
    return word_list

def get_player_letter(player):
    return player.participant.vars['letters'][player.round_number-1];

def get_display_letters(player):
    if (player.report):
        return player.participant.vars['reportedletters']
    else:
        return player.participant.vars['reportedletters'] + list(get_player_letter(player))

def basic_word_validation(word_to_check,player):
    if(player.report):
        letters_available = copy.deepcopy(player.participant.vars['reportedletters'])
    else:
        letters_available = copy.deepcopy(player.participant.vars['reportedletters']) + list(get_player_letter(player))
    for each_letter in word_to_check:
        if(each_letter not in letters_available):
            return False
        else:
            letters_available.remove(each_letter)
    return True

def advanced_word_validation(word_to_check):
    word_list = get_word_list()
    insertion_point = bisect.bisect_left(word_list, word_to_check)
    if insertion_point != len(word_list) and word_list[insertion_point]==word_to_check:
        return True
    return False


def get_team(player):
    if(player.participant.vars['color']=='blue'):
        return 'blue'
    else:
        return 'red'

def get_word_length(player):
    return len(player.word)

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

class ReportPage(Page): # Page in which players are asked to report or not.
    def vars_for_template(self):
        return{'letter' : get_player_letter(self.player), 'round': self.round_number,}
    form_model = 'player'
    form_fields = ['report']

class WaitListPage(WaitPage):
    title_text = "Starting game"
    body_text = "Please wait while we set up the game."
    def __init__(self):
        self.red_list = []
        self.blue_list = []
    def after_all_players_arrive(self):
        for player in self.group.get_players():
            if(player.participant.vars['color']=='blue' and player.report==1):
                self.blue_list.append(get_player_letter(player))
            elif (player.participant.vars['color']=='red' and player.report==1):
                self.red_list.append(get_player_letter(player))
        for player in self.group.get_players():
            if player.participant.vars['color']=='blue':
                player.participant.vars['reportedletters'] = self.blue_list
            else:
                player.participant.vars['reportedletters'] = self.red_list

def get_chat_channel(player):
    if(get_team(player)== 'blue'):
        return Constants.blue_channel[player.round_number-1]
    elif(get_team(player) == 'red'):
        return Constants.red_channel[player.round_number-1]

class ChatPage(Page): # Go to this if user chose to report
    def is_displayed(self):
        return self.player.report == 1
    def vars_for_template(self):
        #self.subsession.displaying()
        return {'ReportedLetters': get_display_letters(self.player), 'chat_channel': get_chat_channel(self.player),}

    form_model = 'player'
    form_fields = ['word']
    def word_error_message(self,value):
        value = value.upper()
        if(basic_word_validation(value, self.player)==False):
            return 'This word uses letters that have not been reported'
        if(advanced_word_validation(value) == False):
            return 'This is not a valid word'
    timeout_seconds = 300
    def before_next_page(self):
        if self.timeout_happened:
            self.player.word = ''
        self.player.word.upper()


class WithoutChatPage(Page): # Go to this if user did not choose to report
    def is_displayed(self):
        return self.player.report == 0

    def vars_for_template(self):
        return {'ReportedLetters': get_display_letters(self.player)}

    form_model = 'player'
    form_fields = ['word']
    def word_error_message(self,value):
        value = value.upper()
        if(basic_word_validation(value, self.player)==False):
            return 'This word uses letters that have not been reported'
        if(advanced_word_validation(value) == False):
            return 'This is not a valid word'
    timeout_seconds = 300

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

def print_player_vars(players):
    for player in players:
        print(player.participant.vars)

class CalculateScorePage(WaitPage):
    def after_all_players_arrive(self):
        blue_score = 0
        red_score = 0
        sum_of_blue_word_length = 0
        sum_of_red_word_length = 0
        # commented out below code because payoff function changed (again)
        # for player in self.group.get_players():
        #     if get_team(player) == 'blue':
        #         average_blue_word_length += get_word_length(player)
        #         number_of_blue_players += 1
        #     else:
        #         average_red_word_length += get_word_length(player)
        #         number_of_red_players += 1
        # blue_group_score = 0
        # red_group_score = 0 
        # average_red_word_length /= number_of_red_players
        # average_blue_word_length /= number_of_blue_players
        # for player in self.group.get_players():
        #     if get_team(player) == 'blue' and get_word_length(player) >= average_red_word_length:
        #         blue_group_score+=1
        #     elif get_team(player) == 'red' and get_word_length(player) >= average_blue_word_length:
        #         red_group_score +=1
        # for player in self.group.get_players():
        #     if(get_team(player) == 'red'):
        #         player.participant.payoff += c(5*red_group_score)
        #     else:
        #         player.participant.payoff += c(5*blue_group_score)

        for player in self.group.get_players():
            if get_team(player) == 'blue':
                sum_of_blue_word_length += get_word_length(player)
            else:
                sum_of_red_word_length += get_word_length(player)
        for player in self.group.get_players():
            payoff = 0
            if (sum_of_blue_word_length > sum_of_red_word_length):
                if get_team(player) == 'blue':
                    payoff = 100
            elif (sum_of_red_word_length > sum_of_blue_word_length):
                if get_team(player) == 'red':
                    payoff = 100
            player.participant.vars['group_enhancing_payoff'].append(payoff)
            print(player.round_number)
            if player.round_number == 1:
                player.payoff_1 = payoff
            else:
                player.payoff_2 = payoff

        print_player_vars(self.group.get_players())

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

class Instructions(Page):
    def is_displayed(self):
        return self.round_number == 1

class LetterInstructions(Page):
    def is_displayed(self):
        return self.round_number == 1

class PayoffInstructions(Page):
    def is_displayed(self):
        return self.round_number == 1

class ChatInstructions(Page):
    def is_displayed(self):
        return self.player.report == 1

class WithoutChatInstructions(Page):
    def is_displayed(self):
        return self.player.report == 0 

page_sequence = [
    # LandingPage,
    # Instructions,
    # LetterInstructions,
    # PayoffInstructions,
    ReportPage,
    WaitListPage,
    # ChatInstructions,
    # WithoutChatInstructions,
    ChatPage,
    WithoutChatPage,
    WaitForWordsPage,
    CalculateScorePage,
    #DisplayScorePage,
    #ResultsWaitPage,
    #Page5,
    #Page6
    #Results
]