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


import random
from csv import reader

doc = """
Your app description
"""

## What I have right now:
#create q list and topic list
# create ranodm topic selection and related questions
#next: pass topic list (popped) accross apps --> do this last
# next: show each question on one page

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

    test_file = 345


class Player(BasePlayer):

    #sample_question = models.IntegerField(widget=widgets.RadioSelect, blank=True, choices=[1,2,3], label="sample question?")
    # submitted1 = models.IntegerField(widget=widgets.RadioSelect, blank=True)
    # def submitted1_choices(player):
    #     choices = [1, 2, 3]
    #     return choices
    # fruit = models.CharField(widget=widgets.RadioSelect, blank=True)

    question_displayed_this_round = models.StringField()
    response_1 = models.StringField()
    response_2 = models.StringField()
    response_3 = models.StringField()
    response_4 = models.StringField()

    #question_id = models.PositiveIntegerField()
    #question = models.CharField()
    #solution = models.CharField()
    #submitted_answer = models.CharField(widget=widgets.RadioSelect)
    #is_correct = models.BooleanField()

    score = models.FloatField()

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

    choice_1_1 = models.IntegerField()
    choice_1_2 = models.IntegerField()
    choice_1_3 = models.IntegerField()
    choice_1_4 = models.IntegerField()

    choice_2_1 = models.IntegerField()
    choice_2_2 = models.IntegerField()
    choice_2_3 = models.IntegerField()
    choice_2_4 = models.IntegerField()

    question1 = models.StringField()

    # def question1_choices(player):
    #     import random
    #
    #     #choice_1_1 = player.choice_1_1
    #
    #     #choice_1_1 = question_data[3]
    #     #choice_1_2 = question_data[4]
    #     #choice_1_3 = question_data[5]
    #     #choice_1_4 = question_data[6]
    #     choice_1_1 = player.choice_1_1
    #     choice_1_2 = player.choice_1_2
    #     choice_1_3 = player.choice_1_3
    #     choice_1_4 = player.choice_1_4
    #
    #     choices = []
    #     choices.extend((choice_1_1, choice_1_2, choice_1_3, choice_1_4))
    #
    #
    #     #choices_question_1 = list(choice_1_1, choice_1_2, choice_1_3, choice_1_4)
    #     #choices_question_1 = question_data[3:6]
    #     #choices_question_1 = player.choices_question_1
    #
    #     #choices = choices_question_1
    #     random.shuffle(choices)
    #     return choices

    question2 = models.CharField()

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

    submitted_answer1 = models.StringField(widget=widgets.RadioSelect, blank=True)
    # def submitted_answer1_choices(player):
    #     choices = [1, 2, 3]
    #     return choices

    # https://groups.google.com/g/otree/c/TXANWYoezs8

    # def submitted_answer1_choices(self):
    #     import random
    #     choices = ['a', 'b', 'c']
    #     random.shuffle(choices)
    #     return choices

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

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


    def current_question(self, k):
        return self.participant.vars['questionsQuizzes'][10 * (self.round_number - 1) + k - 1]

    ## current_question need not be stored in the result table

    def check_correct(self):
        self.is_correct1 = self.submitted_answer1 == self.solution1
        self.is_correct2 = self.submitted_answer2 == self.solution2


        l = [self.is_correct1, self.is_correct2, self.is_correct3, self.is_correct4, self.is_correct5, self.is_correct6,
             self.is_correct7,
             self.is_correct8, self.is_correct9, self.is_correct10]

        self.score = sum(l) * Constants.correct_point - (Constants.numPerQuizz - sum(l)) * Constants.wrong_point


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)

        # num_rounds = len(quiz_file) --> see below
        # print(quiz_file)

        #### See how we can save the order of questions!!
        # Let's select a random topic:
        # 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)
        # print(type(topic_list))
        # number_of_topics = len(topic_list)
        # print(number_of_topics)
        # print(type(number_of_topics))
        # random_topic_number = random.randint(0,number_of_topics-1)
        # print(random_topic_number)
        # random_topic = topic_list[random_topic_number]
        # print(random_topic)
        # topic_list = topic_list.pop(random_topic_number)

        ## This is likely useless since we want a random integer
        # random_choice = random.choice(topic_list)
        # print(random_choice)
        # print(type(random_choice))
        # round_topic = "test"
        # print(type(round_topic))
        # round_topic = topic_list.pop(random_choice)

        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

        #def extract_questions(quiz_file, random_topic=random_topic):
        #    return [item[2] for item in quiz_file if item[1] == random_topic]

        #round_questions = extract_questions(quiz_file)
        #print("questions", round_questions)
        #num_rounds = len(round_questions)
        #print("number of rounds", num_rounds)

        # create question ID list
        #def Extract_IDs(quiz_file, random_topic=random_topic):
        #    return [item[0] for item in quiz_file if item[1] == random_topic]

        #id_list = Extract_IDs(quiz_file)
        # id_list = id_list[1:]

        #print("id_list", id_list)


        #list_of_question_ids =  range(1, len(quiz_file), 1)
        for player in subsession.get_players():
            #temp_list = round_quiz_file.copy()
            #random.shuffle(temp_list)
            #round_quiz_file = temp_list # we want to save the order for the records

            #print("id_list", id_list)
            #random.shuffle(temp_list)
            #player.in_round(1).question_displayed_this_round = temp_list.pop(0)
            #print("temp_list round 1", temp_list)
            #player.in_round(2).question_displayed_this_round = temp_list.pop(0)
            #print("temp_list round 2", temp_list)

            #temp_list_ids = temp_list[0]
            #print("temp_list_ids", temp_list_ids)
            # !!! -> the output is: temp_list_ids ['1', 'History', 'What is the capital of China?', 'Shanghai', 'Guangzhou', 'Hong Kong', 'Beijing', 'Beijing']

            #player.question_id_1 = temp_list[0].pop(0)
            #player.question_id_2 = temp_list[0].pop(0)


            # player.in_round(3).question_displayed_this_round = temp_list.pop(0)
            # player.in_round(4).question_displayed_this_round = temp_list.pop(0)
            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]
            #question 1 choice 1, choice 2, ...
            # choice_1_1 = question_data[3]
            # choice_1_2 = question_data[4]
            # choice_1_3 = question_data[5]
            # choice_1_4 = question_data[6]
            #player.choices_question_1 = list(choice_1_1, choice_1_2, choice_1_3, choice_1_4)

            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]
            # player.choice_2_1 = question_data[3]
            # player.choice_2_2 = question_data[4]
            # player.choice_2_3 = question_data[5]
            # player.choice_2_4 = question_data[6]


            ###########################################################################################################
            ## I don't think I need this:

            # def question1_choices(player):
            #     import random
            #     choice_1_1 = question_data[3]
            #     choice_1_2 = question_data[4]
            #     choice_1_3 = question_data[5]
            #     choice_1_4 = question_data[6]
            #     #choices_question_1 = list(choice_1_1, choice_1_2, choice_1_3, choice_1_4)
            #     choices_question_1 = question_data[3:6]
            #     choices = choices_question_1
            #     random.shuffle(choices)
            #     print("choices question 1", choices)
            #     return choices

            ###########################################################################################################



    #treatment_result_entered = models.FloatField(label="Result")
    #random_number = models.IntegerField()
    #is_treatment = models.StringField()



def submitted_answer1_choices(player):
    import random

    #choice_1_1 = player.choice_1_1

    #choice_1_1 = question_data[3]
    #choice_1_2 = question_data[4]
    #choice_1_3 = question_data[5]
    #choice_1_4 = question_data[6]

    # choice_1_1 = player.choice_1_1
    # choice_1_2 = player.choice_1_2
    # choice_1_3 = player.choice_1_3
    # choice_1_4 = player.choice_1_4
    # choices = []
    # choices.extend((choice_1_1, choice_1_2, choice_1_3, choice_1_4))

    #choices = ['apple', 'kiwi']
    #choices_question_1 = list(choice_1_1, choice_1_2, choice_1_3, choice_1_4)
    #choices_question_1 = question_data[3:6]
    #choices_question_1 = player.choices_question_1
    #player.in_round(1)

    #for player in.get_players():

    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 submitted_answer1_choices(self):
#     # return [k for k in range(1, self.player.num_choices+1)]
#     qd = self.player.current_question(form_fields)
#     return [
#         qd['choice1'],
#         qd['choice2'],
#         qd['choice3'],
#         qd['choice4'],


# def question2_choices(player):
#     import random
#
#     choice_2_1 = player.choice_2_1
#     choice_2_2 = player.choice_2_2
#     choice_2_3 = player.choice_2_3
#     choice_2_4 = player.choice_2_4
#
#     choices = []
#     choices.extend((choice_2_1, choice_2_2, choice_2_3, choice_2_4))
#     print("choices", choices)
#     random.shuffle(choices)
#     return choices
#
# def submitted_answer2_choices(player):
#     import random
#
#     choice_2_1 = player.choice_2_1
#     choice_2_2 = player.choice_2_2
#     choice_2_3 = player.choice_2_3
#     choice_2_4 = player.choice_2_4
#
#     choices = []
#     choices.extend((choice_2_1, choice_2_2, choice_2_3, choice_2_4))
#     print("choices", choices)
#     random.shuffle(choices)
#     return choices
#
#
#
#########from tutorial:
#Functions
#def creating_session(subsession):
    # if subsession.round_number ==1:
    #     number_players = len(subsession.get_players())
    # treatment_list =[]
    #
    # # reates a list from 0 of #players -1
    # for i in range(number_players):
    #     # % gives the remainder of a division
    #     if i % 2 == 0:
    #         treatment_list.append(True)
    #     else:
    #         treatment_list.append(False)
    # for player in subsession.get_players():
    #     index = random.randint(0,len(treatment_list)-1) #or instead of treatment_list we could use number_players-1
    #     player.is_treatment_1 = treatment_list.pop(index)
    #     #pop takes a value from the list, returns the value and then removes the value from the list



# # PAGES
# class MyPage(Page):
#     form_model="player"
#     form_fields = ["division_result_entered"]
#
#     @statisticmethod
#     def vars_for_template(player: Player):
#         player.random_number = random.randint(1,100)
#         if player.is_treatment_1:
#             divisor = Constants.divisor_1
#         else:
#             divisor = Constants.divisor_2
#         return{
#             "divisor": divisor
#         }
#
#


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


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

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


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]