from otree.api import *
import random

doc = """
Your app description
"""
random_costs = []
lst = [5, 10, 15]
seed = random.randint(0, 1000)
random.seed(seed)
for i in range(24):
    random_number = random.choice(lst)
    random_costs.append(random_number)


class Constants(BaseConstants):
    name_in_url = 'prisoners_dilemma'
    players_per_group = None
    num_rounds = 24
    payoff_both_cooperate = 15
    payoff_both_defect = 4
    payoff_to_cooperator_when_other_defect = 3
    payoff_to_defector_when_other_cooperate = 17


class Subsession(BaseSubsession):
    how_many_sent = []
    how_many_true = []


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    decision = models.StringField(
        label="Given these payoffs, please choose if you want to defect(x), cooperate(y)",
        choices=["(X)Defect", "(Y)Cooperate"],
        widget=widgets.RadioSelect
    )
    risk_preference = models.StringField(
        choices=['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10'],
        label="Risk almaktan kaçınırım.",
        widget=widgets.RadioSelect
    )
    comp_check1 = models.StringField(
        choices=['a', 'b', 'c', 'd'],
        widget=widgets.RadioSelect,
        label="<b><u>S1:</u></b> Karşınızdaki oyuncunun Y'yi seçtiğini ve sizin X'i seçtiğinizi varsayalım. Kazancınız nedir?"
    )
    comp_check2_1 = models.StringField(
        choices=['Evet', 'Hayır'],
        widget=widgets.RadioSelect,
        label="<b><u>S2-1:</u></b> 'Bir rapor göndermek için _e_ ECU (ancak daha fazla değil) harcamaya razıyım' seçeneğini seçtiğinizi ve bilgisayarın o dönemde bir rapor gönderme maliyeti olarak rastgele _f_ seçtiğini varsayalım. Raporunuz gönderilecek mi?"
    )
    comp_check2_1_1 = models.StringField(
        choices=['0', 'e', 'f', 'g'],
        widget=widgets.RadioSelect,
        label="<b><u>S2-1-1:</u></b> Bu durumda, dönemin raporlama kısmında ne gibi bir maliyetle karşılaşacaksınız?"
    )
    comp_check2_2 = models.StringField(
        choices=['Evet', 'Hayır'],
        widget=widgets.RadioSelect,
        label="<b><u>S2-2:</u></b> Bunun yerine 'Rapor göndermek için _g_ ECU harcamaya razıyım' seçeneğini belirlediğinizi varsayalım ve bilgisayarın o dönemde bir rapor gönderme maliyeti olarak rastgele _f_ seçtiğini düşünelim. Raporunuz gönderilecek mi?"
    )
    comp_check2_2_1 = models.StringField(
        choices=['0', 'e', 'f', 'g'],
        widget=widgets.RadioSelect,
        label="<b><u>S2-2-1:</u></b> Bu durumda, dönemin raporlama kısmında ne gibi bir maliyetle karşılaşacaksınız?"
    )
    accuracy_check = models.StringField(
        choices=['0-10%', '10.1-20%', '20.1-30%', '30.1-40%', '40.1-50%', '50.1-60%', '60.1-70%', '70.1-80%',
                 '80.1-90%', '90.1-100%'],
        widget=widgets.RadioSelect,
        label="<b><u>Accuracy Check</u></b> What percentage of reports do you think were accurate"
    )
    sending_report = models.StringField(
        choices=["Rapor göndermek istemiyorum.", "1", "4", "7"],
        widget=widgets.RadioSelect,
        label="<b><u>Sending a Report</u></b> Do you want to send a report on your about your current counterpart? If yes, how much are you willing to pay?"
    )
    while_reporting = models.StringField(
        choices=["Karsinizdaki oyuncunun hareketi X idi(defect).", "Karsinizdaki oyuncunun hareketi Y idi(cooperate)"],
        widget=widgets.RadioSelect,
        label="<b><u>Which Report</u></b> Please select the report you wish to send."
    )
    belief_e1 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="Sizce bu tur oyuncularin yuzde kaci X oynadi?"
    )
    belief_e2 = models.IntegerField(
        min = 0,
        max = 100,
        initial=0,
        label="Sizce bu tur rapor gonderilenlerin yuzde kacinin durumu (X,X) idi?"
    )
    belief_e3 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="Sizce bu tur rapor gonderilenlerin yuzde kacinin durumu (X,Y) idi?"
    )
    belief_e4 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="Sizce bu tur rapor gonderilenlerin yuzde kacinin durumu (Y,X) idi?"
    )
    belief_e5 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="Sizce bu tur rapor gonderilenlerin yuzde kacinin durumu (Y,Y) idi?"
    )
    belief_e6 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="What percentage no report?"
    )
    belief_e7 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="What percentage report c1?"
    )
    belief_e8 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="What percentage report c2?"
    )
    belief_e9 = models.IntegerField(
        min=0,
        max=100,
        initial=0,
        label="What percentage report c3?"
    )

    reporting_to = models.IntegerField(initial=0)
    report_from = models.IntegerField(initial=0)
    next_opponent = models.IntegerField(initial=0)
    report_being_sent = models.BooleanField(initial=False)


def creating_session(subsession: BaseSubsession):
    if subsession.round_number < 16:
        i = subsession.round_number - 1
    else:
        i = subsession.round_number - 16
    weeks = []
    teams = subsession.get_group_matrix()[0]
    n = len(teams)
    for a in range(n - 1):
        b = zip(teams[:n // 2], reversed(teams[n // 2:]))
        weeks.append(list(b))
        teams.insert(1, teams.pop())
    subsession.set_group_matrix(weeks[i])
    print(f"Displaying group matrix for round {subsession.round_number}")
    print(subsession.get_group_matrix())
    print("Random costs", random_costs)


def get_reporting_opponent_id(player: Player):
    lst = []

    if player.id_in_group == 1:
        me = player.group.get_player_by_id(1)
        myself = me.id_in_subsession
    else:
        me = player.group.get_player_by_id(2)
        myself = me.id_in_subsession

    matrix_next_round = player.subsession.in_round(player.round_number + 1).get_group_matrix()

    for group in matrix_next_round:
        for p in group:
            if p == myself:
                group.remove(p)
                player.next_opponent = group[0]

    matrix = player.subsession.in_round(player.round_number).get_group_matrix()

    for group in matrix:
        for p in group:
            if p == player.next_opponent:
                group.remove(p)
                player.report_from = group[0]

    all_players = player.subsession.get_players()

    for p in all_players:
        if p.id_in_subsession == player.report_from:
            want = p
            return p


def set_payoffs(group: Group):
    list_of_players = group.get_players()
    player_1 = list_of_players[0]
    player_2 = list_of_players[1]
    if player_1.decision == "(X)Defect":
        if player_2.decision == "(X)Defect":
            player_1.payoff = Constants.payoff_both_defect
            player_2.payoff = Constants.payoff_both_defect
        else:
            player_1.payoff = Constants.payoff_to_defector_when_other_cooperate
            player_2.payoff = Constants.payoff_to_cooperator_when_other_defect
    else:
        if player_2.decision == "(X)Defect":
            player_1.payoff = Constants.payoff_to_cooperator_when_other_defect
            player_2.payoff = Constants.payoff_to_defector_when_other_cooperate
        else:
            player_1.payoff = Constants.payoff_both_cooperate
            player_2.payoff = Constants.payoff_both_cooperate

    # for p in list_of_players:
    #     print("Player", p.id_in_subsession, "s opponent is", get_opponent_id(p))

    for p in list_of_players:
        print("Player", p.id_in_subsession, "hello", get_reporting_opponent_id(p).id_in_subsession)


def update_payoffs(group: Group):
    cost_list = random_costs
    list_of_players_in_group = group.get_players()
    cost_of_reporting = cost_list[group.round_number - 1]
    for player in list_of_players_in_group:
        print("ben", player.sending_report, "o", cost_of_reporting)
    for player in list_of_players_in_group:
        player.report_being_sent = False
    for player in list_of_players_in_group:
        if player.sending_report == "Rapor göndermek istemiyorum.":
            player.payoff = player.payoff
            player.report_being_sent = False
        elif (player.sending_report == "1") and (cost_of_reporting <= 1):
            player.payoff -= cost_of_reporting
            player.report_being_sent = True
        elif (player.sending_report == "4") and (cost_of_reporting <= 4):
            player.payoff -= cost_of_reporting
            player.report_being_sent = True
        elif (player.sending_report == "7") and (cost_of_reporting <= 7):
            player.payoff -= cost_of_reporting
            player.report_being_sent = True

    # for p in list_of_players_in_group:
    #     print("Player", p.id_in_subsession, "report from", p.report_from)
    # for p in list_of_players_in_group:
    #     print("Player", p.id_in_subsession,
    #           "za", get_reporting_opponent_id(get_reporting_opponent_id(p)[1])[0].id_in_subsession)


def get_report(player: Player):
    return player.while_reporting

def belief_elicitation_everyRound(subsession:Subsession):

    players_in_subsession = subsession.get_players()
    count_x = 0
    count_y = 0

    for p in players_in_subsession:
        if p.decision == "(X)Defect":
            count_x += 1
        else:
            count_y += 1

    percentage_x = (count_x / len(players_in_subsession)) * 100
    percentage_y = (count_y / len(players_in_subsession)) * 100

    for p in players_in_subsession:
        if ((percentage_x * 0.90) <= float(p.belief_e1)) and ((percentage_x * 1.10) >= float(p.belief_e1)):
            p.payoff += 1



    print("percent", percentage_x)

def willing_to_pay_elicitation(subsession: Subsession):
    not_willing = []
    willing_c1 = []
    willing_c2 = []
    willing_c3 = []
    players_in_subsession = subsession.get_players()
    for p in players_in_subsession:
        if p.in_round(subsession.round_number).sending_report == "Rapor göndermek istemiyorum.":
            not_willing.append(p)
        elif p.in_round(subsession.round_number).sending_report == "1":
            willing_c1.append(p)
        elif p.in_round(subsession.round_number).sending_report == "4":
            willing_c2.append(p)
        else:
            willing_c3.append(p)
    percentage_not_willing = (len(not_willing)/len(players_in_subsession) * 100)
    percentage_willing_c1 = (len(willing_c1)/len(players_in_subsession) * 100)
    percentage_willing_c2 = (len(willing_c2) / len(players_in_subsession) * 100)
    percentage_willing_c3 = (len(willing_c3) / len(players_in_subsession) * 100)
    for p in players_in_subsession:
        if ((percentage_willing_c1 * 0.90) <= float(p.belief_e1)) and ((percentage_willing_c1 * 1.10) >= float(p.belief_e7)):
            p.payoff += 0.5
        if ((percentage_willing_c2 * 0.90) <= float(p.belief_e1)) and ((percentage_willing_c2 * 1.10) >= float(p.belief_e8)):
            p.payoff += 0.5
        if ((percentage_willing_c3 * 0.90) <= float(p.belief_e1)) and ((percentage_willing_c3 * 1.10) >= float(p.belief_e9)):
            p.payoff += 0.5


def every8thRoundElicitation(player: Player):
    pass
















# PAGES
class Welcome(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1


class ConsentForm(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1


class Pre_Experiment(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1


class Pre_Experiment_Q1(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    form_model = 'player'
    form_fields = ['risk_preference']


class MyPage(Page):
    wait_for_all_groups = True
    form_model = "player"
    form_fields = ["decision"]


class Instructions_1(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.participant.vars['threshold_reached'] = False


class Instructions_2(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.participant.vars['threshold_reached'] = False


class Instructions_3(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.participant.vars['threshold_reached'] = False


class Instructions_4(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.participant.vars['threshold_reached'] = False


class Comprehension_Check1(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    form_model = 'player'
    form_fields = ['comp_check1']

    def error_message(player: Player, values):
        if values['comp_check1'] != 'c':
            return 'Bu soruya doğru cevap vermediniz.'


class Instructions_5(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.participant.vars['threshold_reached'] = False


class Instructions_6(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.participant.vars['threshold_reached'] = False


class Comprehension_Check2(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1

    form_model = 'player'
    form_fields = ['comp_check2_1', 'comp_check2_1_1', 'comp_check2_2', 'comp_check2_2_1']

    def error_message(player: Player, values):
        if values['comp_check2_1'] != 'Hayır':
            return 'İlk soruya doğru cevap vermediniz.'
        if values['comp_check2_1_1'] != '0':
            return 'İkinci soruya doğru cevap vermediniz.'
        if values['comp_check2_2'] != 'Evet':
            return 'Üçüncü soruya doğru cevap vermediniz.'
        if values['comp_check2_2_1'] != 'f':
            return 'Dördüncü soruya doğru cevap vermediniz.'


class Instructions_7(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number == 1


class AccuracySurvey(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.group.round_number == 8 or player.group.round_number == 16 or player.group.round_number == 24

    form_model = 'player'
    form_fields = ['accuracy_check']

    # def error_message(player: Player, values):
    #     if values['accuracy_check'] == None:
    #         return 'You must answer the question near the bottom of the screen in order to proceed'


class Results(Page):
    @staticmethod
    def vars_for_template(player: Player):
        return dict(
            p1decision=player.group.get_player_by_id(1).decision,
            p2decision=player.group.get_player_by_id(2).decision,
            p1payoff=player.group.get_player_by_id(1).payoff,
            p2payoff=player.group.get_player_by_id(2).payoff
        )


class ResultsWaitPage(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        set_payoffs(group)


class Reporting(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.round_number > 0

    form_model = 'player'
    form_fields = ['sending_report']


class Reporting_Wait_Page(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        update_payoffs(group)


class Reporting_Results(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.report_being_sent is True

    form_model = 'player'
    form_fields = ['while_reporting']


class Before_Actual_Report(WaitPage):
    wait_for_all_groups = True

    @staticmethod
    def is_displayed(player: Player):
        return player.group.round_number > 1



class Actual_Report(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.group.round_number > 1

    @staticmethod
    def vars_for_template(player: Player):
        return dict(
            report=get_reporting_opponent_id(player).in_round(player.round_number - 1).field_maybe_none('while_reporting')
        )


class Belief_Elicitation(Page):
    @staticmethod
    def is_displayed(player: Player):
        return player.group.round_number > 0

    form_model = 'player'
    form_fields = ['belief_e1']

class Belief_Elicitation_WaitPage(WaitPage):
    wait_for_all_groups = True

    @staticmethod
    def after_all_players_arrive(subsession):
        belief_elicitation_everyRound(subsession)

class Belief_Elicitation_4_Situations(Page):
    def is_displayed(player: Player):
        return player.group.round_number == 8 or player.group.round_number == 16 or player.group.round_number == 24
    form_model = 'player'
    form_fields = ['belief_e2', 'belief_e3', 'belief_e4', 'belief_e5']
    def error_message(player: Player, values):
        if values['belief_e2'] + values['belief_e3'] + values['belief_e4'] + values['belief_e5'] != 100:
            return 'Toplamlarin 100 olmasi lazim.'

class Report_Costs_Elicitation(Page):

    def is_displayed(player: Player):
        return player.group.round_number == 1 or player.group.round_number == 4 or player.group.round_number == 7 or \
            player.group.round_number == 9 or player.group.round_number == 12 or player.group.round_number == 15 or \
            player.group.round_number == 17 or player.group.round_number == 20 or player.group.round_number == 23

    form_model = 'player'
    form_fields = ['belief_e6', 'belief_e7', 'belief_e8', 'belief_e9']

    def error_message(player: Player, values):
        if values['belief_e6'] + values['belief_e7'] + values['belief_e8'] + values['belief_e9'] != 100:
            return 'Toplamlarin 100 olmasi lazim.'

class Report_Costs_Elicitation_WaitPage(WaitPage):
    wait_for_all_groups = True

    @staticmethod
    def after_all_players_arrive(subsession):
        willing_to_pay_elicitation(subsession)










page_sequence = [Welcome, ConsentForm, Instructions_1, Instructions_2, Instructions_3, Instructions_4,
                 Comprehension_Check1, Instructions_5, Instructions_6, Instructions_7, Comprehension_Check2,
                 Before_Actual_Report, Actual_Report, MyPage, ResultsWaitPage, Results, Reporting, Reporting_Wait_Page,
                 Report_Costs_Elicitation,Report_Costs_Elicitation_WaitPage, Belief_Elicitation,
                 Belief_Elicitation_WaitPage, Belief_Elicitation_4_Situations, Reporting_Results,  AccuracySurvey]