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


doc = """
A demo of how rounds work in oTree, in the context of 'die rolling'
"""


class Constants(BaseConstants):
    name_in_url = 'project_ecc'
    players_per_group = 4
    num_rounds = 1
    instructions_template = 'project_ecc/Instructions.html'
    dictator_endowment = c(300)
    trust_endowment = c(10)
    trust_multiplier = 3
    public_good_endowment = c(20)
    public_good_multiplier = 2


class Subsession(BaseSubsession):
    def creating_session(self):
        self.group_randomly(fixed_id_in_group=True)
        # randomize to treatments
        if self.round_number == 1:
            for p in self.get_players():
                p.participant.vars['cheat_treatment'] = random.choice(['have the possibility to cheat',
                                                                       'have no possibility to cheat'])
                if p.participant.vars['cheat_treatment'] == 'have the possibility to cheat':
                    p.cheat = True
                else:
                    p.cheat = False

    def vars_for_admin_report(self):
        contributions = [p.contribution for p in self.get_players() if p.contribution != None]
        if contributions:
            return {
                'avg_contribution': sum(contributions)/len(contributions),
                'min_contribution': min(contributions),
                'max_contribution': max(contributions),
            }
        else:
            return {
                'avg_contribution': '(no data)',
                'min_contribution': '(no data)',
                'max_contribution': '(no data)',
            }


class Group(BaseGroup):
    total_vote_p1 = models.IntegerField()
    total_vote_p2 = models.IntegerField()
    total_vote_p3 = models.IntegerField()
    total_vote_p4 = models.IntegerField()
    real_leader_offer = models.CurrencyField()
    total_sent_amount = models.CurrencyField()
    sent_back_amount1 = models.CurrencyField()
    sent_back_amount2 = models.CurrencyField()
    sent_back_amount3 = models.CurrencyField()
    total_contribution = models.CurrencyField()
    individual_share = models.CurrencyField()

    message = models.LongStringField(label='What message do you want to send to your employees?')

    public_good_suggested_amount = models.CurrencyField(min=0, max=Constants.public_good_endowment, label='Let us contribute:')

    def set_roles(self):

        self.total_vote_p1 = sum([p.vote_p1 for p in self.get_players()])
        self.total_vote_p2 = sum([p.vote_p2 for p in self.get_players()])
        self.total_vote_p3 = sum([p.vote_p3 for p in self.get_players()])
        self.total_vote_p4 = sum([p.vote_p4 for p in self.get_players()])

        max_total_vote = max(self.total_vote_p1, self.total_vote_p2, self.total_vote_p3, self. total_vote_p4)

        p1 = self.get_player_by_id(1)
        p2 = self.get_player_by_id(2)
        p3 = self.get_player_by_id(3)
        p4 = self.get_player_by_id(4)

        if self.total_vote_p1 == max_total_vote:
            p1.is_winner = True
            p2.is_winner = False
            p3.is_winner = False
            p4.is_winner = False
            p1.role = 'Leader'
            p2.role = 'Employee1'
            p3.role = 'Employee2'
            p4.role = 'Employee3'
        elif self.total_vote_p2 == max_total_vote:
            p1.is_winner = False
            p2.is_winner = True
            p3.is_winner = False
            p4.is_winner = False
            p1.role = 'Employee1'
            p2.role = 'Leader'
            p3.role = 'Employee2'
            p4.role = 'Employee3'
        elif self.total_vote_p3 == max_total_vote:
            p1.is_winner = False
            p2.is_winner = False
            p3.is_winner = True
            p4.is_winner = False
            p1.role = 'Employee1'
            p2.role = 'Employee2'
            p3.role = 'Leader'
            p4.role = 'Employee3'
        else:
            p1.is_winner = False
            p2.is_winner = False
            p3.is_winner = False
            p4.is_winner = True
            p1.role = 'Employee1'
            p2.role = 'Employee2'
            p3.role = 'Employee3'
            p4.role = 'Leader'

    def set_dictator_payoffs(self):

        p1 = self.get_player_by_id(1)
        p2 = self.get_player_by_id(2)
        p3 = self.get_player_by_id(3)
        p4 = self.get_player_by_id(4)

        if p1.is_winner == 1:
            self.real_leader_offer = p1.dictator_leader_offer
            p1.dictator_payoffs = Constants.dictator_endowment - p1.dictator_leader_offer - p1.dictator_leader_offer - p1.dictator_leader_offer
            p2.dictator_payoffs = p1.dictator_leader_offer
            p3.dictator_payoffs = p1.dictator_leader_offer
            p4.dictator_payoffs = p1.dictator_leader_offer

        elif p2.is_winner == 1:
            self.real_leader_offer = p2.dictator_leader_offer
            p2.dictator_payoffs = Constants.dictator_endowment - p2.dictator_leader_offer - p2.dictator_leader_offer - p2.dictator_leader_offer
            p1.dictator_payoffs = p2.dictator_leader_offer
            p3.dictator_payoffs = p2.dictator_leader_offer
            p4.dictator_payoffs = p2.dictator_leader_offer

        elif p3.is_winner == 1:
            self.real_leader_offer = p3.dictator_leader_offer
            p3.dictator_payoffs = Constants.dictator_endowment - p3.dictator_leader_offer - p3.dictator_leader_offer - p3.dictator_leader_offer
            p2.dictator_payoffs = p3.dictator_leader_offer
            p1.dictator_payoffs = p3.dictator_leader_offer
            p4.dictator_payoffs = p3.dictator_leader_offer

        else:
            self.real_leader_offer = p4.dictator_leader_offer
            p4.dictator_payoffs = Constants.dictator_endowment - p4.dictator_leader_offer - p4.dictator_leader_offer - p4.dictator_leader_offer
            p2.dictator_payoffs = p4.dictator_leader_offer
            p3.dictator_payoffs = p4.dictator_leader_offer
            p1.dictator_payoffs = p4.dictator_leader_offer

    def set_trust_payoffs(self):

        for p in self.get_players():
            p1 = self.get_player_by_id(1)
            p2 = self.get_player_by_id(2)
            p3 = self.get_player_by_id(3)
            p4 = self.get_player_by_id(4)
            if p1.is_winner == 1:
                self.total_sent_amount = p4.sent_amount + p2.sent_amount + p3.sent_amount
            elif p2.is_winner == 1:
                self.total_sent_amount = p1.sent_amount + p4.sent_amount + p3.sent_amount
            elif p3.is_winner == 1:
                self.total_sent_amount = p1.sent_amount + p2.sent_amount + p4.sent_amount
            else:
                self.total_sent_amount = p1.sent_amount + p2.sent_amount + p3.sent_amount
            if p.role == 'Leader':
                p.trust_payoffs = self.total_sent_amount + self.total_sent_amount + self.total_sent_amount - self.sent_back_amount1 - self.sent_back_amount2 - self.sent_back_amount3
            elif p.role == 'Employee1':
                p.trust_payoffs = Constants.trust_endowment - p.sent_amount + self.sent_back_amount1
            elif p.role == 'Employee2':
                p.trust_payoffs = Constants.trust_endowment - p.sent_amount + self.sent_back_amount2
            elif p.role == 'Employee3':
                p.trust_payoffs = Constants.trust_endowment - p.sent_amount + self.sent_back_amount3

    def set_public_good_payoffs(self):
        self.total_contribution = sum([p.contribution for p in self.get_players()])
        self.individual_share = self.total_contribution * Constants.public_good_multiplier / Constants.players_per_group
        for p in self.get_players():
            p.public_good_payoffs = (Constants.public_good_endowment - p.contribution) + self.individual_share

    def set_payoffs(self):
        for p in self.get_players():
            p.payoffs = p.public_good_payoffs + p.dictator_payoffs + p.trust_payoffs
            p.payoff = 5 + p.payoffs/10


class Player(BasePlayer):
    die_rolling = models.IntegerField(min=1, max=6)
    vote_number = models.IntegerField()
    group_label = models.StringField()
    cheat_treatment = models.StringField()
    cheat = models.BooleanField()

    vote_p1 = models.IntegerField(
        label='How much will you vote to A? (If not, enter 0)',
        min=0, max=5)

    vote_p2 = models.IntegerField(
        label='How much will you vote to B?(If not, enter 0)',
        min=0, max=5)

    vote_p3 = models.IntegerField(
        label='How much will you vote to C?(If not, enter 0)',
        min=0, max=5)

    vote_p4 = models.IntegerField(
        label='How much will you vote to D?(If not, enter 0)',
        min=0, max=5)

    practice_question1 = models.IntegerField(
        doc="""correct answer is 5""",
    )

    practice_question2 = models.IntegerField(
        doc="""correct answer is 45""",
    )

    practice_question3 = models.IntegerField(
        doc="""correct answer is 13""",
    )

    practice_question4 = models.IntegerField(
        doc="""correct answer is 30""",
    )

    practice_question5 = models.IntegerField(
        doc="""correct answer is 16""",
    )

    practice_question6 = models.IntegerField(
        doc="""correct answer is 16""",
    )

    practice_question7 = models.IntegerField(
        doc="""correct answer is 18""",
    )

    sent_amount = models.IntegerField(
        doc="""Amount sent by Employee""",
    )

    is_winner = models.BooleanField()
    role = models.StringField()
    dictator_leader_offer = models.CurrencyField(
        doc="""Amount dictator decided to distribute for each of the employees""",
        min=0, max=Constants.dictator_endowment/3,
    )

    contribution = models.CurrencyField(min=0, max=Constants.public_good_endowment,
                                        label='How much will you contribute to the project (from 0 to 10)?')

    public_good_payoffs = models.CurrencyField()
    trust_payoffs = models.CurrencyField()
    dictator_payoffs = models.CurrencyField()
    payoffs = models.CurrencyField()

    age = models.IntegerField(
        label='Year of birth: year',
        max=2001)

    gender = models.StringField(
        choices=['Male', 'Female', 'Other'],
        label='Gender',
        widget=widgets.RadioSelect)

    grade = models.StringField(
        choices=['First', 'Second', 'Third', 'Forth'],
        label='What is your grade?',
        widget=widgets.RadioSelect)

    ethnic = models.StringField(
        choices=['Han', 'Minority'],
        label='Your ethnic group:',
        widget=widgets.RadioSelect)

    major = models.StringField(
        label='''Major '''
    )

    crt_trust1 = models.StringField(
        choices=['Most people can be trusted', 'Need to be very careful'],
        label='''
                Generally speaking, would you say that most people can be trusted or 
                that you need to be very careful in dealing with people? ''',
        widget=widgets.RadioSelect
    )

    crt_trust2 = models.StringField(
        choices=['Most of the time they would try to be fair', 'Most of the time they would try to take advantage'],
        label='''
                Do you think most people would try to take advantage of you if they got the chance, 
                or would they try to be fair?  ''',
        widget=widgets.RadioSelect
    )

    crt_trust3 = models.StringField(
        choices=['Most of the time people are helpful', 'Most of the time they are just looking out for themselves '],
        label='''
                Would you say that most of the time people try to be helpful, or 
                that they are mostly just looking out for themselves?   ''',
        widget=widgets.RadioSelect
    )

    def group_label(self):
        if self.id_in_group == 1:
            return 'A'
        elif self.id_in_group == 2:
            return 'B'
        elif self.id_in_group == 3:
            return 'C'
        else:
            return 'D'

    def vote_number(self):
        if self.die_rolling == 1:
            return '1'
        elif self.die_rolling == 2:
            return '1'
        elif self.die_rolling == 3:
            return '1'
        elif self.die_rolling == 4:
            return '3'
        elif self.die_rolling == 5:
            return '5'
        else:
            return '0'

    def vote_check(self):
        if self.player.vote_number == sum([self.player.vote_p1, self.player.vote_p2, self.player.vote_p3,
                                           self.player.vote_p4]):
            return '1'
        else:
            return '2'