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

import random


author = ''

doc = """
Your app description
"""

class Constants(BaseConstants):
    name_in_url = 'sample_pages'
    players_per_group = None
    num_rounds = 150

    order_max = 42 #number of unique rounds in stage1-1
    order_max_s2 = 10 #number of unique rounds in stage 2

    # randomize order of rounds
    round_order = list(range(1, order_max+2, 1)) #round order is range from 1 to 43 (or number of unique rounds)
    # print("Original: ", round_order)
    random.shuffle(round_order)
    # print("1 shuffle: ", round_order)


    # input the round parameters
    endowment = [0]
    probA = [0]
    probB = [0]
    returnA = [0]
    returnB = [0]

    endowment.insert(1, 10)
    probA.insert(1, 1)
    probB.insert(1, 0)
    returnA.insert(1, 2.1)
    returnB.insert(1, -1)

    endowment.insert(2, 10)
    probA.insert(2, 0.1)
    probB.insert(2, 0.9)
    returnA.insert(2, 1.9)
    returnB.insert(2, 2.3)

    endowment.insert(3, 10)
    probA.insert(3, 0.55)
    probB.insert(3, 0.45)
    returnA.insert(3, 2.7)
    returnB.insert(3, 1.6)

    endowment.insert(4, 10)
    probA.insert(4, 1)
    probB.insert(4, 0)
    returnA.insert(4, 1)
    returnB.insert(4, -1)

    endowment.insert(5, 10)
    probA.insert(5, 1)
    probB.insert(5, 0)
    returnA.insert(5, 1.1)
    returnB.insert(5, -1)

    endowment.insert(6, 10)
    probA.insert(6, 1)
    probB.insert(6, 0)
    returnA.insert(6, 1.2)
    returnB.insert(6, -1)

    endowment.insert(7, 10)
    probA.insert(7, 1)
    probB.insert(7, 0)
    returnA.insert(7, 1.3)
    returnB.insert(7, -1)

    endowment.insert(8, 10)
    probA.insert(8, 1)
    probB.insert(8, 0)
    returnA.insert(8, 1.4)
    returnB.insert(8, -1)

    endowment.insert(9, 10)
    probA.insert(9, 1)
    probB.insert(9, 0)
    returnA.insert(9, 1.5)
    returnB.insert(9, -1)

    endowment.insert(10, 10)
    probA.insert(10, 1)
    probB.insert(10, 0)
    returnA.insert(10, 1.6)
    returnB.insert(10, -1)

    endowment.insert(11, 10)
    probA.insert(11, 1)
    probB.insert(11, 0)
    returnA.insert(11, 1.7)
    returnB.insert(11, -1)

    endowment.insert(12, 10)
    probA.insert(12, 1)
    probB.insert(12, 0)
    returnA.insert(12, 1.8)
    returnB.insert(12, -1)

    endowment.insert(13, 10)
    probA.insert(13, 1)
    probB.insert(13, 0)
    returnA.insert(13, 1.9)
    returnB.insert(13, -1)

    endowment.insert(14, 10)
    probA.insert(14, 0.05)
    probB.insert(14, 0.95)
    returnA.insert(14, 1.7)
    returnB.insert(14, 2.5)

    endowment.insert(15, 10)
    probA.insert(15, 0.8)
    probB.insert(15, 0.2)
    returnA.insert(15, 1.7)
    returnB.insert(15, 2.5)

    endowment.insert(16, 10)
    probA.insert(16, 0.3)
    probB.insert(16, 0.7)
    returnA.insert(16, 1.7)
    returnB.insert(16, 2.5)

    endowment.insert(17, 10)
    probA.insert(16, 0.6)
    probB.insert(16, 0.4)
    returnA.insert(16, 1.7)
    returnB.insert(16, 2.5)

    endowment.insert(18, 10)
    probA.insert(18, 0.5)
    probB.insert(18, 0.5)
    returnA.insert(18, 1.7)
    returnB.insert(18, 2.5)

    endowment.insert(19, 10)
    probA.insert(19, 0.95)
    probB.insert(19, 0.05)
    returnA.insert(19, 1.7)
    returnB.insert(19, 2.5)

    endowment.insert(20, 10)
    probA.insert(20, 0.2)
    probB.insert(20, 0.8)
    returnA.insert(20, 1.7)
    returnB.insert(20, 2.5)

    endowment.insert(21, 10)
    probA.insert(21, 0.7)
    probB.insert(21, 0.3)
    returnA.insert(21, 1.7)
    returnB.insert(21, 2.5)

    endowment.insert(22, 10)
    probA.insert(22, 0.4)
    probB.insert(22, 0.6)
    returnA.insert(22, 1.7)
    returnB.insert(22, 2.5)

    endowment.insert(23, 10)
    probA.insert(23, 0.5)
    probB.insert(23, 0.5)
    returnA.insert(23, 1.7)
    returnB.insert(23, 2.5)

    endowment.insert(24, 10)
    probA.insert(24, 0.05)
    probB.insert(24, 0.95)
    returnA.insert(24, 2.4)
    returnB.insert(24, 1.8)

    endowment.insert(25, 10)
    probA.insert(25, 0.8)
    probB.insert(25, 0.2)
    returnA.insert(25, 2.4)
    returnB.insert(25, 1.8)

    endowment.insert(26, 10)
    probA.insert(26, 0.3)
    probB.insert(26, 0.7)
    returnA.insert(26, 2.4)
    returnB.insert(26, 1.8)

    endowment.insert(27, 10)
    probA.insert(27, 0.6)
    probB.insert(27, 0.4)
    returnA.insert(27, 2.4)
    returnB.insert(27, 1.8)

    endowment.insert(28, 10)
    probA.insert(28, 0.5)
    probB.insert(28, 0.5)
    returnA.insert(28, 2.4)
    returnB.insert(28, 1.8)

    endowment.insert(29, 10)
    probA.insert(29, 0.95)
    probB.insert(29, 0.05)
    returnA.insert(29, 2.4)
    returnB.insert(29, 1.8)

    endowment.insert(30, 10)
    probA.insert(30, 0.2)
    probB.insert(30, 0.8)
    returnA.insert(30, 2.4)
    returnB.insert(30, 1.8)

    endowment.insert(31, 10)
    probA.insert(31, 0.7)
    probB.insert(31, 0.3)
    returnA.insert(31, 2.4)
    returnB.insert(31, 1.8)

    endowment.insert(32, 10)
    probA.insert(32, 0.4)
    probB.insert(32, 0.6)
    returnA.insert(32, 2.4)
    returnB.insert(32, 1.8)

    endowment.insert(33, 10)
    probA.insert(33, 0.5)
    probB.insert(33, 0.5)
    returnA.insert(33, 2.4)
    returnB.insert(33, 1.8)

    endowment.insert(34, 10)
    probA.insert(34, 0.05)
    probB.insert(34, 0.95)
    returnA.insert(34, 2.2)
    returnB.insert(34, 2)

    endowment.insert(35, 10)
    probA.insert(35, 0.8)
    probB.insert(35, 0.2)
    returnA.insert(35, 2.2)
    returnB.insert(35, 2)

    endowment.insert(36, 10)
    probA.insert(36, 0.3)
    probB.insert(36, 0.7)
    returnA.insert(36, 2.2)
    returnB.insert(36, 2)

    endowment.insert(37, 10)
    probA.insert(37, 0.6)
    probB.insert(37, 0.4)
    returnA.insert(37, 2.2)
    returnB.insert(37, 2)

    endowment.insert(38, 10)
    probA.insert(38, 0.5)
    probB.insert(38, 0.5)
    returnA.insert(38, 2.2)
    returnB.insert(38, 2)

    endowment.insert(39, 10)
    probA.insert(39, 0.95)
    probB.insert(39, 0.05)
    returnA.insert(39, 2.2)
    returnB.insert(39, 2)

    endowment.insert(40, 10)
    probA.insert(40, 0.2)
    probB.insert(40, 0.8)
    returnA.insert(40, 2.2)
    returnB.insert(40, 2)

    endowment.insert(41, 10)
    probA.insert(41, 0.7)
    probB.insert(41, 0.3)
    returnA.insert(41, 2.2)
    returnB.insert(41, 2)

    endowment.insert(42, 10)
    probA.insert(42, 0.4)
    probB.insert(42, 0.6)
    returnA.insert(42, 2.2)
    returnB.insert(42, 2)

    endowment.insert(43, 10)
    probA.insert(43, 0.5)
    probB.insert(43, 0.5)
    returnA.insert(43, 2.2)
    returnB.insert(43, 2)

    stage2_alt = [1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5, 9, 9.5, 10]


class Subsession(BaseSubsession):
    def creating_session(self):
        if self.round_number == 1:
            #determine paying round order (between 0 and max round order)
            paying_round = random.randint(0,Constants.order_max)
            self.session.vars['paying_round'] = paying_round

            #draw number between 0 and 1 that will determine paying asset
            paying_asset_number = random.uniform(0,1) # if less than probA in the paying round then A pays, else B
            self.session.vars['paying_asset_number'] = paying_asset_number

            #map from paying_asset_number to the asset letter
            #compare paying_asset_number to the return probability of asset A in the paying round
            #if paying_asset_number <= Constants.probA[Constants.round_order[self.round_number]]:
            #    paying_asset = "A"
            #else: paying_asset = "B"
            #self.session.vars['paying_asset'] = paying_asset


            paying_order_s2 = random.randint(0, Constants.order_max_s2-1)
            self.session. vars['paying_order_s2'] = paying_order_s2

            paying_choice_number_s2 = random.randint(0, 19)
            self.session.vars['paying_choice_number_s2'] = paying_choice_number_s2

            paying_asset_s2 = random.uniform(0,1)
            self.session.vars['paying_asset_number_s2'] = paying_asset_s2


class Group(BaseGroup):
    pass

class Player(BasePlayer):

    # Comprehension Question Fields
    comp_instant = models.FloatField()
    comp_oneMonthA = models.FloatField()
    comp_oneMonthB = models.FloatField()
    comp_prob1 = models.FloatField()
    comp_prob2 = models.FloatField()

    #Round Parameters
    counter = models.IntegerField()
    round_order = models.IntegerField()
    round_endowment = models.CurrencyField()
    round_probA = models.FloatField()
    round_probB = models.FloatField()
    round_returnA = models.FloatField()
    round_returnB = models.FloatField()

    #Round Choices
    savings = models.CurrencyField(min = 0, max = 10)
    investA = models.CurrencyField()
    # set min value for input in investA
    def investA_min(self):
        if (self.round_probB == 0):
            return self.round_endowment - self.savings
        return 0

    # set max value for input in investA
    def investA_max(self):
        return self.round_endowment - self.savings
    investB = models.CurrencyField()

    #Payoffs
    paying_asset = models.StringField()
    payoff_today = models.CurrencyField()
    payoff_oneMonth = models.CurrencyField()

    make_changes = models.BooleanField()

    stage1_round = models.IntegerField()
    choice1 = models.IntegerField(
        choices = [
            [1, ''],
            [2, ''],
        ],
        widget = widgets.RadioSelectHorizontal
    )
    choice2 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget = widgets.RadioSelectHorizontal
    )
    choice3 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget = widgets.RadioSelectHorizontal
    )
    choice4 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget = widgets.RadioSelectHorizontal
    )
    choice5 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice6 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget = widgets.RadioSelectHorizontal
    )
    choice7 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice8 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice9 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice10 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice11 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice12 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice13 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget = widgets.RadioSelectHorizontal
    )
    choice14 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice15 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice16 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice17 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice18 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )
    choice19 = models.IntegerField(
        choices=[
            [1, ''],
            [2, ''],
        ],
        widget=widgets.RadioSelectHorizontal
    )


    #Error Messages for incorrect user inputs
    def comp_instant_error_message(self, value):
       if value != 10:
           return 'Incorrect. Try Again.'
    def comp_oneMonthA_error_message(self, value):
         if value != 11:
             return 'Incorrect. Try Again.'
    def comp_oneMonthB_error_message(self, value):
         if value != 5:
             return 'Incorrect. Try Again.'
    def comp_prob1_error_message(self, value):
         if value != 60:
             return 'Incorrect. Try Again.'
    def comp_prob2_error_message(self, value):
         if value != 40:
             return 'Incorrect. Try Again.'