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 = 3
    exchange_rate = 0.002


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_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=250, label="Please indicate how many points you would spend to use the AI system")
    BDM_baseline  = models.IntegerField(min=0, max=250, label="Please indicate how many points you would spend to use the AI system")
    BDM_final = models.IntegerField(min=0, max=250, label="Please indicate how many points you would spend to use the AI system")

    BDM_result_treatment = models.BooleanField()
    BDM_result_baseline  = models.BooleanField()
    BDM_result_final = models.BooleanField()

    random_threshold_treatment = models.IntegerField()
    random_threshold_baseline = models.IntegerField()
    random_threshold_final = models.IntegerField()

    # Participants' descriptives
    # Alter
    age = models.IntegerField(label="<b>Your age:</b>", min=18, max=99, blank=False, error_message='You must be at least 18 years old to participate.')
    sex = models.IntegerField(choices=[[1, "Female"], [0, "Male"]],widget=widgets.RadioSelect, label="<b>Your biological sex:</b>", blank=False, error_message="Invalid value.")
    germborn = models.IntegerField(choices=[[0, 'Not born in the USA'], [1, 'Born in the USA']], label="<b>Were you born in the USA?</b>", widget=widgets.RadioSelect, error_message="Invalid value.")

    height = models.IntegerField(label="<b>Your body height</b>", blank=False)
    height_feet = models.IntegerField(min=0, max = 8, error_message='Invalid value.')
    height_inches = models.IntegerField(min=0, max=11, error_message="Invalid value.")

    income = models.IntegerField(choices=[[0, '< 1400 $'],[1, '1401 - 2100 $'],[2, '2101 - 2800 $'],
                                          [3, '2801 - 3500 $'],[4, '3501 - 4200 $'],[5, '4201 - 4900 $'],
                                          [6, '4901 - 5600 $'],[7, '5601 - 6300 $'],[8, '6301 - 7000 $'],
                                         [9, '> 7000 $']], label="<b>Your gross monthly income in dollars:</b>", blank=False, error_message="Invalid value.")

    education = models.IntegerField(min=0, max=30, label="<b>The total duration of your education in years (starting from the 1st grade)?</b>"
                                          "<br>Example 1: You have attended school for 13 years and then studied for 5 years: Total duration = 18 years"
                                          "<br>Example 2: You have attended school for 8 years and then completed 3 years of vocational training: Total duration = 11 years", blank=False,
                                           error_message='This value must be between 0 and 30.')
    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, error_message="Invalid value.")
    sat_health = models.IntegerField(choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], label="Your health?", widget=widgets.RadioSelectHorizontal, blank=False, error_message="Invalid value.")
    importance_religion = models.IntegerField(choices=[[4, "Unimportant"], [3, "Less important"], [2, "Important"], [1,"Very important"]],
                                              label="Faith, religion", widget=widgets.RadioSelectHorizontal, blank=False, error_message="Invalid value.")
    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, error_message="Invalid value.")
    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="<b>How often do you check your bank account balance?</b>",
                                              widget=widgets.RadioSelectHorizontal, blank=False, error_message="Invalid value.")
    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="<b>How often do you drink alcohol?</b>",
                                              widget=widgets.RadioSelect, blank=False, error_message="Invalid value.")
    smoke = models.IntegerField(choices=[[1, "Yes"], [0, "No"]], widget=widgets.RadioSelect, label="<b>Do you currently smoke, whether cigarettes, a pipe, or cigars?</b>", blank=False, error_message="Invalid value.")

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

    # Dummy variables
    age_dummy       = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Age", widget=widgets.RadioSelect, blank=False)###
    sex_dummy       = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Gender", widget=widgets.RadioSelect, blank=False)###
    height_dummy    = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Body height", widget=widgets.RadioSelect, blank=False)###
    germborn_dummy  = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Born in the USA", widget=widgets.RadioSelect, blank=False)###
    income_dummy    = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Gross monthly income", widget=widgets.RadioSelect, blank=False)###
    education_dummy       = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Years of education", widget=widgets.RadioSelect, blank=False)###
    sat_socialLife_dummy  = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Satisfaction with friends and acquaintances", widget=widgets.RadioSelect, blank=False)###
    sat_health_dummy = models.IntegerField(choices=[[0, 'Provide to AI system'],[1, 'Hold back']], label="Satisfaction with your health", widget=widgets.RadioSelect, blank=False)
    importance_religion_dummy = models.IntegerField(choices=[[0, 'Provide to AI system'], [1, 'Hold back']],label="Importance of faith, religion", widget=widgets.RadioSelect, blank=False)###
    importance_involvement_dummy = models.IntegerField(choices=[[0, 'Provide to AI system'], [1, 'Hold back']],label="Importance of being politically, socially involved", widget=widgets.RadioSelect, blank=False)
    check_account_dummy = models.IntegerField(choices=[[0, 'Provide to AI system'], [1, 'Hold back']],label="Frequency of checking your bank account balance",widget=widgets.RadioSelect, blank=False)###
    alcohol_dummy = models.IntegerField(choices=[[0, 'Provide to AI system'], [1, 'Hold back']],label="Frequency of drinking alcohol", widget=widgets.RadioSelect, blank=False)###
    smoke_dummy = models.IntegerField(choices=[[0, 'Provide to AI system'], [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
    curiosity_treatment = models.IntegerField(choices=list(range(1, 8)),
                                              label="I am curious to learn about the AI prediction about me.",
                                              widget=widgets.RadioSelect)
    curiosity_baseline = models.IntegerField(choices=list(range(1, 8)),
                                              label="I am curious to learn about the AI prediction about me.",
                                              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 the AI systems knows 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 the AI systems knows 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 the AI system’s access to my information violates 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 the AI system’s access to my information violates 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)

    # SOEP risk tolerance
    risk_level_revealed = models.IntegerField(choices=list(range(0, 11)), widget=widgets.RadioSelect,
                                              label="How do you rate yourself personally? In general, are you someone who is ready to take risks or do you try to avoid risks?", blank=False)


    spec_endowment_treatment = models.IntegerField(initial=250)
    spec_endowment_baseline  = models.IntegerField(initial=250)
    spec_endowment_final = models.IntegerField(initial=250)

    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)

    scenario = models.IntegerField()

    lottery_dominance_class = models.StringField()
    lottery_original_id = models.IntegerField()

    payoff_dollar = models.FloatField()

# Functions

### error messages
def age_error_message(player, value):
    if value < 18:
        return 'You must be at least 18 years old to participate.'
    elif value > 100:
        return 'Your age cannot be larger than 100.'

#########

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
    print("Prediction full:", player.risk_prediction_full)

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))
    print("Prediction dec. FS.:", player.risk_prediction_decfs)

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 convert_height(player: Player):
    height_in_inches = (player.height_feet * 12) + player.height_inches
    height_in_cm = round((height_in_inches * 2.54))
    return height_in_cm

def personalize_lotteries_risk_round_1(player: Player):
    random.seed(player.seed)
    lottery_AB_list = pickle.load(open('lotteries_AB_smaller_values_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_order == 'A':
        if player.scenario == 1:
            for lottery in lottery_AB_list:
                if lottery['risk_level'] == player.risk_prediction_decfs:
                    ID_found = lottery['ID']
        elif player.scenario == 2:
            for lottery in lottery_AB_list:
                if lottery['risk_level'] == player.risk_prediction_full:
                    ID_found = lottery['ID']

    elif player.treatment_order == 'B':
        if player.scenario == 1:
            for lottery in lottery_AB_list:
                if lottery['risk_level'] == player.risk_prediction_full:
                    ID_found = lottery['ID']
        elif player.scenario == 2:
            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 BDM_decision_treatment(player: Player):
    player.random_threshold_treatment = random.randint(0, 250)
    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, 250)
    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_smaller_values_en.sav', 'rb'))
    random.shuffle(lotteriesAB)
    for i in range(len(lotteriesAB)):
        lotteriesAB[i]['ID_shuffled'] = i

    ### round 1
    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']

    return dict(lottery_one_payoff=lottery_one_payoff,
                lottery_one_selected_text=lottery_one_selected_text)


def choose_scenario_and_determine_DBM_result(player:Player):
    random.seed()
    player.scenario = random.randint(1,2)
    if player.treatment_order == 'A':
        if player.scenario == 1:
            player.BDM_result_final = player.BDM_result_treatment
            player.BDM_final = player.BDM_treatment
            player.spec_endowment_final = player.spec_endowment_treatment
            player.random_threshold_final = player.random_threshold_treatment
        else:
            player.BDM_result_final = player.BDM_result_baseline
            player.BDM_final = player.BDM_baseline
            player.spec_endowment_final = player.spec_endowment_baseline
            player.random_threshold_final = player.random_threshold_baseline
    else:
        if player.scenario == 1:
            player.BDM_result_final = player.BDM_result_baseline
            player.BDM_final = player.BDM_baseline
            player.spec_endowment_final = player.spec_endowment_baseline
            player.random_threshold_final = player.random_threshold_baseline
        else:
            player.BDM_result_final = player.BDM_result_treatment
            player.BDM_final = player.BDM_treatment
            player.spec_endowment_final = player.spec_endowment_treatment
            player.random_threshold_final = player.random_threshold_treatment

def log_lottery_id(player:Player):
    random.seed(player.seed)
    lotteries = pickle.load(open('lotteries_AB_smaller_values_en.sav', 'rb'))
    random.shuffle(lotteries)
    for i in range(len(lotteries)):
        lotteries[i]['ID_shuffled'] = i
    player.lottery_original_id = lotteries[player.decision_round_one]['ID']
    player.lottery_dominance_class = lotteries[player.decision_round_one]['dominance_class']

def payoff_Dollars(player:Player):
    payoff_list = lottery_payoff_sum(player)
    lottery_payoff_incl_spec_endow = payoff_list["lottery_one_payoff"] + player.spec_endowment_final
    payoff_dollar = round((lottery_payoff_incl_spec_endow * C.exchange_rate), 2)
    player.payoff_dollar = payoff_dollar


# 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_feet", "height_inches", "sex", "germborn", "smoke",
                  "sat_health","sat_socialLife","importance_religion",
                   "check_account","alcohol","importance_involvement","income"]
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.unfold_list_tracker = 0
        player.height = convert_height(player)

    def vars_for_template(player: Player):
        descriptives = ["age", "sex", "germborn", "income", "education"]
        Likert_vars_10 = ["sat_socialLife","sat_health"]
        importances = ["importance_religion","importance_involvement"]
        miscellaneous = ["smoke","alcohol","check_account"]
        height = ["height_feet", "height_inches"]
        return dict(descriptives=descriptives,
                    Likert_vars_10=Likert_vars_10)



class Explanation_of_experiment(Page):
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        predict_risk_full(player)


class SOEP_risk_collection(Page):
    form_model = "player"
    form_fields = ["risk_level_revealed"]

#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',
                  "perceived_accuracy_treatment",
                  #"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",
                  "curiosity_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',
                  "perceived_accuracy_baseline",
                  #"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",
                  "curiosity_baseline"]
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        BDM_decision_baseline(player)
        Calc_spec_endowment_baseline(player)
        choose_scenario_and_determine_DBM_result(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',
                  "perceived_accuracy_treatment",
                  #"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",
                  "curiosity_treatment"]
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        BDM_decision_treatment(player)
        Calc_spec_endowment_treatment(player)
        choose_scenario_and_determine_DBM_result(player)
    def is_displayed(player: Player):
        return (player.treatment_order == 'B')


class BDM_baseline_copy(Page):
    form_model = 'player'
    form_fields= ['BDM_baseline',
                  "perceived_accuracy_baseline",
                  #"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",
                  "curiosity_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(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_round_1(player)
        random.seed(player.seed)
        lotteries_one_full = pickle.load(open('lotteries_AB_smaller_values_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.BDM_result_final == 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_smaller_values_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.BDM_result_final == 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_smaller_values_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}
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        log_lottery_id(player)

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_smaller_values_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)
        payoff_Dollars(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_payoff_incl_spec_endow      = payoff_list["lottery_one_payoff"] + player.spec_endowment_final
        payoff_dollar               = round((lottery_payoff_incl_spec_endow * C.exchange_rate),2)

        return{"lottery_one_payoff":lottery_one_payoff,
               "lottery_one_selected_text":lottery_one_selected_text,

               "lottery_payoff_incl_spec_endow":lottery_payoff_incl_spec_endow,
               "payoff_dollar":payoff_dollar}

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!'

            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 Scenario_presentation(Page):
    pass

class Scenario_one_presentation(Page):
    pass

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

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

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')




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

                 # Group A
                 Decentralized_feature_selection,
                 BDM_treatment,
                 Scenario_two_presentation_A,
                 BDM_baseline,

                 # Group B
                 BDM_baseline_copy,
                 Scenario_two_presentation_B,
                 Decentralized_feature_selection_copy,
                 BDM_treatment_copy,

                 # Results round 1
                 BDM_result,

                 Lotteries_round_one_without_AI,
                 Lotteries_round_one_with_AI,
                 Lotteries_round_one_result,

                 Attitudes_towards_ai,
                 SOEP_risk_collection,
                 Results,
                 Final_comments
                 ]