from otree.api import *


doc = """
Your app description
"""
contain_a = []
contain_b = []

class Constants(BaseConstants):
    name_in_url = 'my_simple_survey'
    players_per_group = None
    num_rounds = 1
    endowment = 45
    multiplier = 10
    choices = [1,2,3,4]
    
    

class Subsession(BaseSubsession):
    pass
    
class Group(BaseGroup):
    private_signal1 = models.StringField()
    private_signal2 = models.StringField()
    private_signal3 = models.StringField()
    private_signal4 = models.StringField()
    private_signal5 = models.StringField()
    private_signal6 = models.StringField()

    public_signal1 = models.StringField()
    public_signal2 = models.StringField()
    public_signal3 = models.StringField()

    urn_type = models.IntegerField()

    selected_round = models.IntegerField()

    cumulative_bet_on_even = models.CurrencyField()
    cumulative_bet_on_odd  = models.CurrencyField()

    def  cumulative_bet(self):
        self.cumulative_bet_on_even = (sum([p.round_1_even for p in self.get_players()])+
                                    sum([p.round_2_even for p in self.get_players()])+
                                    sum([p.round_3_even for p in self.get_players()])+
                                    sum([p.round_4_even for p in self.get_players()]))
                                    
        self.cumulative_bet_on_odd  = (sum([p.round_1_odd for p in self.get_players()])+
                                    sum([p.round_2_odd for p in self.get_players()])+
                                    sum([p.round_3_odd for p in self.get_players()])+
                                    sum([p.round_4_odd for p in self.get_players()]))


    def select_urn(self):
        import random
        self.urn_type = random.choice((1,2,3,4))
        if self.urn_type == 1:
            contain_a.append('Red')
            contain_a.append('Green')
            contain_a.append('Green')
            contain_a.append('Green')
            contain_b.append('Black')
            contain_b.append('White')
            contain_b.append('White')
            contain_b.append('White')
        elif self.urn_type == 2:
            contain_a.append('Red')
            contain_a.append('Red')
            contain_a.append('Red')
            contain_a.append('Green')
            contain_b.append('Black')
            contain_b.append('Black')
            contain_b.append('Black')
            contain_b.append('White')
        elif self.urn_type == 3:
            contain_a.append('Red')
            contain_a.append('Green')
            contain_a.append('Green')
            contain_a.append('Green')
            contain_b.append('Black')
            contain_b.append('Black')
            contain_b.append('Black')
            contain_b.append('White')
        else:
            contain_a.append('Red')
            contain_a.append('Red')
            contain_a.append('Red')
            contain_a.append('Green')
            contain_b.append('Black')
            contain_b.append('White')
            contain_b.append('White')
            contain_b.append('White')

        




    def  signal_maker(self):
        import random
        self.private_signal1 = random.choice(contain_a)
        self.private_signal2 = random.choice(contain_a)
        self.private_signal3 = random.choice(contain_a)
        self.private_signal4 = random.choice(contain_a)
        self.private_signal5 = random.choice(contain_a)
        self.private_signal6 = random.choice(contain_a)
        self.public_signal1 = random.choice(contain_b)
        self.public_signal2 = random.choice(contain_b)
        self.public_signal3 = random.choice(contain_b)
        
    

    
    
    def random_round(self):
        import random
        self.selected_round = random.choice(Constants.choices)
        
    def round_applier(self):
        for player in self.get_players():
            if self.selected_round == 1:
                player.selected_bet_even = player.round_1_even
                player.selected_bet_odd = player.round_1_odd
            elif self.selected_round == 2:
                player.selected_bet_even = player.round_2_even
                player.selected_bet_odd = player.round_2_odd
            elif self.selected_round == 3:
                player.selected_bet_even = player.round_3_even
                player.selected_bet_odd = player.round_3_odd
            else:
                player.selected_bet_even = player.round_4_even
                player.selected_bet_odd = player.round_4_odd
 
        
        
    def set_payoffs(self):
        if self.urn_type == 1 or 2:
            for player in self.get_players():
                player.revenew = player.selected_bet_even * Constants.multiplier
                player.payoff = Constants.endowment + player.revenew - player.costs
        else:
            for player in self.get_players():
                player.revenew = player.selected_bet_odd * Constants.multiplier
                player.payoff = Constants.endowment + player.revenew - player.costs

    def costs_difinition(self):
        for player in self.get_players():
            player.costs = 0
            for i in range(0,player.selected_bet_even + 1):
                player.costs = player.costs + i
            for i in range(0,player.selected_bet_odd + 1):
                player.costs = player.costs + i

    

class Player(BasePlayer):
    round_1_even = models.IntegerField(min = 0,max = 9)
    round_2_even = models.IntegerField(min = 0,max = 9)
    round_3_even = models.IntegerField(min = 0,max = 9)
    round_4_even = models.IntegerField(min = 0,max = 9)
    

    round_1_odd = models.IntegerField(min = 0,max = 9)
    round_2_odd = models.IntegerField(min = 0,max = 9)
    round_3_odd = models.IntegerField(min = 0,max = 9)
    round_4_odd = models.IntegerField(min = 0,max = 9)
    


    selected_bet_even = models.IntegerField()
    selected_bet_odd = models.IntegerField()

    revenew = models.CurrencyField()
    costs = models.CurrencyField()

    
    


     


# PAGES
class Intro(Page):
    pass


class division(WaitPage):
    @staticmethod
    def after_all_players_arrive(group):
        group.select_urn()
        group.signal_maker()
    

class Page_for_1(Page):
    @staticmethod
    def is_displayed(player):
        return player.id_in_group == 1
    form_model = 'player'
    form_fields = ['round_1_even', 'round_1_odd']
    
class Page_for_2(Page):
    @staticmethod
    def is_displayed(player):
        return player.id_in_group == 2
    form_model = 'player'
    form_fields = ['round_1_even', 'round_1_odd']

class Page_for_3(Page):
    @staticmethod
    def is_displayed(player):
        return player.id_in_group == 3
    form_model = 'player'
    form_fields = ['round_1_even', 'round_1_odd']

class Page_for_4(Page):
    @staticmethod
    def is_displayed(player):
        return player.id_in_group == 4
    form_model = 'player'
    form_fields = ['round_1_even', 'round_1_odd']

class Page_for_5(Page):
    @staticmethod
    def is_displayed(player):
        return player.id_in_group == 5
    form_model = 'player'
    form_fields = ['round_1_even', 'round_1_odd']

class Page_for_6(Page):
    @staticmethod
    def is_displayed(player):
        return player.id_in_group == 6
    form_model = 'player'
    form_fields = ['round_1_even', 'round_1_odd']

class Round2(Page):
    form_model = 'player'
    form_fields = ['round_2_even', 'round_2_odd']

class Round3(Page):
    form_model = 'player'
    form_fields = ['round_3_even', 'round_3_odd']

class Round4(Page):
    form_model = 'player'
    form_fields = ['round_4_even', 'round_4_odd']



class ResultWaitPage(WaitPage):
    @staticmethod
    def after_all_players_arrive(group):
        group.random_round()
        group.round_applier()
        group.costs_difinition()
        group.set_payoffs()

class Results(Page):
    pass



    
      


page_sequence = [Intro, division, Page_for_1, Page_for_2, Page_for_3, Page_for_4,
                  Page_for_5, Page_for_6, Round2, Round3, Round4, ResultWaitPage, Results]