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


def vars_for_all_templates(self):

    price_list= []
    for r in self.subsession.in_previous_rounds():
        for g in r.get_groups():
            if g.round_number < self.session.vars['init_round']: # only include prices from previous markets
                if g.someone_accepted:
                    price_list.append(g.amount_offered)

    if price_list:
        average_price= statistics.mean(price_list)
    else:
        average_price = -10

    if int(self.session.vars['time_series'])==1:
        display_time_series = True
    else:
        display_time_series = False



    return {
        'player_in_market': reversed(self.player.in_rounds(self.session.vars['init_round'], self.group.round_number)),
        'other_players': self.group.get_players(),
        'average_price':round(average_price),
        'price_list': price_list,
        'market_active': self.group.market_ends() == False,
        'display_time_series': display_time_series
    }

#### Round begins,
class RoundBeginsWP(WaitPage):
    template_name = 'walras/WaitPages.html'
    body_text=""

    def after_all_players_arrive(self):

        for p in self.subsession.get_players():
            if self.subsession.period() > 1:
                p.traded=p.participant.vars['traded']
                p.trading_price = p.participant.vars['trading_price']
                # p.set_payoffs()

        # match players and select proposer
        self.group.make_match()

#### Screen for proposer
class Proposal(Page):
    # timeout_seconds = 10

    form_model = 'group'
    #form_fields = ['amount_offered','proposer_pass']
    form_fields = ['amount_offered']

    def is_displayed(self):
        return self.player.proposing() and self.group.market_ends()==False

    #### Error messages if you propose a price that would lose you money
    def amount_offered_error_message(self, value):
        if self.player.role()=='buyer' and value>self.player.value_cost():
            return 'You cannot offer a price higher than your value!'
        if self.player.role()=='seller' and value<self.player.value_cost():
            return 'You cannot offer a price lower than your cost!'

    #### Counterpart information for display
    def vars_for_template(self):

        proposers, responders, secondresponders, showsecondresponders = self.group.create_matchlist(self.player.id_in_group)

        if self.player.role() == 'buyer':
            part_value_cost = self.session.vars['value_cost'][self.group.active_seller - 1]
            second_value_cost = self.session.vars['value_cost'][self.group.active_seller2 - 1]
        else:
            part_value_cost = self.session.vars['value_cost'][self.group.active_buyer - 1]
            second_value_cost = self.session.vars['value_cost'][self.group.active_buyer2 - 1]

        return {'part_value_cost': part_value_cost,
                'second_value_cost': second_value_cost,
                'lb': -10,
                'ub': 110,
                'proposers': proposers,
                'responders': responders,
                'secondresponders': secondresponders,
                'showsecondresponders' : showsecondresponders
        }

#### Screen for responder while waiting for proposal
class WaitForOthersWP(WaitPage):
    template_name = 'walras/WaitPages.html'
    title_text = "Please wait for counterpart to decide. "
    body_text=""
    def is_displayed(self):
        return self.player.active() and self.group.market_ends()==False

#### Have everyone wait in case market is completed so that can show results; also combine accept decisions
class InactiveWP(WaitPage):
    template_name = 'walras/WaitPages.html'
    title_text = "Please wait."
    body_text=""

    def after_all_players_arrive(self):

        self.group.someone_accepted = any([p.offer_accepted for p in self.group.get_players()])

        if self.group.someone_accepted:
            first_accept = [p.offer_accepted for p in self.group.get_players() if p.id_in_group==self.group.first_responder()][0] # should be exactly one match
            for p in self.group.get_players():
                if p.id_in_group==self.group.proposer or (p.id_in_group==self.group.first_responder() and first_accept) or (p.id_in_group==self.group.second_responder() and not first_accept):
                    p.traded = True
                    p.trading_price = self.group.amount_offered
                    p.participant.vars['traded'] = True
                    p.participant.vars['trading_price'] = self.group.amount_offered
                    p.set_payoffs()

#### Screen for responder
class Response(Page):
    # timeout_seconds = 10

    form_model = 'player'
    form_fields = ['offer_accepted','kill_trade']

    def is_displayed(self):
        #return  self.player.responding() and self.group.no_trade()==False and self.group.proposer_pass==False and self.round_number==self.participant.vars['next_round'] and self.group.market_ends()==False
        return self.player.responding() and self.group.market_ends() == False

    #### Counterpart information for display
    def vars_for_template(self):

        proposers, responders, secondresponders, showsecondresponders = self.group.create_matchlist(self.player.id_in_group)

        if self.player.role() == 'buyer':
            part_value_cost = self.session.vars['value_cost'][self.group.active_seller - 1]
        else:
            part_value_cost = self.session.vars['value_cost'][self.group.active_buyer - 1]

        return {'part_value_cost': part_value_cost,
                'proposers': proposers,
                'responders': responders,
                'secondresponders': secondresponders,
                'showsecondresponders' : showsecondresponders
        }

    #### Error messages if you accept a price that would lose you money
    def offer_accepted_error_message(self, value):
        if value==True:
            price=self.group.amount_offered
            if self.player.role()=='buyer' and price>self.player.value_cost():
                return "You cannot accept a price higher than your value!  You must click 'Reject.'"
            if self.player.role()=='seller' and price<self.player.value_cost():
                return "You cannot accept a price lower than your cost!  You must click 'Reject.'"

#### Screen for active subjects who can't trade
#class NoTrade(Page):
#    timeout_seconds = 5
#
#    def is_displayed(self):
#        return self.group.no_trade() and self.player.active() and self.round_number==self.participant.vars['next_round'] and self.participant.vars['traded']==False and self.group.market_ends()==False
#
#    #### Counterpart information for display
#    def vars_for_template(self):
#        if self.player.role() == 'buyer':
#            r = {'part_value_cost': self.session.vars['value_cost'][self.group.active_seller - 1],}
#        else:
#            r = {'part_value_cost': self.session.vars['value_cost'][self.group.active_buyer - 1],}
#        return r

### synchronizes groups and set up grouping for next round
class UpdateWP(WaitPage):
    wait_for_all_groups = True
    template_name = 'walras/WaitPages.html'
    title_text = "Please wait"
    body_text=""

    def after_all_players_arrive(self):

        for g in self.subsession.get_groups():
            # for recording purposes
            g.market_ended = g.market_ends()

            num_traded = sum([p.traded for p in g.get_players()])
            current_first_trade = max([p.participant.vars['first_trade_period'] for p in g.get_players()])
            if num_traded>0 and current_first_trade==0:
                for p in g.get_players():
                    p.participant.vars['first_trade_period'] = g.subsession.period()

        if self.subsession.both_groups_done():

            ### form groups for next round
            self.session.vars['current_market'] = self.session.vars['current_market'] + 1  # increment market (used in forming groups and making matches)
            self.subsession.form_groups(self.round_number + 1,self.round_number+1)

            # add last market's earnings to list and randomly choose markets to pay (for admin report page)
            self.subsession.randomize_payments()

            # reset for new market
            for p in self.subsession.get_players():
                p.participant.vars['market_earn'] = 0
                p.participant.vars['traded'] = False
                p.participant.vars['trading_price'] = -1
                p.participant.vars['saw_results'] = False
                p.participant.vars['first_trade_period'] = 0

            self.session.vars['init_round'] = self.round_number + 1

        else:
            # copy grouping to next round
            for subsession in self.subsession.in_rounds(self.round_number+1,self.round_number+1):
                subsession.group_like_round(self.round_number)

### set up new market
class Results(Page):
    def is_displayed(self):
        return self.group.market_ends() == True and self.participant.vars['saw_results'] == False

    def before_next_page(self):
        self.participant.vars['saw_results'] = True

page_sequence = [
    RoundBeginsWP,
    Proposal,
#    NoTrade,
    WaitForOthersWP,
    Response,
    InactiveWP,
    Results,
    UpdateWP

]