import random
from otree.api import *

doc = """
Simple implementation of 12-item Raven's progressive matrices.
"""


class Constants(BaseConstants):
    name_in_url = "raven_matrices"
    players_per_group = None
    num_rounds = 1


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


def generate_raven_field():
    """
    :return: otree IntegerField with eight choices for Raven's matrices test.
    """
    return models.IntegerField(
        choices=(1, 2, 3, 4, 5, 6, 7, 8),
        widget=widgets.RadioSelectHorizontal,
        label="Please, indicate which of the eight options completes the pattern in the picture.",
        blank=True,
        initial=0,
    )


class Player(BasePlayer):
    raven_1 = generate_raven_field()
    raven_2 = generate_raven_field()
    raven_3 = generate_raven_field()
    raven_4 = generate_raven_field()
    raven_5 = generate_raven_field()
    raven_6 = generate_raven_field()
    raven_7 = generate_raven_field()
    raven_8 = generate_raven_field()
    raven_9 = generate_raven_field()
    raven_10 = generate_raven_field()
    raven_11 = generate_raven_field()
    raven_12 = generate_raven_field()

    # Mark if a specific matrix was answered correctly (for payoff and data analysis purposes)
    raven_1_correct = models.BooleanField(initial=False)
    raven_2_correct = models.BooleanField(initial=False)
    raven_3_correct = models.BooleanField(initial=False)
    raven_4_correct = models.BooleanField(initial=False)
    raven_5_correct = models.BooleanField(initial=False)
    raven_6_correct = models.BooleanField(initial=False)
    raven_7_correct = models.BooleanField(initial=False)
    raven_8_correct = models.BooleanField(initial=False)
    raven_9_correct = models.BooleanField(initial=False)
    raven_10_correct = models.BooleanField(initial=False)
    raven_11_correct = models.BooleanField(initial=False)
    raven_12_correct = models.BooleanField(initial=False)

    ravenNumberCorrect = models.IntegerField(initial=0)
    raven_payoff = models.IntegerField()


class GoToPatternGame(Page):
    timeout_seconds = 600

    @staticmethod
    def vars_for_template(player: Player):
        raven_bonus = player.session.config["raven_points"]
        duration = round(player.session.config["raven_timeout"] / 60)
        return dict(raven_bonus=raven_bonus, duration_min=duration)

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        if timeout_happened:
            player.participant.timeout = True

    @staticmethod
    def app_after_this_page(player, upcoming_apps):
        participant = player.participant
        if participant.timeout:
            return "kick"


class RavenMatrices(Page):
    form_model = "player"
    form_fields = [
        "raven_1",
        "raven_2",
        "raven_3",
        "raven_4",
        "raven_5",
        "raven_6",
        "raven_7",
        "raven_8",
        "raven_9",
        "raven_10",
        "raven_11",
        "raven_12",
    ]

    @staticmethod
    def get_timeout_seconds(player):
        session = player.session
        return session.config["raven_timeout"]

    # Input correct solutions to raven matrices here
    # Make sure that they track the correct answer!
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        if player.raven_1 == 7:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_1_correct = True
        if player.raven_2 == 4:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_2_correct = True
        if player.raven_3 == 6:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_3_correct = True
        if player.raven_4 == 2:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_4_correct = True
        if player.raven_5 == 4:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_5_correct = True
        if player.raven_6 == 7:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_6_correct = True
        if player.raven_7 == 8:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_7_correct = True
        if player.raven_8 == 7:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_8_correct = True
        if player.raven_9 == 5:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_9_correct = True
        if player.raven_10 == 5:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_10_correct = True
        if player.raven_11 == 4:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_11_correct = True
        if player.raven_12 == 1:
            player.ravenNumberCorrect = player.ravenNumberCorrect + 1
            player.raven_12_correct = True

        # Set payoff for the raven task
        # Pick one random raven matrix
        player.participant.raven_selection = random.choice(
            [
                player.raven_1_correct,
                player.raven_2_correct,
                player.raven_3_correct,
                player.raven_4_correct,
                player.raven_5_correct,
                player.raven_6_correct,
                player.raven_7_correct,
                player.raven_8_correct,
                player.raven_9_correct,
                player.raven_10_correct,
                player.raven_11_correct,
                player.raven_12_correct,
            ]
        )


page_sequence = [GoToPatternGame, RavenMatrices]