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


import random
from csv import reader

doc = """
Your app description
"""

class Constants(BaseConstants):
    name_in_url = 'randomise_questions'
    players_per_group = None
    num_rounds = 1

    correct_point = 1
    wrong_point = 0

    number_of_topics = 2
    numPerQuizz = 10

    PerQuestion = c(0.25)

    TotalTime = 20


class Player(BasePlayer):
    is_correct = models.BooleanField()
    score = models.PositiveIntegerField()
    count_question = models.PositiveIntegerField()

    question_id_1 = models.PositiveIntegerField()
    question_id_2 = models.PositiveIntegerField()

    question1 = models.StringField()
    question2 = models.CharField()

    solution1 = models.CharField()
    solution2 = models.CharField()

    submitted_answer1 = models.StringField(widget=widgets.RadioSelect, blank=True)
    submitted_answer2 = models.StringField(widget=widgets.RadioSelect, blank=True)

    is_correct1 = models.BooleanField()
    is_correct2 = models.BooleanField()

class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


# FUNCTIONS
def creating_session(subsession: Subsession):

    if subsession.round_number == 1:

        # with open('quiz/quiz.csv') as f:
        #    quiz_file = list(csv.DictReader(f)) #--> this creates a dictionary
        with open('quiz/quiz.csv', 'r') as read_obj:
            csv_reader = reader(read_obj)
            quiz_file = list(csv_reader)
            print(quiz_file)
        def Extract_topics(quiz_file):
            return [item[1] for item in quiz_file]

        topic_list = Extract_topics(quiz_file)

        topic_list = list(dict.fromkeys(topic_list))
        topic_list = topic_list[1:]
        print("topic_list", topic_list)
        print("type", type(topic_list))
        number_of_topics = len(topic_list)
        print("number of topics", number_of_topics)
        print("type", type(number_of_topics))
        random_topic_number = random.randint(0, number_of_topics - 1)
        print("random topic number", random_topic_number)
        # random topic
        # random_topic = topic_list[random_topic_number]
        random_topic = topic_list.pop(random_topic_number)
        print("random topic", random_topic)
        print("updated topic list", topic_list)

        def extract_sub_dataset(quizfile, random_topic = random_topic):
            return [item for item in quiz_file if item[1] == random_topic]

        round_quiz_file = extract_sub_dataset(quiz_file)
        print("round_quiz_file", round_quiz_file)

        ## this is just for testing:
        temp_list = round_quiz_file.copy()
        print("temp_list", temp_list)
        random.shuffle(temp_list)
        print("temp_list", temp_list)
        round_quiz_file = temp_list  # we want to save the order for the records
        print("round_quiz_file = temp_list", round_quiz_file)  #looking good

        #list_of_question_ids =  range(1, len(quiz_file), 1)
        for player in subsession.get_players():
            print('round_quiz_file', round_quiz_file)

            question1_data = round_quiz_file[0]
            print("question 1 data", question1_data)
            player.participant.question1_data = question1_data
            print("question 1 data player.participant", question1_data)


            player.participant.question1 = question1_data[2]
            player.question1 = question1_data[2]

            #player.in_round(1).question_displayed_this_round = question_data[2]
            player.question_id_1 = question1_data[0]
            player.solution1 = question1_data[7]

            question2_data = round_quiz_file[1]
            print("question 2 data", question2_data)
            player.participant.question2_data = round_quiz_file[1]
            print("question 2 data - player.participant.question2_data", question2_data)


            player.participant.question2 = question2_data[2]
            player.question2 = question2_data[2]

            player.question_id_2 = question2_data[0]
            player.solution2 = question2_data[7]

def submitted_answer1_choices(player):
    import random
    question1_data = player.participant.question1_data
    print('participant question data -question 1', question1_data)
    choices = [ question1_data[3], question1_data[4], question1_data[5], question1_data[6],]
    #choices = choices_question_1
    random.shuffle(choices)
    print('submitted answers 1 - choices', choices)
    return choices


def submitted_answer2_choices(player):
    import random

    question2_data = player.participant.question2_data
    print('participant question data -question 2', question2_data)
    choices = [ question2_data[3], question2_data[4], question2_data[5], question2_data[6],]
    #choices = choices_question_1
    random.shuffle(choices)
    print('submitted answers 2 - choices', choices)
    return choices


def check_correct(player: Player):
    round_number = player.round_number
    # player.is_correct+round_number = player.submitted_answer+round_number == player.solution+round_number
    # player.is_correct = player.submitted_answer+round_number == player.solution+round_number

    # score = player.score

    if player.count_question ==1:
        player.is_correct1 = player.submitted_answer1 == player.solution1
        player.score = player.is_correct1
    else:
        player.is_correct2 = player.submitted_answer2 == player.solution2
        player.score = player.score + player.is_correct2


    # l = [player.is_correct1, player.is_correct2]
    # for player in round.get_all_players():
    #     player.score = sum([p.is_correct for p in player_in_all_rounds])



###### PAGES

class Question1(Page):
    form_model = "player"
    form_fields = ["submitted_answer1"]

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        player.count_question = 1
        check_correct(player)
        player.count_question = player.count_question + 1


class Question2(Page):
    form_model = "player"
    form_fields = ["submitted_answer2"]

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        check_correct(player)
        player.count_question = player.count_question + 1


class Question3(Page):
    form_model = "player"
    form_fields = ["response_3"]

    @staticmethod
    def is_displayed(player: Player):
        return player.question_displayed_this_round == 3

class Question4(Page):
    form_model = "player"
    form_fields = ["response_4"]

    @staticmethod
    def is_displayed(player: Player):
        return player.question_displayed_this_round == 4


page_sequence = [Question1, Question2]