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


import random
from random import randint
author = 'Castagnetti_Sharma'

doc = """
Your app description
"""

class Constants(BaseConstants):
    name_in_url = 'Ex_mainexperiment_D2'
    players_per_group = 2
    num_rounds = 1
    pot = c(350)
    highpayoff = c(550)
    lowpayoff = c(0)
    beliefpayoff = c(75)
    probability_c0 = 2
    probability_c0com = 98
    probability_c1 = 15
    probability_c1com = 85
    probability_c2 = 25
    probability_c2com = 75
    probability_c3 = 35
    probability_c3com = 65
    probability_c4 = 45
    probability_c4com = 55
    probability_c5 = 55
    probability_c5com = 45

    grid1 = c(11)
    grid2 = c(11)
    grid3 = c(9)
    grid4 = c(12)
    grid5 = c(8)
    grid6 = c(14)
    grid7 = c(8)
    grid8 = c(11)
    grid9 = c(11)
    grid10 = c(12)

    randomnumber_names = random.randint(0,14)
    randomnumber_lottery = random.randint(0,100)
    showupfee = c(250)
    roundnumber = 2
    tasknumber = 2

class Subsession(BaseSubsession):
    def before_session_starts(self):
        if self.round_number ==1:
            for p in self.get_players():
                p.randomnumber_names = random.randint(0, 14)
        if self.round_number ==1:
            for p in self.get_players():
                p.randomnumber_lottery = random.randint(0, 100)

    def set_rand_agent(self):
        players = self.get_players()
        return [p.participant.id_in_session for p in players if p.id_in_group==2]

    def set_gender(self):
        self.Gender1 = self.participant.vars['gender1']

    def set_age(self):
            self.Age = self.participant.vars['age']

    #def set_rand_agent_new(self):
        #players = self.set_rand_agent()
       # p2 = self.get_player_by_id(2)
        #return [p for p in players if not p == self.p2.participant.id_in_session]

    def creating_session(self):
        self.group_randomly (fixed_id_in_group=True)
        for g in self.get_groups():
            p2 = g.get_player_by_id(2)
            others = [x for x in self.set_rand_agent() if p2.participant.id_in_session!=x]
            g.rand_agent = random.choice(others)

    def rand_payoff_agent1(self):
            p2 = [p for p in self.get_players() if p.id_in_group == 2 ]
            for x in p2:
                all_groups = self.get_groups()
                match = [g for g in all_groups if x.participant.id_in_session==g.rand_agent]
                x.final_pay_ran = sum([g.random_payoff for g in match]) or 0

class Group(BaseGroup):
    def set_payoff(self):
        if self.round_number == 1:
            p1 = self.get_player_by_id(1)
            p2 = self.get_player_by_id(2)
            p1.payoff = p2.profitP
            p2.payoff = p1.Decider_pay1

    def set_beliefs(self):
        if self.round_number == 1:
            p1 = self.get_player_by_id(1)
            p2 = self.get_player_by_id(2)
            p1.correctQ = p2.total

    def ran_pay(self):
            p1 = self.get_player_by_id(1)
            return p1.Decider_pay2

    def ran_pay_final(self):
        if self.round_number == 1:
            self.random_payoff=self.ran_pay()

    random_payoff = models.CurrencyField()
    rand_agent = models.IntegerField()

class Player (BasePlayer):

    randomnumber_names = models.IntegerField ()
    randomnumber_lottery = models.IntegerField ()
    genderap = models.IntegerField()
    ageap = models.IntegerField ()
    ageother = models.IntegerField ()

    def genderapp(self):
        self.genderap = self.participant.vars['gender1']

    def ageapp(self):
        self.ageap = self.participant.vars['age']

    def age_other(self):
        self.ageother = self.get_partner().ageap


    def role(self):
        if self.id_in_group == 1:
            return 'Decider'
        if self.id_in_group == 2:
            return 'Performer'

    def get_partner(self):
        return self.get_others_in_group()[0]

    def name(self):
        if self.get_partner().genderap == 1:
                return ['Mayank', 'Aaditya', 'Deepak', 'Vaibhav', 'Prateek', 'Ankit', 'Raghav', 'Rishabh', 'Akash', 'Kunal', 'Nitin', 'Ashish', 'Manish', 'Rohan', 'Amit'][self.randomnumber_names]
        if self.get_partner().genderap == 2:
                return ['Priya', 'Sakshi', 'Simran', 'Tanvi', 'Anjali', 'Tanu', 'Ishita', 'Seema', 'Akansha', 'Krithika', 'Neha', 'Priyanka', 'Aastha', 'Nishi', 'Sneha'][self.randomnumber_names]

    def pronoun(self):
        if self.get_partner().genderap == 1:
                return ['he'][0]
        if self.get_partner().genderap == 2:
                return ['she'][0]
    def Pronoun(self):
        if self.get_partner().genderap == 1:
                return ['him'][0]
        if self.get_partner().genderap == 2:
                return ['her'][0]

    Q1_correct = models.BooleanField()
    Q2_correct = models.BooleanField()
    Q3_correct = models.BooleanField()
    Q4_correct = models.BooleanField()
    Q5_correct = models.BooleanField()
    Q6_correct = models.BooleanField()
    Q7_correct = models.BooleanField()
    Q8_correct = models.BooleanField()
    Q9_correct = models.BooleanField()
    Q10_correct = models.BooleanField()

    Grid1 = models.IntegerField()
    Grid2 = models.IntegerField()
    Grid3 = models.IntegerField()
    Grid4 = models.IntegerField()
    Grid5 = models.IntegerField()
    Grid6 = models.IntegerField()
    Grid7 = models.IntegerField()
    Grid8 = models.IntegerField()
    Grid9 = models.IntegerField()
    Grid10 = models.IntegerField()

    # defining the number of correct answers given by the performer
    Belief1 = models.CurrencyField (
        choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    )

    Belief2 = models.IntegerField (
        choices = [
            [1, 'Yes'],
            [2, 'No'],
        ]
    )

    Belief3 = models.IntegerField (
        choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    )

   # Decider_pay2 = models.FloatField (min=0, max=10)

    SelfBelief1 = models.IntegerField (
        choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    )

    SelfBelief2 = models.IntegerField (
        choices=[
            [1, Constants.lowpayoff],
            [2, Constants.highpayoff],
            ],
        widget=widgets.RadioSelectHorizontal
    )

    SelfBelief3 = models.FloatField (min=0, max=100)

    Decider_pay1 = models.CurrencyField()
    Decider_pay2 = models.CurrencyField()

    total = models.IntegerField ()
    problottery = models.IntegerField ()
    profitP = models.CurrencyField ()
    correctQ = models.CurrencyField()
    final_pay_ran = models.CurrencyField ()
    profitB = models.CurrencyField ()
    final_payoff = models.CurrencyField()

    def set_payoff1(self):
        if self.Grid1 == Constants.grid1:
            self.Q1_correct = 1 * 1
        if not self.Grid1 == Constants.grid1:
            self.Q1_correct = 0 * 0

    def set_payoff2(self):
        if self.Grid2 == Constants.grid2:
            self.Q2_correct = 1 * 1
        if not self.Grid2 == Constants.grid2:
            self.Q2_correct = 0 * 0

    def set_payoff3(self):
        if self.Grid3 == Constants.grid3:
            self.Q3_correct = 1 * 1
        if not self.Grid3 == Constants.grid3:
            self.Q3_correct = 0 * 0

    def set_payoff4(self):
        if self.Grid4 == Constants.grid4:
            self.Q4_correct = 1 * 1
        if not self.Grid4 == Constants.grid4:
            self.Q4_correct = 0 * 0

    def set_payoff5(self):
        if self.Grid5 == Constants.grid5:
            self.Q5_correct = 1 * 1
        if not self.Grid5 == Constants.grid5:
            self.Q5_correct = 0 * 0

    def set_payoff6(self):
        if self.Grid6 == Constants.grid6:
            self.Q6_correct = 1 * 1
        if not self.Grid6 == Constants.grid6:
            self.Q6_correct = 0 * 0

    def set_payoff7(self):
        if self.Grid7 == Constants.grid7:
            self.Q7_correct = 1 * 1
        if not self.Grid7 == Constants.grid7:
            self.Q7_correct = 0 * 0

    def set_payoff8(self):
        if self.Grid8 == Constants.grid8:
            self.Q8_correct = 1 * 1
        if not self.Grid8 == Constants.grid8:
            self.Q8_correct = 0 * 0

    def set_payoff9(self):
        if self.Grid9 == Constants.grid9:
            self.Q9_correct = 1 * 1
        if not self.Grid9 == Constants.grid9:
            self.Q9_correct = 0 * 0

    def set_payoff10(self):
        if self.Grid10 == Constants.grid10:
            self.Q10_correct = 1 * 1
        if not self.Grid10 == Constants.grid10:
            self.Q10_correct = 0 * 0

    def set_payoff_total(self):
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 10:
            self.total = 10
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 9:
            self.total = 9
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 8:
            self.total = 8
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 7:
            self.total = 7
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 6:
            self.total = 6
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 5:
            self.total = 5
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 4:
            self.total = 4
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 3:
            self.total = 3
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 2:
            self.total = 2
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 1:
            self.total = 1
        if self.Q1_correct + self.Q2_correct + self.Q3_correct + self.Q4_correct + self.Q5_correct + self.Q6_correct + self.Q7_correct + self.Q8_correct + self.Q9_correct + self.Q10_correct == 0:
            self.total = 0

    def set_lottery(self):
        if self.total == 10:
            self.problottery = Constants.probability_c5
        if self.total == 9:
            self.problottery = Constants.probability_c5
        if self.total == 8:
            self.problottery = Constants.probability_c4
        if self.total == 7:
            self.problottery = Constants.probability_c4
        if self.total == 6:
            self.problottery = Constants.probability_c3
        if self.total == 5:
            self.problottery = Constants.probability_c3
        if self.total == 4:
            self.problottery = Constants.probability_c2
        if self.total == 3:
            self.problottery = Constants.probability_c2
        if self.total == 2:
            self.problottery = Constants.probability_c1
        if self.total == 1:
            self.problottery = Constants.probability_c1
        if self.total == 0:
            self.problottery = Constants.probability_c0
        if self.total == None:
            self.problottery = Constants.probability_c0

    def set_profitp1(self):
        if self.problottery >= self.randomnumber_lottery:
            self.profitP = Constants.highpayoff
        if not self.problottery >= self.randomnumber_lottery:
            self.profitP = Constants.lowpayoff

    def set_profitbeliefs(self):
        if self.id_in_group==1:
            if self.Belief1 == self.correctQ:
                self.profitB = Constants.beliefpayoff
            if not self.Belief1 == self.correctQ:
                self.profitB = 0

    def final_pay_round(self):
        if self.id_in_group == 1:
            self.final_payoff = self.payoff + self.profitB + 250
        if self.id_in_group == 2:
            self.final_payoff = self.payoff + self.final_pay_ran + 250