from otree.api import *

doc = """
Your app description
"""


class C(BaseConstants):
    NAME_IN_URL = 'comb'
    PLAYERS_PER_GROUP = 2
    NUM_ROUNDS = 1
    CHAT_TEMPLATE = __name__ + '/chat.html'


class Subsession(BaseSubsession):
    pass


class Group(BaseGroup):
    pass


class Player(BasePlayer):
    ans1 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk1 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans2 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk2 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans3 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk3 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans4 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk4 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans5 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk5 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans6 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk6 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans7 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk7 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans8 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk8 = models.IntegerField(
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans9 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk9 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans10 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk10 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans11 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk11 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans12 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk12 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans13 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk13 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans14 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk14 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans15 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk15 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans16 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk16 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans17 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk17 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans18 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk18 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans19 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk19 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    ans20 = models.StringField(
        initial='', blank=True, max_length=3, label="The answer is,"
    )

    chk20 = models.IntegerField(
        blank=True,
        choices=[[0, "Correct"], [1, "Incorrect"], [2, "Pass"]],
        widget=widgets.RadioSelect,
        label="The answer is:"
    )

    pay = models.FloatField(
        initial='0'
    )

    pay2 = models.FloatField(
        initial='0'
    )

    pay_divide = models.FloatField(
        initial='0',
        label="How much would you assign for yourself?"
    )

    num_corr = models.FloatField(
        initial='0'
    )

    num_corr2 = models.FloatField(
        initial='0'
    )


class Message(ExtraModel):
    group = models.Link(Group)
    sender = models.Link(Player)
    text = models.StringField()


def to_dict(msg: Message):
    return dict(sender=msg.sender.id_in_group, text=msg.text)


# def set_timers(group):
#     for p in group.get_players():
#         participant = p.participant
#         import time
#         participant.expiry = time.time() + 60 * 1
#
#
# def get_timeout_seconds(player):
#     participant = player.participant
#     import time
#     return participant.expiry - time.time()

# PAGES
class Inst(Page):
    pass



class Solve1(Page):
    form_model = 'player'
    form_fields = ['ans1']

    timeout_seconds = 20


    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            n1=13,
            n2=9,
            n3=1,
            n4=1
        )


class Wait1_1(WaitPage):
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_2 = player_lists[1]
        player_2.pay = player_2.pay + 0


class Check1(Page):
    form_model = 'player'
    form_fields = ['chk1']

    timeout_seconds = 10




    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        for p in player.get_others_in_group():
            a1 = p.field_maybe_none('ans1')
            c = True
            d = False
            if len(a1) < 3:
                a1 = 'Pass'
                c = False
                d = True
            if a1 == '   ':
                a1 = 'Pass'
                c = False
                d = True
            b1 = a1[0]
            b2 = a1[1]
            b3 = a1[2]
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            a1=a1,
            n1=13,
            n2=9,
            n3=1,
            n4=1,
            b1=b1,
            b2=b2,
            b3=b3,
            c=c,
            d=d
        )


class Wait1(WaitPage):

    @staticmethod
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_1 = player_lists[0]
        player_2 = player_lists[1]
        if player_1.ans1 == '+++':
            player_2.pay = player_2.pay + 1
            if player_2.field_maybe_none('chk1') == 0:
                player_2.pay2 = player_2.pay2 + 1
        else:
            if player_2.field_maybe_none('chk1') == 1:
                if len(player_1.field_maybe_none('ans1')) == 3:
                    if player_1.field_maybe_none('ans1') != '   ':
                        player_2.pay2 = player_2.pay2 + 0.5


class Solve2(Page):
    form_model = 'player'
    form_fields = ['ans2']
    timeout_seconds = 20

    timer_text = 'Time left to complete this section:'



    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            n1=13,
            n2=12,
            n3=1,
            n4=2
        )


class Wait2_1(WaitPage):
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_2 = player_lists[1]
        player_2.pay = player_2.pay + 0


class Check2(Page):
    form_model = 'player'
    form_fields = ['chk2']
    timeout_seconds = 10




    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        for p in player.get_others_in_group():
            a1 = p.field_maybe_none('ans2')
            c = True
            d = False
            if len(a1) < 3:
                a1 = 'Pass'
                c = False
                d = True
            if a1 == '   ':
                a1 = 'Pass'
                c = False
                d = True
            b1 = a1[0]
            b2 = a1[1]
            b3 = a1[2]
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            a1=a1,
            n1=13,
            n2=12,
            n3=1,
            n4=2,
            b1=b1,
            b2=b2,
            b3=b3,
            c=c,
            d=d
        )


class Wait2(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_1 = player_lists[0]
        player_2 = player_lists[1]
        if player_1.ans2 == '++-':
            player_2.pay = player_2.pay + 1
            if player_2.field_maybe_none('chk2') == 0:
                player_2.pay2 = player_2.pay2 + 1
        else:
            if player_2.field_maybe_none('chk2') == 1:
                if len(player_1.field_maybe_none('ans2')) == 3:
                    if player_1.field_maybe_none('ans2') != '   ':
                        player_2.pay2 = player_2.pay2 + 0.5


class Solve3(Page):
    form_model = 'player'
    form_fields = ['ans3']
    timeout_seconds = 20



    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            n1=10,
            n2=6,
            n3=9,
            n4=4
        )


class Wait3_1(WaitPage):
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_2 = player_lists[1]
        player_2.pay = player_2.pay + 0


class Check3(Page):
    form_model = 'player'
    form_fields = ['chk3']

    timeout_seconds = 10



    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        for p in player.get_others_in_group():
            a1 = p.field_maybe_none('ans3')
            c = True
            d = False
            if len(a1) < 3:
                a1 = 'Pass'
                c = False
                d = True
            if a1 == '   ':
                a1 = 'Pass'
                c = False
                d = True
            b1 = a1[0]
            b2 = a1[1]
            b3 = a1[2]
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            a1=a1,
            n1=10,
            n2=6,
            n3=9,
            n4=4,
            b1=b1,
            b2=b2,
            b3=b3,
            c=c,
            d=d
        )


class Wait3(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_1 = player_lists[0]
        player_2 = player_lists[1]
        if player_1.ans3 == '*-*':
            player_2.pay = player_2.pay + 1
            if player_2.field_maybe_none('chk3') == 0:
                player_2.pay2 = player_2.pay2 + 1
        else:
            if player_2.field_maybe_none('chk3') == 1:
                if len(player_1.field_maybe_none('ans3')) == 3:
                    if player_1.field_maybe_none('ans3') != '   ':
                        player_2.pay2 = player_2.pay2 + 0.5


class Solve4(Page):
    form_model = 'player'
    form_fields = ['ans4']

    timeout_seconds = 20

    # @staticmethod
    # def is_displayed(player):
    #     return get_timeout_seconds(player) > 1


    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            n1=13,
            n2=12,
            n3=3,
            n4=3
        )


class Wait4_1(WaitPage):
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_2 = player_lists[1]
        player_2.pay = player_2.pay + 0


class Check4(Page):
    form_model = 'player'
    form_fields = ['chk4']

    timeout_seconds = 10

    # @staticmethod
    # def is_displayed(player):
    #     return get_timeout_seconds(player) > 1

    @staticmethod
    def live_method(player: Player, data):
        my_id = player.id_in_group
        group = player.group

        if 'text' in data:
            text = data['text']
            msg = Message.create(group=group, sender=player, text=text)
            return {0: [to_dict(msg)]}
        return {my_id: [to_dict(msg) for msg in Message.filter(group=group)]}

    def vars_for_template(player: Player):
        sender = player.id_in_group
        for p in player.get_others_in_group():
            a1 = p.field_maybe_none('ans4')
            c = True
            d = False
            if len(a1) < 3:
                a1 = 'Pass'
                c = False
                d = True
            if a1 == '   ':
                a1 = 'Pass'
                c = False
                d = True
            b1 = a1[0]
            b2 = a1[1]
            b3 = a1[2]
        return dict(
            sender=(sender == 2),
            receiver=(sender == 1),
            a1=a1,
            n1=13,
            n2=12,
            n3=3,
            n4=3,
            b1=b1,
            b2=b2,
            b3=b3,
            c=c,
            d=d
        )


class Wait4(WaitPage):
    @staticmethod
    def after_all_players_arrive(group: Group):
        player_lists = group.get_players()
        player_1 = player_lists[0]
        player_2 = player_lists[1]
        if player_1.ans4 == '+-/':
            player_2.pay = player_2.pay + 1
            if player_2.field_maybe_none('chk4') == 0:
                player_2.pay2 = player_2.pay2 + 1
        else:
            if player_2.field_maybe_none('chk4') == 1:
                if len(player_1.field_maybe_none('ans4')) == 3:
                    if player_1.field_maybe_none('ans4') != '   ':
                        player_2.pay2 = player_2.pay2 + 0.5





class Decide(Page):
    form_model = 'player'
    form_fields = ['pay_divide']

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

    @staticmethod
    def before_next_page(player, timeout_happened):
        for p in player.get_others_in_group():
            p.num_corr = player.pay
            player.num_corr = p.num_corr
            p.pay_divide = player.pay - player.pay_divide
            p.pay = p.pay_divide
            p.num_corr2 = player.pay2
            player.num_corr2 = p.num_corr2
        player.pay = player.pay_divide+player.pay2

    def vars_for_template(player: Player):
        divide = player.pay
        return dict(
            divide=divide
        )

    @staticmethod
    def error_message(player, values):
        a = player.pay
        if values['pay_divide'] > a:
            return 'You cannot choose an amount greater than the group gain.'


class MyWait(WaitPage):
    pass


class Results(Page):
    @staticmethod
    def before_next_page(player: Player, timeout_happened):
        participant = player.participant
        participant.pt8 = player.pay
        participant.mem1 = player.num_corr
        participant.led1 = player.num_corr2


page_sequence = [Inst, Solve1,  Check1, Wait1,
                 Solve2,  Check2, Wait2,
                 Solve3, Check3, Wait3,
                 Solve4, Check4, Wait4,
                 Decide, MyWait, Results]


# page_sequence = [Inst, Assign,
#                  Solve1, Wait1_1, Check1, Wait1,
#                  Solve2, Wait2_1, Check2, Wait2,
#                 # Solve3, Wait3_1, Check3, Wait3,
#                 # Solve4, Wait4_1, Check4, Wait4,
#                 Decide, Results]
# page_sequence = [Inst]