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

def after_timeout(self):
    if self.timeout_happened:
        self.player.participant_left = True
        self.player.participant.vars["participant_left"]=True
        #add period
        other=self.player.get_others_in_group()[0]
        other.collegue_left = True
        other.participant.vars["collegue_left"]=True


def kick_after_page(self):
    if 'participant_left' in self.participant.vars or 'collegue_left' in self.participant.vars:
            self.participant.vars["kicked_out_period"] = self.subsession.round_number
            self.player.kicked_out_period = self.subsession.round_number
            return "kicked_out"



class mtrurk_wait_page(WaitPage):
    template_name = Constants.template_mturk_wait_page
    group_by_arrival_time = True
   
    def is_displayed(self):
        return self.round_number == 1
    
    def vars_for_template(self):
        self.player.waited_for_group=True
        return dict(
            is_wrong_role=False,
            waiting_for_effort=False,
            waiting_for_bonus=False,
            waiting_for_confrontation=False,
             )
    

        


class supervisorEffortWaitPage(WaitPage):
    
    template_name = Constants.template_wait_page
    title_text = "Please wait for the employee to decide how many winning balls to buy. "
    body_text = ""
    
    def vars_for_template(self):
        if self.player.id_in_group == 2:
            
            is_employee=True
            bold=False
        else:
            
            is_employee=False
            bold=True

        return dict(
            is_wrong_role=is_employee,
            waiting_for_effort=bold,
            waiting_for_bonus=False,
            waiting_for_confrontation=False,
        )
  
    def app_after_this_page(self, upcoming_apps):
        return kick_after_page(self)
        
class employeeBonusWaitPage(WaitPage):
    template_name = Constants.template_wait_page
    title_text = "Please wait for the supervisor to decide how much bonus to award to you. "
    body_text = ""
    
    def vars_for_template(self):
        if self.player.id_in_group == 1:
            is_supervisor=True
            bold=False
        else:
            is_supervisor=False
            bold=True


        return dict(
            is_wrong_role=is_supervisor,
            waiting_for_effort=False,
            waiting_for_bonus=bold,
            waiting_for_confrontation=False,
        )

    def app_after_this_page(self, upcoming_apps):
        return kick_after_page(self)

class supervisorConfrontationWaitPage(WaitPage):
    template_name = Constants.template_wait_page
    title_text = "Please wait for the employee to decide if they will confront you. "
    body_text = ""
    
    def vars_for_template(self):
        return dict(
            is_wrong_role=False,
            waiting_for_effort=False,
            waiting_for_bonus=False,
            waiting_for_confrontation=True,
        )
    
    def app_after_this_page(self, upcoming_apps):
        return kick_after_page(self)

class Intro(Page):
    timeout_seconds = Constants.max_per_page
    def is_displayed(self):
        return self.subsession.round_number==1
    def vars_for_template(self):
        self.player.waited_for_group=False

        if self.player.id_in_group == 1:
            self.player.participant.vars['role']="Supervisor"
            
        if self.player.id_in_group == 2:
            self.player.participant.vars['role']="Employee"
        
        return dict(
            is_wrong_role=False,
            waiting_for_effort=False,
            waiting_for_bonus=False,
            waiting_for_confrontation=False,
        )
    def before_next_page(self):
        after_timeout(self)


class rocks(Page):
    
    timeout_seconds = Constants.max_per_page
    form_model = 'group'
    form_fields = ['effort']

    def vars_for_template(self):
        p1 = self.group.get_player_by_id(1)
        treatment_info = p1.participant.vars['treatment_info']
        treatment_confrontation = p1.participant.vars['treatment_confrontation']
        self.group.treatment_info = treatment_info
        self.group.treatment_confrontation = treatment_confrontation
        
        return dict(
            effort_label="Please select an amount between 0 to {}:".format(Constants.probability_dif)
        )

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

    def before_next_page(self):
        after_timeout(self)
        if self.group.profit_random():
            self.group.profit="High"
            self.group.supervisor_bonus = Constants.supervisor_bonus_high
        else:
            self.group.profit="Low"
            self.group.supervisor_bonus = Constants.supervisor_bonus_low

class employee_profit_report(Page):
    timeout_seconds = Constants.max_per_page
    def is_displayed(self):
        return self.player.id_in_group == 2   

    def vars_for_template(self):
        return dict(
            treatment_info=self.group.treatment_info,
            profit=self.group.profit,
            effort=self.group.effort,
        )
    def before_next_page(self):
        after_timeout(self)

class bonus(Page):
    timeout_seconds = Constants.max_per_page
    form_model = 'group'
    form_fields = ['bonus']

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

    def vars_for_template(self):
        self.group.payoff_supervisor=self.group.supervisor_bonus+Constants.supervisor_endowment
        return dict(
            treatment_info=self.group.treatment_info,
            profit=self.group.profit,
            effort=self.group.effort,
        )
    def before_next_page(self):
        after_timeout(self)

class employee_bonus_report(Page):
    timeout_seconds = Constants.max_per_page
    form_model = 'group'
    form_fields = ['confrontation']

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

    def vars_for_template(self):
        self.group.payoff_employee=Constants.employee_endowment+self.group.bonus-self.group.effort*Constants.cost_per_rock
        return dict(
            cost_effort = self.group.effort*Constants.cost_per_rock,
        )

    def before_next_page(self):
        if self.group.confrontation == 1:
            self.group.payoff_employee = self.group.payoff_employee - Constants.confronatation_employee
            self.group.payoff_supervisor = self.group.payoff_supervisor - Constants.confronatation_supervisor
        if self.subsession.round_number==Constants.num_rounds:
            payoff_period=random.randrange(1,Constants.num_rounds+1,1)
            self.group.random_period=payoff_period
            self.participant.payoff=self.group.in_round(payoff_period).payoff_employee
                
        after_timeout(self)

class supervisor_payoff_report(Page):
    
    def get_timeout_seconds(self):
        if self.subsession.round_number!=Constants.num_rounds:
            return Constants.max_per_page
    def is_displayed(self):
        return self.player.id_in_group == 1  

    def vars_for_template(self):

        current_period = self.subsession.round_number
        list_periods=[]
        if current_period==Constants.num_rounds:
            self.participant.payoff=self.group.in_round(self.group.random_period).payoff_supervisor
            list_periods=list(self.group.in_all_rounds())
        else:
            list_periods.append(self.group.in_round(current_period))

        return dict(
            treatment_info = self.group.treatment_info,
            next_round = self.subsession.round_number+1,
            group_periods = list_periods,

        )
    def before_next_page(self):
        self.participant.payoff=self.participant.payoff-Constants.fixed_payment_in_points
        if self.subsession.round_number!=Constants.num_rounds:
            after_timeout(self)

class employee_payoff_report(Page):
   
    def is_displayed(self):
        return self.player.id_in_group == 2  and self.subsession.round_number==Constants.num_rounds
    def vars_for_template(self):
        list_periods=[]
        list_periods=list(self.group.in_all_rounds())
        return dict(
            treatment_info = self.group.treatment_info,
            next_round = self.subsession.round_number+1,
            group_periods = list_periods,
        )
    def before_next_page(self):
        self.participant.payoff=self.participant.payoff-Constants.fixed_payment_in_points



page_sequence = [
    mtrurk_wait_page,
    Intro,
    rocks,
    supervisorEffortWaitPage,  
    employee_profit_report,
    bonus,
    employeeBonusWaitPage,
    employee_bonus_report,
    supervisorConfrontationWaitPage,
    supervisor_payoff_report,
    employee_payoff_report,
]