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):
    def is_displayed(self):
        return self.subsession.round_number == 1 and self.subsession.gamemode == 2

    live_method = "live_instruct"
    def vars_for_template(self):
        players = self.subsession.get_players()
        num_pairs = self.subsession.num_S
        incen1 = Constants.incentive / 20

        tabledraw=random.random()

        return {'read' : self.player.read,
                'incen1': incen1,
                '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),
                'participation_fee' : int(self.session.participation_fee),
                'tabledraw' : tabledraw
        }


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 SenderPage1PAN(Page):
    form_model = 'player'
    form_fields = ['recom_0','check_slider_one']

    def is_displayed(self):
        return self.player.roles == 'S' and self.subsession.framework == 0

    def error_message(self, value):
        if value["check_slider_one"] == 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 SenderPage1PC(Page):
    form_model = 'player'
    form_fields = ['recom_1','check_slider_one']

    def is_displayed(self):
        return self.player.roles == 'S' and self.subsession.framework == 1

    def error_message(self, value):
        if value["check_slider_one"] == 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':
            if self.subsession.framework == 0:
                self.player.check_slider_one = None
                self.player.recom_1 = 0
                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:
                    self.player.message_sent = 1
                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.framework == 1:
                self.player.check_slider_one = None
                self.player.recom_0 = 0
                spindraw = random.randint(1, 100)
                if self.player.shell == 1:
                    if spindraw > self.player.recom_1:
                        self.player.message_sent = 0
                    else:
                        self.player.message_sent = 1
                else:
                    self.player.message_sent = 0
                self.player.finalDeg0 = self.player.recom_1 * 360 / 100
                self.player.finalDeg1 = 360
                spindeg = spindraw * 360 / 100

        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 = 'lying_deception/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','check_slider_three']

    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 error_message(self, value):
        if value["check_slider_three"] == None:
            return 'Please use the slider to make a decision.'

    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':
            if self.subsession.framework == 0:
                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.framework == 1:
                self.player.message_received = 1
                self.player.message_sent = 1
                self.player.finalDeg0 = 360
                self.player.finalDeg1 = 0
                self.player.recom_0 = 100
                self.player.recom_1 = 100

        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):
        if self.subsession.framework == 0:
            self.player.payoff1 = (1-(self.player.type-self.player.conjecture/100)**2)
            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.payoff1 = (1-(1-self.player.conjecture/100)**2)
            return
        elif self.subsession.framework == 1:
            self.player.payoff1 = (1-(self.player.type-self.player.conjecture/100)**2)
            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.payoff1 = (1-(self.player.type-self.player.conjecture/100)**2)
            return


class WaitR1(WaitPage):
    template_name = 'lying_deception/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.type == 1:
            type="RED"
        elif self.player.type == 0:
            type="BLUE"


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

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 SenderPage2PAN(Page):
    form_model = 'player'
    form_fields = ['recom2_0','check_slider_one']

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

    def error_message(self, value):
        if value["check_slider_one"] == 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 SenderPage2PC(Page):
    form_model = 'player'
    form_fields = ['recom2_1','check_slider_one']

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

    def error_message(self, value):
        if value["check_slider_one"] == 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':
            if self.subsession.framework == 0:
                spindraw = random.randint(1, 100)
                self.player.recom2_1 = 0
                if self.player.shell2 == 0:
                    if spindraw > self.player.recom2_0:
                        self.player.message_sent2 = 0
                    else:
                        self.player.message_sent2 = 1
                else:
                    self.player.message_sent2 = 1
                finalDeg0=self.player.recom2_0*360/100
                finalDeg1=self.player.recom2_1*360/100
                spindeg = spindraw * 360 / 100
            if self.subsession.framework == 1:
                spindraw = random.randint(1, 100)
                self.player.recom2_0 = 0
                if self.player.shell2 == 1:
                    if spindraw > self.player.recom2_1:
                        self.player.message_sent2 = 0
                    else:
                        self.player.message_sent2 = 1
                else:
                    self.player.message_sent2 = 0
                finalDeg0 = self.player.recom2_1 * 360 / 100
                finalDeg1 = 360
                spindeg = spindraw * 360 / 100


        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.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 = 'lying_deception/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','check_slider_three']

    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 error_message(self, value):
        if value["check_slider_three"] == None:
            return 'Please use the slider to make a decision.'

    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':
            if self.subsession.framework == 0:
                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.framework == 1:
                self.player.message_received2 = 1
                self.player.message_sent2 = 1
                self.player.recom2_0 = 100
                self.player.recom2_1 = 100

        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):
        if self.subsession.framework == 0:
            self.player.payoff2 = (1-(self.player.type2-self.player.conjecture2/100)**2)
            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.payoff2 = (1-(1-self.player.conjecture2/100)**2)
            return
        if self.subsession.framework == 1:
            self.player.payoff2 = (1-(self.player.type2-self.player.conjecture2/100)**2)
            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.payoff2 = (1-(self.player.type2-self.player.conjecture2/100)**2)
            return



class WaitR2(WaitPage):
    template_name = 'lying_deception/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 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_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.type2 == 1:
            type2="RED"
        elif self.player.type2 == 0:
            type2="BLUE"

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



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

class Info_feedback(Page):
    def cal_round_payoff(self):
        self.player.roundpay = Constants.incentive * (self.player.payoff1/20 + self.player.payoff2)
        return self.player.roundpay

    def vars_for_template(self):
        roundpay = self.cal_round_payoff()

        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"

        incen1 = Constants.incentive/20

        return dict(title_text=title,
                    shell=shell,
                    type=type,
                    message=message,
                    conjecture=self.player.conjecture,
                    conjecture2=self.player.conjecture2,
                    payoff1=self.player.payoff1,
                    payoff2=self.player.payoff2,
                    roundpay=roundpay,
                    incen1=incen1,
                    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 Beforedictator_ResultsWaitPage(WaitPage):
    def is_displayed(self):
        return self.subsession.round_number == Constants.num_rounds

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

class Dictator_Game(Page):
    form_model = 'player'
    form_fields = ['kept']
    def is_displayed(self):
        return self.subsession.round_number == Constants.num_rounds

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

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

    def vars_for_template(self):
        draw=random.random()
        if draw<=1/2:
            self.player.payoff3=self.player.kept
            role="Participant 1"
            reason="귀하가 결정한 몫에 따라,"
        else:
            players=self.subsession.get_players()
            if self.player.id_in_group==self.session.num_participants:
                dictator=players[0]
            else:
                dictator=players[self.player.id_in_group]
                #i.e. selecting next next player as one's dictator
            self.player.payoff3=Constants.dictator_pay-dictator.kept
            role="Participant 2"
            reason="상대방이 결정한 몫에 따라,"
        return dict(payoff3=self.player.payoff3,
                    role=role,
                    kept=self.player.kept,
                    reason=reason)

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}

        #chosen_pair = random.randint(1, self.session.num_participants)
        #player1 = self.group.get_player_by_id(chosen_pair)
        #if chosen_pair+1>self.session.num_participants:
        #    player2 = self.group.get_player_by_id(1)
        #else:
        #    player2 = self.group.get_player_by_id(chosen_pair+1)
        if self.player.id_in_group == 1 or self.player.id_in_group == 2:
            self.participant.payoff=final_payment+self.player.payoff3



        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,
                    payoff3=self.player.payoff3
                    )

page_sequence = [Instruction, InstructionSingle, PracticeWaitPage, RoundUsher, Stage1Usher, SenderPage1PAN, SenderPage1PC, SenderPage11, WaitS1, ReceiverPage1, WaitR1, ResultsWaitPage1, Results1, Stage2Usher, SenderPage2PAN, SenderPage2PC, SenderPage22, WaitS2, ReceiverPage2, WaitR2, ResultsWaitPage2, Results2, Info_feedback, OffroundWaitPage, Offround_start, Beforedictator_ResultsWaitPage, Dictator_Instruction, Dictator_Game, Dictator_ResultsWaitPage, Dictator_Results, Final_payment]