from otree.api import Currency as c, currency_range
from ._builtin import Page, WaitPage
from .models import Constants


class Introduction(Page):

    def is_displayed(self) -> bool:
        return(
            # Show this page only for treatment 2 in round 1
            self.participant.vars['treatment'] == 2 and self.subsession.round_number == 1
        )


class ExecutiveStory(Page):

    def is_displayed(self) -> bool:
        return(
            # Show this page only for treatment 2 in round 1
            self.participant.vars['treatment'] == 2 and self.subsession.round_number == 1
        )


class WaitingForFullGroup(WaitPage):
    template_name = 'TREATMENT_02/WaitingForFullGroup.html'

    def is_displayed(self) -> bool:
        return (
            # Show this page only for treatment 2 in round 1
            self.participant.vars['treatment'] == 2 and self.subsession.round_number == 1
        )

    def vars_for_template(self):
        # Get: All collected arguments
        arguments_table = self.player.get_arguments_for_template()
        # Return: Collected arguments
        return dict(
            arguments_table=arguments_table.items()
        )

    def after_all_players_arrive(self):
        # Get: Groups start time
        groups_start_time = self.subsession.get_current_timestamp()
        # Get: All players in group
        players = self.group.get_players()
        # Loop: All players in the group
        for p in players:
            # Set: Groups start time for all members
            p.participant.vars['argument_collecting_start_time'] = groups_start_time


class CollectArguments(Page):
    form_model = 'player'
    form_fields = [
        'ARGUMENT_TYPE',
        'PRO_ARG_TEXT',
        'CON_ARG_TEXT'
    ]

    def is_displayed(self) -> bool:
        return(
            # Show this page only for treatment 2 AND
            self.participant.vars['treatment'] == 2 and
            # Player who is next argument collector AND
            self.participant.vars['is_next_argument_collector'] and
            # Argument collecting time isn't over
            not self.participant.vars['argument_collecting_time_is_over']
        )

    def get_timeout_seconds(self):
        # Get: Remaining time
        remaining_time = self.participant.vars['argument_collecting_start_time'] + \
                         Constants.argument_collecting_time - \
                         self.subsession.get_current_timestamp()
        # Get: Time for player
        time_for_player = 120 if remaining_time >= 120 else remaining_time
        # Return: Time for player
        return(
            time_for_player
        )

    def vars_for_template(self):
        # Get: All collected arguments
        arguments_table = self.player.get_arguments_for_template()
        # Return: Collected arguments
        return dict(
            arguments_table=arguments_table.items()
        )

    def before_next_page(self):
        # Set: Error message for pro argument to false
        self.participant.vars['pro_argument_is_empty_error'] = False
        # Set: Error message for contra argument to false
        self.participant.vars['con_argument_is_empty_error'] = False

        # Check: Is the time over?
        if self.participant.vars['argument_collecting_start_time'] + \
                Constants.argument_collecting_time - self.subsession.get_current_timestamp() <= 0:
            # Loop: All players in group
            for p in self.group.get_players():
                # Set: Argument collecting time is over
                p.participant.vars['argument_collecting_time_is_over'] = True

        # Check: Is the submit button for a pro argument pressed?
        if self.player.ARGUMENT_TYPE == 'PRO':
            # Set: Contra argument text to empty
            self.player.CON_ARG_TEXT = ''

            # Check: Is the pro argument empty?
            if self.player.PRO_ARG_TEXT.strip() == '':
                # Set: Pro argument text to empty
                self.player.PRO_ARG_TEXT = ''
                # Set: Error message to true
                self.participant.vars['pro_argument_is_empty_error'] = True
            else:
                # Increase: Pro argument counter
                self.participant.vars['pro_argument_counter'] += 1
                # Data base: Add argument number
                self.player.ARGUMENT_NUMBER = 2 * self.participant.vars['pro_argument_counter'] - 1

        # Check: Is the submit button for a contra argument pressed?
        elif self.player.ARGUMENT_TYPE == 'CONTRA':
            # Set: Pro argument text to empty
            self.player.PRO_ARG_TEXT = ''

            # Check: Is the pro argument empty?
            if self.player.CON_ARG_TEXT.strip() == '':
                # Set: Pro argument text to empty
                self.player.CON_ARG_TEXT = ''
                # Set: Error message to true
                self.participant.vars['con_argument_is_empty_error'] = True
            else:
                # Increase: Pro argument counter
                self.participant.vars['con_argument_counter'] += 1
                # Data base: Add argument number
                self.player.ARGUMENT_NUMBER = 2 * self.participant.vars['con_argument_counter']

        # In case of time out or next button
        else:
            # Set: Pro and contra argument text to empty
            self.player.PRO_ARG_TEXT = ''
            self.player.CON_ARG_TEXT = ''

        # Check: Is there an error on this page?
        if self.participant.vars['pro_argument_is_empty_error'] or \
           self.participant.vars['con_argument_is_empty_error']:
            # Stay on this page
            self._is_frozen = False
            self._index_in_pages -= 1
            self.participant._index_in_pages -= 1
        else:
            # Data base: Add argument is from
            self.player.ARGUMENT_FROM_PLAYER = 'P' + str(self.participant.vars['original_id'])
            # Set: Next argument collector to false for this player
            self.participant.vars['is_next_argument_collector'] = False
            # Set: Next player to argument collector
            self.player.set_next_player_to_argument_collector()

            # Check: Is argument type empty?
            if self.player.ARGUMENT_TYPE is None:
                # Set: Argument type to time out
                self.player.ARGUMENT_TYPE = 'TIMEOUT'

            # Loop: All other players in group
            for p in self.player.get_others_in_group():
                # Data base: Add argument is from
                p.ARGUMENT_FROM_PLAYER = self.player.ARGUMENT_FROM_PLAYER
                # Data base: Add argument number
                p.ARGUMENT_NUMBER = self.player.ARGUMENT_NUMBER
                # Data base: Add argument type
                p.ARGUMENT_TYPE = self.player.ARGUMENT_TYPE
                # Data base: Add argument text
                p.PRO_ARG_TEXT = self.player.PRO_ARG_TEXT
                p.CON_ARG_TEXT = self.player.CON_ARG_TEXT
                # Copy: Pro and contra argument counter
                p.participant.vars['pro_argument_counter'] = self.participant.vars['pro_argument_counter']
                p.participant.vars['con_argument_counter'] = self.participant.vars['con_argument_counter']


class WaitingForArgumentCollector(WaitPage):
    template_name = 'TREATMENT_02/WaitingForArgumentCollector.html'

    def is_displayed(self) -> bool:
        return (
            # Show this page only for treatment 2 if argument collecting time isn't over
            self.participant.vars['treatment'] == 2 and not self.participant.vars['argument_collecting_time_is_over']
        )

    def vars_for_template(self):
        # Get: All collected arguments
        arguments_table = self.player.get_arguments_for_template()
        # Get: Left time
        left_time = int(
            self.participant.vars['argument_collecting_start_time'] +
            Constants.argument_collecting_time -
            self.subsession.get_current_timestamp()
        )
        # Save: Left time for javascript
        left_time_for_js = left_time
        # Get: Left minutes
        left_minutes = int(left_time/60)
        # Get: Left seconds
        left_seconds = left_time % 60
        # Edit: Left seconds
        left_seconds = left_seconds if left_seconds >= 10 else "0" + str(left_seconds)
        # Return: Collected arguments
        return dict(
            arguments_table=arguments_table.items(),
            left_time=str(left_minutes) + ":" + str(left_seconds),
            left_time_for_js=left_time_for_js
        )


class MostConvincingArguments(Page):
    form_model = 'player'
    form_fields = [
        'MOST_CONV_PRO_ARG',
        'MOST_CONV_CON_ARG'
    ]

    def is_displayed(self) -> bool:
        return(
            # Show this page only for treatment 2 in last round WHEN
            self.participant.vars['treatment'] == 2 and self.subsession.round_number == Constants.num_rounds and
            # There is at least one argument
            (self.participant.vars['pro_argument_counter'] > 0 or self.participant.vars['con_argument_counter'] > 0)
        )

    def vars_for_template(self):
        # Get: All collected arguments
        arguments_table = self.player.get_arguments_for_template()
        # Return: Collected arguments
        return dict(
            arguments_table=arguments_table.items()
        )


page_sequence = [
    Introduction,
    ExecutiveStory,
    WaitingForFullGroup,
    CollectArguments,
    WaitingForArgumentCollector,
    MostConvincingArguments
]