from . import models
from ._builtin import Page, WaitPage
from .models import Constants


class Introduction(Page):
    def is_displayed(self):
        return self.subsession.round_number == 1

class LeaderInstruction(Page):
        def is_displayed(self):
            return self.player.role() == 'leader' and self.subsession.round_number == 1


        pass

class Leadercheck(Page):
        def is_displayed(self):
             return self.player.role() == 'leader' and self.subsession.round_number == 1

        form_model = models.Player
        form_fields = ['leadercheck']

        def error_message(self, values):
            if values["leadercheck"] != 'Group Leader':
                return 'Wrong! You will only be playing the Group Leader role for the upcoming rounds!'

        pass


class Membercheck(Page):
    def is_displayed(self):
        return self.player.role() != 'leader' and self.subsession.round_number == 1

    form_model = models.Player
    form_fields = ['membercheck']

    def error_message(self, values):
        if values["membercheck"] != 'Group Member':
            return 'Wrong! You will only be playing the Group Member role for the upcoming rounds!'

    pass

class After2(Page):
    def is_displayed(self):
        return self.subsession.round_number == 1
    pass


class MemberInstruction(Page):
        def is_displayed(self):
            return self.player.role() != 'leader' and self.subsession.round_number == 1



        pass


class GroupingWaitPage(WaitPage):
    # group_by_arrival_time = True
    wait_for_all_groups = True

    # def get_players_for_group(self, waiting_players):
    def after_all_players_arrive(self):
        self.subsession.create_groups()
        return
        print('in get_players_for_group, len(par.get_players)= %d'%len(self.subsession.get_players()))
        leader_players = [p for p in self.subsession.get_players() if p.participant.vars['type'] == 'dominant'
                          or p.participant.vars['type'] == 'non-dominant']
        print([p.participant.vars['type'] for p in leader_players])

        domtype = [p.participant.vars['type'] for p in leader_players]
        print('current nubmer of groups: %d' % len(self.subsession.get_groups()))
        print(domtype)

        if self.round_number > 1:
            r_number = self.round_number - 1
            leader_players = leader_players[r_number:0] + [leader_players[0:r_number]]

        #if self.subsession.round_number == 2:
         #   leader_players = leader_players[1:]+[leader_players[0]]
          #  print('round 2')
        #elif self.subsession.round_number ==3:
         #   leader_players = leader_players[2:] + leader_players[0:2]
          #  print('round 3')
        #elif self.subsession.round_number ==4:
         #   leader_players = leader_players[3:] + leader_players[0:3]
          #  print('round 4')

        n_number = 3
        member_counter = 0
        groupi = 0
        for p in self.get_players():

            if p.participant.vars['type'] == 'member':
                member_counter += 1
                p.participant.vars['memberleadtype'] = domtype[groupi]
                if member_counter % n_number == 0:
                    groupi += 1

        member_players = [p for p in self.subsession.get_players() if p.participant.vars['type'] == 'member']

        group_matrix = []

        # pop elements from M_players until it's empty
        while member_players:
            new_group = [
                member_players.pop(),
                member_players.pop(),
                member_players.pop(),
                leader_players.pop(),
            ]
            group_matrix.append(new_group)

        self.set_group_matrix(group_matrix)

        #if len(leader_players) >= 1 and len(member_players) >= 1:
         #   print('about to create a group')
          #  return [leader_players[0], member_players[0]]
        #print('not enough players to create a group')

# this page is only display for member, this is the first member contribution page
class MemberContribute(Page):
    def is_displayed(self):
        return self.player.role() != 'leader'

    def vars_for_template(self):
        return self.group.leaderdom()

    form_model = models.Player
    form_fields = ['member_contribute']


class SimpleWaitPage2(WaitPage):
    pass


class LeaderContribute(Page):
    def is_displayed(self):
        return self.player.role() == 'leader'

    form_model = models.Player
    form_fields = ['leader_contribute']


class SimpleWaitPage(WaitPage):
    def after_all_players_arrive(self):
        self.group.current()
    pass


# class Purchase(Page):
#     def is_displayed(self):
#         return self.player.role() == 'leader'
#
#     form_model = models.Group
#     form_fields = ['member_id']

# this is leader's decision page for take away points of members.
class LeaderDecision(Page):
    def is_displayed(self):
        return self.player.role() == 'leader'

    def vars_for_template(self):
        return self.group.current()

    form_model = models.Group
    form_fields = ['decision_member1', 'decision_member2', 'decision_member3']

    def error_message(self, values):
        if values["decision_member1"] + values["decision_member2"] + values["decision_member3"] > 120:
            return 'You can only remove up to 120 points for all three Group Members combined!'


class ResultsWaitPage(WaitPage):
    def after_all_players_arrive(self):
        self.group.set_payoffs()


class Results(Page):
    def vars_for_template(self):
        return self.group.set_payoffs()


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

    # def vars_for_template(self):
    #     return self.subsession.vars_for_admin_report()


page_sequence = [
    GroupingWaitPage,
    #After2,
    #LeaderInstruction,
    #MemberInstruction,
    #Leadercheck,
    #Membercheck,
    LeaderContribute,
    # simpleWaitPage2,
    MemberContribute,
    SimpleWaitPage,
    LeaderDecision,
    ResultsWaitPage,
    Results,
    # FinalResults,
]