from otree.api import (
    models, widgets, BaseConstants, BaseSubsession, BaseGroup, BasePlayer,
    Currency as c, currency_range
)
import random
from decimal import Decimal


from otree.models import player
from decimal import Decimal as D
import itertools

def generate(mean,players,upper):
    list = []
    listsum = 0
    for i in range(players - 1):
        generated = random.randrange(0,upper,10)
        listsum += generated
        generate_c = c(generated)
        list.append(generate_c)
    if listsum > mean*players or listsum < (mean*players-upper):
        return generate(mean,players,upper)
    else:
        last_int = mean*players - listsum
        list.append(c(last_int))
    return list


class Constants(BaseConstants):
    name_in_url = 'UG'
    num_rounds = 1

    # startwp_timer = 10

    real_g1 = 1
    real_g2 = 1
    stimulated_players = 6
    players_g2 = real_g2 + stimulated_players
    players_per_group = real_g1 + real_g2

    endowment = c(100)
    total_endowment = endowment * players_g2
    payoff_if_rejected = c(0)
    offer_increment = c(10)
    offer_choices = currency_range(0, endowment, offer_increment)

    pro_mean = 60
    anti_mean = 20


class Subsession(BaseSubsession):
    def before_session_starts(self):
        # randomize to treatments
        for group in self.get_groups():
            group.antisocial_group = random.choice([True, False])

    def creating_session(self):
        treatments = itertools.cycle([True, False])
        for p in self.get_groups():
            p.antisocial_group = next(treatments)

def question(amount):
    return 'Would you accept an offer of {}?'.format(c(amount))




class Group(BaseGroup):
    antisocial_group = models.BooleanField(
        doc="""Whether this group is prosocial"""
    )

    offer_accepted = models.BooleanField(
        doc="if offered amount is accepted"
    )

    amount_offered = []
    p2_offered = models.CurrencyField(min=0, max=Constants.endowment,
                                      choices=(c(0), c(10), c(20), c(30), c(40), c(50), c(60), c(70), c(80), c(90), c(100)),
                                      widget=widgets.RadioSelectHorizontal())
    p2_fairness = models.PositiveIntegerField(choices=range(1, 6, 1), widget=widgets.RadioSelectHorizontal())
    amount_offered.append(p2_offered)

    anti_stimulated = generate(Constants.anti_mean, Constants.stimulated_players, Constants.endowment)
    print(anti_stimulated)
    amount_offered.extend(anti_stimulated)
    if antisocial_group:
        anti_stimulated = generate(Constants.anti_mean, Constants.stimulated_players, Constants.endowment)
        amount_offered.extend(anti_stimulated)
    else:
        pro_stimulated = generate(Constants.pro_mean, Constants.stimulated_players, Constants.endowment)
        amount_offered.extend(pro_stimulated)

    p3_offered = amount_offered[1]
    p4_offered = amount_offered[2]
    p5_offered = amount_offered[3]
    p6_offered = amount_offered[4]
    p7_offered = amount_offered[5]
    p8_offered = amount_offered[6]


    stimulated_sum = 0
    for i in range(Constants.stimulated_players):
        stimulated_sum += amount_offered[i+1]

    stimulated_average = stimulated_sum / Constants.stimulated_players


    def set_payoffs(self):
        p1, p2 = self.get_players()
        total_offered = self.p2_offered + self.p3_offered + self.p4_offered + self.p5_offered + self.p6_offered \
                        + self.p7_offered + self.p8_offered + self.p9_offered + self.p10_offered + self.p11_offered \
                        + self.p12_offered

        if self.offer_accepted:
            p1.payoff = total_offered / Constants.players_g2
            p2.payoff = Constants.endowment - self.p2_offered

        else:
            p1.payoff = Constants.payoff_if_rejected
            p2.payoff = Constants.payoff_if_rejected


class Player(BasePlayer):
    def role(self):
        if self.id_in_group == 1:
            return 'g1'
        else:
            return 'g2'

    startwp_timer_set = models.BooleanField(default=False)
    startwp_time = models.PositiveIntegerField()
    outofthegame = models.BooleanField()

    # def get_ug_decision(self):
    #     return self.participant.vars['ug']= self.group.p2_offered