from otree.api import *
from Instructions import C as GC 
from Instructions import creating_session as cs_Intro
from checkFunctions import addCheckVars
import numpy.random as rnd  
import random 
import pandas as pd 

doc = """
Your app description
"""


class C(BaseConstants):
    NAME_IN_URL = 'Task'
    PLAYERS_PER_GROUP = None
    NUM_ROUNDS = GC.iNumTrials 
    NUM_PROUNDS = GC.iPracticeRounds
    # In between round messages
    BetweenTrialMessages = {
        "1": f"Now you will have {GC.iPracticeRounds} practice rounds.", 
        str(int(GC.iPracticeRounds+1)): "The practice rounds are over."
        }
    # Image 
    imgCandidate    = "global/figures/candidate.png"
    imgNumbers      = "global/figures/numbers/n_"
    # Confidence page
    iLikertConf     = 7
    sConfQuestion   = f"From 1 to {iLikertConf}, how confident are you on your choice?"
    sLeftConf       = "Very unsure"
    sRightConf      = "Very sure"




class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    # DVs
    iChooseB    = models.IntegerField()
    iConfidence = models.IntegerField()
    dRT_dec     = models.FloatField()
    dRT_conf    = models.FloatField()
    dTime2first = models.FloatField()


    # Attention variables
    sNames      = models.LongStringField(blank=True)
    sDT         = models.LongStringField(blank=True)
    # Candidates
    sCandA      = models.StringField()
    sCandB      = models.StringField()
    # Timestamps
    sStartDec   = models.StringField()
    sEndDec     = models.StringField()
    sStartCross = models.StringField()
    sEndCross   = models.StringField()
    sStartConf  = models.StringField()
    sEndConf    = models.StringField()
    # Other
    sBetweenPosition = models.StringField()

    
def creating_session(subsession):
    # Load Session variables
    s = subsession.session 
    cs_Intro(subsession)

    for player in subsession.get_players():
        p = player.participant
        player.sCandA = p.lTrials[player.round_number-1][0]
        player.sCandB = p.lTrials[player.round_number-1][1]
        player.sBetweenPosition = random.sample(['left','right'],1)[0]
        
def attributeList(lAttrA,lAttrB,lPos):
    Attributes = {
        'gma': {
            "name": "GMA",  
            "id" : "gma",               
            "valueA": f"{C.imgNumbers}{lAttrA[0]}.png", 
            "valueB": f"{C.imgNumbers}{lAttrB[0]}.png", 
        },
        'con': {
            "name": "Conscientiousness",           
            "id" : "con",               
            "valueA": f"{C.imgNumbers}{lAttrA[1]}.png", 
            "valueB": f"{C.imgNumbers}{lAttrB[1]}.png", 
        },
        'int': {
            "name": "Interview",           
            "id" : "int",               
            "valueA": f"{C.imgNumbers}{lAttrA[2]}.png", 
            "valueB": f"{C.imgNumbers}{lAttrB[2]}.png", 
        },
        'gender': {
            "name": "Gender", 
            "id" : "gender",               
            "valueA": f"{C.imgNumbers}{lAttrA[3]}.png", 
            "valueB": f"{C.imgNumbers}{lAttrB[3]}.png", 
        },
        'rand': {
            "name": "Random", 
            "id" : "rand",               
            "valueA": f"{C.imgNumbers}{lAttrA[4]}.png", 
            "valueB": f"{C.imgNumbers}{lAttrB[4]}.png", 
        },
    }
    lValues = []
    for id in lPos:
        lValues.append(Attributes[id])
    return lValues

# PAGES
class Between(Page):
    form_model = 'player'
    form_fields = [ 'sStartCross','sEndCross' ]

    @staticmethod 
    def js_vars(player: Player):
        
        return dict(
            position = player.sBetweenPosition
        )
    
    @staticmethod
    def vars_for_template(player: Player):
        p = player.participant

        lAttr = []
        for attr in p.lEmployerOrder:
            match attr:
                case 0:
                    lAttr.append(f"is a {p.sEmployerGender.lower()}")
                case 1:
                    lAttr.append(f"is {p.sEmployerAge} <br> years old")
                case 2:
                    lAttr.append(f"has a {p.sEmployerMath} <br> maths level")

        return dict(
            lAttr = lAttr,
        )

class PracticeRoundMessage(Page):
    template_name = 'global/Message.html'
    form_model      = 'player'
    form_fields     = []


    @staticmethod 
    def is_displayed(player: Player):
        return str(player.round_number) in C.BetweenTrialMessages.keys()
    
    @staticmethod
    def vars_for_template(player: Player):
        return dict(
            MessageText = C.BetweenTrialMessages[str(player.round_number)]
        )


class Decision(Page):
    form_model      = 'player'
    form_fields     = [ 'sStartDec','sEndDec', 'dRT_dec', 'sNames', 'sDT' , 'dTime2first', 'iChooseB']
    
    @staticmethod
    def vars_for_template(player: Player):
        # Order of attributes (from participant var)
        p = player.participant
        lPos = p.lPos      
        # Candidates values          
        lValuesA = list(player.sCandA)
        lValuesB = list(player.sCandB)
        return dict(
            lAttr = attributeList(lValuesA,lValuesB,lPos),
        )
    
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        p = player.participant
        
        if player.round_number == p.iSelectedTrial: 
            p.bChoseA = player.iChooseB==0   
            print(f"Decision in selected trial recorded: {p.bChoseA}")


class Confidence(Page):
    form_model      = 'player'
    form_fields     = [ 'sStartConf','sEndConf', 'dRT_conf','iConfidence']

    
    @staticmethod
    def vars_for_template(player: Player):
        p = player.participant
        return dict(
            lScale = list(range(1,C.iLikertConf+1))
        )



page_sequence = [PracticeRoundMessage,Between,Decision,Confidence]
addCheckVars(Player, page_sequence)