from otree.api import *
c = cu

doc = ''
class C(BaseConstants):
    NAME_IN_URL = 'desktop_columbiacardtask_live'
    PLAYERS_PER_GROUP = None
    NUM_ROUNDS = 54
    BOXES = 32
    LOSSCARDS = (1, 2, 3)
    GAINAMOUNTS = (10, 10, 10, 20, 20, 20, 30, 30, 30)
    LOSSAMOUNTS = (250, 250, 250, 250, 250, 250, 250, 250, 250, 500, 500, 500, 500, 500, 500, 500, 500, 500, 750, 750, 750, 750, 750, 750, 750, 750, 750)
    NFCLONG = 0
class Subsession(BaseSubsession):
    pass
def creating_session(subsession: Subsession):
    session = subsession.session
    # https://otree.readthedocs.io/en/latest/treatments.html#creating-session
    if subsession.round_number == 1:
    
        import itertools
        import random
    
        # create 5 different random orderings
        indices1 = [i for i in range(1,C.NUM_ROUNDS+1)]
        random.shuffle(indices1)
        indices2 = [i for i in range(1,C.NUM_ROUNDS+1)]
        random.shuffle(indices2)
        indices3 = [i for i in range(1,C.NUM_ROUNDS+1)]
        random.shuffle(indices3)
        indices4 = [i for i in range(1,C.NUM_ROUNDS+1)]
        random.shuffle(indices4)
        indices5 = [i for i in range(1,C.NUM_ROUNDS+1)]
        random.shuffle(indices5)
    
        # cycle the players between the random orderings
        index_cycle = itertools.cycle([indices1,indices2,indices3,indices4,indices5])
    
        for player in subsession.get_players():
            participant = player.participant
            participant.indexlist = next(index_cycle)
class Group(BaseGroup):
    pass
class Player(BasePlayer):
    chosencard = models.IntegerField(initial=0)
    endedinloss = models.BooleanField()
    stopped = models.IntegerField(initial=0)
    profit = models.IntegerField()
    roundlosscards = models.IntegerField()
    firstlosscard = models.IntegerField()
    roundgain = models.IntegerField()
    roundloss = models.IntegerField()
    losscardlist = models.StringField()
    dectimes = models.StringField(initial='')
    startleft = models.StringField(initial='')
    touchtimes = models.StringField(initial='')
    xs = models.StringField(initial='')
    ys = models.StringField(initial='')
    polyareas = models.StringField(initial='')
    computer_randomround1 = models.IntegerField()
    computer_randomround2 = models.IntegerField()
    randomprofit1 = models.IntegerField()
    randomprofit2 = models.IntegerField()
    reward = models.FloatField()
    dohmen = models.IntegerField(choices=[[1, '1 = not at all willing to take risks'], [2, '2'], [3, '3'], [4, '4'], [5, '5'], [6, '6'], [7, '7'], [8, '8'], [9, '9'], [10, '10 = very willing to take risks']], widget=widgets.RadioSelect)
    nfcscore = models.IntegerField()
    nfcall = models.StringField()
    ismobile_touchstart = models.IntegerField(blank=True, initial=0)
    screenwidth = models.StringField(blank=True, initial='')
    screenheight = models.IntegerField(blank=True, initial=0)
    browser = models.StringField(blank=True, initial='')
    ace1 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Emotional abuse', widget=widgets.RadioSelect)
    ace2 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Physical abuse', widget=widgets.RadioSelect)
    ace3 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Sexual abuse', widget=widgets.RadioSelect)
    ace4 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Physical neglect', widget=widgets.RadioSelect)
    ace5 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Emotional neglect', widget=widgets.RadioSelect)
    ace6 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Household mental illness', widget=widgets.RadioSelect)
    ace7 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Property victimisation', widget=widgets.RadioSelect)
    ace8 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Peer victimisation', widget=widgets.RadioSelect)
    ace9 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Exposure to community violence', widget=widgets.RadioSelect)
    ace10 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Socioeconomic status', widget=widgets.RadioSelect)
    ace11 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Someone close had a bad accident or illness', widget=widgets.RadioSelect)
    ace12 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Below-average grades', widget=widgets.RadioSelect)
    ace13 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='Parents always arguing', widget=widgets.RadioSelect)
    ace14 = models.StringField(choices=[['Yes', 'Yes'], ['No', 'No']], label='No good childhood friends', widget=widgets.RadioSelect)
    affectbased = models.IntegerField(choices=[[1, '1 = Strongly disagree'], [2, '2 = Moderately disagree'], [3, '3 = Slightly disagree'], [4, '4 = Slightly agree'], [5, '5 = Moderately agree'], [6, '6 = Strongly agree']], label='<p>I solved the task on a gut level</p>', widget=widgets.RadioSelect)
    deliberative = models.IntegerField(choices=[[1, '1 = Strongly disagree'], [2, '2 = Moderately disagree'], [3, '3 = Slightly disagree'], [4, '4 = Slightly agree'], [5, '5 = Moderately agree'], [6, '6 = Strongly agree']], label='<p>I tried to solve the task mathematically</p>', widget=widgets.RadioSelect)
    checkup1 = models.StringField(choices=[['1', 'Points earned from two randomly chosen rounds'], ['3', 'Points earned from half of the rounds'], ['2', 'Points earned from all rounds']], label='<p>My bonus payments for the study consist of ...</p>', widget=widgets.RadioSelect)
    checkup2 = models.StringField(choices=[['1', 'True'], ['2', 'False']], label='<p>The number of loss boxes changes from round to another</p> ', widget=widgets.RadioSelect)
    checkup3 = models.StringField(choices=[['2', 'Changes from round to round'], ['1', 'Always 32'], ['3', 'Depends on the number of loss boxes']], label='<p>How many boxes in total are there in a round?</p>', widget=widgets.RadioSelect)
    prolificcode = models.StringField()
    handedness = models.StringField(choices=[['Right hand', 'Right hand'], ['Left hand', 'Left hand']], label='<p>Which hand do you typically use to browse your mobile device? </p>', widget=widgets.RadioSelect)
def live_open(player: Player, data):
    time = data['time'] # this is a single timestamp indicating when the message was sent to server
    touchtimes = data['touchtimes'] # these timestamps indicate when the card was touched
    starttime = data['starttime'] # this is a timestamp recorded on page, indicating when box moving started
    opened = data['opened'] # this is zero if swiped right
    player.chosencard += opened
    player.dectimes += str(int(time) - int(starttime)) + ';'
    
    player.xs += data['x'] + ';'
    player.ys += data['y'] + ';' # this should correspond to decision times
    player.touchtimes += touchtimes + ';'
    
    player.startleft += data['startleft'] + ';' # this is recorded just in case the polyarea calculations are wrong
    
    ### POLYAREA
    x = data['x']
    y = data['y']
    xx = x.split(',')
    xx = xx[:-1]
    xxx = map(float,xx)
    x = list(map(int,xxx))
    yy = y.split(',')
    yy = yy[:-1]
    y = list(map(int,yy))
    
    # flip the y coordinate
    y = list(reversed(y))
    
    xy = []
    j = 0
    # append all the points in the curve except the tail points
    for jj in range(j,len(x)):
        if x[-1] < int(data['startleft']): # rejected when final x-coordinate is 150 px lower than startleft
            if x[jj] >= x[0]-150:
                xy.append([x[jj],y[jj]])
                jjj = jj # stopping index
        else:                         # accepted when final x-coordinate is 150 px higher than startleft
            if x[jj] < x[0]+150:
                xy.append([x[jj],y[jj]])
                jjj = jj # stopping index
    
    # close the curve to determine the polyarea
    
    
    xy.append([x[jjj],y[jjj]]) # append the end point
    xy.append([x[jjj],y[0]])   # append the point that is vertically upwards from the end point
    xy.append([x[0],y[0]])     # append the start point
    l = len(xy)
    s = 0.0
    for i in range(l):
        j = (i+1)%l  # keep index in [0,l)
        s += (xy[j][0] - xy[i][0])*(xy[j][1] + xy[i][1])
    
    polyarea = -0.5*s
    
    player.polyareas += str(polyarea) + ';'
    
    
    response = {'openedcards': player.chosencard} # how many cards have been opened so far
    return {0: response}
def checkup1_error_message(player: Player, value):
    if value != '1':
        return "Your answer is wrong. Hint: as the instructions state, two blocks will be randomly selected at the end of the study and the points from these blocks paid to you."
def checkup2_error_message(player: Player, value):
    if value != '1':
        return "Your answer is wrong. Hint: there can be 1, 2, or 3 loss boxes within a round and this is randomised from round to another."
def checkup3_error_message(player: Player, value):
    if value != '1':
        return "Your answer is wrong. Hint: the total number of boxes remains constant, only the number of loss boxes and gain boxes changes from round to another."
class Welcome(Page):
    form_model = 'player'
    form_fields = ['prolificcode']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == 1 and session.config['pilot'] == 0
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( icons = session.config['icons'] )
class Instructions(Page):
    form_model = 'player'
    form_fields = ['checkup1', 'checkup2', 'checkup3']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        if session.config['icons'] == 'smileys':
            return player.round_number < 4 
        else:
            return player.round_number == 1
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( roundi = player.round_number, icons = session.config['icons'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        return dict(boxes = C.BOXES,
                    icons = session.config['icons'])
class RoundStart(Page):
    form_model = 'player'
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        participant = player.participant
        # THE FOLLOWING VARIABLES ARE SET ONLY AT THE START OF THE ROUND 
        
        # THESE HAVE BEEN MODIFIED FROM THE BLOCKSTART PAGE OF THE OLD APP
        
        # determine the amount of loss cards, gainamount, and lossamount
        trialnumber = participant.indexlist[player.round_number-1]
        # vector of how many loss cards in each round [1,2,3,1,2,3,1,2,3,...]
        losscardsvec = int(C.NUM_ROUNDS / len(C.LOSSCARDS)) * C.LOSSCARDS
        # how many loss cards in this specific round
        player.roundlosscards = losscardsvec[trialnumber - 1]
        # which specific card numbers are loss cards in this block
        import random
        numbs = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32]
        losscardlist = []
        num1 = random.choice(numbs)
        losscardlist.append(num1)
        numbs.remove(num1)
        if (player.roundlosscards >= 2):
            num2 = random.choice(numbs)
            losscardlist.append(num2)
            numbs.remove(num2)
        if (player.roundlosscards == 3):
            num3 = random.choice(numbs)
            losscardlist.append(num3)
        # which one is the first loss card because the block ends in this card
        player.firstlosscard = min(losscardlist)
        player.losscardlist = str(losscardlist)
        # gain amount in this block based on trialnumber (excel file) 10,10,10,20,20,20,30,30,30,10,10,10,...
        gainsvec = int(C.NUM_ROUNDS / len(C.GAINAMOUNTS)) * C.GAINAMOUNTS
        player.roundgain = gainsvec[trialnumber - 1]
        # loss amount in this block based on trialnumber (excel file) 250,250,250,250,250,250,250,250,250,500,500,...
        lossvec = int(C.NUM_ROUNDS / len(C.LOSSAMOUNTS)) * C.LOSSAMOUNTS
        player.roundloss = lossvec[trialnumber - 1]
        
        
        return dict( roundi = player.round_number, 
                     example1 = player.roundgain*6, 
                     example2 = max(player.roundgain*6 - player.roundloss, 0), 
                     pilot = session.config['pilot'], icons = session.config['icons'] )
class Decision(Page):
    form_model = 'player'
    form_fields = ['stopped']
    live_method = 'live_open'
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( roundi = player.round_number, icons = session.config['icons'] )
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        # create the number of boxes opened for js_vars (same as blockround in the old app)
        # ???
        return dict( gainvalue = player.roundgain,
                     openedcards = player.chosencard, # this is only used to display the initial row of cards
                     roundi = player.round_number,
                     firstlosscard = player.firstlosscard,
                     boxes = C.BOXES, 
                     icons = session.config['icons'], 
                     losscards = player.roundlosscards )
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        if player.chosencard == player.firstlosscard: # if round ended in turning over loss card
            player.endedinloss = True
            player.chosencard -= 1                    # subtract one card from the record of chosen cards
            player.profit = max(0,player.chosencard * player.roundgain - player.roundloss)
        else: # if round ended in stopping
            player.endedinloss = False
            player.profit = player.chosencard * player.roundgain
class RoundEnd(Page):
    form_model = 'player'
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        
        # table of block results
        tabledata = ""
        for j in range(player.round_number):
            j_player = player.in_round(j+1)
            if session.config['icons'] == 'smileys':
                tabledata += "<tr><td class=roundendtable>" + str(j_player.round_number) + "</td><td class=roundendtable>" + str(j_player.chosencard) + "</td><td class=roundendtable>" + str(format(j_player.profit, '.0f')) + "</td></tr>"
            else:
                tabledata += "<tr><td class=roundendtable>" + str(j_player.round_number) + "</td><td class=roundendtable>" + str(j_player.chosencard) + "</td></tr>"
        
        return dict( gains = player.roundgain * player.chosencard, tabledata = tabledata, icons = session.config['icons'])
    @staticmethod
    def js_vars(player: Player):
        session = player.session
        losscardlist = player.losscardlist
        losscardlist = losscardlist[1:]
        losscardlist = losscardlist[:-1]
        losscardlist = losscardlist.split(',')
        
        return dict(chosencard = player.chosencard,
                    boxes = C.BOXES,
                    endedinloss = player.endedinloss,
                    losscardlist = losscardlist,
                    firstlosscard = player.firstlosscard,
                    icons = session.config['icons'])
class RewardPage(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == C.NUM_ROUNDS
    @staticmethod
    def vars_for_template(player: Player):
        import random
        
        if player.field_maybe_none('computer_randomround1') == None and player.field_maybe_none('computer_randomround2') == None:
        
            roundlist = list(range(3, C.NUM_ROUNDS+1))
            # randomly chosen rounds
            randomround1 = random.choice(roundlist)
            roundlist.remove(randomround1) # make sure that randomround2 is not the same as randomround1
            randomround2 = random.choice(roundlist)
        
            rewardplayer1 = player.in_round(randomround1)
            rewardplayer2 = player.in_round(randomround2)
        
            player.computer_randomround1 = rewardplayer1.round_number
            player.computer_randomround2 = rewardplayer2.round_number
            player.reward = (rewardplayer1.profit + rewardplayer2.profit)/100
            player.randomprofit1 = rewardplayer1.profit
            player.randomprofit2 = rewardplayer2.profit
        
        profitzero = False
        if player.reward == 0:
            profitzero = True
        
        return dict( profitzero = profitzero )
class NFC(Page):
    form_model = 'player'
    form_fields = ['dohmen', 'nfcscore', 'nfcall', 'affectbased', 'deliberative', 'handedness']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == C.NUM_ROUNDS and session.config['icons'] == 'smileys'
    @staticmethod
    def js_vars(player: Player):
        group = player.group
        import random
        nfcorder = [
            ['nfc1','I think that having clear rules and order at work is essential for success.'],
            ['nfc2','Even after I have made up my mind about something, I am always eager to consider a different opinion.'],
            ['nfc3','I do not like situations that are uncertain.'],
            ['nfc4','I dislike questions which could be answered in many different ways.'],
            ['nfc5','I like to have friends who are unpredictable.'],
            ['nfc6','I find that a well ordered life with regular hours suits my temperament.'],
            ['nfc7','When dining out, I like to go to places where I have been before so that I know what to expect.'],
            ['nfc8','I feel uncomfortable when I do not understand the reason why an event occurred in my life.'],
            ['nfc9','I feel irritated when one person disagrees with what everyone else in a group believes.'],
            ['nfc10','I hate to change my plans at the last minute.'],
            ['nfc11','I do not like to go into a situation without knowing what I can expect from it.'],
            ['nfc12','When I have made a decision, I feel relieved.'],
            ['nfc13','When I am confronted with a problem, I''m dying to reach a solution very quickly.'],
            ['nfc14','When I am confused about an important issue, I feel very upset.'],
            ['nfc15','I would quickly become impatient and irritated if I would not find a solution to a problem immediately.'],
            ['nfc16','I would rather make a decision quickly than sleep over it.'],
            ['nfc17','Even if I get a lot of time to make a decision, I still feel compelled to decide quickly.'],
            ['nfc18','I think it is fun to change my plans at the last moment.'],
            ['nfc19','I enjoy the uncertainty of going into a new situation without knowing what might happen.'],
            ['nfc20','My personal space is usually messy and disorganised.'],
            ['nfc21','In most social conflicts, I can easily see which side is right and which is wrong.'],
            ['nfc22','I almost always feel hurried to reach a decision, even when there is no reason to do so.'],
            ['nfc23','I believe that orderliness and organisation are among the most important characteristics of a good student.'],
            ['nfc24','When considering most conflict situations, I can usually see how both sides could be right.'],
            ['nfc25','I do not like to be with people who are capable of unexpected actions.'],
            ['nfc26','I prefer to socialise with familiar friends because I know what to expect from them.'],
            ['nfc27','I think that I would learn best in a class that lacks clearly stated objectives and requirements.'],
            ['nfc28','When thinking about a problem, I consider as many different opinions on the issue as possible.'],
            ['nfc29','I like to know what people are thinking all the time.'],
            ['nfc30','I dislike it when a person''s statement could mean many different things.'],
            ['nfc31','It is annoying to listen to someone who cannot seem to make up his or her mind.'],
            ['nfc32','I find that establishing a consistent routine enables me to enjoy life more.'],
            ['nfc33','I enjoy having a clear and structured mode of life.'],
            ['nfc34','I prefer interacting with people whose opinions are very different from my own.'],
            ['nfc35','I like to have a place for everything and everything in its place.'],
            ['nfc36','I feel uncomfortable when someone''s meaning or intention is unclear to me.'],
            ['nfc37','I always see many possible solutions to problems I face.'],
            ['nfc38','I would rather know bad news than stay in a state of uncertainty.'],
            ['nfc39','I do not usually consult many different opinions before forming my own view.'],
            ['nfc40','I dislike unpredictable situations.'],
            ['nfc41','I dislike the routine aspects of my work (studies).']
        ]
        
        random.shuffle(nfcorder)
        
        # NFC Short includes nfc3, nfc4, nfc6, nfc8, nfc9, nfc11, nfc12, nfc13, nfc15, nfc25, nfc30, nfc32, nfc33, nfc39, nfc40
        
        # N = not reversed, R = reversed
        reversedscoring = ['N','R','N','N','R','N','N','N','N','N','N','N','N','N','N','N','N','R','R','R','N','N','N','R','N','N','R','R','N','N','N','N','N','R','N','N','R','N','N','N','R']
        
        # the varianle player.nfcall returns the list of answers in the order nfc1, nfc2, nfc3, ... so with reverse scoring included
        
        # subscales a,b,c,d,e
        subscales = ['a','e','d','e','b','a','b','d','e','a','b','c','c','d','c','c','c','b','b','a','d','c','a','e','b','b','a','e','d','d','d','a','a','e','a','d','e','d','e','b','a']
        
        responses = [' 1 = Strongly disagree',' 2 = Moderately disagree',' 3 = Slightly disagree',' 4 = Slightly agree', ' 5 = Moderately agree', ' 6 = Strongly agree']
        
        return dict( nfcorder = nfcorder, reversedscoring = reversedscoring, responses = responses, subscales = subscales, nfclong = C.NFCLONG )
class ACE(Page):
    form_model = 'player'
    form_fields = ['ace1', 'ace2', 'ace4', 'ace3', 'ace5', 'ace6', 'ace7', 'ace8', 'ace9', 'ace10', 'ace11', 'ace12', 'ace13', 'ace14']
    @staticmethod
    def is_displayed(player: Player):
        session = player.session
        return player.round_number == C.NUM_ROUNDS and session.config['icons'] == 'smileys'
    @staticmethod
    def vars_for_template(player: Player):
        ace1 = '<p>Did a parent or an adult in your home ever swear at you, insult you, or put you down?</p>'
        ace2 = '<p>Did a parent or an adult in your home ever hit, beat, kick, or physically hurt you in any way?</p>'
        ace3 = '<p>Did you experience unwanted sexual contact (such as fondling or oral/anal/vaginal intercourse/penetration)?</p>'
        ace4 = '<p>Did you feel that you did not have enough to eat, had to wear dirty clothes, or had no one to protect or take care of you?</p>'
        ace5 = '<p>Did you feel that no one in your family loved you or thought you were special?</p>'
        ace6 = '<p>Did you live with anyone who was depressed, mentally ill, or attempted suicide?</p>'
        ace7 = '<p>Did you ever experience robbery, theft, or vandalism from your peers outside of your household (such as from someone from your school)?</p>'
        ace8 = '<p>Were you ever assaulted, intimidated, or seriously harassed by your peers outside of your household (such as by someone from your school)?</p>'
        ace9 = '<p>Did you experience or witness violence or other serious crime in the neighbourhood or community in which you lived?</p>'
        ace10 = '<p>Was your socioeconomic status below average?</p>'
        ace11 = '<p>Did someone close to you experience a bad accident or illness?</p>'
        ace12 = '<p>Did you think that your grades in school were below average?</p>'
        ace13 = '<p>Did your parents or adults in your home ever hit, punch, beat, or threaten to harm each other?</p>'
        ace14 = '<p>Did you feel that you had no good friends while growing up?</p>'
        
        return dict( ace1 = ace1, ace2 = ace2, ace3 = ace3, ace4 = ace4, ace5 = ace5, ace6 = ace6, ace7 = ace7, ace8 = ace8, ace9 = ace9, ace10 = ace10, ace11 = ace11, ace12 = ace12, ace13 = ace13, ace14 = ace14 )
class FinalPage(Page):
    form_model = 'player'
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == C.NUM_ROUNDS
    @staticmethod
    def vars_for_template(player: Player):
        session = player.session
        return dict( prolificurl = session.config['prolificurl'],  icons = session.config['icons'] )
page_sequence = [Welcome, Instructions, RoundStart, Decision, RoundEnd, RewardPage, NFC, ACE, FinalPage]