import random
import itertools
from otree.api import *


doc = """
Your app description
"""


class C(BaseConstants):
    NAME_IN_URL = 'puzzle_rounds_agents'
    PLAYERS_PER_GROUP = None
    PARAMETERIZATIONS = list(range(1, 11))
    NUM_ROUNDS = len(PARAMETERIZATIONS)
    # NUM_ROUNDS = 1

    HIGHPAYOFF = cu(2)
    LOWPAYOFF = cu(0)
    BELIEFPAYOFF = cu(2.5)


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):

    Puzzles1 = models.IntegerField(
        choices=[1, 2, 3, 4, 5, 6, 7, 8],
        blank=True,
        initial = 0,
        label=''
    )

    Puzzles2 = models.IntegerField(
        choices=[1, 2, 3, 4, 5, 6, 7, 8],
        blank=True,
        initial=0,
        label=''
    )

    Puzzles3 = models.IntegerField(
        choices=[1, 2, 3, 4, 5, 6, 7, 8],
        blank=True,
        initial=0,
        label=''
    )

    selfbelief1 = models.IntegerField(
        choices=[0, 1, 2, 3],
        label='How many puzzles do you think you solved correctly?',
    )

    selfbelief2 = models.IntegerField(
        choices=[
            [1, '0'],
            [2, '2'],
        ],
        label='How much do you think the Decider will earn because of your effort?',
        widget=widgets.RadioSelectHorizontal,
    )

    selfbelief3 = models.FloatField(min=0, max=1.75,
                  label='How much out of $1.75 do you think the Decider will give to you?',
    )

    Raven_Q1_correct = models.IntegerField()
    Raven_Q2_correct = models.IntegerField()
    Raven_Q3_correct = models.IntegerField()

    total = models.IntegerField()
    problottery = models.IntegerField()
    profitP = models.CurrencyField()
   # correctQ = models.CurrencyField()
    profitB = models.CurrencyField()
    final_payoff = models.CurrencyField()
    randomnumber_lottery = models.IntegerField()

    def rnumber_lottery(player):
        player.randomnumber_lottery = random.randint(0,100)


    def set_payoff1(player):
        if player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-7] == player.Puzzles1:
            player.Raven_Q1_correct = 1
        if not player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-7] == player.Puzzles1:
            player.Raven_Q1_correct = 0

    def set_payoff2(player):
        if player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-6] == player.Puzzles2:
            player.Raven_Q2_correct = 1
        if not player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-6] == player.Puzzles2:
            player.Raven_Q2_correct = 0

    def set_payoff3(player):
        if player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-5] == player.Puzzles3:
            player.Raven_Q3_correct = 1
        if not player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-5] == player.Puzzles3:
            player.Raven_Q3_correct = 0

    def set_payoff_total(player):
        player.total = (player.Raven_Q1_correct + player.Raven_Q2_correct + player.Raven_Q3_correct)

    def set_lottery(player):
        if player.total == 3:
            player.problottery = player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-1]
        if player.total == 2:
            player.problottery = player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-2]
        if player.total == 1:
            player.problottery = player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-3]
        if player.total == 0:
            player.problottery = player.session.parameterization[player.participant.param_rounds[player.round_number - 1] - 1][-4]

    def set_profitp1(player):
        if player.problottery >= player.randomnumber_lottery:
            player.profitP = C.HIGHPAYOFF
        if not player.problottery >= player.randomnumber_lottery:
            player.profitP = C.LOWPAYOFF
# PAGES
class Start_round(Page):
    pass

class calibration(Page):
    @staticmethod
    def vars_for_template(player):
        pp = player.participant
        ps = player.session
        current_parameterization = pp.param_rounds[player.round_number - 1]
        probability = ps.parameterization[current_parameterization - 1][-4:]
        # probability = ps.parameterization[current_parameterization - 1]
        return dict(
            current_parameterization=current_parameterization,
            prob_c0=probability[0],
            prob_c1=probability[1],
            prob_c2=probability[2],
            prob_c3=probability[3],
        )

class performer_puzzles(Page):
    form_model='player'
    form_fields=['Puzzles1', 'Puzzles2', 'Puzzles3']

    timeout_seconds = 3
    @staticmethod
    def vars_for_template(player):
        pp = player.participant
        ps = player.session
        current_parameterization = pp.param_rounds[player.round_number - 1]
        puzzles = ps.parameterization[current_parameterization - 1][-10:-7]
        return dict(
            current_parameterization=current_parameterization,
            puzzle1=puzzles[0],
            puzzle2=puzzles[1],
            puzzle3=puzzles[2],
        )

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.rnumber_lottery()
        player.set_payoff1()
        player.set_payoff2()
        player.set_payoff3()
        player.set_payoff_total()
        player.set_lottery()
        player.set_profitp1()

class Performer_beliefs(Page):
    form_model='player'
    form_fields=['selfbelief1', 'selfbelief2', 'selfbelief3']

    @staticmethod
    def app_after_this_page(player, upcoming_apps):
        if player.round_number == 10:
            if player.participant.treatment == 'Afirst':
                return "debriefing_agents"

page_sequence = [Start_round, calibration, performer_puzzles, Performer_beliefs]