from otree.api import (
    models,
    widgets,
    BaseConstants,
    BaseSubsession,
    BaseGroup,
    BasePlayer,
    Currency as c,
    currency_range,
)
import random

author = 'Your name here'

doc = """
Your app description
"""


class Constants(BaseConstants):
    name_in_url = 'part1'
    players_per_group = 3
    num_rounds = 3

    winner_payoff = 4
    loser_payoff = 1

    Alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

class Subsession(BaseSubsession):
    def creating_session(self):
        n = Constants.num_rounds

        if self.round_number == 1:


            # Draw all codes in all rounds when creating the session
            num_letters = len(Constants.Alphabet)
            letters = Constants.Alphabet.copy()
            # For each player
            for p in self.get_players():
                # In each round
                for r in range(1, n + 1):
                    # Just call player p in round r once
                    player_r = p.in_round(r)

                    # Assign codes (from 100 999) to each letter
                    random_numbers = random.sample(range(101, 1000), num_letters)
                    codes = {letters[i]: random_numbers[i] for i in range(num_letters)}

                    # Pick a random word! (no letter repetition)
                    a = random.sample(range(0, num_letters), 3)
                    player_r.letter1 = letters[a[0]]
                    player_r.letter2 = letters[a[1]]
                    player_r.letter3 = letters[a[2]]

                    # Pick a random word! (no letter repetition)
                    player_r.code1 = codes[letters[a[0]]]
                    player_r.code2 = codes[letters[a[1]]]
                    player_r.code3 = codes[letters[a[2]]]

                    # Save codes for all letters (must be more efficient way to do this!!!!)
                    player_r.code_A = random_numbers[0]
                    player_r.code_B = random_numbers[1]
                    player_r.code_C = random_numbers[2]
                    player_r.code_D = random_numbers[3]
                    player_r.code_E = random_numbers[4]
                    player_r.code_F = random_numbers[5]
                    player_r.code_G = random_numbers[6]
                    player_r.code_H = random_numbers[7]
                    player_r.code_I = random_numbers[8]
                    player_r.code_J = random_numbers[9]
                    player_r.code_K = random_numbers[10]
                    player_r.code_L = random_numbers[11]
                    player_r.code_M = random_numbers[12]
                    player_r.code_N = random_numbers[13]
                    player_r.code_O = random_numbers[14]
                    player_r.code_P = random_numbers[15]
                    player_r.code_Q = random_numbers[16]
                    player_r.code_R = random_numbers[17]
                    player_r.code_S = random_numbers[18]
                    player_r.code_T = random_numbers[19]
                    player_r.code_U = random_numbers[20]
                    player_r.code_V = random_numbers[21]
                    player_r.code_W = random_numbers[22]
                    player_r.code_X = random_numbers[23]
                    player_r.code_Y = random_numbers[24]
                    player_r.code_Z = random_numbers[25]

class Group(BaseGroup):
    pass

class Player(BasePlayer):

    # Make code variable for each letter of the alphabet
    for j in range(0, len(Constants.Alphabet)):
        locals()['code_' + Constants.Alphabet[j]] = models.IntegerField()
    del j

    # 3 letter word
    letter1 = models.StringField()
    letter2 = models.StringField()
    letter3 = models.StringField()

    # The codes for each letter
    code1 = models.IntegerField()
    code2 = models.IntegerField()
    code3 = models.IntegerField()

    # Answers
    answer1 = models.IntegerField(label="")
    answer2 = models.IntegerField(label="")
    answer3 = models.IntegerField(label="")

    # Multipliers
    multiplier = models.IntegerField()

    # Correct & points
    correct = models.IntegerField()
    points = models.IntegerField()
    def determine_correct(self):
        self.correct = [self.answer1 == self.code1,
                        self.answer2 == self.code2,
                        self.answer3 == self.code3].count(True)
        r = self.round_number
        m = self.participant.vars['multipliers'][r - 1]
        self.points = self.correct * m