import random
import uuid

class Stage3Pairing: 

    def __init__(self, first_mover_participant, second_mover_participant, game_number, is_in_group):
        self.first_mover_participant = first_mover_participant
        self.second_mover_participant = second_mover_participant
        self.game_number = game_number
        self.is_in_group = is_in_group
        self.participants = [first_mover_participant, second_mover_participant]
        self.pairing_uuid = str(uuid.uuid4())

        self.first_mover_choice = None
        self.second_mover_choice_ifA = None
        self.second_mover_choice_ifB = None

class Stage3Game:

    def __eq__(self, other):
        for i, game in enumerate(self.games):
            for j, pairing in enumerate(game):
                if pairing.first_mover_choice != other.games[i][j].first_mover_choice or \
                    pairing.second_mover_choice_ifA != other.games[i][j].second_mover_choice_ifA or \
                    pairing.second_mover_choice_ifB != other.games[i][j].second_mover_choice_ifB:
                    return False

        return True

    def __init__(self, subsession):
        from .models import Constants

        self.games_payoff_dict = {
            1: [[[30, 30], [10, 50]],
                [[30, 10], [10, 10]]],
            2: [[[30, 30], [10, 50]],
                [[50, 10], [10, 10]]],
            3: [[[30, 30], [10, 60]],
                [[60, 10], [10, 10]]],
            4: [[[30, 30], [10, 30]],
                [[30, 10], [10, 10]]],
            5: [[[30, 30], [10, 30]],
                [[50, 10], [10, 10]]],
            6: [[[30, 30], [10, 50]],
                [[10, 10], [10, 10]]],
            7: [[[40, 20], [10, 50]],
                [[20, 0], [20, 0]]],
            8: [[[30, 30], [10, 50]],
                [[0, 20], [0, 20]]],
            9: [[[30, 30], [0, 0]],
                [[50, 10], [0, 0]]],
            10: [[[30, 30], [30, 30]],
                [[50, 10], [50, 10]]],
        }

        self.chosen_game_number = random.randint(1, 10)
        self.chosen_in_out_group = random.randint(0, 1)

        # init Constants.num_games number of games
        self.games = [[] for i in range(0, Constants.num_games)]

        group_matrix = subsession.get_group_matrix()

        # first assign all participants 'is_first_mover' to False
        for group in group_matrix:
            for player in group:
                player.participant.vars['is_first_mover'] = False
        # now randomly choice two from each group to be first mover
        for group in group_matrix:
            idx_sample = random.sample(range(0, len(group)), 2)
            for idx in idx_sample:
                group[idx].participant.vars['is_first_mover'] = True

        # Pair players for in group
        for i in range(0, Constants.num_games):
            for group in group_matrix:
                group_first_movers = [player.participant for player in group if player.participant.vars['is_first_mover'] == True]
                group_second_movers = [player.participant for player in group if player.participant.vars['is_first_mover'] == False]
                for p in group_first_movers:
                    pairing = Stage3Pairing(p, group_second_movers.pop(random.randint(0, len(group_second_movers)-1)), i+1, True)
                    self.games[i].append(pairing)

        # Pair players for out group    
        for i in range(0, Constants.num_games):
            group1 = group_matrix[0]
            group1_first_movers = [player.participant for player in group1 if player.participant.vars['is_first_mover'] == True]
            group1_second_movers = [player.participant for player in group1 if player.participant.vars['is_first_mover'] == False]
            group2 = group_matrix[1]
            group2_first_movers = [player.participant for player in group2 if player.participant.vars['is_first_mover'] == True]
            group2_second_movers = [player.participant for player in group2 if player.participant.vars['is_first_mover'] == False]
            
            for p in group1_first_movers:
                pairing = Stage3Pairing(p, group2_second_movers.pop(random.randint(0, len(group2_second_movers)-1)), i+1, False)
                self.games[i].append(pairing)

            for p in group2_first_movers:
                pairing = Stage3Pairing(p, group1_second_movers.pop(random.randint(0, len(group1_second_movers)-1)), i+1, False)
                self.games[i].append(pairing)

        # initialise dict with player object as the key
        # and sequence of games as the value
        self.participant_game_sequence_dict = {}
        players = subsession.get_players()
        for player in players:
            self.participant_game_sequence_dict[player.participant] = self.get_sequence_of_pairings(player.participant)

    def get_sequence_of_pairings(self, participant):
        sequence_of_games = []
        for game in self.games:
            for pairing in game:
                if participant in pairing.participants:
                    sequence_of_games.append(pairing)

        random.shuffle(sequence_of_games)

        return sequence_of_games

    def get_payoff_matrix(self, participant, round_number):
        pairing = self.participant_game_sequence_dict[participant][round_number-1]
        game_number = pairing.game_number
        return self.games_payoff_dict[game_number]

    def get_payoff(self, first_mover_player, second_mover_player, is_first_mover):
        game_number = first_mover_player.game_number
        first_mover_choice = first_mover_player.choice
        second_mover_choice_ifA = second_mover_player.choice_if_A
        second_mover_choice_ifB = second_mover_player.choice_if_B
        payoff_matrix = self.games_payoff_dict[game_number]

        if is_first_mover:
            if first_mover_choice == 1:
                return payoff_matrix[0][second_mover_choice_ifA-1][0]
            else:
                return payoff_matrix[1][second_mover_choice_ifB-1][0]
        else:
            if first_mover_choice == 1:
                return payoff_matrix[0][second_mover_choice_ifA-1][1]
            else:
                return payoff_matrix[1][second_mover_choice_ifB-1][1]