from otree.api import Currency as c, currency_range
from . import models
from ._builtin import Page, WaitPage
from .models import Constants

#from django.views.decorators.csrf import csrf_exempt
#from django.utils.decorators import method_decorator

def shared_vars(self):
    """ get variables from session configs level """
    return {
        'fee': c(self.session.config['participation_fee']),
        'exp_duration': self.session.config['exp_duration'],
        'machine_probability': self.session.config['machine_probability'],
        'num_questions': self.session.config['total_belief_rounds'],
        'max_payment': c(self.session.config['participation_fee'] + self.session.config['prize'] + self.session.config['endowment']),
        'max_duration': self.session.config['max_duration'],
        #'task': self.player.task_identifier,
        'round': self.round_number+6,
        'prize': c(self.session.config['prize']),
        'endowment': self.session.config['endowment'],
        # 'every_xth_person_paid': self.session.config['every_xth_person_paid'],
        #'task_type': self.player.task_type,
        'fixed_bonus': c(self.session.config['fixed_round_bonus']),
        'total_fixed_bonus': c(Constants.num_rounds * self.session.config['fixed_round_bonus']),
        'id': self.participant.id_in_session,
    }

def spec_vars(self):
    return {
#        'compound_low_bound': self.player.specification()['red_chips_a'] - 10,
#        'compound_high_bound': self.player.specification()['red_chips_a'] + 10,
        'specification': self.player.specification(),
#        'other_cards': self.player.other_cards(),
        }

complex_vars = {}

#@method_decorator(csrf_exempt, name='dispatch')
class Welcome(Page):
    print("welcome")
    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)


class Consent(Page):
    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)


class Instructions(Page):

    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)


class Payment(Page):

    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)

class SequenceEvents(Page):

    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)

class Machine(Page):

    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return {**shared_vars(self),  'radio_amounts': list(zip([5*x for x in range(0,21)], list(range(1,22))))}


class Example(Page):

    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)


class WaitExample(Page):
    timeout_seconds = 3

    def is_displayed(self):
        return self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)
# class BallsUrnsPrior(Page):
#
#     form_model = 'player'
#     form_fields = [
#         'prior',
#     ]




class Belief(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension'] and not self.player.is_load
    def vars_for_template(self):
        global complex_vars
        complex_vars = spec_vars(self)
        return {**shared_vars(self), **complex_vars}

    form_model = 'player'
    form_fields = [
        'answer', 'timed_out', 'time_on_p', 'time_before_next_p', 'closed_p',
    ]

    def before_next_page(self):
        self.player.set_payoffs()

class Belief_new(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension']
    def vars_for_template(self):
        global complex_vars
        complex_vars = self.player.specification()
        sample = [1 for y in range(self.player.number_blacks)]
        sample.extend([0 for y in range(self.player.number_whites)])
        return {**shared_vars(self), **complex_vars, 'draw': sample, 'rows': [x for x in range(0,14)]}

    form_model = 'player'
    form_fields = [
        'answer','timed_out', 'time_on_p', 'time_before_next_p', 'closed_p', 'load_sum',
    ]

    def before_next_page(self):
        if not self.player.is_load:
            self.player.set_payoffs()

class BeliefLoad(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension'] and self.player.is_load
    def vars_for_template(self):
        global complex_vars
        complex_vars = spec_vars(self)
        return {**shared_vars(self), **complex_vars, 'rows': [x for x in range(0,14)]}

    form_model = 'player'
    form_fields = [
        'answer', 'timed_out', 'load_sum', 'time_on_p', 'time_before_next_p', 'closed_p',
    ]

    


class BeginStudy(Page):

    def is_displayed(self):
        return self.player.round_number == 1 and not self.participant.vars['failed_comprehension'] and self.player.is_complex
    def vars_for_template(self):
        return {**shared_vars(self)}

class TimerInfo(Page):

    def is_displayed(self):
        return self.player.round_number == 1 and not self.participant.vars['failed_comprehension']
    def vars_for_template(self):
        return {**shared_vars(self)}
    
    form_model = 'player'
    form_fields = [
        'qn_timer', 'qn_bonus',
    ]


class Confidence(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension']

    def vars_for_template(self):

        sample = [1 for y in range(self.player.number_blacks)]
        sample.extend([0 for y in range(self.player.number_whites)])
        
        window_size = 1
        if abs(self.player.answer)>= window_size and self.player.answer + window_size <= 100:
            bound_DE = [abs(self.player.answer+window_size), abs(self.player.answer-window_size)]
        elif self.player.answer < window_size:
            bound_DE = [0, abs(self.player.answer + window_size)]
        elif self.player.answer+window_size > 100:
            bound_DE = [self.player.answer - window_size, 100]
            print('up_bound')
        else:
            print(self.player.answer+window_size > self.player.lottery_amount)
        
        return {
            'val_up_DE': '%.1f' % round(max(bound_DE),1),
            'val_low_DE': '%.1f' % round(min(bound_DE),1),
            "red_bag_prob": self.player.answer,
            "blue_bag_prob": 100 - self.player.answer,
            "draw": sample,
            'radio_amounts': list(zip([5*x for x in range(0,21)], list(range(1,22)))),
            #shared vars
            **shared_vars(self),
            **complex_vars
        }

    form_model = 'player'
    form_fields = [
        'confidence',
    ]

        

class WTP(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension']

    form_model = 'player'
    form_fields = [
        'wtp',
    ]
    def vars_for_template(self):
        return {**shared_vars(self), **spec_vars(self),}

    def before_next_page(self):
        self.player.resolve_machine()


class ResolutionMachine(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension']
    def vars_for_template(self):
        return {**shared_vars(self), **spec_vars(self)}


class FailedComprehension(Page):

    def is_displayed(self):
        return self.participant.vars['failed_comprehension'] and self.round_number == 1
    def vars_for_template(self):
        return shared_vars(self)


class ComprehensionQns(Page):

    def is_displayed(self):
        return self.round_number == 1

    form_model = 'player'
    form_fields = [
        'qn_alloc',
        #'qn_select',
        'qn_draws',
        'qn_incent',
        # 'qn_machine1',
        # 'qn_machine2',
    ]

    def vars_for_template(self):
        return shared_vars(self)
    def before_next_page(self):

        if self.player.qn_alloc != 1:
            self.player.qn_alloc_got_wrong = True
            self.player.failed_comprehension = True
            self.participant.vars['failed_comprehension'] = True

        if self.player.qn_draws != 1:
            self.player.qn_draws_got_wrong = True
            self.player.failed_comprehension = True
            self.participant.vars['failed_comprehension'] = True

        if self.player.qn_incent != 1:
            self.player.qn_incent_got_wrong = True
            self.player.failed_comprehension = True
            self.participant.vars['failed_comprehension'] = True
        
        


class Wait(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension']

    timeout_seconds = 2
    
    def vars_for_template(self):
        return shared_vars(self)

    def before_next_page(self):
        self.player.set_treatment()
        self.player.create_task()

class Timeout(Page):

    form_model = 'player'

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension'] and self.player.timed_out

    def vars_for_template(self):
        return shared_vars(self)


class LoadSumEntry(Page):
    def is_displayed(self):
        return not self.participant.vars['failed_comprehension'] and self.player.is_load

    def vars_for_template(self):
        return shared_vars(self)

    form_model = 'player'
    form_fields = ['load_guess']

    def before_next_page(self):
        if self.player.load_guess == self.player.load_sum:
            self.player.load_correct = 1
            if self.player.round_number == 1:
                self.player.load_num_correct = 1
            else:
                self.player.load_num_correct = self.participant.vars['load_num_correct'] + self.player.load_correct
        else:
            self.player.load_correct = 0
            if self.player.round_number == 1:
                self.player.load_num_correct = 0
            else:
                self.player.load_num_correct = self.participant.vars['load_num_correct'] + self.player.load_correct

        if self.player.timed_out:
            self.player.participant.vars['disqualified'] = True
        self.participant.vars['load_num_correct'] = self.player.load_num_correct
        self.player.set_payoffs()

class BetaPage(Page):

    def is_displayed(self):
        return not self.participant.vars['failed_comprehension']
    
    form_model = 'player'
    form_fields = ['task_type_beta']

    def before_next_page(self):
        self.player.set_treatment_beta()
    



page_sequence = [
    # Welcome,
    # Consent,
    # Instructions,
    # Machine,
    # SequenceEvents,
    # Payment,
    # ComprehensionQns,
    # FailedComprehension,
    # Example,
    # WaitExample,
    #WTP,
    #ResolutionMachine,
    Wait,
    BeginStudy,
    #TimerInfo,
    #BetaPage,
    Belief_new,
    #Belief,
    #BeliefLoad,
    Confidence,
    LoadSumEntry,
    #Timeout
]