from otree.api import Currency as c, currency_range

from ._builtin import Page, WaitPage
from .models import Constants

class Instruction(Page):
    form_model = 'player'
    form_fields = ['screen_name', 'sex']
    def is_displayed(self):
        return self.round_number == 1
    # def before_next_page(self):
    #     self.player.get_partner()
    #
    # def vars_for_template(self):
    #     self.player.get_partner()
    #     return {
    #         'partner_name': self.session.vars['partner_name'],
    #         'partner_sex': self.session.vars['partner_sex'],
    #     }


class FirstWaitPage(WaitPage):
    pass


class Question(Page):
    form_model = 'group'
    form_fields = ['submitted_answer', 'confidence']
    def is_displayed(self):
        return self.player.id_in_group == 1
    def submitted_answer_choices(self):
        qd = self.group.current_question()
        return [
            qd['choice1'],
            qd['choice2'],
            qd['choice3'],
            qd['choice4'],
        ]
    def vars_for_template(self):
        self.player.get_partner()
        print('partner name', self.session.vars['partner_name'][1])
        print('partner sex', self.session.vars['partner_sex'][1])
        return {
            'partner_name': self.session.vars['partner_name'],
            'partner_sex': self.session.vars['partner_sex'],
        }

    def before_next_page(self):
        self.group.check_correct()



class WaitForStudent(WaitPage):
    def is_displayed(self):
        return self.player.id_in_group == 2


class Grading(Page):
    form_model = 'group'
    form_fields = ['init_grading']
    def is_displayed(self):
        return self.player.id_in_group == 2
    def vars_for_template(self):
        return {
            'student_answer': self.group.submitted_answer,
            'init_grading': self.group.init_grading,
        }

    def vars_for_template(self):
        self.player.get_partner()
        return {
            'partner_name': self.session.vars['partner_name'],
            'partner_sex': self.session.vars['partner_sex'],
        }

    def before_next_page(self):
        self.group.init_grading_right()
        # print('init_grading_right', self.group.init_right)



class WaitForInstructor(WaitPage):
    def is_displayed(self):
        return self.player.id_in_group == 1



class Request(Page):
    form_model = 'group'
    form_fields = ['request']

    def is_displayed(self):
        # print('init_grading', self.group.init_grading)
        # print('is_correct', self.group.is_correct)
        return self.player.id_in_group == 1
    def vars_for_template(self):
        return {
            'request': self.group.request,
        }
    def before_next_page(self):
        self.group.fn_grade()
        self.group.fn_grading_right()
    def vars_for_template(self):
        self.player.get_partner()
        return {
            'partner_name': self.player.partner_name,
            'partner_sex': self.player.partner_sex,
        }


class WaitForStudent2(WaitPage):
    def is_displayed(self):
        return self.player.id_in_group == 2


class Regrade(Page):
    form_model = 'group'
    form_fields = ['regrade']
    def is_displayed(self):
        # print(self.player.id_in_group)
        # print(self.group.request)
        return self.player.id_in_group == 2 and self.group.request == True

    def vars_for_template(self):
        return {
            'regrade': self.group.regrade,
        }
    def before_next_page(self):
        self.group.fn_grade()
        self.group.fn_grading_right()
        # print('fn_grading_right', self.group.fn_right)
        self.group.set_payoffs()
    def vars_for_template(self):
        self.player.get_partner()
        return {
            'partner_name': self.player.partner_name,
            'partner_sex': self.player.partner_sex,
        }

class WaitForInstructor2(WaitPage):
    def is_displayed(self):
        return self.player.id_in_group == 1



class Results(Page):

    def is_displayed(self):
        # print('regrade', self.group.regrade)
        # print('fn_grading', self.group.fn_grading)
        return self.round_number == Constants.num_rounds


    def vars_for_template(self):
        group_in_all_rounds = self.group.in_all_rounds()
        return {
            'group_in_all_rounds': group_in_all_rounds,
            'questions_correct': sum([p.is_correct for p in group_in_all_rounds]),
            'init_correct': sum([p.init_grading for p in group_in_all_rounds]),
            'fn_correct': sum([p.fn_grading for p in group_in_all_rounds]),
            'num_requests': sum([p.request for p in group_in_all_rounds]),
            'initgrade_correct': sum([p.init_right for p in group_in_all_rounds]),
            'fngrade_correct': sum([p.fn_right for p in group_in_all_rounds]),
            # 'student_payoff': 10*self.group.fn_correct - 2*self.group.num_requests,
            # 'instructor_payoff': 10*self.group.fngrade_correct,

        }


#
# class Payoff(Page):
#     def is_displayed(self):
#         # print('regrade', self.group.regrade)
#         # print('fn_grading', self.group.fn_grading)
#         return self.round_number == Constants.num_rounds
#
#         # print('fn_correct', self.group.fn_correct)
#         # print('num_requests', self.group.num_requests)
#         # print('fngrade_correct', self.group.fngrade_correct)
#     def vars_for_template(self):
#         print('player_in_all_round', self.player.in_all_rounds())
#         return {
#             'player_payoff': sum([p.payoff for p in self.player.in_all_rounds()]),
#         }


page_sequence = [
    Instruction,
    FirstWaitPage,
    Question,
    WaitForStudent,
    Grading,
    WaitForInstructor,
    Request,
    WaitForStudent2,
    Regrade,
    WaitForInstructor2,
    Results,
    #Payoff,
]