import random
from otree.api import *

doc = """
For each participant, randomize the order of tasks A, B, and C.
Task B has 2 pages, which are always shown in the same order.
The page_sequence contains all tasks;
in each round we show a randomly determined subset of pages.
"""


class C(BaseConstants):
    NAME_IN_URL = 'Givers_Survey'
    PLAYERS_PER_GROUP = None
    PAYMENT_PER_ANSWER = cu(250)
    TASKS = ['A', 'B', 'C']
    NUM_ROUNDS = len(TASKS) + 2
    public_goods_game_choices = [
        [1, "Same for Exhibit Blue type and Exhibit Green type people"],
        [2, "Greater for Exhibit Blue type than Exhibit Green type people"],
        [3, "Lesser for Exhibit Blue type than Exhibit Green type people"]
    ]
    random.shuffle(public_goods_game_choices)
    real_effort_task_choices = [
        [1, "Same for Exhibit Blue type and Exhibit Green type people"],
        [2, "Greater for Exhibit Blue type than Exhibit Green type people"],
        [3, "Lesser for Exhibit Blue type than Exhibit Green type people"]
    ]
    random.shuffle(real_effort_task_choices)

    coin_flip_game_choices = [
        [1, "Same for Exhibit Blue type and Exhibit Green type people"],
        [2, "Greater for Exhibit Blue type than Exhibit Green type people"],
        [3, "Lesser for Exhibit Blue type than Exhibit Green type people"]
    ]
    random.shuffle(coin_flip_game_choices)


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):

    payoff_game1 = models.CurrencyField()
    payoff_game2 = models.CurrencyField()
    payoff_game3 = models.CurrencyField()
    correct_answer_game1 = models.IntegerField(initial=0)
    correct_answer_game2 = models.IntegerField(initial=0)
    correct_answer_game3 = models.IntegerField(initial=0)

    # Game 1

    public_goods_game = models.IntegerField(
        label="Think about the number of people who contributed 0 to the joint pot. Is the number:",
        choices=C.public_goods_game_choices,
        widget=widgets.RadioSelect
    )

    def set_payoff_game1(player):
        if player.public_goods_game in [1, 2]:
            player.payoff += C.PAYMENT_PER_ANSWER
            player.correct_answer_game1 += 1
        else:
            player.payoff += cu(0)
        player.participant.vars['payoff_game1'] = player.payoff
        player.participant.vars['correct_answer_game1'] = player.correct_answer_game1

    # Game 2

    real_effort_task = models.IntegerField(
        label="Think about the number of people who choose to receive the flat fee of 50 INR instead of "
              "doing the letter production task. Is this number:",
        choices=C.real_effort_task_choices,
        widget=widgets.RadioSelect
    )

    def set_payoff_game2(player):
        if player.real_effort_task in [1, 2]:
            player.payoff += C.PAYMENT_PER_ANSWER
            player.correct_answer_game2 += 1
        else:
            player.payoff += cu(0)
        player.participant.vars['payoff_game2'] = player.payoff
        player.participant.vars['correct_answer_game2'] = player.correct_answer_game2

    # Game 3

    coin_flip_game = models.IntegerField(
        label="Think about the average number of heads reported per person. Is the reported number of heads:",
        choices=C.coin_flip_game_choices,
        widget=widgets.RadioSelect
    )

    def set_payoff_game3(player):
        if player.coin_flip_game in [1,2]:

            player.payoff += C.PAYMENT_PER_ANSWER
            player.correct_answer_game3 += 1
        else:
            player.payoff += cu(0)
        player.participant.vars['payoff_game3'] = player.payoff
        player.participant.vars['correct_answer_game3'] = player.correct_answer_game3


# FUNCTIONS
def creating_session(subsession: Subsession):
    if subsession.round_number == 1:
        for p in subsession.get_players():
            round_numbers = list(range(1, C.NUM_ROUNDS + 1))
            random.shuffle(round_numbers)
            task_rounds = dict(zip(C.TASKS, round_numbers))
            print('player', p.id_in_subsession)
            print('task_rounds is', task_rounds)
            p.participant.task_rounds = task_rounds


# PAGES
class TaskA(Page):
    @staticmethod
    def is_displayed(player: Player):
        participant = player.participant

        return player.round_number == participant.task_rounds['A']

    form_model = "player"
    form_fields = ["public_goods_game"]

    @staticmethod
    def before_next_page(player, timeout_happened):
        player.set_payoff_game1()


class TaskB1(Page):
    @staticmethod
    def is_displayed(player: Player):
        participant = player.participant

        return player.round_number == participant.task_rounds['B']

    form_model = 'player'
    form_fields = ['real_effort_task']

    @staticmethod
    def before_next_page(player, timeout_happened):
        player.set_payoff_game2()


class TaskC(Page):
    @staticmethod
    def is_displayed(player: Player):
        participant = player.participant

        return player.round_number == participant.task_rounds['C']

    form_model = 'player'
    form_fields = ['coin_flip_game']

    @staticmethod
    def before_next_page(player, timeout_happened):
        player.set_payoff_game3()


class TaskD(Page):
    @staticmethod
    def vars_for_template(player: Player):
        participant = player.participant

        payoff_game1 = participant.vars['payoff_game1']
        payoff_game2 = participant.vars['payoff_game2']
        payoff_game3 = participant.vars['payoff_game3']
        final_payoff = payoff_game1 + payoff_game2 + payoff_game3
        correct_answer_game1 = participant.vars['correct_answer_game1']
        correct_answer_game2 = participant.vars['correct_answer_game2']
        correct_answer_game3 = participant.vars['correct_answer_game3']
        num_correct_answers = correct_answer_game1 + correct_answer_game2 + correct_answer_game3

        return{
            'final_payoff': final_payoff,
            'num_correct_answers': num_correct_answers
        }

    @staticmethod
    def is_displayed(player: Player):
        participant = player.participant
        return player.round_number == C.NUM_ROUNDS


page_sequence = [
    TaskA,
    TaskB1,
    TaskC,
    TaskD
]