from otree.api import *
from random import choice
import random


class Constants(BaseConstants):
    # 用 dataframe
    import random
    import pandas as pd
    SV_grouping_fix = pd.DataFrame([(2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0),
                                    (0, 2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0),
                                    (0, 0, 2, 2, 2, 2, 2, 1, 1, 1, 1, 0),
                                    (0, 0, 0, 2, 2, 2, 2, 2, 1, 1, 1, 1),
                                    (1, 0, 0, 0, 2, 2, 2, 2, 2, 1, 1, 1),
                                    (1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 1, 1),
                                    (1, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 1),
                                    (1, 1, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2),
                                    (2, 1, 1, 1, 1, 0, 0, 0, 2, 2, 2, 2),
                                    (2, 2, 1, 1, 1, 1, 0, 0, 0, 2, 2, 2),
                                    (2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 2, 2),
                                    (2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 2),
                                    (2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0),
                                    (0, 2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0),
                                    (0, 0, 2, 2, 2, 2, 2, 1, 1, 1, 1, 0),
                                    (0, 0, 0, 2, 2, 2, 2, 2, 1, 1, 1, 1),
                                    (1, 0, 0, 0, 2, 2, 2, 2, 2, 1, 1, 1),
                                    (1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 1, 1),
                                    (1, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 1),
                                    (1, 1, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2),
                                    (2, 1, 1, 1, 1, 0, 0, 0, 2, 2, 2, 2),
                                    (2, 2, 1, 1, 1, 1, 0, 0, 0, 2, 2, 2),
                                    (2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 2, 2),
                                    (2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0, 2), ],
                                   columns=('Player1', 'Player2', 'Player3', 'Player4', 'Player5', 'Player6', 'Player7',
                                            'Player8', 'Player9', 'Player10', 'Player11', 'Player12'))
    print(SV_grouping_fix)

    SV_grouping_fix_T = pd.DataFrame(SV_grouping_fix.values.T)

    print(SV_grouping_fix_T)

    import numpy as np
    SV_grouping_random1_T = pd.DataFrame(np.random.permutation((2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0), ), columns=['1_T'])
    SV_grouping_random2_T = pd.DataFrame(np.random.permutation((2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0), ), columns=['2_T'])
    SV_grouping_random3_T = pd.DataFrame(np.random.permutation((2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0), ), columns=['3_T'])
    SV_grouping_random4_T = pd.DataFrame(np.random.permutation((2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0), ), columns=['4_T'])
    SV_grouping_random5_T = pd.DataFrame(np.random.permutation((2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0), ), columns=['5_T'])
    SV_grouping_random6_T = pd.DataFrame(np.random.permutation((2, 2, 2, 2, 2, 1, 1, 1, 1, 0, 0, 0), ), columns=['6_T'])
    print(SV_grouping_random1_T)
    SV_grouping_random_T = pd.concat(
        [SV_grouping_random1_T, SV_grouping_random2_T, SV_grouping_random3_T, SV_grouping_random4_T,
         SV_grouping_random5_T, SV_grouping_random6_T], sort=False, axis=1)
    print(SV_grouping_random_T)

    SV_grouping_random = pd.DataFrame(SV_grouping_random_T.values.T,
                                      columns=(
                                          'Player1', 'Player2', 'Player3', 'Player4', 'Player5', 'Player6', 'Player7',
                                          'Player8', 'Player9', 'Player10', 'Player11', 'Player12'))
    print(SV_grouping_random)

    SV_grouping_T = pd.concat([SV_grouping_fix_T, SV_grouping_random_T], sort=False, axis=1)

    # 創好 30 rows * 12 columns 的 dataframe
    SV_grouping = pd.DataFrame(SV_grouping_T.values.T,
                               columns=(
                                   'Player1', 'Player2', 'Player3', 'Player4', 'Player5', 'Player6', 'Player7',
                                   'Player8', 'Player9', 'Player10', 'Player11', 'Player12'))
    print('SV_K_sim 的 30 回合為')
    print(SV_grouping)

    # 多少 rounds
    num_rounds = len(SV_grouping)
    print(num_rounds)
    # 打亂
    round_order = list(range(1, num_rounds+1))
    random.shuffle(round_order)
    #
    SV_grouping_shuffle = SV_grouping.sample(frac=1)
    print('SV_K_sim 洗亂的 30 回合為')
    print(SV_grouping_shuffle)
    #用 excel 抽
    # import csv
    # import math
    #
    # # use this if you want a 3 rounds game
    # # with open('SV_K_sim/SV_group_3.csv', 'r') as para:
    # # use this if you want a 30 rounds game
    # with open('SV_K_sim/SV_group.csv', 'r') as para:
    #     para = list(csv.DictReader(para))
    #     print(para)
    #     num_rounds = len(para)  # number of row     #總回合數 = csv 裡有多少 rows
    #     print(num_rounds)
    #     # players_per_group = len(para[0]) - 1  # number of column-1 #設定受試者人數
    #     # print(players_per_group)
    #
    # round_order = list(range(1, num_rounds+1))
    # random.shuffle(round_order)

    name_in_url = 'SV_K_sim'
    players_per_group = 12
    # NUM_ROUNDS = 5
    # VOTES = cu(1)

    # 報酬
    exchange_rate = 14
    attendance_fee = 100

    #定義乘數
    MULTIPLIER1 = 12
    MULTIPLIER2 = 9
    MULTIPLIER3 = 2


class Subsession(BaseSubsession):
    #記錄抽到的 round
    selected_round = models.IntegerField(initial=1)
    round_row = models.IntegerField(initial=0)


class Group(BaseGroup):

    #隨機抽三種情形的一種
    random_table = models.IntegerField(initial=0)

    #計算票數
    num_vote_alpha = models.IntegerField()
    num_vote_beta = models.IntegerField()
    num_vote_gamma = models.IntegerField()
    vote_result = models.IntegerField(min=1, max=3, initial=1)
    vote_result_str = models.StringField(initial='a')

    #subgroup# 用來紀錄受試者在該回合分到a, b, c哪一組的人數
    subgroup1 = models.IntegerField()
    subgroup2 = models.IntegerField()
    subgroup3 = models.IntegerField()

    subgroup_result = models.IntegerField(min=1, max=3, initial=1)
    subgroup_result_str = models.StringField(initial='a')


class Player(BasePlayer):
    vote = models.IntegerField(
        choices=[[1, ' α '], [2, ' β '], [3, ' γ ']],
        widget=widgets.RadioSelectHorizontal,
        label="您想要選擇哪一個選項？",
    )
    #定義is_winner判斷誰是贏家
    is_winner = models.BooleanField()

    #定義random_table變數在class Player
    #能不能指定義一個變數然後用loop跑就好
    random_group = models.IntegerField(min=1, max=3)

    #定義並記錄每個受試者的type
    #還是要所有受試者都定義一遍，然後一個一個檢查
    Type_subject1 = models.IntegerField(min=1, max=3, initial=1)
    Type_subject2 = models.IntegerField(min=1, max=3, initial=1)
    Type_subject3 = models.IntegerField(min=1, max=3, initial=1)

    #紀錄抽到的回合是哪個table ( 5/4/3, 4/3/5, 3/5/4 )
    random_table = models.IntegerField(initial=0)

    #紀錄抽到的是哪個回合
    random_round = models.IntegerField(initial=0)
    player_in_selected_round = models.IntegerField(initial=0)

    #紀錄抽到回合的總票數 ( alpha, beta, gamma )
    num_vote_alpha = models.IntegerField(initial=0)
    num_vote_beta = models.IntegerField(initial=0)
    num_vote_gamma = models.IntegerField(initial=0)

    #紀錄抽到的回合的法幣
    final_payoff = models.IntegerField(initial=0)

    #紀錄抽到的回合的新台幣
    total_pay_yuan = models.IntegerField(initial=0)

    is_large_team = models.BooleanField()   # 判斷是否在大組
    is_med_team = models.BooleanField()     # 判斷是否在中組
    is_small_team = models.BooleanField()   # 判斷是否在小組

# FUNCTIONS **(一個function只能做一件事)**

#抽三種環境
def random_tables(group:Group):
    group.random_table = random.randint(1, 3)

def creating_session(subsession: Subsession):

    global S1_big, S1_med, selected_round
    import random

    session = subsession.session
    # subsession.round_row = Constants.round_order[subsession.round_number-1]
    # 現在第幾回合就抽第幾 row
    if subsession.round_number == 1:
        selected_round = Constants.SV_grouping_shuffle.iloc[0]
    elif subsession.round_number == 2:
        selected_round = Constants.SV_grouping_shuffle.iloc[1]
    elif subsession.round_number == 3:
        selected_round = Constants.SV_grouping_shuffle.iloc[2]
    elif subsession.round_number == 4:
        selected_round = Constants.SV_grouping_shuffle.iloc[3]
    elif subsession.round_number == 5:
        selected_round = Constants.SV_grouping_shuffle.iloc[4]
    elif subsession.round_number == 6:
        selected_round = Constants.SV_grouping_shuffle.iloc[5]
    elif subsession.round_number == 7:
        selected_round = Constants.SV_grouping_shuffle.iloc[6]
    elif subsession.round_number == 8:
        selected_round = Constants.SV_grouping_shuffle.iloc[7]
    elif subsession.round_number == 9:
        selected_round = Constants.SV_grouping_shuffle.iloc[8]
    elif subsession.round_number == 10:
        selected_round = Constants.SV_grouping_shuffle.iloc[9]
    elif subsession.round_number == 11:
        selected_round = Constants.SV_grouping_shuffle.iloc[10]
    elif subsession.round_number == 12:
        selected_round = Constants.SV_grouping_shuffle.iloc[11]
    elif subsession.round_number == 13:
        selected_round = Constants.SV_grouping_shuffle.iloc[12]
    elif subsession.round_number == 14:
        selected_round = Constants.SV_grouping_shuffle.iloc[13]
    elif subsession.round_number == 15:
        selected_round = Constants.SV_grouping_shuffle.iloc[14]
    elif subsession.round_number == 16:
        selected_round = Constants.SV_grouping_shuffle.iloc[15]
    elif subsession.round_number == 17:
        selected_round = Constants.SV_grouping_shuffle.iloc[16]
    elif subsession.round_number == 18:
        selected_round = Constants.SV_grouping_shuffle.iloc[17]
    elif subsession.round_number == 19:
        selected_round = Constants.SV_grouping_shuffle.iloc[18]
    elif subsession.round_number == 20:
        selected_round = Constants.SV_grouping_shuffle.iloc[19]
    elif subsession.round_number == 21:
        selected_round = Constants.SV_grouping_shuffle.iloc[20]
    elif subsession.round_number == 22:
        selected_round = Constants.SV_grouping_shuffle.iloc[21]
    elif subsession.round_number == 23:
        selected_round = Constants.SV_grouping_shuffle.iloc[22]
    elif subsession.round_number == 24:
        selected_round = Constants.SV_grouping_shuffle.iloc[23]
    elif subsession.round_number == 25:
        selected_round = Constants.SV_grouping_shuffle.iloc[24]
    elif subsession.round_number == 26:
        selected_round = Constants.SV_grouping_shuffle.iloc[25]
    elif subsession.round_number == 27:
        selected_round = Constants.SV_grouping_shuffle.iloc[26]
    elif subsession.round_number == 28:
        selected_round = Constants.SV_grouping_shuffle.iloc[27]
    elif subsession.round_number == 29:
        selected_round = Constants.SV_grouping_shuffle.iloc[28]
    elif subsession.round_number == 30:
        selected_round = Constants.SV_grouping_shuffle.iloc[29]

    for p in subsession.get_players():
        p.is_large_team = selected_round['Player' + str(p.id_in_group)] == 2
        p.is_med_team = selected_round['Player' + str(p.id_in_group)] == 1
        p.is_small_team = selected_round['Player' + str(p.id_in_group)] == 0

    #用 excel 抽
    # session = subsession.session
    # subsession.round_row = Constants.round_order[subsession.round_number - 1]
    #
    # subsession.session.vars['para'] = Constants.para.copy()
    # for p in subsession.get_players():
    #     para_round = subsession.session.vars['para'][subsession.round_row-1]  # subsession.round_number - 1th row
    #     p.is_large_team = para_round['Player' + str(p.id_in_group)] == '2'
    #     p.is_med_team = para_round['Player' + str(p.id_in_group)] == '1'
    #     p.is_small_team = para_round['Player' + str(p.id_in_group)] == '0'
    #
    # # if subsession.round_number == 1:
    # #     paying_round = random.randint(1, Constants.num_rounds)
    # #     session.vars['paying_round'] = paying_round

    # list
    all_list = [p.id_in_group for p in subsession.get_players()]

    # 創大組的 list
    large_list = []
    for p in subsession.get_players():
        if p.is_large_team == 1:
            large_list.append(p.id_in_group)
            if len(large_list) == 5:            # 創好大組的 List
                print(large_list)

    # 創中組的 list
    med_list = []
    for p in subsession.get_players():
        if p.is_med_team == 1:
            med_list.append(p.id_in_group)
            if len(med_list) == 4:            # 創好中組的 List
                print(med_list)

    # 創小組的 list
    small_list = []
    for p in subsession.get_players():
        if p.is_small_team == 1:
            small_list.append(p.id_in_group)
            if len(small_list) == 3:            # 創好小組的 List
                print(small_list)


    for p in subsession.get_players():
        # a=5, b=4, c=3
        if p.group.random_table == 1:
            if p.is_large_team == 1:  # 如果id = 抽到的5人 (大組)
                p.random_group = 1
                p.random_table = 1
            elif p.is_med_team == 1:  # 如果id = 抽到的4人 (中組)
                p.random_group = 2
                p.random_table = 1
            elif p.is_small_team == 1:  # 如果id = 抽到的3人 (小組)
                p.random_group = 3
                p.random_table = 1

        # a=4, b=3, c=5
        elif p.group.random_table == 2:
            if p.is_large_team == 1:  # 如果id = 抽到的五人
                p.random_group = 3
                p.random_table = 2
            elif p.is_med_team == 1:  # 如果id = 抽到的4人
                p.random_group = 1
                p.random_table = 2
            elif p.is_small_team == 1:  # 如果id = 抽到的3人
                p.random_group = 2
                p.random_table = 2

        # a=3, b=5, c=4
        elif p.group.random_table == 3:
            if p.is_large_team == 1:  # 如果id = 抽到的五人
                p.random_group = 2
                p.random_table = 3
            elif p.is_med_team == 1:  # 如果id = 抽到的4人
                p.random_group = 3
                p.random_table = 3
            elif p.is_small_team == 1:  # 如果id = 抽到的3人
                p.random_group = 1
                p.random_table = 3

# #抽大、中、小組
# def grouping(group: Group):
#
#     # 從12人中抽5(大)、再4(中)、再3(小)
#     # 產生id: 1-12
#     p_id0 = list(range(1, 13))
#     print(p_id0)
#
#     # 抽5人
#     random_big = random.sample(p_id0, 5)
#     print(random_big)
#     # group.subgroup1 = random_big    #subgroup1 = 大組
#
#     p_id1 = list(set(p_id0) - set(random_big))
#     print(p_id1)
#
#     # 抽4人
#     random_med = random.sample(p_id1, 4)
#     print(random_med)
#     # group.subgroup2 = random_med    #subgroup2 = 中組
#
#     # 抽3人
#     random_smol = list(set(p_id1) - set(random_med))
#     print(random_smol)
#     # group.subgroup3 = random_smol   #subgroup3 = 小組
#
#     #開始分組
#     players = group.get_players()  # 定義players for 下行的迴圈
#
#     for p in players:
#         # a=5, b=4, c=3
#         if p.group.random_table == 1:
#             if p.id_in_group in random_big:  #如果id = 抽到的5人
#                 p.random_group = 1
#                 p.random_table = 1
#             elif p.id_in_group in random_med:#如果id = 抽到的4人
#                 p.random_group = 2
#                 p.random_table = 1
#             elif p.id_in_group in random_smol:#如果id = 抽到的3人
#                 p.random_group = 3
#                 p.random_table = 1
#
#         # a=4, b=3, c=5
#         elif p.group.random_table == 2:
#             if p.id_in_group in random_big:  #如果id = 抽到的五人
#                 p.random_group = 3
#                 p.random_table = 2
#             elif p.id_in_group in random_med:#如果id = 抽到的4人
#                 p.random_group = 1
#                 p.random_table = 2
#             elif p.id_in_group in random_smol:#如果id = 抽到的3人
#                 p.random_group = 2
#                 p.random_table = 2
#
#         # a=3, b=5, c=4
#         elif p.group.random_table == 3:
#             if p.id_in_group in random_big:  #如果id = 抽到的五人
#                 p.random_group = 2
#                 p.random_table = 3
#             elif p.id_in_group in random_med:#如果id = 抽到的4人
#                 p.random_group = 3
#                 p.random_table = 3
#             elif p.id_in_group in random_smol:#如果id = 抽到的3人
#                 p.random_group = 1
#                 p.random_table = 3


def count_votes(group: Group):  # 統計總票數

    players = group.get_players()  # 定義players for 下行的迴圈
    votes = [p.vote for p in players]  # 定義votes是player這個class下的vote變數，每個受試者跑迴圈紀錄投下的票
    group.num_vote_alpha = votes.count(1)  # 計算alpha總票數
    group.num_vote_beta = votes.count(2)  # 計算beta總票數
    group.num_vote_gamma = votes.count(3)  # 計算gamma總票數

    for p in players:
        p.num_vote_alpha = group.num_vote_alpha
        p.num_vote_beta = group.num_vote_beta
        p.num_vote_gamma = group.num_vote_gamma

# 判斷誰贏(計算票數)
    # alpha贏
    if group.num_vote_alpha > group.num_vote_beta and group.num_vote_alpha > group.num_vote_gamma:
        group.vote_result_str = "本回合選項 α 為最多人選擇的選項"
        group.vote_result = 1
        return 'Candidate α wins'

    # beta贏
    elif group.num_vote_beta > group.num_vote_alpha and group.num_vote_beta > group.num_vote_gamma:
        group.vote_result_str = "本回合選項 β 為最多人選擇的選項"
        group.vote_result = 2
        return 'Candidate β wins'

    # gamma贏
    elif group.num_vote_gamma > group.num_vote_alpha and group.num_vote_gamma > group.num_vote_beta:
        group.vote_result_str = "本回合選項 γ 為最多人選擇的選項"
        group.vote_result = 3
        return 'Candidate γ wins'
    # a, b平手
    elif group.num_vote_alpha == group.num_vote_beta and group.num_vote_alpha > group.num_vote_gamma:
        # 隨機抽1,2
        group.vote_result = random.randint(1, 2)
        # 抽到a贏
        if group.vote_result == 1:
            group.vote_result_str = "選項 α 和 選項 β 平手，由電腦隨機抽出的結果是：選項 α 為最多人選擇的選項"
            return 'tie Candidate α wins'
        # 抽到b贏
        elif group.vote_result == 2:
            group.vote_result_str = "選項 α 和 選項 β 平手，由電腦隨機抽出的結果是：選項 β 為最多人選擇的選項"
            return 'tie Candidate β wins'
    # a, r平手
    elif group.num_vote_alpha == group.num_vote_gamma and group.num_vote_alpha > group.num_vote_beta:
        # 隨機抽1,3
        list = [1, 3]
        group.vote_result = random.choice(list)
        # 抽到a贏
        if group.vote_result == 1:
            group.vote_result_str = "選項 α 和 選項 γ 平手，由電腦隨機抽出的結果是：選項 α 為最多人選擇的選項"
            return 'tie Candidate α wins'
        # 抽到r贏
        elif group.vote_result == 3:
            group.vote_result_str = "選項 α 和 選項 γ 平手，由電腦隨機抽出的結果是：選項 γ 為最多人選擇的選項"
            return 'tie Candidate γ wins'
    # b, r平手
    elif group.num_vote_gamma == group.num_vote_beta and group.num_vote_beta > group.num_vote_alpha:
        # 隨機抽2,3
        group.vote_result = random.randint(2, 3)
        # 抽到b贏
        if group.vote_result == 2:
            group.vote_result_str = "選項 β 和 選項 γ 平手，由電腦隨機抽出的結果是：選項 β 為最多人選擇的選項"
            return 'tie Candidate β wins'
        # 抽到r贏
        elif group.vote_result == 3:
            group.vote_result_str = "選項 β 和 選項 γ 平手，由電腦隨機抽出的結果是：選項 γ 為最多人選擇的選項"
            return 'tie Candidate γ wins'
    # a, b, r三人平手
    elif group.num_vote_alpha == group.num_vote_beta and group.num_vote_alpha == group.num_vote_gamma and group.num_vote_beta == group.num_vote_gamma:
        # 隨機抽1, 2, 3
        group.vote_result = random.randint(1, 3)
        # 抽到a贏
        if group.vote_result == 1:
            group.vote_result_str = "選項 α 、選項 β 、選項 γ 三者平手，由電腦隨機抽出的結果是：選項 α 為最多人選擇的選項"
            return 'tie Candidate α wins'
        # 抽到b贏
        elif group.vote_result == 2:
            group.vote_result_str = "選項 α 、選項 β 、選項 γ 三者平手，由電腦隨機抽出的結果是：選項 β 為最多人選擇的選項"
            return 'tie Candidate β wins'
        # 抽到r贏
        elif group.vote_result == 3:
            group.vote_result_str = "選項 α 、選項 β 、選項 γ 三者平手，由電腦隨機抽出的結果是：選項 γ 為最多人選擇的選項"
            return 'tie Candidate γ wins'

def set_payoffs(group: Group):

    players = group.get_players()  # 定義players for 下行的迴圈

#計算每人每回合報酬
    for p in players:
        # alpha贏
        if p.group.vote_result == 1:
            #Voter type a
            if p.random_group == 1:
                p.payoff = 1*Constants.MULTIPLIER1
            #Voter type b
            elif p.random_group == 2:
                p.payoff = 1*Constants.MULTIPLIER2
            # Voter type c
            elif p.random_group == 3:
                p.payoff = 1*Constants.MULTIPLIER3
        #beta贏
        elif group.vote_result == 2:
            #Voter type a
            if p.random_group == 1:
                p.payoff = 1*Constants.MULTIPLIER3
            #Voter type b
            elif p.random_group == 2:
                p.payoff = 1*Constants.MULTIPLIER1
            # Voter type c
            elif p.random_group == 3:
                p.payoff = 1*Constants.MULTIPLIER2
        #gamma贏
        elif group.vote_result == 3:
            #Voter type a
            if p.random_group == 1:
                p.payoff = 1*Constants.MULTIPLIER2
            #Voter type b
            elif p.random_group == 2:
                p.payoff = 1*Constants.MULTIPLIER3
            # Voter type c
            elif p.random_group == 3:
                p.payoff = 1*Constants.MULTIPLIER1

#抽結算回合
def draw_round(subsession: Subsession):

    if subsession.round_number == Constants.num_rounds:
        subsession.selected_round = random.randint(1, Constants.num_rounds)
        for p in subsession.get_players():
            p.random_round = subsession.selected_round


# PAGES

class Ready(Page):
    pass


class Game1(Page):
    form_model = 'player'
    form_fields = ['vote']      #定義產生的表格是甚麼形式。ex.'vote'是在class Player那邊定義的


class ResultsWaitPage_Table(WaitPage):
    after_all_players_arrive = random_tables    #抽表格
    body_text = "等待所有實驗參與者開始實驗..."

class ResultsWaitPage_session(WaitPage):
    wait_for_all_groups = True
    after_all_players_arrive = creating_session  # 分組方式：事先排/隨機抽
    body_text = "等待所有實驗參與者開始實驗..."

# class ResultsWaitPage_Group(WaitPage):
#     after_all_players_arrive = grouping         #分組5/4/3
#     body_text = "等待所有實驗參與者開始實驗..."

class ResultsWaitPage_Vote(WaitPage):               #統計票數
    after_all_players_arrive = count_votes
    body_text = "等待所有實驗參與者完成選擇..."

class ResultsWaitPage_Payoff(WaitPage):               #算報酬
    after_all_players_arrive = set_payoffs
    body_text = "等待所有實驗參與者完成選擇..."

class ResultsWaitPage_Round(WaitPage):               #抽結算回合
    wait_for_all_groups = True
    after_all_players_arrive = draw_round
    body_text = "等待所有實驗參與者完成選擇..."


class Result1(Page):
    def vars_for_template(player):
        group = player.group
        return dict(
            alpha = group.num_vote_alpha,    # 計算alpha總票數
            beta = group.num_vote_beta,    # 計算beta總票數
            gamma = group.num_vote_gamma,    # 計算gamma總票數

        )

class Final_payoff(Page):
    @staticmethod
    #所有回合跑完才結算
    def is_displayed(player: Player):
        return player.round_number == Constants.num_rounds

    @staticmethod
    # participant = player，把變數變為 participant 變數
    def before_next_page(player: Player, timeout_happened):
        participant = player.participant

        player_in_selected_round = player.in_round(player.random_round)
        participant.SV_K_sim_random_round = player.random_round

        # 抓抽中回合的報酬(法幣)
        final_payoff = int(player_in_selected_round.payoff)
        player.final_payoff = final_payoff
        total_pay_yuan = final_payoff * Constants.exchange_rate + Constants.attendance_fee
        player.total_pay_yuan = total_pay_yuan
        participant.SV_K_sim_payoff = player.final_payoff

        #抓抽中回合的 Type a, b, c的人數
        #用 random table 做判斷
        random_table = int(player_in_selected_round.random_table)
        if random_table == 1:
            participant.SV_K_sim_num_a = 5
            participant.SV_K_sim_num_b = 4
            participant.SV_K_sim_num_c = 3

        elif random_table == 2:
            participant.SV_K_sim_num_a = 4
            participant.SV_K_sim_num_b = 3
            participant.SV_K_sim_num_c = 5

        elif random_table == 3:
            participant.SV_K_sim_num_a = 3
            participant.SV_K_sim_num_b = 5
            participant.SV_K_sim_num_c = 4

        #判斷受試者看到的報酬表
        random_group = int(player_in_selected_round.random_group)
        if random_group == 1:
            participant.SV_K_sim_Type = 1
        elif random_group == 2:
            participant.SV_K_sim_Type = 2
        elif random_group == 3:
            participant.SV_K_sim_Type = 3

        #紀錄alpha, beta, gamma總票數
        num_vote_alpha = int(player_in_selected_round.num_vote_alpha)
        num_vote_beta = int(player_in_selected_round.num_vote_beta)
        num_vote_gamma = int(player_in_selected_round.num_vote_gamma)
        participant.SV_K_sim_num_vote_alpha = num_vote_alpha
        participant.SV_K_sim_num_vote_beta = num_vote_beta
        participant.SV_K_sim_num_vote_gamma = num_vote_gamma

class Close(Page):
    @staticmethod
    #所有回合跑完才結算
    def is_displayed(player: Player):
        return player.round_number == Constants.num_rounds

    @staticmethod
    def vars_for_template(player):
        player_in_selected_round = player.in_round(player.random_round)
        final_payoff = int(player_in_selected_round.payoff)
        total_pay_yuan = final_payoff * Constants.exchange_rate + Constants.attendance_fee

        return dict(
            selected_round=player.random_round,
            total_pay_yuan=total_pay_yuan,
        )


page_sequence = [
    ResultsWaitPage_Table,
    ResultsWaitPage_session,
    Game1,
    ResultsWaitPage_Vote,
    ResultsWaitPage_Payoff,
    ResultsWaitPage_Round,
    Final_payoff,
]

#<img src="D:\Otree\picture\a.png", width=600, height=200>(放payoff_info_result)