from itertools import count
from pickle import NONE
from random import choices
from secrets import choice
from tokenize import group
from otree.api import *


doc = """
Your app description
"""



class C(BaseConstants):
    NAME_IN_URL = 'vote'
    PLAYERS_PER_GROUP = 2
    NUM_ROUNDS = 1


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
     x1=models.IntegerField()
     x2=models.IntegerField()
     x3=models.IntegerField()
     win1=models.IntegerField()
     win2=models.IntegerField()
     win3=models.IntegerField()
     optR=models.IntegerField()
     y1=models.IntegerField()
     y2=models.IntegerField()
     y3=models.IntegerField()
     again1=models.IntegerField()
     again2=models.IntegerField()
     again3=models.IntegerField()
     win_dict = models.LongStringField()
     winner_again = models.IntegerField()


class Player(BasePlayer):
    Choice=models.IntegerField(
        choices=[
            [1,'A党'],
            [2,'B党'],
            [3,'C党'],
            
        ],
        widget=widgets.RadioSelectHorizontal,
        label="",
    )
    num_winners=models.IntegerField()
    vote2=models.IntegerField()
    
    
    

   

    

# Functions
def set_payoffs(group: Group):
    players = group.get_players()
    votes = [p.Choice for p in players]
    group.x1 = votes.count(1)
    group.x2 = votes.count(2)
    group.x3 = votes.count(3)
    
    if group.x1 == max(group.x1,group.x2,group.x3):
        group.win1=1
    else:
        group.win1=0

    if group.x2 == max(group.x1,group.x2,group.x3,):
        group.win2=1
    else:
        group.win2=0

    if group.x3 == max(group.x1,group.x2,group.x3,):
        group.win3=1
    else:
        group.win3=0
    
    import json
    win_dict = {"A": group.win1, "B": group.win2, "C": group.win3}
    a_subset = list({key for key, value in win_dict.items() if value >= 1})

    group.win_dict = json.dumps(a_subset)

    for p in group.get_players():
        p.num_winners = group.win1+group.win2+group.win3


def set_payoffs_again(group:Group):
    players=group.get_players()
    votesagain=[q.vote2 for q in players]
    group.y1 = votesagain.count(1)
    group.y2 = votesagain.count(2)
    group.y3 = votesagain.count(3)

    if group.y1 == max(group.y1,group.y2,group.y3):
        group.again1=1
    else:
        group.again1=0
    
    if group.y2 == max(group.y1,group.y2,group.y3):
        group.again2=1
    else:
        group.again2=0
    
    if group.y3 == max(group.y1,group.y2,group.y3):
        group.again3=1
    else:
        group.again3=0

#勝者複数で0, A党が勝てば1, Bが勝てば2, Cが勝てば3の値をとる変数を作る
    import json
    a_subset = json.loads(group.win_dict)
    if group.again1 + group.again2 + group.again3 >= 2:
        group.winner_again = 0
    elif group.y1 == max(group.y1,group.y2,group.y3):
        group.winner_again = ord(a_subset[0]) - 64
    elif group.y2 == max(group.y1,group.y2,group.y3):
        group.winner_again = ord(a_subset[1]) - 64 
    else:
        group.winner_again = ord(a_subset[3]) - 64 





    




# PAGES
class MyWaitPage(WaitPage):
    group_by_arrival_time = True

class explanation(Page):
    pass



class experiment(Page):
   form_model='player'
   form_fields=['Choice']




class ResultsWaitPage(WaitPage):
    after_all_players_arrive = set_payoffs


class Results(Page):
    pass


class voteagain(Page):
    @staticmethod 
    def is_displayed(player):
        return player.num_winners > 1
    def vars_for_template(player:Player):
        import json
        a_subset = json.loads(player.group.win_dict)
        return dict (
            a_subset = a_subset
        )
        
    
        
        
    
    form_model='player'
    form_fields=['vote2']


class resultwaitpageagain(WaitPage):
    @staticmethod 
    def is_displayed(player):
        return player.num_winners > 1
    after_all_players_arrive = set_payoffs_again
    

class resultagain(Page):
    @staticmethod 
    def is_displayed(player):
        return player.num_winners > 1

    @staticmethod     
    def vars_for_template(player:Player):
        import json
        a_subset = json.loads(player.group.win_dict)
        if player.num_winners == 3:
            tokuhyou_dict = {"A党": player.group.y1, "B党": player.group.y2, "C党": player.group.y3}
        else:
            tokuhyou_dict = {a_subset[0]: player.group.y1, a_subset[1]: player.group.y2}
        return dict(
            tokuhyou_dict = tokuhyou_dict,
            voted_for = a_subset[player.vote2 - 1],
        )
        
        


    

    
   

    



page_sequence = [MyWaitPage,explanation,
experiment,ResultsWaitPage, Results,voteagain,resultwaitpageagain,resultagain]