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

class Instruction(Page):
    form_model = 'player'

    form_fields = ['q1a','q1b','q1c', 'q2a','q2b','q2c', 'q3', 'q4', 'q5', 'q6', 'q7', 'q8']

    def is_displayed(self):
        return self.subsession.round_number == 1 and self.subsession.gamemode == 2

    def error_message(self, value):
        return self.player.set_error_message(value)

    live_method = "live_instruct"
    def vars_for_template(self):
        players = self.subsession.get_players()
        num_pairs = self.subsession.num_S

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.subsession.gamemode == 2:
            correct_answers = {"q1a": 2,
                               "q1b": 2,
                               "q1c": 1,
                               "q2a": 2,
                               "q2b": 1,
                               "q2c": 2,
                               "q3": 1,
                               "q4": 2,
                               "q5": 1,
                               "q6": 2,
                               "q7": 2,
                               "q8": 2
                               }
        else:
            correct_answers = {"q1a": 2,
                               "q1b": 2,
                               "q1c": 1,
                               "q2a": 2,
                               "q2b": 1,
                               "q2c": 2,
                               "q5": 1,
                               "q6": 2,
                               "q7": 2,
                               "q8": 2
                               }

        return {'read' : self.player.read,
                'solutions': correct_answers,
                'num_rounds': Constants.num_rounds,
                'num_prac_rounds': Constants.num_prac_rounds,
                'num_off_rounds': Constants.num_rounds-Constants.num_prac_rounds,
                'num_S': self.subsession.num_S,
                'gamemode': self.subsession.gamemode,
                'num_pairs': num_pairs,
                'expertise': self.subsession.expertise,
                'correct_shell_red': round(self.subsession.expertise*10),
                'wrong_shell_red': round((1-self.subsession.expertise)*10),
                'correct_shell_blue': round(self.subsession.expertise*20),
                'wrong_shell_blue': round((1-self.subsession.expertise)*20),
                'correct_prob': round(self.subsession.expertise*100),
                'payoffs' : payoffs,
                'participation_fee' : int(self.session.participation_fee)
        }

class InstructionSingle(Page):
    form_model = 'player'

    form_fields = ['q1a','q1b','q1c', 'q2a','q2b','q2c', 'q5', 'q6', 'q7', 'q8']

    def is_displayed(self):
        return self.subsession.round_number == 1 and self.subsession.gamemode != 2

    def error_message(self, value):
        return self.player.set_error_message(value)

    live_method = "live_instruct"
    def vars_for_template(self):
        players = self.subsession.get_players()
        num_pairs = self.subsession.num_S

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.subsession.gamemode == 2:
            correct_answers = {"q1a": 2,
                               "q1b": 2,
                               "q1c": 1,
                               "q2a": 2,
                               "q2b": 1,
                               "q2c": 2,
                               "q3": 1,
                               "q4": 2,
                               "q5": 1,
                               "q6": 2,
                               "q7": 2,
                               "q8": 2
                               }
        else:
            correct_answers = {"q1a": 2,
                               "q1b": 2,
                               "q1c": 1,
                               "q2a": 2,
                               "q2b": 1,
                               "q2c": 2,
                               "q5": 1,
                               "q6": 2,
                               "q7": 2,
                               "q8": 2
                               }

        return {'read' : self.player.read,
                'solutions': correct_answers,
                'num_rounds':Constants.num_rounds,
                'num_prac_rounds':Constants.num_prac_rounds,
                'num_off_rounds': Constants.num_rounds - Constants.num_prac_rounds,
                'num_S': self.subsession.num_S,
                'gamemode': self.subsession.gamemode,
                'num_pairs': num_pairs,
                'expertise': self.subsession.expertise,
                'correct_shell_red': round(self.subsession.expertise*10),
                'wrong_shell_red': round((1-self.subsession.expertise)*10),
                'correct_shell_blue': round(self.subsession.expertise*20),
                'wrong_shell_blue': round((1-self.subsession.expertise)*20),
                'correct_prob': round(self.subsession.expertise*100),
                'payoffs' : payoffs,
                'participation_fee' : int(self.session.participation_fee)
        }


class PracticeWaitPage(WaitPage):
    def is_displayed(self):
        return self.subsession.round_number == 1


class RoundUsher(Page):
    def vars_for_template(self):
        players = self.subsession.get_players()

        if self.subsession.round_number<Constants.num_prac_rounds+1:
            title="Practice Round "+str(self.subsession.round_number)
        else:
            title ="Official Round "+str(self.subsession.round_number - Constants.num_prac_rounds)

        return dict(
            roundnum=self.subsession.round_number - 2,
            title_text=title
        )

class Stage1Usher(Page):
    def is_displayed(self):
        return self.subsession.gamemode == 2

    def vars_for_template(self):
        players = self.subsession.get_players()

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        return dict(
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            role=self.player.roles,
            title_text=title
        )

class SenderPage1(Page):
    form_model = 'player'
    form_fields = ['recom_0','recom_1','check_slider_one','check_slider_two']

    def is_displayed(self):
        return self.player.roles == 'S'

    def error_message(self, value):
        if value["check_slider_one"] == None or value["check_slider_two"] == None:
            return 'Please use the slider to make a decision.'

    def vars_for_template(self):

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs=dict()
        for conjecture in range(0,2):
            payoffs[conjecture]={'R0': 1-conjecture,
                             'R1': conjecture,
                             'S0': conjecture,
                             'S1': conjecture}

        return dict(
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            type = self.player.type,
            shell = self.player.shell,
            payoffs = payoffs,
            title_text=title
        )




class SenderPage11(Page):
    def is_displayed(self):
        return self.player.roles == 'S'

    def vars_for_template(self):
        if self.player.roles == 'S':
            self.player.check_slider_one=None
            self.player.check_slider_two=None
            spindraw = random.randint(1, 100)
            if self.player.shell == 0:
                if spindraw > self.player.recom_0:
                    self.player.message_sent = 0
                else:
                    self.player.message_sent = 1
            else:
                if spindraw > self.player.recom_1:
                    self.player.message_sent = 1
                else:
                    self.player.message_sent = 0
            self.player.finalDeg0 = self.player.recom_0 * 360 / 100
            self.player.finalDeg1 = self.player.recom_1 * 360 / 100
            spindeg = spindraw*360/100

            if self.subsession.robotR == 1:
                if self.subsession.gamemode == 0:
                    self.player.message_received = self.player.message_sent
                    recomp_0=self.player.recom_0/100   # Out of 100, so should change to prob 0~1
                    recomp_1=self.player.recom_1/100
                    if self.player.message_received == 1:
                        s_posterior_1=(1/3)*(self.subsession.expertise*(1-recomp_1)+(1-self.subsession.expertise)*recomp_0)/((1/3)*(self.subsession.expertise*(1-recomp_1)+(1-self.subsession.expertise)*recomp_0)+(2/3)*((1-self.subsession.expertise)*(1-recomp_1)+self.subsession.expertise*recomp_0))
                        if s_posterior_1 >= 1/2:
                            self.player.conjecture = 1
                            self.player.payoff = Constants.incentive
                        else:
                            self.player.conjecture = 0
                            self.player.payoff = 0
                    else:
                        s_posterior_0=(1/3)*(self.subsession.expertise*recomp_1+(1-self.subsession.expertise)*(1-recomp_0))/((1/3)*(self.subsession.expertise*recomp_1+(1-self.subsession.expertise)*(1-recomp_0))+(2/3)*((1-self.subsession.expertise)*recomp_1+self.subsession.expertise*(1-recomp_0)))
                        if s_posterior_0 >= 1/2:
                            self.player.conjecture = 1
                            self.player.payoff = Constants.incentive
                        else:
                            self.player.conjecture = 0
                            self.player.payoff = 0
                    self.player.Rpayoff = round((1 - abs(self.player.type - self.player.conjecture))*Constants.incentive)
                elif self.subsession.gamemode == 1:
                    self.player.message_received = self.player.message_sent
                    self.player.conjecture = 0
                    self.player.payoff = 0
                    self.player.Rpayoff = round((1 - abs(self.player.type - self.player.conjecture))*Constants.incentive)
                else:
                    self.player.message_received =self.player.message_sent
                    if self.player.message_sent == 0:
                        self.player.conjecture = 0
                        self.player.conjecture2 = 1
                        self.player.payoff1 = 0 # This is the first stage payoff
                        self.player.payoff = Constants.incentive # This is the second stage payoff
                    else:
                        self.player.conjecture = 1
                        self.player.conjecture2 = 0
                        self.player.payoff1 = Constants.incentive
                        self.player.payoff = 0
                    self.player.Rpayoff1 = round((1 - abs(self.player.type - self.player.conjecture))*Constants.incentive)
                    self.player.Rpayoff = round((1 - abs(self.player.type2 - self.player.conjecture2))*Constants.incentive)
            elif self.subsession.robotR == 2:
                self.player.message_received = self.player.message_sent
                self.player.conjecture = 0
                self.player.conjecture2 = 0
                self.player.payoff1 = 0  # This is the first stage payoff
                self.player.payoff = 0  # This is the second stage payoff
                self.player.Rpayoff1 = round((1 - abs(self.player.type - self.player.conjecture))*Constants.incentive)
                self.player.Rpayoff = round((1 - abs(self.player.type2 - self.player.conjecture2))*Constants.incentive)

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.player.shell == 0:
            shell="BLUE"
        elif self.player.shell == 1:
            shell="RED"



        return dict(
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            type=self.player.type,
            shell=shell,
            payoffs=payoffs,
            title_text=title,
            spindraw=spindraw,
            spindeg=spindeg,
            recom_0=self.player.recom_0,
            recomm_0=100-self.player.recom_0,
            recom_1=self.player.recom_1,
            recomm_1=100-self.player.recom_1,
            finalDeg0=self.player.finalDeg0,
            finalDeg1=self.player.finalDeg1,
            message_sent=self.player.message_sent
        )


class WaitS1(WaitPage):
    template_name = 'repeatedct_k/WaitS1.html'

    def is_displayed(self):
        if self.subsession.robotR == 0:
            return self.player.roles=='R' or self.player.roles=='R_vs_bot'
        else:
            return False

    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        return dict(body_text="Please wait for the message from S.",
                    title_text=title,
                    roundnum = self.subsession.round_number -Constants.num_prac_rounds,
                    payoffs=payoffs
        )



import random

class ReceiverPage1(Page):
    form_model = 'player'
    form_fields = ['conjecture']

    def is_displayed(self):
        if self.subsession.robotR == 0:
            return self.player.roles == 'R' or self.player.roles == 'R_vs_bot'
        else:
            return False

    def vars_for_template(self):
        players = self.subsession.get_players()
        if self.player.roles =='R':
            for player in players:
                if player.id_in_group != self.player.id_in_group and player.pseudo_group == self.player.pseudo_group:
                    self.player.message_received = player.message_sent
                    self.player.message_sent = player.message_sent
                    self.player.finalDeg0 = player.finalDeg0
                    self.player.finalDeg1 = player.finalDeg1
                    self.player.recom_0 = player.recom_0
                    self.player.recom_1 = player.recom_1
                    player.message_received = player.message_sent

        if self.player.roles =='R_vs_bot':
            self.player.message_received = self.player.shell
            self.player.message_sent = self.player.shell
            self.player.finalDeg0 = 0
            self.player.finalDeg1 = 0
            self.player.recom_0 = 0
            self.player.recom_1 = 0

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.player.message_received == 0:
            message = "The color of the core of chosen ball is BLUE."
        if self.player.message_received == 1:
            message = "The color of the core of chosen ball is RED."

        return dict(
            message=message,
            body_text="Please wait for the message from Sender.",
            title_text=title,
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            payoffs=payoffs,
            shell=self.player.shell,
            finalDeg0=self.player.finalDeg0,
            finalDeg1=self.player.finalDeg1,
            recom_0=self.player.recom_0,
            recomm_0=100-self.player.recom_0,
            recom_1=self.player.recom_1,
            recomm_1=100 - self.player.recom_1
        )

    def before_next_page(self):
        self.player.payoff = round(Constants.incentive*(1-abs(self.player.type-self.player.conjecture)))
        players = self.subsession.get_players()
        if self.player.roles =='R':
            for player in players:
                if player.id_in_group != self.player.id_in_group and player.pseudo_group == self.player.pseudo_group:
                    player.conjecture = self.player.conjecture
                    player.payoff = round(self.player.conjecture*Constants.incentive)
                    player.payoff1 = player.payoff
        self.player.payoff1 = self.player.payoff
        return


class WaitR1(WaitPage):
    template_name = 'repeatedct_k/WaitR1.html'

    def is_displayed(self):
        if self.subsession.robotR == 0:
            return self.player.roles=='S'
        else:
            return False

    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs=dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.player.message_sent == 0:
            message = "Color of the shell is BLUE."
        if self.player.message_sent == 1:
            message = "Color of the shell is RED."

        return dict(
                    message =message,
                    body_text="Please wait for the message from Sender.",
                    title_text=title,
                    roundnum = self.subsession.round_number -Constants.num_prac_rounds,
                    payoffs=payoffs
        )



class ResultsWaitPage1(WaitPage):
    pass


class Results1(Page):
    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.player.message_received == 0:
            message = "Color of the shell is BLUE."
        if self.player.message_received == 1:
            message = "Color of the shell is RED."

        if self.player.payoff == Constants.incentive:
            reason = "귀하의 액션이 core의 색깔과 일치하므로"
        elif self.player.payoff == 0:
            reason = "귀하의 액션이 core의 색깔과 일치하지 않으므로"

        if self.player.conjecture == 1:
            conjecture="RED"
        elif self.player.conjecture == 0:
            conjecture="BLUE"

        if self.player.type == 1:
            type="RED"
        elif self.player.type == 0:
            type="BLUE"

        if self.subsession.gamemode != 2:
            self.player.roundpay = self.player.payoff

        return dict(
            reason=reason,
            message=message,
            conjecture=conjecture,
            type=type,
            title_text=title,
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            payoffs=payoffs,
            payoff=self.player.payoff
        )

class OffroundWaitPage(WaitPage):
    def is_displayed(self):
        return self.subsession.round_number == Constants.num_prac_rounds

class Offround_start(Page):
    def is_displayed(self):
        return self.subsession.round_number == Constants.num_prac_rounds

    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        return dict(
            title_text = title,
            )




class Stage2Usher(Page):
    def is_displayed(self):
        return self.subsession.gamemode==2

    def vars_for_template(self):
        players = self.subsession.get_players()

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        return dict(
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            role=self.player.roles,
            title_text=title
        )

class SenderPage2(Page):
    form_model = 'player'
    form_fields = ['recom2_0','recom2_1','check_slider_one','check_slider_two']

    def is_displayed(self):
        return self.player.roles == 'S' and self.subsession.gamemode==2

    def error_message(self, value):
        if value["check_slider_one"] == None or value["check_slider_two"] == None:
            return 'Please use the slider to make a decision.'

    def vars_for_template(self):

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs=dict()
        for conjecture in range(0,2):
            payoffs[conjecture]={'R0': 1-conjecture,
                             'R1': conjecture,
                             'S0': conjecture,
                             'S1': conjecture}

        return dict(
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            type2 = self.player.type2,
            shell2 = self.player.shell2,
            payoffs = payoffs,
            title_text=title
        )

class SenderPage22(Page):
    def is_displayed(self):
        return self.player.roles == 'S' and self.subsession.gamemode==2

    def vars_for_template(self):
        if self.player.roles == 'S':
            spindraw = random.randint(1, 100)
            if self.player.shell2 == 0:
                if spindraw > self.player.recom2_0:
                    self.player.message_sent2 = 0
                else:
                    self.player.message_sent2 = 1
            else:
                if spindraw > self.player.recom2_1:
                    self.player.message_sent2 = 1
                else:
                    self.player.message_sent2 = 0
            finalDeg0=self.player.recom2_0*360/100
            finalDeg1=self.player.recom2_1*360/100
            spindeg = spindraw * 360 / 100

            if self.subsession.robotR == 1:
                self.player.message_received2 = self.player.message_sent2
                if self.player.message_sent2 == 0:
                    self.player.conjecture2 = 0
                    self.player.payoff = 0
                    self.player.Rpayoff = round((1-self.player.type2)*Constants.incentive)
            elif self.subsession.robotR == 2:
                self.player.message_received2 = self.player.message_sent2

        if self.subsession.round_number < 3:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - 2)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}
        if self.player.shell2 == 0:
            shell2="BLUE"
        elif self.player.shell2 == 1:
            shell2="RED"

        return dict(
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            type2=self.player.type2,
            shell2=shell2,
            payoffs=payoffs,
            title_text=title,
            spindeg=spindeg,
            recom2_0=self.player.recom2_0,
            recomm2_0=100-self.player.recom2_0,
            recom2_1=self.player.recom2_1,
            recomm2_1=100-self.player.recom2_1,
            finalDeg0=finalDeg0,
            finalDeg1=finalDeg1,
            message_sent2=self.player.message_sent2
        )

class WaitS2(WaitPage):
    template_name = 'repeatedct_k/WaitS2.html'

    def is_displayed(self):
        if self.subsession.gamemode==2 and self.subsession.robotR == 0:
            return self.player.roles=='R' or self.player.roles=='R_vs_bot'
        else:
            return False

    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        return dict(body_text="Please wait for the message from S.",
                    title_text=title,
                    roundnum = self.subsession.round_number -Constants.num_prac_rounds,
                    payoffs=payoffs
        )

class ReceiverPage2(Page):
    form_model = 'player'
    form_fields = ['conjecture2']

    def is_displayed(self):
        if self.subsession.gamemode==2 and self.subsession.robotR == 0:
            return self.player.roles=='R' or self.player.roles=='R_vs_bot'
        else:
            return False

    def vars_for_template(self):
        players = self.subsession.get_players()
        if self.player.roles =='R':
            for player in players:
                if player.id_in_group != self.player.id_in_group and player.pseudo_group == self.player.pseudo_group:
                    self.player.message_received2 = player.message_sent2
                    self.player.message_sent2 = player.message_sent2
                    player.message_received2 = player.message_sent2
                    self.player.recom2_0 = player.recom2_0
                    self.player.recom2_1 = player.recom2_1

        if self.player.roles =='R_vs_bot':
            self.player.message_received2 = self.player.shell2
            self.player.message_sent2 = self.player.shell2
            self.player.recom2_0 = 0
            self.player.recom2_1 = 0

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.player.message_received2 == 0:
            message = "The color of the core of chosen ball is BLUE."
        if self.player.message_received2 == 1:
            message = "The color of the core of chosen ball is RED."

        return dict(
            message=message,
            body_text="Please wait for the message from Sender.",
            title_text=title,
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            payoffs=payoffs,
            expertise=self.subsession.expertise
        )

    def before_next_page(self):
        self.player.payoff = round(Constants.incentive*(1-abs(self.player.type2-self.player.conjecture2)))
        players = self.subsession.get_players()
        if self.player.roles =='R':
            for player in players:
                if player.id_in_group != self.player.id_in_group and player.pseudo_group == self.player.pseudo_group:
                    player.conjecture2 = self.player.conjecture2
                    player.payoff = round(self.player.conjecture2*Constants.incentive)
        return


class WaitR2(WaitPage):
    template_name = 'repeatedct_k/WaitR2.html'

    def is_displayed(self):
        if self.subsession.robotR == 0:
            return self.player.roles == 'S' and self.subsession.gamemode==2
        else:
            return False

    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs=dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        if self.player.message_sent2 == 0:
            message = "Color of the shell is BLUE."
        if self.player.message_sent2 == 1:
            message = "Color of the shell is RED."

        return dict(
                    message =message,
                    body_text="Please wait for the message from Sender.",
                    title_text=title,
                    roundnum = self.subsession.round_number - Constants.num_prac_rounds,
                    payoffs=payoffs
        )

class Results2(Page):
    def is_displayed(self):
        return self.subsession.gamemode == 2

    def cal_round_payoff(self,local_seed):
        local_random = random.Random(local_seed+self.player.id_in_group)
        chosen_stage = local_random.randint(1, 2)
        if chosen_stage == 1:
            self.player.roundpay = self.player.payoff1
        else:
            self.player.roundpay = self.player.payoff
        return self.player.roundpay, chosen_stage

    def vars_for_template(self):
        roundpay, chosen_stage = self.cal_round_payoff(self.subsession.local_seed)

        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        payoffs = dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}


        if self.player.message_received2 == 0:
            message = "Color of the shell is BLUE."
        if self.player.message_received2 == 1:
            message = "Color of the shell is RED."

        if self.player.payoff == Constants.incentive:
            reason2 = "귀하의 액션이 core의 색깔과 일치하므로"
        elif self.player.payoff == 0:
            reason2 = "귀하의 액션이 core의 색깔과 일치하지 않으므로"

        if self.player.conjecture2 == 1:
            conjecture2="RED"
        elif self.player.conjecture2 == 0:
            conjecture2="BLUE"

        if self.player.type2 == 1:
            type2="RED"
        elif self.player.type2 == 0:
            type2="BLUE"

        return dict(
            reason2=reason2,
            message=message,
            conjecture2=conjecture2,
            type2=type2,
            title_text=title,
            roundnum=self.subsession.round_number - Constants.num_prac_rounds,
            payoffs=payoffs,
            payoff=self.player.payoff,
            chosen_stage=chosen_stage,
            roundpay=roundpay
        )



class ResultsWaitPage2(WaitPage):
    def is_displayed(self):
        return self.subsession.gamemode==2

class Info_feedback(Page):
    def vars_for_template(self):
        if self.subsession.round_number < Constants.num_prac_rounds+1:
            title = "Practice Round " + str(self.subsession.round_number)
        else:
            title = "Official Round " + str(self.subsession.round_number - Constants.num_prac_rounds)

        if self.player.shell == 0:
            shell = "BLUE"
        elif self.player.shell == 1:
            shell = "RED"

        if self.player.type == 1:
            type="RED"
        elif self.player.type == 0:
            type="BLUE"

        if self.player.message_sent == 0:
            message = "BLUE"
        elif self.player.message_sent == 1:
            message = "RED"

        if self.player.conjecture == 1:
            conjecture="RED"
        elif self.player.conjecture == 0:
            conjecture="BLUE"




        return dict(title_text=title,
                    shell=shell,
                    type=type,
                    message=message,
                    conjecture=conjecture,
                    payoff=self.player.payoff,
                    payoff1=self.player.payoff1,
                    recom_0=self.player.recom_0,
                    recomm_0=100-self.player.recom_0,
                    recom_1=self.player.recom_1,
                    recomm_1=100-self.player.recom_1
        )


class Final_payment(Page):
    def cal_final_payoff(self,local_seed):
        local_random = random.Random(local_seed+self.player.id_in_group)
        chosen_round = local_random.randint(Constants.num_prac_rounds+1, Constants.num_rounds)
        player = self.player.in_round(chosen_round)
        self.participant.payoff = player.roundpay
        return self.participant.payoff, chosen_round

    def is_displayed(self):
        return self.subsession.round_number == Constants.num_rounds


    def vars_for_template(self):
        final_payment, chosen_round = self.cal_final_payoff(self.subsession.local_seed)
        Shell_dict = {}
        Type_dict = {}
        Message_dict = {}
        Conjecture_dict = {}
        Earning_dict = {}


        for m in range(Constants.num_prac_rounds+1,Constants.num_rounds+1):
            player = self.player.in_round(m)
            Shell_dict[m-Constants.num_prac_rounds] = player.shell
            Type_dict[m-Constants.num_prac_rounds] = player.type
            Message_dict[m - Constants.num_prac_rounds] = player.message_sent
            Conjecture_dict[m-Constants.num_prac_rounds] = player.conjecture
            Earning_dict[m-Constants.num_prac_rounds] = int(player.roundpay)

        payoffs=dict()
        for conjecture in range(0, 2):
            payoffs[conjecture] = {'R0': 1 - conjecture,
                                   'R1': conjecture,
                                   'S0': conjecture,
                                   'S1': conjecture}

        return dict(money=final_payment,
                    chosen_round=chosen_round - Constants.num_prac_rounds,
                    total_payment=self.participant.payoff_plus_participation_fee(),
                    tot_match_num=Constants.num_rounds - Constants.num_prac_rounds,
                    Type_dict=Type_dict,
                    Conjecture_dict=Conjecture_dict,
                    Earning_dict=Earning_dict,
                    payoffs=payoffs,
                    expertise=self.subsession.expertise,
                    num_S=self.subsession.num_S
                    )

page_sequence = [Instruction, InstructionSingle, PracticeWaitPage, RoundUsher, Stage1Usher, SenderPage1, SenderPage11, WaitS1, ReceiverPage1, WaitR1, ResultsWaitPage1, Results1, Stage2Usher, SenderPage2, SenderPage22, WaitS2, ReceiverPage2, WaitR2, ResultsWaitPage2, Results2, Info_feedback, OffroundWaitPage, Offround_start, Final_payment]