from otree.api import *
import random
import pickle
from datetime import datetime
import pandas as pd

c = cu

doc = """
Your app description
"""

class C(BaseConstants):
    NAME_IN_URL = 'risk_attitude'
    PLAYERS_PER_GROUP = None
    NUM_ROUNDS = 1
    NUM_TRIES = 2
    exchange_rate = 0.02


class Subsession(BaseSubsession):
    pass

class Group(BaseGroup):
    pass

class Player(BasePlayer):
    decision_round_one = models.IntegerField(min=0, max=199, label="Which option do you choose? Please indicate the number of the lottery.")
    decision_round_two = models.IntegerField(choices=[[0, "I"],
                                                      [1, "II"],
                                                      [2, "III"],
                                                      [3, "IV"],
                                                      [4, "V"],
                                                      [5, "VI"],
                                                      [6, "VII"],
                                                      [7, "VIII"],
                                                      [8, "IX"],
                                                      [9, "X"],
                                                      [10, "XI"]], label="Which option do you choose? Please indicate the number of the lottery.")
    risk_level_revealed = models.IntegerField()
    risk_prediction_full = models.IntegerField()
    risk_prediction_decfs = models.IntegerField()
    unfold_list_tracker = models.BooleanField(blank=True)


    treatment_order = models.StringField()
    tries_left = models.IntegerField(initial=C.NUM_TRIES)
    quiz1 = models.IntegerField(label='How many payout options does a lottery include?',
                                choices=[1,2,3])
    quiz2 = models.IntegerField(label='What purpose does the AI system serve?',
                               choices=[[1,"Predicting your helpfulness"],
                                        [2,'Predicting your risk tolerance'],
                                        [3,'Predicting your age']])

    BDM_treatment = models.IntegerField(min=0, max=2500, label="Please indicate how many points you would spend to use the AI system")
    BDM_baseline  = models.IntegerField(min=0, max=2500, label="Please indicate how many points you would spend to use the AI system")

    BDM_result_treatment = models.BooleanField()
    BDM_result_baseline  = models.BooleanField()
    random_threshold_treatment = models.IntegerField()
    random_threshold_baseline = models.IntegerField()

    # Participants' descriptives
    # Alter
    age = models.IntegerField(label="Your age:", min=18, max=99, blank=False)
    sex = models.IntegerField(choices=[[1, "Female"], [0, "Male"]],widget=widgets.RadioSelect, label="Your gender:", blank=False)
    germborn = models.IntegerField(choices=[[0, 'Not born in the USA'], [1, 'Born in the USA']], label="Were you born in the USA?", widget=widgets.RadioSelect)
    height = models.IntegerField(label="Your body height <b>in centimeters</b>", min=100, max=230, blank=False)
    income = models.IntegerField(choices=[[0, '< 1000 $'],[1, '1001 - 1500 $'],[2, '1501 - 2000 $'],
                                          [3, '2001 - 2500 $'],[4, '2501 - 3000 $'],[5, '3001 - 3500 $'],
                                          [6, '3501 - 4000 $'],[7, '4001 - 4500 $'],[8, '4501 - 5000 $'],
                                          [9, '> 5000 $']], label="Your gross monthly income in dollars:", blank=False)
    education = models.IntegerField(min=0, max=30, label="The total duration of your education in years (starting from the 1st grade)."
                                          "<br><b>Example 1:</b> You have attended school for 13 years and then studied for 5 years: Total duration = 18 years"
                                          "<br><b>Example 2:</b> You have attended school for 8 years and then completed 3 years of vocational training: Total duration = 11 years", blank=False)
    sat_socialLife = models.IntegerField(choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], label="Your friends and acquaintances?", widget=widgets.RadioSelectHorizontal, blank=False)
    sat_health = models.IntegerField(choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], label="Your health?", widget=widgets.RadioSelectHorizontal, blank=False)
    importance_religion = models.IntegerField(choices=[[4, "Unimportant"], [3, "Less important"], [2, "Important"], [1,"Very important"]],
                                              label="Faith, religion", widget=widgets.RadioSelectHorizontal, blank=False)
    importance_involvement = models.IntegerField(choices=[[4, "Unimportant"], [3, "Less important"], [2, "Important"], [1,"Very important"]],
                                                 label="Being politically, socially involved", widget=widgets.RadioSelectHorizontal, blank=False)
    check_account = models.IntegerField(choices= [[5, "Never"], [4, "Less often than once a month"], [3, "At least once a month"], [2, "At least once a week"], [1, "Daily"]],
                                              label="Frequency of checking your bank account balance:",
                                              widget=widgets.RadioSelectHorizontal, blank=False)
    alcohol = models.IntegerField(choices=[[6, "Never"], [5, "Once a month or less often"], [4, "On two to four days monthly"], [3, "On two to three days weekly"],
                                           [2, "On four to six days weekly"], [1, "Daily"]], label="Frequency of drinking alcohol",
                                              widget=widgets.RadioSelect, blank=False)
    smoke = models.IntegerField(choices=[[1, "Yes"], [0, "No"]], widget=widgets.RadioSelect, label="Do you currently smoke, whether cigarettes, a pipe, or cigars?", blank=False)

    # - - - - - - - - - - - - - - - - - - - - - -

    # Dummy variables
    age_dummy       = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Age", widget=widgets.RadioSelect, blank=False)###
    sex_dummy       = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Gender", widget=widgets.RadioSelect, blank=False)###
    height_dummy    = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Body height", widget=widgets.RadioSelect, blank=False)###
    germborn_dummy  = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Born in the USA", widget=widgets.RadioSelect, blank=False)###
    income_dummy    = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Gross monthly income", widget=widgets.RadioSelect, blank=False)###
    education_dummy       = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Years of education", widget=widgets.RadioSelect, blank=False)###
    sat_socialLife_dummy  = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Satisfaction with friends and acquaintances", widget=widgets.RadioSelect, blank=False)###
    sat_health_dummy = models.IntegerField(choices=[[0, 'Reveal'],[1, 'hold back']], label="Satisfaction with your health", widget=widgets.RadioSelect, blank=False)
    importance_religion_dummy = models.IntegerField(choices=[[0, 'Reveal'], [1, 'hold back']],label="Importance of faith, religion", widget=widgets.RadioSelect, blank=False)###
    importance_involvement_dummy = models.IntegerField(choices=[[0, 'Reveal'], [1, 'hold back']],label="Importance of being politically, socially involved", widget=widgets.RadioSelect, blank=False)
    check_account_dummy = models.IntegerField(choices=[[0, 'Reveal'], [1, 'hold back']],label="Frequency of checking your bank account balance",widget=widgets.RadioSelect, blank=False)###
    alcohol_dummy = models.IntegerField(choices=[[0, 'Reveal'], [1, 'hold back']],label="Frequency of drinking alcohol", widget=widgets.RadioSelect, blank=False)###
    smoke_dummy = models.IntegerField(choices=[[0, 'Reveal'], [1, 'hold back']],label="Smoke", widget=widgets.RadioSelect, blank=False)

    # Feature evaluations
    age_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5], widget=widgets.RadioSelect, label="Age", blank=False)
    sex_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5], widget=widgets.RadioSelect, label="Gender", blank=False)
    height_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5], label="Body height", widget=widgets.RadioSelect, blank=False)  ###
    germborn_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5], label="Born in the USA", widget=widgets.RadioSelect, blank=False)  ###
    income_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                       label="Gross monthly income", widget=widgets.RadioSelect, blank=False)  ###
    education_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                          label="Years of education", widget=widgets.RadioSelect, blank=False)  ###
    sat_socialLife_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                               label="Satisfaction with friends and acquaintances",
                                               widget=widgets.RadioSelect, blank=False)  ###
    sat_health_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                           label="Satisfaction with your health", widget=widgets.RadioSelect,
                                           blank=False)
    importance_religion_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                                    label="Importance of faith, religion",
                                                    widget=widgets.RadioSelect, blank=False)  ###
    importance_involvement_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                                       label="Importance of being politically, socially involved",
                                                       widget=widgets.RadioSelect, blank=False)
    check_account_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                              label="Frequency of checking your bank account balance", widget=widgets.RadioSelect, blank=False)  ###
    alcohol_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5],
                                        label="Frequency of drinking alcohol", widget=widgets.RadioSelect,
                                        blank=False)  ###
    smoke_evaluation = models.IntegerField(choices=[1, 2, 3, 4, 5], label="Smoke",
                                      widget=widgets.RadioSelect, blank=False)

    ### ------ Secondary measures
    # cognitive trust
    algo_expert_treatment = models.IntegerField(choices=list(range(1, 8)),
                                      label="The AI system is an expert in predicting risk tolerance.",
                                      widget=widgets.RadioSelect) # original: his RA is a real expert in assessing products.
    algo_expert_baseline = models.IntegerField(choices=list(range(1, 8)),
                                      label="The AI system is an expert in predicting risk tolerance.",
                                      widget=widgets.RadioSelect) # original: his RA is a real expert in assessing products.
    algo_knowledge_treatment = models.IntegerField(choices=list(range(1, 8)),
                                         label="The AI system has good knowledge about the risk tolerance of the participants.",
                                         widget=widgets.RadioSelect) # This RA has good knowledge about products.
    algo_knowledge_baseline = models.IntegerField(choices=list(range(1, 8)),
                                         label="The AI system has good knowledge about the risk tolerance of the participants.",
                                         widget=widgets.RadioSelect) # This RA has good knowledge about products.

    # emotional trust
    feel_secure_treatment = models.IntegerField(choices=list(range(1, 8)),
                                      label="I feel safe relying on the AI system when making my lottery decision.",
                                      widget=widgets.RadioSelect) #  I feel secure about relying on this RA for my decision.
    feel_secure_baseline = models.IntegerField(choices=list(range(1, 8)),
                                      label="I feel safe relying on the AI system when making my lottery decision.",
                                      widget=widgets.RadioSelect) #  I feel secure about relying on this RA for my decision.
    feel_comfortable_treatment = models.IntegerField(choices=list(range(1, 8)),
                                           label="I feel comfortable relying on the AI system when making my lottery decision.",
                                           widget=widgets.RadioSelect)
    feel_comfortable_baseline = models.IntegerField(choices=list(range(1, 8)),
                                                     label="I feel comfortable relying on the AI system when making my lottery decision.",
                                                     widget=widgets.RadioSelect)
    feel_content_treatment = models.IntegerField(choices=list(range(1, 8)),
                                       label="I feel content relying on the AI system when making my lottery decision.",
                                       widget=widgets.RadioSelect)
    feel_content_baseline = models.IntegerField(choices=list(range(1, 8)),
                                                 label="I feel content relying on the AI system when making my lottery decision.",
                                                 widget=widgets.RadioSelect)

    # Transparency
    transparency_treatment = models.IntegerField(choices=list(range(1, 8)),
                                       label="I understand how the AI system predicts risk tolerance.",
                                       widget=widgets.RadioSelect)
    transparency_baseline = models.IntegerField(choices=list(range(1, 8)),
                                       label="I understand how the AI system predicts risk tolerance.",
                                       widget=widgets.RadioSelect)

    # Power citation: Spiekermann, S. (2007). Perceived control: Scales for privacy in ubiquitous computing. In Digital Privacy (pp. 289-304). Auerbach Publications.
    power_treatment = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,
                               label="I feel that I can steer the AI system in a direction that I think is right.",
                               blank=False)
    power_baseline = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,
                               label="I feel that I can steer the AI system in a direction that I think is right.",
                               blank=False)

    # Privacy citation: Xu, H., Gupta, S., Rosson, M. B., & Carroll, J. M. (2012). Measuring mobile users' concerns for information privacy.
    privacy_1_treatment = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,
                               label="I feel that by using the AI system, others know more about me than I would like.",
                               blank=False) # original: I feel that as a result of my using mobile apps, others know about me more than I am comfortable with.
    privacy_1_baseline = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,
                               label="I feel that by using the AI system, others know more about me than I would like.",
                               blank=False) # original: I feel that as a result of my using mobile apps, others know about me more than I am comfortable with.
    privacy_2_treatment = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,
                               label="I feel that by using the AI system, there is information circulating about me that, if used, will violate my privacy.",
                               blank=False) # original: I feel that as a result of my using mobile apps, information about me is out there that, if used, will invade my privacy.
    privacy_2_baseline = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,
                               label="I feel that by using the AI system, there is information circulating about me that, if used, will violate my privacy.",
                               blank=False) # original: I feel that as a result of my using mobile apps, information about me is out there that, if used, will invade my privacy.

    # Perceived acc
    perceived_accuracy_treatment = models.IntegerField(min=0, max=100)
    perceived_accuracy_baseline = models.IntegerField(min=0, max=100)

    perceived_rmse_treatment = models.IntegerField(min=0, max=10)
    perceived_rmse_baseline = models.IntegerField(min=0, max=10)


    # Control measures (ATAI)
    ATAI_fear = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,label="I fear artifcial intelligence.", blank=False)
    ATAI_trust = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,label="I trust artifcial intelligence.", blank=False)
    ATAI_destroy_humankind = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,label=" Artifcial intelligence will destroy humankind.", blank=False)
    ATAI_benefit = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,label="Artifcial intelligence will beneft humankind.", blank=False)
    ATAI_job_loss = models.IntegerField(choices=list(range(1, 8)), widget=widgets.RadioSelect,label="Artifcial intelligence will cause many job losses.", blank=False)

    spec_endowment_treatment = models.IntegerField(initial=2500)
    spec_endowment_baseline  = models.IntegerField(initial=2500)

    comments = models.LongStringField(blank=True)
    seed = models.IntegerField()
    seed_questionnaire_1 = models.IntegerField()
    seed_questionnaire_2 = models.IntegerField()
    seed_questionnaire_3 = models.IntegerField()
    tries_left = models.IntegerField(initial=C.NUM_TRIES)
    payoff_lotteries = models.IntegerField(blank=True)

# Functions
ml_model = pickle.load(open('risk_model_multi.sav', 'rb'))

def predict_risk_full(player: Player):  # Predict the risk attitude based on all attributes
    # Create the input for the ML model; consists of (1) questionnaire attr. and (2) dummies=0
    input_obs_dict = pd.DataFrame({"age": player.age,
                                   "education": player.education,
                                   "height": player.height,
                                   "sex": player.sex,
                                   "germborn": player.germborn,
                                   "smoke": player.smoke,
                                   "sat_health": player.sat_health,
                                   "sat_socialLife": player.sat_socialLife,
                                   "importance_religion": player.importance_religion,
                                   "check_account": player.check_account,
                                   "alcohol": player.alcohol,
                                   "importance_involvement": player.importance_involvement,
                                   "income": player.income,
                                   # ----- Dummies --------
                                   "age_dummy": 0,
                                   "education_dummy": 0,
                                   "height_dummy":0,
                                   "sex_dummy": 0,
                                   "germborn_dummy": 0,
                                   "smoke_dummy": 0,
                                   "sat_health_dummy": 0,
                                   "sat_socialLife_dummy": 0,
                                   "importance_religion_dummy": 0,
                                   "check_account_dummy": 0,
                                   "alcohol_dummy": 0,
                                   "importance_involvement_dummy":0,
                                   "income_dummy": 0
                                   },
                                  index=[0])

    input_obs = pd.DataFrame(input_obs_dict)  # Convert dict to DataFrame (only 1 row since we look at each single participant)
    print(input_obs)
    player.risk_prediction_full = int(ml_model.predict(input_obs))  # Perform the prediction

def set_seed(player: Player):
    player.seed = random.randint(1,10000)
    player.seed_questionnaire_1 = random.randint(1,10000)
    player.seed_questionnaire_2 = random.randint(1, 10000)
    player.seed_questionnaire_3 = random.randint(1, 10000)

def predict_risk_decfs(player: Player):
    dummies = [player.height_dummy, player.age_dummy, player.sex_dummy, player.germborn_dummy, player.income_dummy, player.education_dummy,
               player.sat_socialLife_dummy, player.sat_health_dummy, player.importance_religion_dummy,
               player.importance_involvement_dummy, player.check_account_dummy, player.alcohol_dummy, player.smoke_dummy]

    player_vars = [player.height, player.age, player.sex, player.germborn, player.income, player.education,
                   player.sat_socialLife, player.sat_health,
                   player.importance_religion, player.importance_involvement,
                   player.check_account, player.alcohol, player.smoke]

    participant = player.participant

    par_fields = ["height","age", "sex", "germborn", "income", "education",
                  "sat_socialLife", "sat_health",
                  "importance_religion","importance_involvement",
                  "check_account", "alcohol", 'smoke']

    for dummy, var, par_field in zip(dummies, player_vars, par_fields):

        if dummy == 1:
            participant.vars[par_field] = -1
        else:
            participant.vars[par_field] = var

    input_obs_dict = pd.DataFrame({"age": participant.age,
                                   "education": participant.education,
                                   "height": participant.height,
                                   "sex": participant.sex,
                                   "germborn": participant.germborn,
                                   "smoke": participant.smoke,
                                   "sat_health": participant.sat_health,
                                   "sat_socialLife": participant.sat_socialLife,
                                   "importance_religion": participant.importance_religion,
                                   "check_account": participant.check_account,
                                   "alcohol": participant.alcohol,
                                   "importance_involvement": participant.importance_involvement,
                                   "income": participant.income,
                                   # ----- Dummies --------
                                   "age_dummy": player.age_dummy,
                                   "education_dummy": player.education_dummy,
                                   "height_dummy": player.height_dummy,
                                   "sex_dummy": player.sex_dummy,
                                   "germborn_dummy": player.germborn_dummy,
                                   "smoke_dummy": player.smoke_dummy,
                                   "sat_health_dummy": player.sat_health_dummy,
                                   "sat_socialLife_dummy": player.sat_socialLife_dummy,
                                   "importance_religion_dummy": player.importance_religion_dummy,
                                   "check_account_dummy": player.check_account_dummy,
                                   "alcohol_dummy": player.alcohol_dummy,
                                   "importance_involvement_dummy":player.importance_involvement_dummy,
                                   "income_dummy": player.income_dummy
                                   },
                                  index=[0])

    input_obs = pd.DataFrame(input_obs_dict)
    print(input_obs)
    player.risk_prediction_decfs = int(ml_model.predict(input_obs))

def creating_session(subsession): # Assigns the experimental groups; itertools.cycle ensures that we have 50/50 distribution of treatment groups
    import itertools
    order_conditions = itertools.cycle(['A', 'B'])
    x = 1
    for player in subsession.get_players():
        player.treatment_order = next(order_conditions)
        print('player', x, 'is in condition:', player.treatment_order)
        x += 1
    subsession.group_randomly()

def start_timestamp(player: Player):
    participant = player.participant
    participant.vars['start_time'] = datetime.now()

def end_timestamp(player: Player):
    participant = player.participant
    participant.vars['end_time'] = datetime.now()
    completion_time = participant.vars['end_time'] - participant.vars['start_time']
    participant.vars['completion_time'] = completion_time.seconds

"""
def create_lottery(p1, v1, v2):
    parameter_list = [p1, v1, v2]
    expected_value = p1 * v1 + (1 - p1) * v2

    if (v1 != 1) and (v2 != 1):
        lottery = f"Mit einer Wahrscheinlichkeit von {p1 * 100}% erhalten Sie {v1} Punkte. Mit einer Wahrscheinlichkeit von {(1 - p1) * 100}% erhalten Sie {v2} Punkte."
    elif (v1 == 1) and (v2 != 1):
        lottery = f"Mit einer Wahrscheinlichkeit von {p1 * 100}% erhalten Sie {v1} Punkt. Mit einer Wahrscheinlichkeit von {(1 - p1) * 100}% erhalten Sie {v2} Punkte."
    elif (v1 != 1) and (v2 == 1):
        lottery = f"Mit einer Wahrscheinlichkeit von {p1 * 100}% erhalten Sie {v1} Punkte. Mit einer Wahrscheinlichkeit von {(1 - p1) * 100}% erhalten Sie {v2} Punkt."

    return lottery, parameter_list, expected_value
"""

def personalize_lotteries_risk_A(player: Player):
    random.seed(player.seed)
    lottery_AB_list = pickle.load(open('lotteries_AB_en.sav', 'rb'))
    random.shuffle(lottery_AB_list)
    for i in range(len(lottery_AB_list)):
        lottery_AB_list[i]['ID_shuffled'] = i

    personalised_lotteries = []
    if player.treatment == 'baseline':
        for lottery in lottery_AB_list:
            if lottery['risk_level'] == player.risk_prediction_full:
                ID_found = lottery['ID']
    elif player.treatment == 'treatment':
        for lottery in lottery_AB_list:
            if lottery['risk_level'] == player.risk_prediction_decfs:
                ID_found = lottery['ID']

    if ID_found == 0:
        ID_presented = [0, 1, 2, 3, 4]
    elif ID_found == 1:
        ID_presented = [0, 1, 2, 3, 4]
    else:
        ID_presented = [ID_found - 2,
                        ID_found - 1,
                        ID_found,
                        ID_found + 1,
                        ID_found + 2]

    for lottery in lottery_AB_list:
        if (lottery['ID'] in ID_presented) and(lottery['dominance_class']=='A'):
            personalised_lotteries.append(lottery)
    return personalised_lotteries

def personalize_lotteries_risk_B(player: Player):
    random.seed(player.seed)
    lottery_AB_list = pickle.load(open('lotteries_AB_en.sav', 'rb'))
    random.shuffle(lottery_AB_list)
    for i in range(len(lottery_AB_list)):
        lottery_AB_list[i]['ID_shuffled'] = i

    personalised_lotteries = []
    if player.treatment == 'baseline':
        for lottery in lottery_AB_list:
            if lottery['risk_level'] == player.risk_prediction_full:
                ID_found = lottery['ID']
    elif player.treatment == 'treatment':
        for lottery in lottery_AB_list:
            if lottery['risk_level'] == player.risk_prediction_decfs:
                ID_found = lottery['ID']

    if ID_found == 0:
        ID_presented = [0, 1, 2, 3, 4]
    elif ID_found == 1:
        ID_presented = [0, 1, 2, 3, 4]
    else:
        ID_presented = [ID_found - 2,
                        ID_found - 1,
                        ID_found,
                        ID_found + 1,
                        ID_found + 2]

    for lottery in lottery_AB_list:
        if (lottery['ID'] in ID_presented) and(lottery['dominance_class']=='A'):
            personalised_lotteries.append(lottery)
    return personalised_lotteries

def extract_risk_level(player: Player):
    random.seed(player.seed)
    lottery_AB_list = pickle.load(open('lotteries_AB_en.sav', 'rb'))
    random.shuffle(lottery_AB_list)
    lotteries_repr = []
    for lottery in lottery_AB_list:
        if lottery['representative'] == True:
            lotteries_repr.append(lottery)

    if player.seed > 5000:
        lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=False)
    else:
        lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=True)

    player.risk_level_revealed = lotteries_repr[player.decision_round_two]["risk_level"]

def BDM_decision_treatment(player: Player):
    player.random_threshold_treatment = random.randint(0, 2500)
    player.BDM_result_treatment = 1 if player.BDM_treatment >= player.random_threshold_treatment else 0

def BDM_decision_baseline(player: Player):
    player.random_threshold_baseline = random.randint(0, 2500)
    player.BDM_result_baseline = 1 if player.BDM_baseline >= player.random_threshold_baseline else 0

def Calc_spec_endowment_treatment(player:Player):
    if player.BDM_result_treatment == 1:
        player.spec_endowment_treatment = player.spec_endowment_treatment - player.random_threshold_treatment
    if player.BDM_result_treatment == 0:
        player.spec_endowment_treatment = player.spec_endowment_treatment

def Calc_spec_endowment_baseline(player:Player):
    if player.BDM_result_baseline == 1:
        player.spec_endowment_baseline = player.spec_endowment_baseline - player.random_threshold_baseline
    if player.BDM_result_baseline == 0:
        player.spec_endowment_baseline = player.spec_endowment_baseline

def lottery_payoff_sum(player:Player):
    random.seed(player.seed)
    lotteriesAB = pickle.load(open('lotteries_AB_en.sav', 'rb'))
    random.shuffle(lotteriesAB)
    for i in range(len(lotteriesAB)):
        lotteriesAB[i]['ID_shuffled'] = i
    lottery_one_selected = lotteriesAB[player.decision_round_one]
    lottery_one_payoff = random.choices([lottery_one_selected['value1'], lottery_one_selected['value2']],
                                        weights = (lottery_one_selected['prob'], 1-lottery_one_selected['prob']))[0]
    lottery_one_selected_text = lottery_one_selected['text']
    ### round 2
    random.seed(player.seed)
    lottery_AB_list = pickle.load(open('lotteries_AB_en.sav', 'rb'))
    random.shuffle(lottery_AB_list)
    lotteries_repr = []
    for lottery in lottery_AB_list:
        if lottery['representative'] == True:
            lotteries_repr.append(lottery)

    if player.seed > 5000:
        lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=False)
    else:
        lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=True)

    lottery_two_selected = lotteries_repr[player.decision_round_two]
    lottery_two_payoff = random.choices([lottery_two_selected['value1'], lottery_two_selected['value2']],
                                        weights=(lottery_two_selected['prob'], 1 - lottery_two_selected['prob']))[0]
    lottery_two_selected_text = lottery_two_selected['text']

    lottery_payoff_both = int(lottery_one_payoff + lottery_two_payoff)
    player.payoff_lotteries=lottery_payoff_both


    return dict(lottery_one_payoff=lottery_one_payoff,
                lottery_one_selected_text=lottery_one_selected_text,
                lottery_two_payoff=lottery_two_payoff,
                lottery_two_selected_text=lottery_two_selected_text,
                lottery_payoff_both=lottery_payoff_both)

# PAGES
class Introduction(Page):
    def before_next_page(player: Player, timeout_happened):
        start_timestamp(player)
        set_seed(player)


class questionnaire(Page):
    form_model = 'player'
    form_fields = ["age", "education","height", "sex", "germborn", "smoke",
                  "sat_health","sat_socialLife","importance_religion",
                   "check_account","alcohol","importance_involvement","income"]
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        predict_risk_full(player)
        player.unfold_list_tracker = 0
    def vars_for_template(player: Player):
        descriptives = ["age", "sex", "height", "germborn", "income", "education"]
        Likert_vars_10 = ["sat_socialLife","sat_health"]
        importances = ["importance_religion","importance_involvement"]
        miscellaneous = ["smoke","alcohol","check_account"]
        return dict(descriptives=descriptives,
                    Likert_vars_10=Likert_vars_10)



class Explanation_of_experiment(Page):
    pass

class Lotteries_round_two(Page):
    form_model = "player"
    form_fields = ["decision_round_two"]
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lottery_AB_list = pickle.load(open('lotteries_AB_en.sav', 'rb'))
        random.shuffle(lottery_AB_list)
        for i in range(len(lottery_AB_list)):
            lottery_AB_list[i]['ID_shuffled'] = i
        lotteries_repr = []
        for lottery in lottery_AB_list:
            if lottery['representative'] == True:
                lotteries_repr.append(lottery)

        if player.seed > 5000:
            lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=False)
        else:
            lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=True)

        for i, roman_id in zip(range(len(lotteries_repr)), ["I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI"]):
            lotteries_repr[i]['roman_index'] = roman_id
        return {"lotteries_repr": lotteries_repr}

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        extract_risk_level(player)

#class Lotteries_round_two_result(Page):
#    form_model = "player"
#    def vars_for_template(player: Player):
#       lottery_A_list = pickle.load(open('lotteries_A.sav', 'rb'))
#       lottery_two_selected = lottery_A_list[player.decision_round_two-1]['text']
#       return {"lottery_two_selected": lottery_two_selected}

class Lotteries_round_one_presentation(Page):
    form_model = "player"
    #form_fields = ["decision_round_one"]
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lotteries_masked = pickle.load(open('lotteries_AB_masked_en.sav', 'rb'))
        random.shuffle(lotteries_masked)
        for i in range(len(lotteries_masked)):
            lotteries_masked[i]['ID_shuffled'] = i
        return {"lotteries_masked": lotteries_masked}

class Explanation_of_AI(Page):
    pass



class Decentralized_feature_selection(Page):
    form_model = 'player'
    form_fields = ["age_dummy", "sex_dummy", "height_dummy", "germborn_dummy", "income_dummy", "education_dummy",
                  "sat_socialLife_dummy", "sat_health_dummy",
                  "importance_religion_dummy","importance_involvement_dummy",
                  "check_account_dummy", "alcohol_dummy", 'smoke_dummy'] #todo: Bei neuen features anpassen!
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        predict_risk_decfs(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class BDM_treatment(Page):
    form_model = 'player'
    form_fields= ['BDM_treatment']
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        BDM_decision_treatment(player)
        Calc_spec_endowment_treatment(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class BDM_baseline(Page):
    form_model = 'player'
    form_fields= ['BDM_baseline']
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        BDM_decision_baseline(player)
        Calc_spec_endowment_baseline(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')


class Decentralized_feature_selection_copy(Page):
    form_model = 'player'
    form_fields = ["age_dummy", "sex_dummy", "height_dummy", "germborn_dummy", "income_dummy", "education_dummy",
                  "sat_socialLife_dummy", "sat_health_dummy",
                  "importance_religion_dummy","importance_involvement_dummy",
                  "check_account_dummy", "alcohol_dummy", 'smoke_dummy'] #todo: Bei neuen features anpassen!
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        predict_risk_decfs(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class BDM_treatment_copy(Page):
    form_model = 'player'
    form_fields= ['BDM_treatment']
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        BDM_decision_treatment(player)
        Calc_spec_endowment_treatment(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')


class BDM_baseline_copy(Page):
    form_model = 'player'
    form_fields= ['BDM_baseline']
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        BDM_decision_baseline(player)
        Calc_spec_endowment_baseline(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')



class Variable_evaluation(Page):
    form_model = 'player'
    form_fields = ["age_evaluation", "sex_evaluation", "height_evaluation", "germborn_evaluation", "income_evaluation",
                   "education_evaluation", "sat_health_evaluation", "sat_socialLife_evaluation", "importance_religion_evaluation", "check_account_evaluation",
                   "importance_involvement_evaluation", "smoke_evaluation",
                   "alcohol_evaluation"]  # todo: Bei neuen features anpassen!

class BDM_result_round_1(Page):
    form_model = 'player'

class Lotteries_round_one_with_AI(Page):
    form_model = "player"
    form_fields = ["decision_round_one", "unfold_list_tracker"]
    def vars_for_template(player: Player):
        lotteries_one_personalized = personalize_lotteries_risk_A(player)
        random.seed(player.seed)
        lotteries_one_full = pickle.load(open('lotteries_AB_en.sav', 'rb'))
        random.shuffle(lotteries_one_full)
        for i in range(len(lotteries_one_full)):
            lotteries_one_full[i]['ID_shuffled'] = i
        return {"lotteries_one_personalized":lotteries_one_personalized,
                "lotteries_one_full":lotteries_one_full}

    @staticmethod
    def is_displayed(player: Player):
        return (((player.treatment_order == 'A') & (player.BDM_result_treatment == 1)) | ((player.treatment_order == 'B') & (player.BDM_result_baseline == 1)))


class Lotteries_round_one_without_AI(Page):
    form_model = "player"
    form_fields = ["decision_round_one"]
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lotteries = pickle.load(open('lotteries_AB_en.sav', 'rb'))
        random.shuffle(lotteries)
        for i in range(len(lotteries)):
            lotteries[i]['ID_shuffled'] = i
        return {"lotteries": lotteries}
    @staticmethod
    def is_displayed(player: Player):
        return (((player.treatment_order=='A') & (player.BDM_result_treatment == 0)) | ((player.treatment_order=='B') & (player.BDM_result_baseline == 0)))

class Lotteries_round_one_result(Page):
    form_model = "player"
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lotteries = pickle.load(open('lotteries_AB_en.sav', 'rb'))
        random.shuffle(lotteries)
        for i in range(len(lotteries)):
            lotteries[i]['ID_shuffled'] = i
        lottery_one_selected = lotteries[player.decision_round_one]['text']
        return {"lottery_one_selected": lottery_one_selected}

class Elicitation_of_model_beliefs_treatment(Page):
    form_model="player"
    form_fields= ["algo_expert_treatment", "algo_knowledge_treatment",
                   "feel_secure_treatment", "feel_comfortable_treatment", "feel_content_treatment",
                   "transparency_treatment", "power_treatment", "privacy_1_treatment", "privacy_2_treatment"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Perceived_accuracy_treatment(Page):
    form_model = "player"
    form_fields = ["perceived_accuracy_treatment"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Perceived_rmse_treatment(Page):
    form_model = "player"
    form_fields = ["perceived_rmse_treatment"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Elicitation_of_model_beliefs_treatment_copy(Page):
    form_model="player"
    form_fields= ["algo_expert_treatment", "algo_knowledge_treatment",
                   "feel_secure_treatment", "feel_comfortable_treatment", "feel_content_treatment",
                   "transparency_treatment", "power_treatment", "privacy_1_treatment", "privacy_2_treatment"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class Perceived_accuracy_treatment_copy(Page):
    form_model = "player"
    form_fields = ["perceived_accuracy_treatment"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')


class Perceived_rmse_treatment_copy(Page):
    form_model = "player"
    form_fields = ["perceived_rmse_treatment"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class Elicitation_of_model_beliefs_baseline(Page):
    form_model="player"
    form_fields= ["algo_expert_baseline", "algo_knowledge_baseline",
                   "feel_secure_baseline", "feel_comfortable_baseline", "feel_content_baseline",
                   "transparency_baseline", "power_baseline", "privacy_1_baseline", "privacy_2_baseline"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')


class Perceived_accuracy_baseline(Page):
    form_model = "player"
    form_fields = ["perceived_accuracy_baseline"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Perceived_rmse_baseline(Page):
    form_model = "player"
    form_fields = ["perceived_rmse_baseline"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Elicitation_of_model_beliefs_baseline_copy(Page):
    form_model="player"
    form_fields= ["algo_expert_baseline", "algo_knowledge_baseline",
                   "feel_secure_baseline", "feel_comfortable_baseline", "feel_content_baseline",
                   "transparency_baseline", "power_baseline", "privacy_1_baseline", "privacy_2_baseline"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class Perceived_accuracy_baseline_copy(Page):
    form_model = "player"
    form_fields = ["perceived_accuracy_baseline"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class Perceived_rmse_baseline_copy(Page):
    form_model = "player"
    form_fields = ["perceived_rmse_baseline"]
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class Attitudes_towards_ai(Page):
    form_model="player"
    form_fields=["ATAI_fear", "ATAI_trust", "ATAI_destroy_humankind", "ATAI_benefit", "ATAI_job_loss"]

class Lotteries_round_two_result(Page):
    form_model = "player"
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lottery_AB_list = pickle.load(open('lotteries_AB_en.sav', 'rb'))
        random.shuffle(lottery_AB_list)
        lotteries_repr = []
        for lottery in lottery_AB_list:
            if lottery['representative'] == True:
                lotteries_repr.append(lottery)

        if player.seed > 5000:
            lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=False)
        else:
            lotteries_repr = sorted(lotteries_repr, key=lambda d: d['risk_level'], reverse=True)

        lottery_two_selected = lotteries_repr[player.decision_round_two]['text']
        return {"lottery_two_selected": lottery_two_selected}

class Results(Page):
    form_model = 'player'
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        end_timestamp(player)
    def vars_for_template(player: Player):

        payoff_list = lottery_payoff_sum(player)
        lottery_one_payoff        = payoff_list["lottery_one_payoff"]
        lottery_one_selected_text = payoff_list["lottery_one_selected_text"]
        lottery_two_payoff        = payoff_list["lottery_two_payoff"]
        lottery_two_selected_text = payoff_list["lottery_two_selected_text"]
        lottery_payoff_both       = payoff_list["lottery_payoff_both"] + player.spec_endowment
        payoff_euro               = round((lottery_payoff_both * C.exchange_rate/100),2)

        return{"lottery_one_payoff":lottery_one_payoff,
               "lottery_one_selected_text":lottery_one_selected_text,
               "lottery_two_payoff":lottery_two_payoff,
               "lottery_two_selected_text":lottery_two_selected_text,
               "lottery_payoff_both":lottery_payoff_both,
               "payoff_euro":payoff_euro}

class Final_comments(Page):
    form_model = 'player'
    form_fields = ['comments']

class Control_page(Page):
    form_model = 'player'
    form_fields = ['quiz1', 'quiz2']

    @staticmethod
    def error_message(player, values):
        if player.tries_left > 0:
            # Add correct solutions to questions in dict below:
            solutions = dict(
                quiz1=2,
                quiz2=2
            )

            error_messages = dict()

            for field_name in solutions:
                if values[field_name] != solutions[field_name]:
                    error_messages = 'At least one wrong answer. You have only one more try!'

            if bool(error_messages):
                player.tries_left -= 1

            return error_messages
    @staticmethod
    def app_after_this_page(player, upcoming_apps):
        if player.tries_left == 0:
            return 'exit_app'


class Transition_to_baseline(Page):
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Transition_to_treatment(Page):
    @staticmethod
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')

class Lotteries_round_two_presentation(Page):
    form_model = "player"
    #form_fields = ["decision_round_one"]
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lotteries_masked = pickle.load(open('lotteries_AB_masked_en.sav', 'rb'))
        random.shuffle(lotteries_masked)
        for i in range(len(lotteries_masked)):
            lotteries_masked[i]['ID_shuffled'] = i
        return {"lotteries_masked": lotteries_masked}
    def is_displayed(player: Player):
        return (player.treatment_order == 'A')

class Lotteries_round_two_presentation_copy(Page):
    form_model = "player"
    #form_fields = ["decision_round_one"]
    def vars_for_template(player: Player):
        random.seed(player.seed)
        lotteries_masked = pickle.load(open('lotteries_AB_masked_en.sav', 'rb'))
        random.shuffle(lotteries_masked)
        for i in range(len(lotteries_masked)):
            lotteries_masked[i]['ID_shuffled'] = i
        return {"lotteries_masked": lotteries_masked}
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')



page_sequence = [Introduction,
                 questionnaire,
                 Explanation_of_experiment,
                 Lotteries_round_one_presentation,
                 Explanation_of_AI,
                 Variable_evaluation,
                 Control_page,

                 # Group A
                 Decentralized_feature_selection,
                 BDM_treatment,
                 Elicitation_of_model_beliefs_treatment,
                 Perceived_accuracy_treatment,
                 Perceived_rmse_treatment,

                 Transition_to_baseline,

                 Lotteries_round_two_presentation,
                 BDM_baseline,
                 Elicitation_of_model_beliefs_baseline,
                 Perceived_accuracy_baseline,
                 Perceived_rmse_baseline,

                 # Group B
                 BDM_baseline_copy,
                 Elicitation_of_model_beliefs_baseline_copy,
                 Perceived_accuracy_baseline_copy,
                 Perceived_rmse_baseline_copy,

                 Transition_to_treatment,

                 Lotteries_round_two_presentation_copy,
                 Decentralized_feature_selection_copy,
                 BDM_treatment_copy,
                 Elicitation_of_model_beliefs_treatment_copy,
                 Perceived_accuracy_treatment_copy,
                 Perceived_rmse_treatment_copy,

                 # Results of both rounds
                 BDM_result_round_1,
                 Lotteries_round_one_without_AI,
                 Lotteries_round_one_with_AI,
                 Lotteries_round_one_result,

                 # Results round 2



                 Attitudes_towards_ai,
                 Lotteries_round_two,
                 Lotteries_round_two_result,
                 Results,
                 Final_comments
                 ]