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


author = 'Aoi_Kokado'

doc = """
卒研用実験
"""


class Constants(BaseConstants):
    name_in_url = '2023年卒論用実験_後半'
    players_per_group = 3
    num_rounds = 8
    num_choices = 10
    min_choice = 101
    max_choice = min_choice + num_choices - 1
    #instructions_template = 'Jikken_2023/instructions.html'
    


class Subsession(BaseSubsession):
    def creating_session(self):
        if self.round_number == 1:
            self.group_randomly()
        else:
            self.group_like_round(1)


class Group(BaseGroup):
    min_choice = models.IntegerField()


class Player(BasePlayer):
    teian = models.StringField(
        choices = [['提案する','提案する'],['提案しない','提案しない']],
        label = 'カルテルを提案しますか？',
        widget = widgets.RadioSelectHorizontal,
    )
    def other_players_all_no(self):
        return all([p.teian == '提案しない' for p in self.get_others_in_group()])
    def other_players_all_yes(self):
        return all([p.teian == '提案する' for p in self.get_others_in_group()])
    def other_player_some_yes(self):
        return any([p.teian == '提案する' for p in self.get_others_in_group()])
    def other_player_some_no(self):
        return any([p.teian == '提案しない' for p in self.get_others_in_group()])
    
    binjo =  models.StringField(
        choices = [['参加する','参加する'],['参加しない','参加しない']],
        label = 'カルテルに参加しますか？',
        widget = widgets.RadioSelectHorizontal,
    )

    def other_player_some_not_binjo(self):
        return any([p.teian == '参加しない' for p in self.get_others_in_group()])
    def other_player_all_not_binjo(self):
        return all([p.teian == '参加しない' for p in self.get_others_in_group()])
    def other_player_all_binjo(self):
        return all([p.teian == '参加する' for p in self.get_others_in_group()])
    
    choice_number = models.IntegerField(
        choices = [(i,i) for i in range (Constants.min_choice,Constants.max_choice + 1)],
    )

    soten = models.FloatField()    
    
    points = models.FloatField(initial=0,doc='このラウンドでの獲得ポイントです。')
    soten_point = models.FloatField()
    
    def set_soten(self):
        self.soten =self.choice_number - 100 
        self.soten_point = 6*self.soten
    
    soten_point = models.FloatField()
    caltel_point = models.FloatField()
    result_point = models.FloatField()

    def set_simple_point(self):
        self.result_point = self.soten_point * self.points

    hokoku_1 = models.StringField(
        choices = [['報告する','報告する'],['報告しない','報告しない']],
        widget = widgets.RadioSelectHorizontal,
        label = 'カルテルを報告しますか？',
    )

    hokoku_2 = models.StringField(
        choices = [['報告する','報告する'],['報告しない','報告しない']],
        widget = widgets.RadioSelectHorizontal,
        label = 'カルテルを報告しますか？',
    )

    hokoku_3 = models.StringField(
        choices = [['報告する','報告する'],['報告しない','報告しない']],
        widget = widgets.RadioSelectHorizontal,
        label = 'カルテルを報告しますか？',
    )

    rank = models.IntegerField(initial=None)
    penalty_point = models.IntegerField(initial=None)

    def set_all_question_to_yes_1(self):
        if self.hokoku_1:
            self.hokoku_2 = '報告する'
            self.hokoku_3 = '報告する'

    def set_all_question_to_yes_2(self):
        if self.hokoku_2:
            self.hokoku_3 = '報告する'
    
    #def tie_penalty_point(self,tied_rank_list):
     #   penalty_point_list = [1, 2, 3]
      #  self.penalty_point = penalty_point_list[tied_rank_list.index(self.rank)]

    def rank_point(self):
        if self.rank == 1:
            self.penalty_point = 0
        elif self.rank == 2:
            self.penalty_point = 0.5
        elif self.rank == 3:
            self.penalty_point = 1
        else:
            self.penalty_point = 0

    random_time = models.IntegerField()

    finally_point = models.IntegerField()

    bakkin = models.IntegerField()

    penalty_random = models.IntegerField()

    random_result = models.IntegerField()
    
    def set_penalty(self):
        self.bakkin = self.result_point * 0.1 * self.penalty_point
    
    def set_penalty_random(self):
        self.penalty_random = self.result_point * 0.1

    def set_penalty_random_point(self):
        self.random_result = self.result_point - self.penalty_random

    def set_finally_point(self):
        self.finally_point = self.result_point - self.bakkin