from otree.api import Currency as c, currency_range
from ._builtin import Page, WaitPage
from .models import Constants
import random
from otree_tools.utils import get_time_per_page


class Intro(Page):

    def is_displayed(self):
        return self.round_number == 1

    def vars_for_template(self):
        return {
            'role': self.player.role()
        }


class BOBO(Page):

    def is_displayed(self):
        return self.player.task == 1 and self.player.variant == 1

    form_model = 'player'
    form_fields = ['offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'BOBO'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14]]
            return fields

    def error_message(self, values):
        if values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class lolo(Page):

    def is_displayed(self):
        return self.player.task == 1 and self.player.variant == 2

    form_model = 'player'
    form_fields = ['offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'lolo'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14]]
            return fields

    def error_message(self, values):
        if values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class BOlo(Page):

    def is_displayed(self):
        return self.player.task == 1 and self.player.variant == 3

    form_model = 'player'
    form_fields = ['offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'BOlo'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14]]
            return fields

    def error_message(self, values):
        if values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class DBOBO(Page):

    def is_displayed(self):
        return self.player.task == 2 and self.player.variant == 1

    form_model = 'player'
    form_fields = ['offer_1', 'offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'DBOBO'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1]) + str(fields[2])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14], self.player.order[14:21]]
            return fields

    def error_message(self, values):
        if values['offer_1'] + values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class Dlolo(Page):

    def is_displayed(self):
        return self.player.task == 2 and self.player.variant == 2

    form_model = 'player'
    form_fields = ['offer_1', 'offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'Dlolo'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1]) + str(fields[2])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14], self.player.order[14:21]]
            return fields

    def error_message(self, values):
        if values['offer_1'] + values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class DBOlo(Page):

    def is_displayed(self):
        return self.player.task == 2 and self.player.variant == 3

    form_model = 'player'
    form_fields = ['offer_1', 'offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'DBOlo'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1]) + str(fields[2])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14], self.player.order[14:21]]
            return fields

    def error_message(self, values):
        if values['offer_1'] + values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class DBOBOR(Page):

    def is_displayed(self):
        return self.player.task == 3 and self.player.variant == 1

    form_model = 'player'
    form_fields = ['offer_1', 'offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'DBOBOR'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1]) + str(fields[2])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14], self.player.order[14:21]]
            return fields

    def error_message(self, values):
        if values['offer_1'] + values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class DloloR(Page):

    def is_displayed(self):
        return self.player.task == 3 and self.player.variant == 2

    form_model = 'player'
    form_fields = ['offer_1', 'offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'DloloR'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1]) + str(fields[2])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14], self.player.order[14:21]]
            return fields

    def error_message(self, values):
        if values['offer_1'] + values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class DBOloR(Page):

    def is_displayed(self):
        return self.player.task == 3 and self.player.variant == 3

    form_model = 'player'
    form_fields = ['offer_1', 'offer_2', 'offer_3']

    def before_next_page(self):
#        self.player.set_payoffs()
        self.player.time_spent = str(get_time_per_page(self.player, 'DBOloR'))

    def vars_for_template(self):
        rounds = Constants.num_rounds
        round = self.round_number
        progress = round / rounds * 100
        return {
            'rounds': rounds,
            'round': round,
            'progress': progress
        }

    def get_form_fields(self):
        if self.player.order is None:
            fields = self.form_fields
            random.shuffle(fields)
            self.player.order = str(fields[0]) + str(fields[1]) + str(fields[2])
            return fields
        else:
            fields = [self.player.order[0:7], self.player.order[7:14], self.player.order[14:21]]
            return fields

    def error_message(self, values):
        if values['offer_1'] + values['offer_2'] + values['offer_3'] != Constants.endowment:
            return 'The sum of your offers must equal {}'.format(Constants.endowment)


class ResultsWaitPage(WaitPage):
    def is_displayed(self):
        return self.round_number == Constants.num_rounds


class ReceiverPage(Page):
    def is_displayed(self):
        return self.round_number == Constants.num_rounds
#
    timeout_seconds = 5

    def before_next_page(self):
        self.player.set_payoffs()


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

    def vars_for_template(self):
        if self.player.role() == 'receiver':
            return {
                'role': self.player.role()
            }
        else:
            return {
                'role': self.player.role(),
                'task': self.player.in_round(self.player.r_for_pay).task,
                'variant': self.player.variant2,
                'offer_1': self.player.in_round(self.player.r_for_pay).offer_1,
                'offer_2': self.player.in_round(self.player.r_for_pay).offer_2,
                'offer_3': self.player.in_round(self.player.r_for_pay).offer_3,
                'lottery': self.player.lottery
            }


page_sequence = [
    Intro,
    BOBO,
    lolo,
    BOlo,
    DBOBO,
    Dlolo,
    DBOlo,
    DBOBOR,
    DloloR,
    DBOloR,
    ResultsWaitPage,
    ReceiverPage,
#    AllGroupsWaitPage,
    Results
]