import random
import time

from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect, Http404, HttpResponse
from django.template.response import TemplateResponse
from otree.api import Currency as c, currency_range
from otree.api import widgets
from otree.common import safe_json
from otree.models_concrete import (
    PageCompletion, CompletedSubsessionWaitPage,
    CompletedGroupWaitPage, PageTimeout, UndefinedFormModel,
    ParticipantLockModel, GlobalLockModel, ParticipantToPlayerLookup
)
from otree.views.abstract import get_view_from_url

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


class Main(Page):
    pass

class Introduction(Page):
    def is_displayed(self):
        return self.round_number == 1 and self.player.id_in_group != 3


class CustomPage(Page):
    timeout_seconds = 60
    def is_displayed(self):
        return not self.player.outofthegame and self.extra_is_displayed()

    def extra_is_displayed(self):
        return True

class ProposerWait(Page):
    timeout_seconds = 10
    template_name = 'paradigm/ProposerWait.html'
    def is_displayed(self):
        return self.player.id_in_group == 2


class CustomWaitPage(WaitPage):
    template_name = 'paradigm/CustomWaitPage.html'


class FirstWaitPage(CustomWaitPage):
    group_by_arrival_time = True

class WaitForPlayers(WaitPage):
    group_by_arrival_time = True

class StartWP(CustomWaitPage):
    group_by_arrival_time = True
    template_name = 'paradigm/FirstWaitPage.html'

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

    def vars_for_template(self):
        now = time.time()
        if not self.player.startwp_timer_set:
            self.player.startwp_timer_set = True
            self.player.startwp_time = time.time()
        time_left = self.player.startwp_time + Constants.startwp_timer - now
        return {'time_left': round(time_left)}

    def get_players_for_group(self, waiting_players):
        post_dict = self.request.POST.dict()
        endofgame = post_dict.get('endofgame')
        slowpokes = [p.participant for p in self.subsession.get_players()
                     if p.participant._index_in_pages
                     <= self.index_in_pages]
        if len(slowpokes) <= Constants.players_per_group:
            self.subsession.not_enough_players = True
        if endofgame:
            curplayer = [p for p in waiting_players if p.pk == int(endofgame)][0]
            curplayer.outofthegame = True
            return [curplayer]
        if len(waiting_players) == Constants.players_per_group:
            return waiting_players

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


class Offer(Page):
    form_model = models.Group
    form_fields = ['p2_offered']

    def is_displayed(self):
        return self.player.id_in_group == 2
    # timeout_seconds = 60


class WaitForProposer(WaitPage):
    def is_displayed(self):
        return self.player.id_in_group == 1


class Accept(Page):
    form_model = models.Group
    form_fields = ['offer_accepted']

    def is_displayed(self):
        return self.player.id_in_group == 1
    def vars_for_template(self):
        total_offered = self.group.stimulated_average * Constants.stimulated_players + self.group.p2_offered
        average_offered = total_offered / Constants.players_g2
        return {
            'total_offered': total_offered,
            'average_offered': average_offered
        }

    timeout_seconds = 60


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


class Results(Page):
    # def is_displayed(self):
    #     self.player.id_in_group != 3
    def vars_for_template(self):
        total_offered = self.group.stimulated_average * Constants.stimulated_players + self.group.p2_offered
        average_offered = total_offered / Constants.players_g2
        return {
            'total_offered': total_offered,
            'average_offered': average_offered
        }
    timeout_seconds = 20


class Stimulated(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2
    timeout_seconds = 15

class Fairness(Page):
    form_model = models.Group
    form_fields = ['p2_fairness']
    def is_displayed(self):
        return self.player.id_in_group == 2
    def vars_for_template(self):
        return {
            'fairness_scales': range(1,6)
        }

# for the trust game
class TGInstructions(Page):
    def is_displayed(self):
        return self.player.id_in_group != 1


class TG_Send(Page):

    form_model = models.Group
    form_fields = ['sent_amount']

    def is_displayed(self):
        return self.player.id_in_group == 3


class TG_SendBack(Page):
    form_model = models.Group
    form_fields = ['sent_back_amount']

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

    def vars_for_template(self):
        tripled_amount = self.group.sent_amount * Constants.multiplication_factor

        return {
                'tripled_amount': tripled_amount,
                'prompt':
                    'Please choose an amount from 0 to %s:' % tripled_amount}

    def sent_back_amount_max(self):
        tripled_amount = self.group.sent_amount * Constants.multiplication_factor
        return tripled_amount

class TG_WaitForSender(WaitPage):
    def is_displayed(self):
        self.player.id_in_group == 2


class TGResultsWaitPage(WaitPage):
    def after_all_players_arrive(self):
        self.group.tg_payoffs()
    def is_displayed(self):
        self.player.id_in_group != 1


class TGResults(Page):
    """This page displays the earnings of each player"""

    def vars_for_template(self):
        return {
            'tripled_amount': self.group.sent_amount * Constants.multiplication_factor,
        }
    def is_displayed(self):
        return self.player.id_in_group != 1


page_sequence = [
    # FirstWaitPage,
    Introduction,
    ProposerWait,
    Stimulated,
    Offer,
    WaitForProposer,
    Fairness,
    Accept,
    ResultsWaitPage,
    Results,
    TGInstructions,
    TG_WaitForSender,
    TG_Send,
    TG_SendBack,
    TGResultsWaitPage,
    TGResults,
]