from otree.api import Currency as c, currency_range
from ._builtin import Page, WaitPage
from . import models
from .models import Constants, Player
from otree.common import safe_json
from otree.views.abstract import get_view_from_url
from otree.api import widgets
import random
from django.http import HttpResponseRedirect, Http404, HttpResponse
from django.template.response import TemplateResponse
from django.core.urlresolvers import reverse
from otree.models_concrete import (
    PageCompletion, CompletedSubsessionWaitPage,
    CompletedGroupWaitPage, PageTimeout, UndefinedFormModel,
    ParticipantLockModel, GlobalLockModel, ParticipantToPlayerLookup
)
import time
import channels
import json
from .consumers import get_group_name
import numpy as np


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

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 CustomWaitPage(WaitPage):
    template_name = 'UG/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 = 'UG/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(CustomWaitPage):
    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.p2_offered + self.group.p3_offered + self.group.p4_offered + self.group.p5_offered \
                        + self.group.p6_offered + self.group.p7_offered + self.group.p8_offered + self.group.p9_offered \
                        + self.group.p10_offered + self.group.p11_offered + self.group.p12_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):
    pass
    # def vars_for_template(self):
    #     player_in_all_rounds = self.player.in_all_rounds()
    #     cumulative_payoff = sum([p.payoff for p in player_in_all_rounds])
    #     return {
    #         'player_in_all_rounds': player_in_all_rounds,
    #         'cumulative_payoff': cumulative_payoff,
    #     }
    # timeout_seconds = 20

class Stimulated1(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2
    timeout_seconds = 5

class Stimulated2(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2
    timeout_seconds = 5

class Stimulated3(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2
    timeout_seconds = 5

class Stimulated4(Page):
    def is_displayed(self):
        return self.player.id_in_group == 2
    timeout_seconds = 5

class Fairness(Page):
    form_model = models.Group
    form_fields = ['p2_fairness']
    def is_displayed(self):
        return self.player.id_in_group == 2

page_sequence = [
    FirstWaitPage,
    # StartWP,
    # WaitForPlayers,
    Introduction,
    # CustomWaitPage,
    Stimulated1,
    Stimulated2,
    Stimulated3,
    Stimulated4,
    Offer,
    WaitForProposer,
    Fairness,
    Accept,
    ResultsWaitPage,
    Results,
]