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



author = 'Vincent Lenglin'

doc = """
    ATTENTION : endowment de l'app MAIF_PREV doit être égal à endowment de MAIF_CONSIGNE
    Pas possible ici de créer une variable de transfert car il sert pour "num_choices" qui est défini dans Constants
"""


class Constants(BaseConstants):
    name_in_url = 'MAIF_PREV'
    players_per_group = None
    
    ENDOWMENT = 10
    epsilon = 10
    
    num_boule = 100
    
    num_choices = ENDOWMENT + 1

    # CONDITIONS EXPERIMENTALES
    # ---------------------------------
    boule_verte_option = [0, 20, 50, 80, 90]
    #asso_price = [100, 100, 100, 100, 100, 10, 10, 10, 10, 10]
    low_price_asso  = 0

    num_rounds = len(boule_verte_option)



class Subsession(BaseSubsession):

    def creating_session(self):
        
        # On definit si la liste des donations sera ascendante ou descendante au niveau du joueur.
        for p in self.get_players():
            p.ENDOWMENT  = Constants.ENDOWMENT
            p.is_list_ascending =  0 #random.choice([0, 1])
            if p.is_list_ascending == 1:
                p.participant.vars['WTP_values'] = list(range(Constants.ENDOWMENT+1))
            else:
                p.participant.vars['WTP_values'] = list(range(Constants.ENDOWMENT, -1, -1))

       

# utile pour construire le tableau de choix dans html (détermine le nombre de lignes dans le tableau qui dépend de l'endowment et du pas)
    @property
    def range_21(self):
        return list(range(Constants.ENDOWMENT+1))


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    page_sequence = models.StringField()
    TREATMENT = models.StringField()
    ENDOWMENT = models.IntegerField()

    # ASSOCIATIONS
    asso_price_order = models.LongStringField()
    asso_price = models.IntegerField()
    association_choice = models.StringField()


    # BOULES
    boule_verte = models.IntegerField()
    boule_rouge = models.IntegerField()
    boule_verte_option_prev = models.IntegerField()
    boule_rouge_option_prev = models.IntegerField()
    boule_order = models.LongStringField()

    # ADDITIONAL VARIABLES
    error = models.BooleanField(initial=False)
    epsilon = models.IntegerField(initial=Constants.epsilon)
    
    boule_rouge_entrainement = models.IntegerField()
    boule_rouge_option_prev_entrainement = models.IntegerField()
    boule_verte_entrainement = models.IntegerField()
    boule_verte_option_prev_entrainement = models.IntegerField()

    is_list_ascending = models.IntegerField()

    # PAIEMENT
    trial_drawn = models.IntegerField()
    row_drawn = models.IntegerField()
    chosen_option = models.StringField()

    # CHOIX
    for j in range(1, Constants.num_choices + 1):
        locals()['choix' + str(j)] = models.StringField(choices=['A', 'B'])
    del j



# BODY
    def chosen_asso(self):
        self.association_choice = self.participant.vars['association_choice'] 


    def create_loteries(self):
        self.participant.vars['asso_price'] = [self.participant.vars['normalisation'] for _ in range(len(Constants.boule_verte_option))]
        print(self.participant.vars['asso_price'])

        pairs = list(zip(Constants.boule_verte_option, self.participant.vars['asso_price']))
        # Mélangez les paires
        random.shuffle(pairs)
        # Divisez les paires mélangées en deux listes séparées
        order, asso = zip(*pairs)
        # On record l'ordre des conditions dans la database
        self.boule_order = str(order)
        self.asso_price_order = str(asso)

        # On répand le résultat de l'aléatoirisation des conditions aux rounds
        for s in range(1, Constants.num_rounds + 1):
            self.in_round(s).boule_verte = order[s - 1]
            self.in_round(s).asso_price = asso[s - 1]                 
            self.in_round(s).boule_verte_option_prev = self.in_round(s).boule_verte + Constants.epsilon


###############################################################
# REAL - task
################################################################
    # crée le nombre de boules vertes de l'option A 
    def create_boule(self):
        self.boule_rouge = Constants.num_boule - self.boule_verte
        boule = []
        for i in range(1, Constants.num_boule + 1):
            couleur = 'verte' if i <= self.boule_verte else 'noire'
            boule.append({'numero': i, 'couleur': couleur})
        return boule

    # crée le nombre de boules vertes de l'option B
    def create_boule_prev(self):
        self.boule_rouge_option_prev = Constants.num_boule - self.boule_verte_option_prev
        boule = []
        for i in range(1, Constants.num_boule + 1):
            couleur = 'verte' if i <= self.boule_verte_option_prev else 'noire'
            boule.append({'numero': i, 'couleur': couleur})
        return boule




###############################################################
# ENTRAINEMENT - consigne
################################################################

    # crée le nombre de boules vertes de l'option A 
    def create_boule_entrainement(self):
        self.boule_rouge_entrainement = Constants.num_boule - 50
        self.boule_verte_entrainement = Constants.num_boule - 50
        boule = []
        for i in range(1, Constants.num_boule + 1):
            couleur = 'verte' if i <= self.boule_verte_entrainement else 'noire'
            boule.append({'numero': i, 'couleur': couleur})
        return boule

    # crée le nombre de boules vertes de l'option B
    def create_boule_prev_entrainement(self):
        self.boule_rouge_option_prev_entrainement = Constants.num_boule - 60
        self.boule_verte_option_prev_entrainement = Constants.num_boule - 40
        boule = []
        for i in range(1, Constants.num_boule + 1):
            couleur = 'verte' if i <= self.boule_verte_option_prev_entrainement else 'noire'
            boule.append({'numero': i, 'couleur': couleur})
        return boule