### All Import Operations
from otree.api import (
    models,
    widgets,
    BaseConstants,
    BaseSubsession,
    BaseGroup,
    BasePlayer,
    Currency as c,
    currency_range,
)
# Imports for Neural Network
import pandas as pd
from sklearn.neural_network import MLPRegressor
import joblib
import random

### Load all global variables and models (e.g., machine learning models)
author = 'Your name here'

doc = """
Your app description
"""

###### Load Neural Networks for inference
## Use this path when working locally via otree devserver
#loaded_model_vw2 = joblib.load(r'C:\Users\Robin\Dropbox\Eigene Dateien_Robin IISM\06 Dissertation\13 P3\02 Erhebung Orga\01 oTree\02 oTree Python\testproject\surveyapp\prestudy2_bestmodel_vw2.pkl')
#loaded_model_vw3 = joblib.load(r'C:\Users\Robin\Dropbox\Eigene Dateien_Robin IISM\06 Dissertation\13 P3\02 Erhebung Orga\01 oTree\02 oTree Python\testproject\surveyapp\prestudy2_bestmodel_vw3.pkl')
#loaded_scaler_vw2 = joblib.load(r'C:\Users\Robin\Dropbox\Eigene Dateien_Robin IISM\06 Dissertation\13 P3\02 Erhebung Orga\01 oTree\02 oTree Python\testproject\surveyapp\prestudy2_scaler_vw2.pkl')
#loaded_scaler_vw3 = joblib.load(r'C:\Users\Robin\Dropbox\Eigene Dateien_Robin IISM\06 Dissertation\13 P3\02 Erhebung Orga\01 oTree\02 oTree Python\testproject\surveyapp\prestudy2_scaler_vw3.pkl')

## Use this path when loading data to Heroku (/app/surveyapp/ leads inside the surveyapp folder). Save .pkl files in surveyapp folder before.
loaded_model_vw2 = joblib.load('/app/surveyapp/prestudy2_bestmodel_vw2.pkl')
loaded_model_vw3 = joblib.load('/app/surveyapp/prestudy2_bestmodel_vw3.pkl')
loaded_scaler_vw2 = joblib.load('/app/surveyapp/prestudy2_scaler_vw2.pkl')
loaded_scaler_vw3 = joblib.load('/app/surveyapp/prestudy2_scaler_vw3.pkl')

def make_field(label):
    return models.IntegerField(
        choices=[1,2,3,4,5,6,7],
        label=label,
        widget=widgets.RadioSelectHorizontal,
    )

class Constants(BaseConstants):
    name_in_url = 'surveyapp'
    players_per_group = None
    num_rounds = 1


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    # Random Szenario Variable 1 bis 4
    exp_zelle = models.IntegerField()

    lab_id = models.StringField(label="")

    rat1 = make_field("Finanzentscheidungen treffe ich gerne sachlich, durch Analyse von Vor- und Nachteilen, nicht nach Gefühl.")
    rat2_r = make_field("Im Leben entscheide ich mich so, wie es sich für mich gut und richtig anfühlt, auch wenn eine andere Entscheidung nach logischen Kriterien sinnvoller sein könnte.")
    rat3 = make_field("Bei Entscheidungen wäge ich eher ab, was meinem Ziel dienlich ist, anstatt auf mein Bauchgefühl zu hören.")
    rat4 = make_field("Wenn ich zwischen zwei Optionen wähle, von denen eine finanziell besser ist, aber die andere sich für mich besser 'anfühlt', entscheide ich mich für die finanziell bessere Option.")
    rat5_r = make_field("Bei der Wahl eines Produkts verlasse ich mich eher auf mein Bauchgefühl als auf angegebene Produktspezifikationen (Zahlenangaben und objektive Beschreibung).")
    rat6 = make_field("Wenn ich Entscheidungen treffe, konzentriere ich mich eher auf objektive Fakten als auf subjektive Gefühle.")

    rataff1 = models.IntegerField(widget=widgets.RadioSelect,choices=[1,2,3,4,5,6,7])
    rataff2 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    rataff3 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    ration_superior = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    emostab1 = models.IntegerField(widget=widgets.RadioSelect,choices=[1,2,3,4,5,6,7])
    emostab2 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    emostab3 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    emostab4 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    emostab5 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    emostab6 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    extra1 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    extra2 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    extra3 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    extra4 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    extra5 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    trustfeel1 = make_field("Inwieweit würden Sie bei einem Autokauf auf das vertrauen, was Ihre Gefühle Ihnen über das Auto sagen?")
    trustfeel2 = make_field("Inwieweit würden Sie sich bei der Auswahl eines Mitbewohners auf das verlassen, was Ihre Gefühle Ihnen über diesen Mitbewohner sagen?")

    shoe = models.IntegerField(label="")

    need1 = make_field("Beim Einkaufen besuche ich mehrere Läden, um den besten Preis zu bekommen.")
    need2_r = make_field("Meistens ist es mir die Zeit nicht wert, mich nach dem besten Preis umzuschauen. ")
    need3 = make_field("Meistens ist das gesparte Geld es wert, Zeit und Mühe in die Suche nach dem besten Preis zu stecken.")
    need4_r = make_field("Ich bin nicht bereit extra Aufwand in die Suche nach günstigeren Preisen für dasselbe Produkt zu stecken.")

    pers1 = make_field("Ich merke es, wenn ein Angebot zu gut ist, um wahr zu sein.")
    pers2 = make_field("Mir fällt es auf, wenn ein Angebot einen Haken hat.")
    pers3 = make_field("Ich habe keine Probleme die Verhandlungstechniken von Vertriebspersonen zu verstehen.")
    pers4 = make_field("Ich kann genau sagen, wenn mich jemand unter Druck setzt um mir etwas zu verkaufen.")
    pers5 = make_field("Ich kann Verkaufstaktiken leicht durchschauen.")
    pers6 = make_field("Wenn ich Werbung sehe, kann ich leicht Echtes von Erfundenem unterscheiden.")

    altru1 = make_field("Mir ist es wichtig, dass Menschen sich bei mir willkommen fühlen.")
    altru2 = make_field("Ich mache mir Gedanken über die Bedürfnisse anderer.")
    altru3 = make_field("Ich liebe es, anderen zu helfen.")
    altru4 = make_field("Ich kümmere mich um andere.")
    altru5 = make_field("Ich helfe anderen gerne mit einem Rat aus.")

    koll_hori1 = make_field("Meine Fröhlichkeit hängt stark vom Glück der Menschen um mich herum ab.")
    koll_hori2 = make_field("Es ist mir wichtig, dass es meinen Kolleginnen und Kollegen gut geht.")
    koll_hori3 = make_field("Wenn eine Kollegin oder ein Kollege einen Preis bekommt, würde ich stolz auf sie/ihn sein.")
    koll_hori4 = make_field("Zusammenarbeit mit anderen fühlt sich für mich gut an.")

    koll_verti1 = make_field("Ich mache das, was meine Familie glücklich macht, auch wenn ich es selbst nicht mag.")
    koll_verti2 = make_field("Üblicherweise ordne ich meine eigenen Interessen denen meiner Gruppe unter.")
    koll_verti3 = make_field("Kinder sollten stolz sein, wenn ihren Eltern ein Preis verliehen wird.")
    koll_verti4 = make_field("Ich würde eines meiner Hobbys aufgeben, weil meine Familie nicht damit einverstanden ist.")

    uti1 = make_field("Es ist moralisch gesehen in Ordnung einer einzigen Person zu schaden, wenn dadurch mehrere andere Personen vor diesem Schaden bewahrt bleiben.")
    uti2 = make_field("Von einem moralischen Standpunkt aus sollten wir uns verpflichtet fühlen einem Menschen, dessen Leben davon abhängt, eine Niere zu spenden, weil wir keine zwei Nieren brauchen.")
    uti3 = make_field("Wenn der einzige Weg, Gesundheit und Glück für alle zu garantieren, in kurzer, vorübergehender politischer Unterdrückung der Menschen liegt, sollte man diesen Weg gehen.  ")
    uti4 = make_field("Von einem moralischen Standpunkt aus sollten sich Menschen um das Wohlergehen aller Menschen auf dem Planeten in gleichem Maße sorgen; nahestehende Menschen sollten nicht priorisiert werden.")
    uti5 = make_field("Es ist hinnehmbar eine einzige unschuldige Person zu foltern, wenn dadurch Informationen gewonnen werden, die einen Bombenanschlag verhindern, bei dem Hunderte sterben würden.")
    uti6 = make_field("Manchmal ist es notwendig, dass unschuldige Menschen sterben, wenn dadurch insgesamt mehr Menschen gerettet werden können.")
    uti7 = make_field("Es ist moralisch falsch, Geld zu behalten, das man nicht wirklich braucht, wenn es stattdessen Menschen helfen könnte, die darauf angewiesen sind.")

    avers1_r = make_field("Ich sehe den Mehrwert dieser KI, die solche Aufgaben besser bewerkstelligen kann als Menschen.")
    avers2_r = make_field("Eine KI, die derartige Angebote auf Kunden zuschneidet, könnte nützlich sein. ")
    avers3_r = make_field("Ich glaube, dass eine solche KI gut funktionieren kann.")
    avers4 = make_field("KI-Systeme, die Angebote passender personalisieren können als Menschen, lösen ein schlechtes Gefühl in mir aus.")
    avers5 = make_field("KI-Systeme, die Angebote personalisieren, sind entgegen meiner Vorstellung von dem, wie Computer genutzt werden sollten.")

    attri_human_1 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    attri_human_2 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    offer_accept = models.BooleanField(label="", choices=[[True, "Ich würde das Angebot annehmen."],[False, "Ich würde das Angebot ablehnen."]])

    moral1 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    moral2 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    moral3 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])
    moral4 = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    fair1 = make_field("...fair")
    fair2_r = make_field("...fragwürdig")
    fair3 = make_field("...angemessen")
    fair4 = make_field("...gerecht")
    fair5_r = make_field("...unfair")
    fair6_r = make_field("...Abzocke")

    manint1_r = make_field("Das Verhalten der KI gegenüber mir erscheint mir akzeptabel.")
    manint2 = make_field("Die KI hat versucht die Situation auf eine Weise zu manipulieren, die ich nicht mag.")
    manint3 = make_field("Ich bin verärgert über diese KI, weil sie versucht hat die Situation in unangemessener Weise zu steuern oder zu beeinflussen.")
    manint4_r = make_field("Das Verhalten der KI hat mich nicht gestört; sie hat versucht ordentlich zu verdienen, aber ohne manipulativ zu sein.")

    rec1 = make_field("Nach meiner Interaktion mit dem Smartphone Hersteller, hätte ich kein Problem damit, meinen Freunden positive Dinge über den Hersteller zu berichten.")
    rec2 = make_field("Ich würde meine Bekannten und Verwandten dazu ermuntern, künftig diesen Smartphone Hersteller zu wählen.")

    repat_service = models.BooleanField(label="", choices=[[True, "Ja"], [False, "Nein"]])

    repat_buy = models.BooleanField(label="", choices=[[True, "Ja"], [False, "Nein"]])

    comp_check = models.IntegerField(widget=widgets.RadioSelect, choices=[1, 2, 3, 4, 5, 6, 7])

    szen2_offer = models.FloatField(label="")


    ## Algorithmic Output for player
    # Empty Variables to store predictions
    pred_vw2 = models.FloatField()
    pred_vw3 = models.FloatField()
    vw2_hersteller_profit = models.FloatField()
    vw3_hersteller_profit = models.FloatField()

    pred_random = models.FloatField()
    random_hersteller_profit = models.FloatField()

    angebot_an_proband = models.FloatField()
    profit_hersteller_nach_angebot = models.FloatField()
    # Compute prediction vw2 (lower limit of van Westendorp)
    def nnet_vw2(self):
        ## Create Input Vector for specific player
        columns = [
            'RAT', 'RATAFF', 'EMOSTAB', 'EXTRA', 'TRUSTFEEL', 'RATION_SUP', 'NEED', 'ALTRU', 'KOLL_HORI', 'KOLL_VERTI', 'PERS',
            'UTI', 'AVERS', 'ATTRI', 'SHO'
        ]
        # Compute construct variables like in CFA
        RAT = (self.rat1 + self.rat3 + self.rat6)/3
        RATAFF = (self.rataff1 + self.rataff2 + self.rataff3)/3
        EMOSTAB = (self.emostab1 + self.emostab2 + self.emostab4 + self.emostab5 + self.emostab6)/5
        EXTRA = (self.extra2 + self.extra3 + self.extra5)/3
        TRUSTFEEL = self.trustfeel1
        RATION_SUP = self.ration_superior
        NEED = (8 - self.need2_r)
        ALTRU = (self.altru1 + self.altru2 + self.altru3 + self.altru4 + self.altru5)/5
        KOLL_HORI = (self.koll_hori2 + self.koll_hori3 + self.koll_hori4)/3
        KOLL_VERTI = (self.koll_verti1 + self.koll_verti4)/2
        PERS = (self.pers1 + self.pers2 + self.pers3 + self.pers4 + self.pers5 + self.pers6)/6
        UTI = (self.uti1 + self.uti5 + self.uti6)/3
        AVERS = ((8 - self.avers1_r) + (8 - self.avers2_r) + (8 - self.avers3_r))/3
        ATTRI = self.attri_human_1
        SHO = ~ self.shoe

        features = {
            'RAT': RAT, 'RATAFF': RATAFF, 'EMOSTAB': EMOSTAB, 'EXTRA': EXTRA, 'TRUSTFEEL': TRUSTFEEL, 'RATION_SUP': RATION_SUP,
            'NEED': NEED, 'ALTRU': ALTRU, 'KOLL_HORI': KOLL_HORI, 'KOLL_VERTI': KOLL_VERTI, 'PERS': PERS,
            'UTI': UTI, 'AVERS': AVERS, 'ATTRI': ATTRI, 'SHO': SHO
        }
        # Create the Input Vector for prediction (as a Dataframe)
        features_vector = pd.DataFrame([features], columns=columns)
        # Use the loaded scaler to transform your data
        features_vector_scaled = loaded_scaler_vw2.transform(features_vector)
        # Use the loaded model for predictions for the validation data set
        pred = loaded_model_vw2.predict(features_vector_scaled)
        pred_final = (pred[0] + 1.44) * 0.79
        # Ensure value is between 0.01 and 9.99 and has 2 digits
        pred_final = max(0.01, min(9.99, round(pred_final, 2)))

        ## Save Output in player class variable
        self.pred_vw2 = pred_final
        return(pred_final)

    # Compute prediction vw3 (lower limit of van Westendorp)
    def nnet_vw3(self):
        ## Create Input Vector for specific player
        columns = [
            'RAT', 'RATAFF', 'EMOSTAB', 'EXTRA', 'TRUSTFEEL', 'RATION_SUP', 'NEED', 'ALTRU', 'KOLL_HORI', 'KOLL_VERTI', 'PERS',
            'UTI', 'AVERS', 'ATTRI', 'SHO'
        ]
        # Compute construct variables like in CFA
        RAT = (self.rat1 + self.rat3 + self.rat6)/3
        RATAFF = (self.rataff1 + self.rataff2 + self.rataff3)/3
        EMOSTAB = (self.emostab1 + self.emostab2 + self.emostab4 + self.emostab5 + self.emostab6)/5
        EXTRA = (self.extra2 + self.extra3 + self.extra5)/3
        TRUSTFEEL = self.trustfeel1
        RATION_SUP = self.ration_superior
        NEED = (8 - self.need2_r)
        ALTRU = (self.altru1 + self.altru2 + self.altru3 + self.altru4 + self.altru5)/5
        KOLL_HORI = (self.koll_hori2 + self.koll_hori3 + self.koll_hori4)/3
        KOLL_VERTI = (self.koll_verti1 + self.koll_verti4)/2
        PERS = (self.pers1 + self.pers2 + self.pers3 + self.pers4 + self.pers5 + self.pers6)/6
        UTI = (self.uti1 + self.uti5 + self.uti6)/3
        AVERS = ((8 - self.avers1_r) + (8 - self.avers2_r) + (8 - self.avers3_r))/3
        ATTRI = self.attri_human_1
        SHO = ~ self.shoe

        features = {
            'RAT': RAT, 'RATAFF': RATAFF, 'EMOSTAB': EMOSTAB, 'EXTRA': EXTRA, 'TRUSTFEEL': TRUSTFEEL, 'RATION_SUP': RATION_SUP,
            'NEED': NEED, 'ALTRU': ALTRU, 'KOLL_HORI': KOLL_HORI, 'KOLL_VERTI': KOLL_VERTI, 'PERS': PERS,
            'UTI': UTI, 'AVERS': AVERS, 'ATTRI': ATTRI, 'SHO': SHO
        }
        # Create the Input Vector for prediction (as a Dataframe)
        features_vector = pd.DataFrame([features], columns=columns)
        # Use the loaded scaler to transform your data
        features_vector_scaled = loaded_scaler_vw3.transform(features_vector)
        # Use the loaded model for predictions for the validation data set
        pred = loaded_model_vw3.predict(features_vector_scaled)
        pred_final = (pred[0] + 1.3) * 0.79
        # Ensure value is between 0.01 and 9.99 and has 2 digits
        pred_final = max(0.01, min(9.99, round(pred_final, 2)))

        ## Save Output in player class variable
        self.pred_vw3 = pred_final
        pred_random = models.FloatField()
        return(pred_final)

    def nnet_random(self):
        pred_final = round(random.uniform(0.01, 9.99), 2)
        self.pred_random = pred_final
        return (pred_final)
    def vw2_profit_hersteller(self):
        ## Save Output in player class variable
        vw2profit = round(10 - self.pred_vw2, 2)
        self.vw2_hersteller_profit = vw2profit
        return(vw2profit)
    def vw3_profit_hersteller(self):
        ## Save Output in player class variable
        vw3profit = round(10 - self.pred_vw3, 2)
        self.vw3_hersteller_profit = vw3profit
        return(vw3profit)
    def random_profit_hersteller(self):
        ## Save Output in player class variable
        randomprofit = round(10 - self.nnet_random(), 2)
        self.random_hersteller_profit = randomprofit
        return(randomprofit)

    def angebot(self):
        zelle = random.randint(1, 4)
        self.exp_zelle = zelle
        if zelle == 1:
            # Unmoral Algo. Zelle
            offer = self.nnet_vw2()
        elif zelle == 2:
            # Moral Algo. Zelle
            offer = self.nnet_vw3()
        elif zelle == 3:
            # Rawlsche Zelle
            offer = 5.00
        elif zelle == 4:
            # Random Zelle
            offer = self.nnet_random()
        ## Save Angebotshähe in player class variable
        self.angebot_an_proband = offer
        return(offer)

    def profit(self):
        offer_betrag = self.angebot_an_proband
        profit_betrag = round(10 - offer_betrag, 2)
        self.profit_hersteller_nach_angebot = profit_betrag
        return(profit_betrag)