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'],
        'pilot': int(self.session.config['pilot']),
        '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,
        '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']),
    }

def spec_vars(self):
    return {
        'specification': self.player.specification(),
        }

class AttentionCheck(Page):
    def is_displayed(self):
        return self.round_number == 1

    def vars_for_template(self):
        return shared_vars(self)

    form_model = 'player'
    form_fields = ['attention_check']

    def before_next_page(self):
        # count number of words for attention answer
        word_count = len(self.player.attention_check.split())
        # check if participants failed attention check
        if word_count < 15:
            self.participant.vars['failed_comprehension'] = True
            self.participant.vars['failed_attention'] = True
            print('test')
        else:
            self.participant.vars['failed_attention'] = False
            self.participant.vars['failed_comprehension'] = False

#@method_decorator(csrf_exempt, name='dispatch')
class Welcome(Page):


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


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


class Instructions(Page):

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

class Example(Page):

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


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

class SequenceEvents(Page):

    form_model = 'player'
    form_fields = ['clicked_payoff_info']

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

class Machine(Page):

    def is_displayed(self):
        return self.round_number == 1 and not self.participant.vars['failed_comprehension']
    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 and not self.participant.vars['failed_comprehension']
    def vars_for_template(self):
        return shared_vars(self)


class WaitExample(Page):
    timeout_seconds = 3

    def is_displayed(self):
        return self.round_number == 1 and not self.participant.vars['failed_comprehension']
    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']
    def vars_for_template(self):
        return {**shared_vars(self), **spec_vars(self)}

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

    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):
        tmp = spec_vars(self)
        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), **tmp, 'draw': sample}

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

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


class BeginStudy(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),}
    
    def before_next_page(self):
        self.player.set_treat()



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),
            **spec_vars(self)
        }

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

    def before_next_page(self):
        if self.round_number == Constants.num_rounds:
                self.player.payoff += Constants.num_rounds * self.session.config['fixed_round_bonus']

        up = self.player.answer + (30 - self.player.confidence)
        low = self.player.answer - (30 - self.player.confidence)
        if up > 100:
            self.player.confidence_upper_bound = 100
        else:
            self.player.confidence_upper_bound = up
        if low < 0:
            self.player.confidence_lower_bound = 0
        else:
            self.player.confidence_lower_bound = low


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 and not self.participant.vars['failed_comprehension']

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

    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)))),}
    
    def before_next_page(self):

        if self.player.qn_confidence1 != 12:
            #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_balls != 1:
            self.player.qn_balls_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 = 1
    def vars_for_template(self):
        return shared_vars(self)
    def before_next_page(self):
        self.player.create_task()



page_sequence = [
    AttentionCheck,
    Welcome,
    Consent,
    Instructions,
    Example,
    Machine,
    SequenceEvents,
    #Payment,
    ComprehensionQns,
    FailedComprehension,
    BeginStudy,
    Wait,
    # Example,
    # WaitExample,
    #WTP,
    #ResolutionMachine,
    Belief_new,
    #Belief,
    Confidence,
]