import numpy as np  #main game code
from numpy import log as ln
import math  #for mathmatical calculations
from otree.api import *

from datetime import datetime
import pytz   #for date and time

import serial
import time

from otree.models import group

doc = """
Your app description
"""


class C(BaseConstants):
    NAME_IN_URL = 'intro_hide_and_seek_2options'
    PLAYERS_PER_GROUP = 2
    NUM_ROUNDS = 2 #number of rounds
    INSTRUCTIONS_TEMPLATE = 'intro_hide_and_seek_2options/instructions.html'
    MATCHER_ROLE = 'Seeker'
    MISMATCHER_ROLE = 'Hider'

    m = 0.2
    s = 4
    min_payoff = 2
    regrow_factor = 0.5
    div_regrow = 10    #parameters of modeling
    TIMEOUT = 60 # for timeout for wait page

    #timing for different pages
    t = 10000  #time for main game
    t_e = 5000  #time for timeout function

    t2 = 15000  #time for demo trials
    t3 = 10000  #time for demo trial for outcome page

    #t = 300000
    #t2 = 300000
    #t3 = 300000

    demo_trial = 7 #number of warmup trials


class Subsession(BaseSubsession):
   pass


def creating_session(subsession: Subsession):
    import random

    for p in subsession.get_players():
        p.completion_code = random.randint(10 ** 6, 10 ** 7)  #generating random number #im not using it now


class Group(BaseGroup):
    modep1 = models.StringField() #modep1
    modep2 = models.StringField()  #modep2
    GameMode = models.StringField() #gamemode
    choosep1 = models.StringField()  #chose
    choosep2 = models.StringField()
    Lastchoosep1 = models.StringField(blank=True) #lastchose
    Lastchoosep2 = models.StringField(blank=True)
    predictionp1 = models.StringField()  #prediction
    predictionp2 = models.StringField()
    Lastpredictionp1 = models.StringField(blank=True)
    Lastpredictionp2 = models.StringField(blank=True)
    modeflagP1= models.BooleanField()  #flag the modes to see if the participant has selected a mode or not
    predictionflagP1 = models.BooleanField()
    chooseflagP1 = models.BooleanField()
    modeflagP2 = models.BooleanField()
    predictionflagP2 = models.BooleanField()
    chooseflagP2 = models.BooleanField()
    predictionStoneP1 = models.IntegerField(blank=True) #prediction
    predictionStoneP2 = models.IntegerField(blank=True)
    predictionTreeP1 = models.IntegerField(blank=True)
    predictionTreeP2 = models.IntegerField(blank=True)
    competitionScore = models.IntegerField() #island scores
    cooperationScore = models.IntegerField()
    independentScore = models.IntegerField()
    divergentScore = models.IntegerField()
    p1Score = models.IntegerField() #scores
    p2Score = models.IntegerField()
    p1TotalScore = models.IntegerField(initial=20.0) #total score
    p2TotalScore = models.IntegerField(initial=20.0)
    p1InterchangePenallty= models.IntegerField() #travel costs
    p2InterchangePenallty= models.IntegerField()
    CreateTime = models.StringField() #date and time of each trial to track
    x = models.IntegerField() #x variable that generates randomly


#for reaction time
    actualTimeP1 = models.StringField(blank=True)
    actualTimeP2 = models.StringField(blank=True)

    reactiontimeP1 = models.StringField(blank=True)
    reactiontimeP2 = models.StringField(blank=True)


    predictTimeNextP1 = models.StringField(blank=True)
    predictTimeNextP2 = models.StringField(blank=True)
#mouse up doan for scroll bar in prediction
    mousedownP1 = models.StringField(blank=True)
    mousedownP2 = models.StringField(blank=True)

    mouseupP1 = models.StringField(blank=True)
    mouseupP2 = models.StringField(blank=True)


class Player(BasePlayer):

    timeout = models.FloatField() #waiting page timeout
    completion_code = models.IntegerField()  #completion code
 #modes
    mode = models.StringField(
        choices=[['Competition', 'Competition'], ['Cooperation', 'Cooperation'], ['Independent', 'Independent']],
        label='Please choose your mode:',
        widget=widgets.RadioSelect,blank=True)

    predictionTree= models.IntegerField(blank=True)
    predictionStone= models.IntegerField(blank=True)

    Choose = models.StringField(choices=[['Stone', 'Stone'], ['Tree', 'Tree']],widget=widgets.RadioSelect,blank=True)

    predictTimeNext = models.StringField(blank=True)
    #actualTime= models.StringField(blank=True)
    actualTime= models.StringField(blank=True)
    reactiontime= models.StringField(blank=True)

    mousedown= models.StringField(blank=True)
    mouseup= models.StringField(blank=True)

    modeflag= models.BooleanField(blank=True)
    predictionflag= models.BooleanField(blank=True)
    chooseflag= models.BooleanField(blank=True)

  #total islands scores
    competitionScore = models.IntegerField(blank=True, initial=70)
    cooperationScore = models.IntegerField(blank=True, initial=50)
    independentScore = models.IntegerField(blank=True, initial=25)
    divergentScore = models.IntegerField(blank=True, initial=25)

    # score= models.FloatField(blank=True,initial=0)
    # totalScore= models.FloatField(blank=True,initial=0)


def set_payoffs(group: Group):

    p1 = group.get_player_by_id(1)
    p2 = group.get_player_by_id(2)

    group.modep1=p1.mode
    group.modep2=p2.mode
    group.independentScore=p1.independentScore
    group.competitionScore=p1.competitionScore
    group.cooperationScore=p1.cooperationScore
    group.divergentScore=p1.divergentScore

    group.actualTimeP1= p1.actualTime
    group.actualTimeP2= p2.actualTime


 #define X

    if (p1.mode==p2.mode):
        if p1.mode == 'Independent':
            group.GameMode = 'Independent'
            #group.x= math.ceil(abs(np.random.normal(0.1* group.independentScore, 5, 1)))
            #group.x = max(math.floor(np.random.normal(C.m * group.independentScore, C.s, 1)), C.min_payoff)
            group.x = int((min((max(math.floor(np.random.normal(C.m * group.independentScore,  C.s, 1)), C.min_payoff)), group.independentScore)))
        elif p1.mode == 'Cooperation':
            group.GameMode = 'Cooperation'
            #group.x= math.ceil(abs(np.random.normal(0.1* group.cooperationScore, 5, 1)))
            #group.x = max(math.floor(np.random.normal(C.m * group.cooperationScore, C.s, 1)), C.min_payoff)
            group.x = int((min((max(math.floor(np.random.normal(C.m * group.cooperationScore,  C.s, 1)), C.min_payoff)), group.cooperationScore)))
        else:
            group.GameMode = 'Competition'

            #group.x= math.ceil(abs(np.random.normal(0.1* group.competitionScore, 5, 1)))
            #group.x = max(math.floor(np.random.normal(C.m * group.competitionScore, C.s, 1)), C.min_payoff)
            group.x = int((min((max(math.floor(np.random.normal(C.m * group.competitionScore,  C.s, 1)), C.min_payoff)), group.competitionScore)))
    else:
        group.GameMode = 'Divergent'
        #group.x= math.ceil(abs(np.random.normal(0.1* min(group.competitionScore,group.cooperationScore,group.independentScore), 5, 1)))
        #group.x = max(math.floor(np.random.normal(C.m * group.divergentScore, C.s, 1)), C.min_payoff)
        group.x = int((min((max(math.floor(np.random.normal(C.m * group.divergentScore,  C.s, 1)), C.min_payoff)), group.divergentScore)))

    group.modeflagP1 = p1.modeflag
    group.modeflagP2 = p2.modeflag

    group.CreateTime= datetime.now(pytz.timezone('Europe/Berlin')).strftime("%d/%m/%Y %H:%M:%S")
    #print(group.CreateTime)
    print(group.actualTimeP1)
    print(group.actualTimeP2)





# PAGES


def set_Predictions(group: Group): #prediction scroll bar  calculation

    p1 = group.get_player_by_id(1)
    p2 = group.get_player_by_id(2)

    if group.GameMode != 'Divergent':

       group.predictTimeNextP1 = p1.predictTimeNext
       group.predictTimeNextP2 = p2.predictTimeNext

       group.mousedownP1=p1.mousedown
       group.mousedownP2=p2.mousedown

       group.mouseupP1 = p1.mouseup
       group.mouseupP2 = p2.mouseup

       group.predictionflagP1 = p1.predictionflag
       group.predictionflagP2 = p2.predictionflag

      # print(p1.modeflag,p1.predictionflag,p1.chooseflag)
      # print(p2.modeflag,p2.predictionflag,p2.chooseflag)

       if (p1.predictionTree>0):

        group.predictionTreeP1 = p1.predictionTree + 50
        group.predictionStoneP1 = 100 - (p1.predictionTree + 50)

       elif(p1.predictionTree<0):
        group.predictionStoneP1 = abs(p1.predictionTree)+50
        group.predictionTreeP1 = 100 - (abs(p1.predictionTree)+50)
       else:
        group.predictionStoneP1 = 50
        group.predictionTreeP1 = 50

       if group.predictionTreeP1 >= group.predictionStoneP1:
          group.predictionp1 = 'Tree'
       else:
          group.predictionp1 = 'Stone'

       if (p2.predictionTree>0):

          group.predictionTreeP2 = p2.predictionTree + 50
          group.predictionStoneP2 = 100 - (p2.predictionTree + 50)
       elif(p2.predictionTree<0):
          group.predictionStoneP2 = abs(p2.predictionTree)+50
          group.predictionTreeP2 = 100 - (abs(p2.predictionTree)+50)
       else:
          group.predictionStoneP2 = 50
          group.predictionTreeP2 = 50

       if group.predictionTreeP2 >= group.predictionStoneP2:
          group.predictionp2 = 'Tree'
       else:
          group.predictionp2 = 'Stone'

    else:
       group.predictionp1 = 'none'
       group.predictionp2 = 'none'
       group.predictTimeNextP1 = 'none'
       group.predictTimeNextP2 = 'none'

       group.mousedownP1 = 'none'
       group.mousedownP2 = 'none'

       group.mouseupP1 = 'none'
       group.mouseupP2 = 'none'

       group.predictionflagP1 = False
       group.predictionflagP2 = False

       group.predictionStoneP1 = 0
       group.predictionStoneP2 = 0
       group.predictionTreeP2 = 0
       group.predictionTreeP1 = 0

    if group.GameMode != 'Divergent':
       group.choosep1 = p1.Choose
       group.choosep2 = p2.Choose
       group.reactiontimeP1=p1.reactiontime
       group.reactiontimeP2=p2.reactiontime
    else:
       group.choosep1 = 'none'
       group.choosep2 = 'none'
       group.reactiontimeP1='none'
       group.reactiontimeP2='none'

    
    if group.GameMode == 'Independent':  #score table
        if (group.choosep1 == 'Tree') and (group.choosep2 == 'Tree'):
            group.p1Score = math.floor(0.3 * group.x)
            group.p2Score = math.floor(0.3 * group.x)

        elif (group.choosep1 == 'Tree') and (group.choosep2 == 'Stone'):
            group.p1Score = math.floor(0.3 * group.x)
            group.p2Score = math.floor(0.7 * group.x)

        elif (group.choosep1 == 'Stone') and (group.choosep2 == 'Tree'):
            group.p1Score = math.floor(0.7 * group.x)
            group.p2Score = math.floor(0.3 * group.x)
        else:
            group.p1Score = math.floor(0.7 * group.x)
            group.p2Score = math.floor(0.7 * group.x)
   
    elif group.GameMode == 'Cooperation':
        if (group.choosep1 == 'Tree') and (group.choosep2 == 'Tree'):
            group.p1Score = math.floor(0.5 * group.x)
            group.p2Score = math.floor(0.5 * group.x)

        elif (group.choosep1 == 'Tree') and (group.choosep2 == 'Stone'):
            group.p1Score = math.floor(0.1 * group.x)
            group.p2Score = math.floor(0.4 * group.x)

        elif (group.choosep1 == 'Stone') and (group.choosep2 == 'Tree'):
            group.p1Score = math.floor(0.4 * group.x)
            group.p2Score = math.floor(0.1 * group.x)
        else:
            group.p1Score = math.floor(0.2 * group.x)
            group.p2Score = math.floor(0.2 * group.x)

    elif group.GameMode == 'Competition':
        if (group.choosep1 == 'Tree') and (group.choosep2 == 'Tree'):
            group.p1Score = math.floor(0.5 * group.x)
            group.p2Score = 0

        elif (group.choosep1 == 'Tree') and (group.choosep2 == 'Stone'):
            group.p1Score = 0
            group.p2Score = math.floor(0.5 * group.x)

        elif (group.choosep1 == 'Stone') and (group.choosep2 == 'Tree'):
            group.p1Score = 0
            group.p2Score = math.floor(0.5 * group.x)
        else:
            group.p1Score = math.floor(0.5 * group.x)
            group.p2Score = 0

    else:
            group.p1Score = math.floor(-0.3 * group.x)
            group.p2Score = math.floor(-0.3 * group.x)
    
    group.p1TotalScore += group.p1Score
    group.p2TotalScore += group.p2Score

    group.modeflagP1 = p1.modeflag
    group.modeflagP2 = p2.modeflag

    #print(group.reactiontimeP1)
    #print(group.reactiontimeP2)



    #print(group.predictTimeNextP1)
    #print(group.predictTimeNextP2)

    #print(group.mousedownP1)
    #print(group.mouseupP1)


    #print(group.mousedownP2)
    #print(group.mouseupP2)

    print(group.predictionStoneP1)
    print(group.predictionTreeP1)

    def update_score_of_interchanges(player_id): #travel costs
        player_of_interest = group.get_player_by_id(player_id)
        prev_mode_p = group.in_round(group.round_number - 1).get_player_by_id(player_id).mode


        if group.GameMode != 'Divergent' and group.in_round(group.round_number - 1).get_player_by_id(1).mode == group.in_round(group.round_number - 1).get_player_by_id(2).mode :
            if (prev_mode_p == 'Independent' and player_of_interest.mode == 'Cooperation'):
                return 6

            elif (prev_mode_p== 'Cooperation' and player_of_interest.mode== 'Independent') :

                 return 8

            elif (prev_mode_p == 'Competition' and player_of_interest.mode == 'Independent') :
                 return 10

            elif (prev_mode_p == 'Cooperation' and player_of_interest.mode == 'Competition'):
                 return 4

            elif (prev_mode_p == 'Competition' and player_of_interest.mode == 'Cooperation'):
                 return 4

            elif (prev_mode_p == 'Independent' and player_of_interest.mode == 'Competition'):
                 return 4

            else:
                 return 0
        else:
            return 0


    if group.round_number > 1: #considering travel cost in points

       group.p1TotalScore = round(group.p1TotalScore- update_score_of_interchanges(1),2)
       group.p2TotalScore = round(group.p2TotalScore- update_score_of_interchanges(2),2)
       group.p1Score =round(group.p1Score -  update_score_of_interchanges(1),2)
       group.p2Score = round(group.p2Score- update_score_of_interchanges(2),2)
    # if self.group.round_number>1:
    #         prev_round_mode =  self.group.in_round(self.group.round_number - 1).GameMode
    #         prev_p1score =  self.group.in_round(self.group.round_number - 1).p1Score
    #         prev_p2score =  self.group.in_round(self.group.round_number - 1).p2Score


    
    if group.GameMode != 'Divergent':  #regrow factor for different modes
        if group.round_number == 1:
            if group.GameMode == 'Independent':

                delta = (abs(round(group.p1Score, 2))+abs(round(group.p2Score, 2)))

                group.independentScore -= delta
                group.cooperationScore = round(group.cooperationScore + (C.regrow_factor * delta))
                group.competitionScore = round(group.competitionScore + (C.regrow_factor * delta))

            if group.GameMode == 'Cooperation':

                delta = (abs(round(group.p1Score, 2))+abs(round(group.p2Score, 2)))

                group.cooperationScore -= delta
                group.independentScore = round(group.independentScore + (C.regrow_factor * delta))
                group.competitionScore = round(group.competitionScore + (C.regrow_factor * delta))
        
               # group.cooperationScore  -=  ( abs(round(group.p1Score,2))+abs(round(group.p2Score,2)))
                #delta= ln( group.independentScore+1)- ln( group.independentScore)
                #group.independentScore= group.independentScore+ (group.independentScore * delta)

                #delta= ln( group.competitionScore+1)- ln( group.competitionScore)
                #group.competitionScore=group.competitionScore+ (group.competitionScore * delta)

            if group.GameMode == 'Competition':

                delta = (abs(round(group.p1Score, 2))+abs(round(group.p2Score, 2)))

                group.competitionScore -= delta
                group.independentScore = round(group.independentScore + (C.regrow_factor * delta))
                group.cooperationScore = round(group.cooperationScore + (C.regrow_factor * delta))
            
                #group.competitionScore  -=  ( abs(round(group.p1Score,2))+abs(round(group.p2Score,2)))

                #delta= ln( group.independentScore+1)- ln( group.independentScore)
                #group.independentScore= group.independentScore+ (group.independentScore * delta)

                #delta= ln( group.cooperationScore+1)- ln( group.cooperationScore)
                #group.cooperationScore=group.cooperationScore+ (group.cooperationScore * delta)


        else :

            prev_independentScore= group.in_round(group.round_number - 1).independentScore 
            prev_competitionScore= group.in_round(group.round_number - 1).competitionScore 
            prev_cooperationScore= group.in_round(group.round_number - 1).cooperationScore


            if group.GameMode == 'Independent':

                delta = (abs(round(group.p1Score, 2))+abs(round(group.p2Score, 2)))

                group.independentScore = prev_independentScore-delta
                group.cooperationScore = round(prev_cooperationScore + (C.regrow_factor * delta))
                group.competitionScore = round(prev_competitionScore + (C.regrow_factor * delta))


                #group.independentScore  =  prev_independentScore-  (abs(round(group.p1Score,2))+abs(round(group.p2Score,2)))
                #delta= ln( prev_competitionScore+1)- ln( prev_competitionScore)
                #group.competitionScore= prev_competitionScore+ (prev_competitionScore * delta)

                #delta= ln( prev_cooperationScore+1)- ln(prev_cooperationScore)
                #group.cooperationScore=prev_cooperationScore+ (prev_cooperationScore* delta)

            if group.GameMode == 'Cooperation':
        
                delta = (abs(round(group.p1Score, 2))+abs(round(group.p2Score, 2)))

                group.cooperationScore = prev_cooperationScore-delta
                group.independentScore = round(prev_independentScore + (C.regrow_factor * delta))
                group.competitionScore = round(prev_competitionScore + (C.regrow_factor * delta))
                #group.cooperationScore  = prev_cooperationScore  - (abs(round(group.p1Score,2))+abs(round(group.p2Score,2)))
                #print(group.cooperationScore)
                #delta= ln( prev_independentScore+1)- ln( prev_independentScore)
                #group.independentScore= prev_independentScore+ (prev_independentScore* delta)

                #delta= ln( prev_competitionScore+1)- ln(prev_competitionScore)
                #group.competitionScore=prev_competitionScore+ (prev_competitionScore * delta)

            if group.GameMode == 'Competition':

                delta = (abs(round(group.p1Score, 2))+abs(round(group.p2Score, 2)))

                group.competitionScore = prev_competitionScore-delta
                group.independentScore = round(prev_independentScore + (C.regrow_factor * delta))
                group.cooperationScore = round(prev_cooperationScore + (C.regrow_factor * delta))
            
                #group.competitionScore =  prev_competitionScore- (abs(round(group.p1Score,2))+abs(round(group.p2Score,2)))

                #delta= ln( prev_independentScore+1)- ln( prev_independentScore)
                #group.independentScore= prev_independentScore+ (prev_independentScore* delta)

                #delta= ln( prev_cooperationScore+1)- ln(prev_cooperationScore)
                #group.cooperationScore=prev_cooperationScore+ (prev_cooperationScore* delta)
    else:
         if group.round_number == 1:
            group.cooperationScore = group.cooperationScore + C.div_regrow
            group.competitionScore = group.competitionScore + C.div_regrow
            group.independentScore = group.independentScore + C.div_regrow
         else:
            prev_independentScore = group.in_round(group.round_number - 1).independentScore
            prev_competitionScore = group.in_round(group.round_number - 1).competitionScore
            prev_cooperationScore = group.in_round(group.round_number - 1).cooperationScore

            group.competitionScore = prev_competitionScore + C.div_regrow
            group.cooperationScore = prev_cooperationScore + C.div_regrow
            group.independentScore = prev_independentScore + C.div_regrow



   
    if group.GameMode != 'Divergent':
       group.chooseflagP1=p1.chooseflag
       group.chooseflagP2=p2.chooseflag
    else:
       group.chooseflagP1 = False
       group.chooseflagP2 = False


    group.p1TotalScore = round(group.p1TotalScore,2)
    group.p2TotalScore = round(group.p2TotalScore,2)
    group.p1Score =round(group.p1Score,2)
    group.p2Score = round(group.p2Score,2)

    #group.reactiontimeP1=p1.reactiontime
    #group.reactiontimeP2=p2.reactiontime

    
# PAGES

class Introduction(Page):  #not using it at the moment

    @staticmethod
    def vars_for_template(player: Player):
        return dict(image_path1="display_image/23.png", image_path2="display_image/24.png",
                    image_path3="display_image/22.PNG")

    def is_displayed(player: Player):
        return player.id_in_group


class pathSelection(Page):  # 1st page. selecting the path
    form_model = "player"
    form_fields = ['mode','modeflag',"actualTime"]

    @staticmethod
    def vars_for_template(self):  


        if self.group.round_number>1:
            self.group.p1TotalScore=20
            self.group.p2TotalScore=20
            result = self.group.in_previous_rounds()
            for roundRow in result:
             self.group.p1TotalScore+= roundRow.p1Score
             self.group.p2TotalScore+= roundRow.p2Score
             self.group.p1TotalScore=round(self.group.p1TotalScore,2)
             self.group.p2TotalScore=round(self.group.p2TotalScore,2)
   
   

        if self.group.round_number>1:
            self.group.cooperationScore = max(round(self.group.in_round(self.group.round_number - 1).cooperationScore, 2), 0)
            self.group.independentScore = max(round(self.group.in_round(self.group.round_number - 1).independentScore, 2), 0)
            self.group.competitionScore = max(round(self.group.in_round(self.group.round_number - 1).competitionScore, 2), 0)


        return {'group.p2TotalScore': self.group.p2TotalScore,'group.p1TotalScore': self.group.p1TotalScore }

    def is_displayed(player: Player): #defining the timeout for waiting page (page before the wait page )
        return player.id_in_group

    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        import time


        player.timeout = time.time() + C.TIMEOUT

        serialPort = serial.Serial(port='COM5', baudrate=115200,
                                bytesize=8, timeout=1, stopbits=serial.STOPBITS_ONE)

        serialPort.close()
        serialPort.open()
        serialString = ""
        serialPort.write(bytes.fromhex("A555FA"))


class ResultsWaitPage(WaitPage): #timeout for wait page
    after_all_players_arrive = set_payoffs
    template_name = 'intro_hide_and_seek_2options/ResultsWaitPage.html'

    @staticmethod
    def js_vars(player: Player):
        return dict(timeout=C.TIMEOUT)

    @staticmethod
    def vars_for_template(player: Player):
        import time

        timeout_happened = time.time() > player.timeout
        return dict(timeout_happened=timeout_happened)


class ResultsWaitPage2(WaitPage): #timeout for wait page
    after_all_players_arrive = set_Predictions

    template_name = 'intro_hide_and_seek_2options/ResultsWaitPage.html'

    @staticmethod
    def js_vars(player: Player):
        return dict(timeout=C.TIMEOUT)

    @staticmethod
    def vars_for_template(player: Player):
        import time

        timeout_happened = time.time() > player.timeout
        return dict(timeout_happened=timeout_happened)


class MyWaitPage(WaitPage): #wait page untill another participant gets ready
    group_by_arrival_time = True

    @staticmethod
    def is_displayed(player):
        return player.round_number == 1


class MainGame(Page): #choose page

    form_model = "player"
    form_fields = ["Choose",'chooseflag','reactiontime']

    def is_displayed(player: Player):
        return player.id_in_group

    def vars_for_template(self):
        found=0


        if self.group.round_number>1:

            for i,row in enumerate(self.group.in_previous_rounds()) :
                if row.GameMode==self.group.GameMode:
                    found=1
                    self.group.Lastchoosep1=row.choosep1
                    self.group.Lastchoosep2=row.choosep2

            if found!=1:
                self.group.Lastchoosep1='nothing'
                self.group.Lastchoosep2='nothing'

    @staticmethod #if the mode is not divergent
    def is_displayed(self):
        return self.group.GameMode != 'Divergent'

    @staticmethod #timer for wait page (page before the wait page )
    def before_next_page(player: Player, timeout_happened):
        import time

        player.timeout = time.time() + C.TIMEOUT


class Choosen_Mode(Page): #showing which island has been selected
    form_model = 'player'
    @staticmethod
    def vars_for_template(self):
    
       
        if self.group.round_number>1:
            self.group.cooperationScore = max(round(self.group.in_round(self.group.round_number - 1).cooperationScore, 2), 0)
            self.group.independentScore = max(round(self.group.in_round(self.group.round_number - 1).independentScore, 2), 0)
            self.group.competitionScore = max(round(self.group.in_round(self.group.round_number - 1).competitionScore, 2), 0)


class Payoff(Page): #payoff table page

    form_model = "player"

    def is_displayed(player:Player):
        return player.id_in_group

    @staticmethod
    def update_score_of_interchanges(player_id, group): #considering travel cost in scoretable showing

        player_of_interest = group.get_player_by_id(player_id)
        prev_mode_p = group.in_round(group.round_number - 1).get_player_by_id(player_id).mode

        if group.GameMode != 'Divergent' and group.in_round(group.round_number - 1).get_player_by_id(1).mode == group.in_round(group.round_number - 1).get_player_by_id(2).mode:
            if (prev_mode_p == 'Independent' and player_of_interest.mode == 'Cooperation'):
                return 6

            elif (prev_mode_p== 'Cooperation' and player_of_interest.mode== 'Independent') :

                 return 8

            elif (prev_mode_p == 'Competition' and player_of_interest.mode == 'Independent') :
                 return 10

            elif (prev_mode_p == 'Cooperation' and player_of_interest.mode == 'Competition'):
                 return 4
            elif (prev_mode_p == 'Competition' and player_of_interest.mode == 'Cooperation'):
                 return 4
            elif (prev_mode_p == 'Independent' and player_of_interest.mode == 'Competition'):
                 return 4

            else:
                 return 0
        else:
            return 0

    @staticmethod
    def vars_for_template(self):

        found = 0

        if self.group.round_number>1:

            for i,row in enumerate(self.group.in_previous_rounds()) :
                if row.GameMode==self.group.GameMode:
                    found=1
                    self.group.Lastchoosep1=row.choosep1
                    self.group.Lastchoosep2=row.choosep2


            if found != 1:
                self.group.Lastchoosep1 = 'nothing'
                self.group.Lastchoosep2 = 'nothing'

            self.group.p1InterchangePenallty = Payoff.update_score_of_interchanges(1, self.group)
            self.group.p2InterchangePenallty = Payoff.update_score_of_interchanges(2, self.group)
        else:
            self.group.p1InterchangePenallty = 0
            self.group.p2InterchangePenallty = 0

        return {'group.p1InterchangePenallty': self.group.p1InterchangePenallty,'group.p2InterchangePenallty': self.group.p2InterchangePenallty }

    @staticmethod #if its not divergent mode
    def is_displayed(self):
        return self.group.GameMode != 'Divergent'


class Prediction(Page): #prediction page
    
    form_model = "player"
    form_fields = ["predictionTree",'predictionflag','predictTimeNext','mousedown',"mouseup"]
    @staticmethod
    def vars_for_template(self):
        found=0

        if self.group.round_number>1:

             for i,row in enumerate(self.group.in_previous_rounds()) :
                if row.GameMode==self.group.GameMode:
                    found=1
                    self.group.Lastchoosep1=row.choosep1
                    self.group.Lastchoosep2=row.choosep2

             if found != 1:
                self.group.Lastchoosep1 = 'nothing'
                self.group.Lastchoosep2 = 'nothing'


        # return {'group.p2TotalScore': self.group.p2TotalScore,'group.p1TotalScore': self.group.p1TotalScore }

    def is_displayed(player: Player):
        return player.id_in_group

    @staticmethod
    def is_displayed(self): #if its nor divergent
        return self.group.GameMode != 'Divergent'



class outcome (Page): #last page (outcome )
    form_model = 'player'

    @staticmethod
    def is_displayed(self):
        return self.group.GameMode != 'Divergent' #if its not divergent

class outcomeDivergent (Page): #outcome only for divergent mode
    form_model = 'player'

    @staticmethod
    def is_displayed(self):
        return self.group.GameMode == 'Divergent'


class payment (Page): #last page for payment
    form_model = 'player'

    @staticmethod
    def is_displayed(player):
     return player.round_number == 40


class last (Page): #completion link at last

    form_model = 'player'

    @staticmethod
    def is_displayed(player):
     return player.round_number == 40 #only at round 40

    @staticmethod
    def js_vars(player):
        return dict(
            completionlink=
              player.subsession.session.config['completionlink']
        )


page_sequence = [MyWaitPage,pathSelection,ResultsWaitPage,Choosen_Mode,Payoff,Prediction,MainGame,ResultsWaitPage2,outcome,outcomeDivergent,payment,last]

#page sequence