from otree.api import *
import random, math, time


doc = """
Your app description
"""


class C(BaseConstants):
    NAME_IN_URL = 'Main2'
    
    # Session size constants
    PLAYERS_PER_GROUP = 5
    ROUNDS_PER_BLOCK  = 10 #2 # original 10
    ROUNDS_DEMO       = 5  #1 # original 5
    NUM_ENDROUND2     = ROUNDS_PER_BLOCK + ROUNDS_DEMO #wb
    NUM_BLOCKS        = 2  # original 2
    NUM_ROUNDS        = ROUNDS_PER_BLOCK * NUM_BLOCKS + ROUNDS_DEMO
    
    # EC constants
    PLAYER_INITIAL_INCOME = 1000
    PLAYER_CONVERSION     =  1/10 # original 10/1000 #wb: mail Oana: The new conversion rate is: 10EC is 1 EURO to payment in cash
    GOVERN_INITIAL_DEBT   = 2500
    GOVERN_INCOME_RANGE   = [-250, 250]
    DEFAULT_PENALTY       = 30/100
    SHOW_UP_FEE           = 7 #5
    
    # Bonds table
    PURCHASE_PRICE_BOND = [1.00, 0.95, 0.90, 0.85, 0.80, 0.75, 0.70]
    AMOUNT_PAID_BACK    = [1,    1,    1,    1,    1,    1,    1   ]
    RETURN_INVESTMENT   = [0.00, 0.05, 0.10, 0.15, 0.20, 0.25, 0.30]
    
    # Timeouts
    TIMEOUT_INTRO    = 30
    TIMEOUT_MAIN_1   = 180 # 300
    TIMEOUT_MAIN_2   = 120 # 200
    ALERT_MAIN       = 100 # 180
    TIMEOUT_FEEDBACK_1 = 30
    TIMEOUT_FEEDBACK_2 = 30 #30
    TIMEOUT_DROPPED  = 20
    

class Subsession(BaseSubsession):
    period        = models.IntegerField()
    period_length = models.IntegerField()
    round         = models.IntegerField()

class Group(BaseGroup):
    player_income         = models.FloatField(initial=0.0)
    player_next_income    = models.FloatField(initial=0.0)
    government_debt       = models.FloatField(initial=0.0)
    government_last_debt  = models.FloatField(initial=0.0)
    government_next_debt  = models.FloatField(initial=0.0)
    government_income     = models.FloatField(initial=0.0)
    default_limit         = models.FloatField(initial=0.0)
    default_limit_reached = models.FloatField(initial=0.0)
    defaulted_this_round  = models.IntegerField(initial=0)
    defaulted_last_round  = models.IntegerField(initial=0)

    sum_input01 = models.IntegerField(initial=0)
    sum_input02 = models.IntegerField(initial=0)
    sum_input03 = models.IntegerField(initial=0)
    sum_input04 = models.IntegerField(initial=0)
    sum_input05 = models.IntegerField(initial=0)
    sum_input06 = models.IntegerField(initial=0)
    sum_input07 = models.IntegerField(initial=0)
    
    sum_bought01 = models.IntegerField(initial=0)
    sum_bought02 = models.IntegerField(initial=0)
    sum_bought03 = models.IntegerField(initial=0)
    sum_bought04 = models.IntegerField(initial=0)
    sum_bought05 = models.IntegerField(initial=0)
    sum_bought06 = models.IntegerField(initial=0)
    sum_bought07 = models.IntegerField(initial=0)
    
    total_bought = models.IntegerField(initial=0)
    
    value01 = models.FloatField(initial=0.0)
    value02 = models.FloatField(initial=0.0)
    value03 = models.FloatField(initial=0.0)
    value04 = models.FloatField(initial=0.0)
    value05 = models.FloatField(initial=0.0)
    value06 = models.FloatField(initial=0.0)
    value07 = models.FloatField(initial=0.0)
    
    total_value = models.FloatField(initial=0.0)

class Player(BasePlayer):
    player_dropped        = models.IntegerField(initial=0)
    player_income      = models.FloatField(initial=0.0)
    player_next_income = models.FloatField(initial=0.0)
    total_earned       = models.FloatField(initial=0.0)
    invested           = models.FloatField(initial=0.0)
    paid_period        = models.IntegerField(initial=0)
    paid_round         = models.IntegerField(initial=0)
    points_to_pay      = models.FloatField(initial=0.0)
    money_to_pay       = models.FloatField(initial=0.0)
    money_with_fee     = models.FloatField(initial=0.0)
    
    input01 = models.IntegerField(initial=0)
    input02 = models.IntegerField(initial=0)
    input03 = models.IntegerField(initial=0)
    input04 = models.IntegerField(initial=0)
    input05 = models.IntegerField(initial=0)
    input06 = models.IntegerField(initial=0)
    input07 = models.IntegerField(initial=0)
    
    sum_input = models.IntegerField(initial=0)
    
    bought01 = models.IntegerField(initial=0)
    bought02 = models.IntegerField(initial=0)
    bought03 = models.IntegerField(initial=0)
    bought04 = models.IntegerField(initial=0)
    bought05 = models.IntegerField(initial=0)
    bought06 = models.IntegerField(initial=0)
    bought07 = models.IntegerField(initial=0)
    
    sum_bought = models.IntegerField(initial=0)
    
    earned01 = models.FloatField(initial=0.0)
    earned02 = models.FloatField(initial=0.0)
    earned03 = models.FloatField(initial=0.0)
    earned04 = models.FloatField(initial=0.0)
    earned05 = models.FloatField(initial=0.0)
    earned06 = models.FloatField(initial=0.0)
    earned07 = models.FloatField(initial=0.0)
    
    sum_earned = models.FloatField(initial=0.0)
    
    timer_end = models.IntegerField(initial=0)

    q1 = models.StringField(
        choices=[['a', 'a.   2500 ECUs'], ['b', 'b.   1500 ECUs'], ['c', 'c.   1000 ECUs']],
        label='1.	Quelle est votre dotation au début de chaque période du jeux (avant un éventuel défaut) ?',
        widget=widgets.RadioSelect,
    )

    q2 = models.StringField(
        choices=[['a', 'a.  2500 ECUs'], ['b', 'b. 1500 ECUs'], ['c', 'c.   1000 ECUs']],
        label='2.	Quel est le niveau initial de la dette publique ? (à la première période de chaque phase)',
        widget=widgets.RadioSelect,
    )

    q3 = models.StringField(
        choices=[['a', 'a.  40 ECUs'], ['b', 'b.  50 ECUs'], ['c', 'c. 1040 ECUs']],
        label='3.	Si pas de défaut, une obligation vous rapporte 1 ECU '
              'en fin de période. Si vous pouvez utiliser une partie de votre dotation '
              'pour acheter 100 obligations à 0.70 et 100 obligations à 0.90, votre gain '
              'pour cette période est :',
        widget=widgets.RadioSelect,
    )

    q4 = models.StringField(
        choices=[['a', 'a.  800 ECUs'], ['b', 'b.   200 ECUs'], ['c', 'c.   1800 ECUs']],
        label='4.	Supposons que la période 5 de la phase 2 a été tirée au sort pour '
              'être payée à la fin de l’expérience, et que dans cette période vous avez '
              'acheté 1000 obligations au prix de 0.80 ECUs. Quel est votre gain final (hors participation) ? ',
        widget=widgets.RadioSelect,
    )

    q5 = models.StringField(
        choices=[['a', "a.    Celles qui proposent le prix le plus élevé (soit le taux d'intérêt le plus bas)"],
                 ['b', "b.    Celles qui proposent le prix le plus bas (les taux d'intérêt ou le coût le plus élevé)"]],
        label='5.	Supposons qu’à une période t la dette à financer s’élève à 4000 ECUs. Tous les cinq '
              'membres du groupe souhaitent investir. La demande totale d’obligations correspond à 5000 ECUs, '
              'ce qui dépasse l’offre. Quelles demandes seront servies en premier ? ',
        widget=widgets.RadioSelect,
    )

    q6 = models.StringField(
        choices=[['a',
                  'a.  Le gouvernement fait défaut car il ne peut pas financer sa dette ; les investisseurs ne gagnent rien pour cette période'],
                 ['b', 'b.  Chacun gagnera 300 ECUS (1000 * (1 - 0.7))']],
        label="6.	Supposons que la dette est de 4000 ECUs, chacun des cinq investisseurs "
              "propose d'acheter 1000 obligations à un prix/obligation 0.70 pour un total de "
              "3500 ECUs (1000 * 0.7 * 5 investisseurs). "
              "Que se passera-t-il ? ",
        widget=widgets.RadioSelect,
    )

    risk = models.IntegerField(widget=widgets.RadioSelectHorizontal,
                               choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                               label="Veuillez sélectionner une option dans l'échelle ci-dessous, où la valeur 0 signifie : « pas du tout disposé à prendre des risques » et la valeur 10 signifie : « très disposé à prendre des risques ».", )
    compete = models.IntegerField(widget=widgets.RadioSelectHorizontal,
                                  choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                                  label="Veuillez sélectionner une option dans l'échelle ci-dessous, où la valeur 0 signifie : « aucune expérience » et la valeur 10 signifie : « expérience substantielle ». ", )
    satisfaction = models.IntegerField(widget=widgets.RadioSelectHorizontal,
                                       choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                                       label="Veuillez sélectionner une option sur l'échelle ci-dessous, où la valeur 0 signifie :  « totalement insatisfait » et la valeur 10 signifie : « entièrement satisfait».", )

    financeknowledge = models.IntegerField(widget=widgets.RadioSelectHorizontal,
                               choices=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
                               label="Veuillez sélectionner une option sur l'échelle ci-dessous, où la valeur 0 signifie :  « aucune connaissance » et la valeur 10 signifie : « connaissances approfondies ».", )

    age = models.IntegerField(label='Quel est votre âge', min=13, max=100)

    gender = models.StringField(
        choices=[['Male', 'Homme'], ['Female', 'Femme'], ['Prefer not to say', 'Je préfère ne pas le dire']],
        label='What is your gender?',
        widget=widgets.RadioSelect,
    )

    degree = models.StringField(
        choices=[['Bachelor', 'Licence'], ['Master', 'Master'], ['PhD', 'Doctorat'], ['Other', 'Other']],
        label='Program currently enrolled in: ',
    )

    admin = models.StringField(
        choices=[['Science', 'Science'], ['Economics', 'Economie'], ['Finance', 'Finance'],
                 ['Management and Business Administration', 'Gestion et administration des affaires'],
                 ['Other', 'Autre']],
        label='Specialty/Major: ',
    )

#########
# PAGES #
#########

class P01_intro(Page):
    def is_displayed(player):
        return player.subsession.period == 1
        
    def get_timeout_seconds(player):
        if player.player_dropped == 1:
            return C.TIMEOUT_DROPPED
        else:
            return C.TIMEOUT_INTRO
        
    def vars_for_template(player: Player):
        return dict(
            round   = player.subsession.round,
            rounds  = C.NUM_BLOCKS + 1,
            period  = player.subsession.period,
            periods = player.subsession.period_length
        )

class Wait_main(WaitPage):
    title_text = "Please wait"
    body_text  = "Waiting for the other participants."

    def after_all_players_arrive(group: Group):
        set_main_vars(group)

class P02_main(Page):
    form_model = 'player'
    form_fields = ['input01', 'input02', 'input03', 'input04', 'input05', 'input06', 'input07']

    #def get_timeout_seconds(player):
    #    if player.player_dropped == 1:
    #        return C.TIMEOUT_DROPPED
    #    else:
    #        if player.subsession.round == 1:
    #            return C.TIMEOUT_MAIN_1
    #        else:
    #            return C.TIMEOUT_MAIN_2

    def vars_for_template(player: Player):
        labels, debt_level, max_debt = gen_graph_data(player.group)
        
        if player.subsession.round == 1:
            if player.timer_end == 0:
                player.timer_end = int(time.time()) + C.TIMEOUT_MAIN_1
            timeout_main = player.timer_end - int(time.time())
            alert_main = timeout_main - C.ALERT_MAIN
            
        else:
            if player.timer_end == 0:
                player.timer_end = int(time.time()) + C.TIMEOUT_MAIN_2
            timeout_main = player.timer_end - int(time.time())
            alert_main = timeout_main - C.ALERT_MAIN
    
        return dict(
            pid                  = player.participant.id,
            round                = player.subsession.round,
            rounds               = C.NUM_BLOCKS + 1,
            period               = player.subsession.period,
            periods              = player.subsession.period_length,
            player_dropped       = player.player_dropped,
            player_income        = player.player_income,
            government_last_debt = player.group.government_last_debt,
            government_income    = player.group.government_income,
            government_debt      = player.group.government_debt,
            labels               = labels,
            debt_level           = debt_level,
            max_debt             = max_debt,
            alert_main           = alert_main,
            timeout_main         = timeout_main
        )

    def error_message(player, values):
        prices  = C.PURCHASE_PRICE_BOND
        inputs = [values['input01'], values['input02'], values['input03'], values['input04'], values['input05'], values['input06'], values['input07']]
        total  = 0
        for price, input in zip(prices, inputs):
            total = total + price * input
        if total > player.player_income:
            return 'Please input a valid quantity of bonds'
            
    #def before_next_page(player, timeout_happened):
    #    if timeout_happened:
    #        player.player_dropped = 1
    #    if player.player_dropped == 1:
    #        player.input01 = 0
    #        player.input02 = math.floor( player.player_income / C.PURCHASE_PRICE_BOND[1] )
    #        player.input03 = 0
    #        player.input04 = 0
    #        player.input05 = 0
    #        player.input06 = 0
    #        player.input07 = 0

# wb:
class P012_Questionnaire(Page):
    form_model = 'player'
    form_fields = ['q1', 'q2', 'q3', 'q4', 'q5', 'q6']

    def is_displayed(player):
        return player.subsession.round == 1 and player.subsession.period == 5

    def error_message(self, values):
        print('values is', values)
        if values['q1'] != 'c':
            return 'Merci de corriger votre réponse 1 !!'
        elif values['q2'] != 'a':
            return 'Merci de corriger votre réponse 2 !!'
        elif values['q3'] != 'a':
            return 'Merci de corriger votre réponse 3 !!'
        elif values['q4'] != 'b':
            return 'Merci de corriger votre réponse 4 !!'
        elif values['q5'] != 'a':
            return 'Merci de corriger votre réponse 5 !!'
        elif values['q6'] != 'a':
            return 'Merci de corriger votre réponse 6 !!'

class P013_Welcome(Page):
    def is_displayed(player):
        return player.subsession.round == 1 and player.subsession.period == 5



class P021_endround(Page):
    form_model = 'player'
    form_fields = []
    def is_displayed(player):
        return (player.subsession.round == 1 and player.subsession.period == 5) or \
               (player.subsession.round == 2 and player.subsession.period == 10) #C.ROUNDS_DEMO # C.NUM_ENDROUND2


    def vars_for_template(player: Player):
        return dict(
            round   = player.subsession.round,
            period  = player.subsession.period,
            periods = player.subsession.period_length
        )
#wb (end)

class Wait_feedback(WaitPage):
    title_text = "Please wait"
    body_text  = "Waiting for the other participants."

    def after_all_players_arrive(group: Group):
        set_feedback_vars(group)

class P03_feedback(Page):
    # ----------------------------------------- wb: attention !! à réactiver
    def get_timeout_seconds(player):
        if player.player_dropped == 1:
            return C.TIMEOUT_DROPPED
        else:
            if player.subsession.round == 1:
                return C.TIMEOUT_FEEDBACK_1
            else:
                return C.TIMEOUT_FEEDBACK_2

    def vars_for_template(player: Player):
        group = player.group
        player_bids          = [player.input01,     player.input02,     player.input03,     player.input04,     player.input05,     player.input06,     player.input07]
        player_purchased     = [player.bought01,    player.bought02,    player.bought03,    player.bought04,    player.bought05,    player.bought06,    player.bought07]
        player_gain          = [player.earned01,    player.earned02,    player.earned03,    player.earned04,    player.earned05,    player.earned06,    player.earned07]
        government_purchased = [group.sum_bought01, group.sum_bought02, group.sum_bought03, group.sum_bought04, group.sum_bought05, group.sum_bought06, group.sum_bought07]
        government_value     = [group.value01,      group.value02,      group.value03,      group.value04,      group.value05,      group.value06,      group.value06]
        return dict(
            round                      = player.subsession.round,
            rounds                     = C.NUM_BLOCKS + 1,
            period                     = player.subsession.period,
            periods                    = player.subsession.period_length,
            defaulted_this_round       = player.group.defaulted_this_round,
            player_dropped             = player.player_dropped,
            player_bids                = player_bids,
            player_purchased           = player_purchased,
            player_gain                = player_gain,
            player_sum_bids            = player.sum_input,
            player_invested            = player.invested,
            player_sum_purchased       = player.sum_bought,
            player_sum_earned          = player.sum_earned,
            player_total_earned        = player.total_earned,
            player_next_income         = player.player_next_income,
            government_purchased       = government_purchased,
            government_value           = government_value,
            government_total_purchased = group.total_bought,
            government_total_value     = group.total_value,
            government_debt            = group.government_debt,
            government_next_debt       = group.government_next_debt,
            default_limit_reached      = group.default_limit_reached
        )


class P031_Additional(Page):
    form_model = "player"
    form_fields = ["risk", "compete", "satisfaction"]
    def is_displayed(player):
        return player.round_number == C.NUM_ROUNDS and player.player_dropped == 0

class P0311_Additional(Page):
    form_model = "player"
    form_fields = ["financeknowledge"]
    def is_displayed(player):
        return player.round_number == C.NUM_ROUNDS and player.player_dropped == 0



class P032_Demographics(Page):
    form_model = 'player'
    form_fields = ['age', 'gender', 'degree', 'admin']
    def is_displayed(player):
        return player.round_number == C.NUM_ROUNDS and player.player_dropped == 0



class P04_payoffs(Page):
    def is_displayed(player):
        return player.round_number == C.NUM_ROUNDS and player.player_dropped == 0

    def vars_for_template(player: Player):
        payoffs = [([0] * C.ROUNDS_DEMO)]
        rounds  = [range(1, C.ROUNDS_DEMO +1)]
        payoffs = payoffs + [([0] * C.ROUNDS_PER_BLOCK) for i in range(C.NUM_BLOCKS)]
        rounds  = rounds +  [range(1, C.ROUNDS_PER_BLOCK +1)] * C.NUM_BLOCKS
              
        for for_player in player.in_all_rounds():
            payoff = for_player.total_earned
            period = for_player.subsession.period
            round  = for_player.subsession.round
            
            payoffs[round -1][period -1] = payoff

        return dict(
            paid_period    = player.paid_period,
            paid_round     = player.paid_round,
            points_to_pay  = player.points_to_pay,
            money_to_pay   = player.money_to_pay,
            money_with_fee = player.money_with_fee,
            round1         = zip(rounds[0], payoffs[0]),
            round2         = zip(rounds[1], payoffs[1]),
            round3         = zip(rounds[2], payoffs[2])
        )
        
class P05_finished(Page):
    def is_displayed(player):
        return player.round_number == C.NUM_ROUNDS and player.player_dropped == 1

page_sequence = [#P01_intro,
                    Wait_main,
                    P02_main,
                    Wait_feedback,
                    P03_feedback,
                    P012_Questionnaire,
                    P013_Welcome,
                    P021_endround,
                    P031_Additional,
                    P0311_Additional,
                    P032_Demographics,
                    P04_payoffs,
                    P05_finished]


#############
# FUNCTIONS #
#############

def creating_session(subsession):
    # Get period and round from round_number
    subsession.round, subsession.period = get_period_round(subsession.round_number)
    
    # Get round length
    if subsession.round == 1:
        subsession.period_length = C.ROUNDS_DEMO
    else:
        subsession.period_length = C.ROUNDS_PER_BLOCK
    
    # Matching
    if subsession.period == 1:
        subsession.group_randomly()
    else:
        subsession.group_like_round(subsession.round_number -1)

    # Get government income randomly
    for group in subsession.get_groups():
        if subsession.period == 1:
            group.government_income = 0
        else:
            group.government_income = random.randint(C.GOVERN_INCOME_RANGE[0], C.GOVERN_INCOME_RANGE[1])
            
    # Set period and round for payments
    if subsession.round_number == 1:
        for player in subsession.get_players():
            rand_round = random.randint(C.ROUNDS_DEMO +1, C.NUM_ROUNDS)
            player.paid_round, player.paid_period = get_period_round(rand_round)
    else:
        for player in subsession.get_players():
            player.paid_round  = player.in_round(1).paid_round
            player.paid_period = player.in_round(1).paid_period

def get_period_round(round_number):
    if round_number <= C.ROUNDS_DEMO:
        round  = 1
        period = round_number
    else:
        round  = 2 + int((round_number - C.ROUNDS_DEMO - 1) / C.ROUNDS_PER_BLOCK)
        period = 1 + int((round_number - C.ROUNDS_DEMO - 1) % C.ROUNDS_PER_BLOCK)
    return [round, period]

def set_main_vars(group):
    if group.subsession.period == 1:
        group.defaulted_last_round = 0
        group.government_last_debt = 0
        group.government_debt      = C.GOVERN_INITIAL_DEBT
    else:
        group.defaulted_last_round = group.in_round(group.round_number -1).defaulted_this_round
        group.government_last_debt = group.in_round(group.round_number -1).government_next_debt
        group.government_debt      = round(group.government_last_debt - group.government_income, 2)
        if group.government_debt < 0:
            group.government_debt = 0
    
    # Update player income
    # wb: ------------------------------------ modif
    if group.subsession.period == 1:
        for player in group.get_players():
            player.player_income = C.PLAYER_INITIAL_INCOME #group.player_income
    else:
        for player in group.get_players():
            player.player_income = player.in_round(group.round_number -1).player_next_income
    # wb:-------------------------------------- modif (end)
    # wb:-------------------------------------- original
    # for player in group.get_players():
    #     player.player_income = group.player_income
    # wb:-------------------------------------- original (end)

    # wb: j'ai changé aussi l'ordre des deux blocs (dans le code original group.player_income est
    #définie avant player.player_income
    # wb: ------------------------------------ modif
    group.player_income = sum([p.player_income for p in group.get_players()])

    # wb: ------------------------------------ modif (end)

    # wb:-------------------------------------- original
    # if group.subsession.period == 1:
    #     group.player_income = C.PLAYER_INITIAL_INCOME
    # else:
    #     group.player_income = group.in_round(group.round_number -1).player_next_income
    # wb:-------------------------------------- original (end)

    # Update player_dropped flag
    if group.round_number > 1:
        for player in group.get_players():
            player.player_dropped = player.in_round(player.round_number -1).player_dropped


def set_feedback_vars(group):
    # Gather all inputs from players
    for player in group.get_players():
        group.sum_input01 = group.sum_input01 + player.input01
        group.sum_input02 = group.sum_input02 + player.input02
        group.sum_input03 = group.sum_input03 + player.input03
        group.sum_input04 = group.sum_input04 + player.input04
        group.sum_input05 = group.sum_input05 + player.input05
        group.sum_input06 = group.sum_input06 + player.input06
        group.sum_input07 = group.sum_input07 + player.input07
    
    # Arrays to iterate
    sum_inputs  = [group.sum_input01, group.sum_input02, group.sum_input03, group.sum_input04, group.sum_input05, group.sum_input06, group.sum_input07]
    sum_boughts = []
        
    # Choose bonds accepted by order
    remaining_debt = group.government_debt
    for sum_input, price in zip(sum_inputs, C.PURCHASE_PRICE_BOND):
        # Not enough bonds
        if sum_input * price < remaining_debt:
            remaining_debt = remaining_debt - (sum_input * price)
            sum_boughts.append(sum_input)
        # Exceeded bonds
        else:
            amount = math.ceil(remaining_debt / price)
            sum_boughts.append(amount)
            remaining_debt = 0
    
    # Check if there was a government default
    if remaining_debt > 0:
        group.defaulted_this_round = 1
    else:
        group.defaulted_this_round = 0
    
    # Storing total bonds bought 
    group.sum_bought01 = sum_boughts[0]
    group.sum_bought02 = sum_boughts[1]
    group.sum_bought03 = sum_boughts[2]
    group.sum_bought04 = sum_boughts[3]
    group.sum_bought05 = sum_boughts[4]
    group.sum_bought06 = sum_boughts[5]
    group.sum_bought07 = sum_boughts[6]
    group.total_bought = sum(sum_boughts)
    
    # Calculate government bond values
    group.value01     = round(group.sum_bought01 * C.PURCHASE_PRICE_BOND[0], 2)
    group.value02     = round(group.sum_bought02 * C.PURCHASE_PRICE_BOND[1], 2)
    group.value03     = round(group.sum_bought03 * C.PURCHASE_PRICE_BOND[2], 2)
    group.value04     = round(group.sum_bought04 * C.PURCHASE_PRICE_BOND[3], 2)
    group.value05     = round(group.sum_bought05 * C.PURCHASE_PRICE_BOND[4], 2)
    group.value06     = round(group.sum_bought06 * C.PURCHASE_PRICE_BOND[5], 2)
    group.value07     = round(group.sum_bought07 * C.PURCHASE_PRICE_BOND[6], 2)
    group.total_value = round(group.value01 + group.value02 + group.value03 + group.value04 + group.value05 + group.value06 + group.value07, 2)
    
    # Calculate debt and income for next round
    if group.defaulted_this_round == 0:
        group.government_next_debt = group.total_bought
        #group.player_next_income   = group.player_income     #wb:  à desactiver
    else:
        group.government_next_debt = round(group.government_debt * (1 - C.DEFAULT_PENALTY), 2)
        #group.player_next_income   = round(group.player_income   * (1 - C.DEFAULT_PENALTY), 2) #wb:  à desactiver

    # Calculate default_limit and check if it was reached

    # wb: modif (start)
    for player in group.get_players():
        if group.defaulted_this_round == 1 :
            if player.input01 != 0 or player.input02 != 0 or player.input03 != 0 or player.input04 != 0 or player.input05 != 0 or player.input06 != 0 or player.input07 != 0  :
                player.player_next_income = round(player.player_income   * (1 - C.DEFAULT_PENALTY), 2)
            else:
                player.player_next_income = player.player_income
        else :
            player.player_next_income = player.player_income

    group.default_limit = round((sum([player.player_next_income for player in group.get_players()]) * 0.95),1) # * 0.95 c'est le premier prix proposé
    # wb: modif (end)

    # wb: original
    #group.default_limit = group.player_next_income * C.PLAYERS_PER_GROUP

    if group.government_next_debt > group.default_limit:
        group.default_limit_reached = 1
        group.defaulted_this_round  = 1
        group.government_next_debt  = round(group.government_debt * (1 - C.DEFAULT_PENALTY), 2)

        # wb:
        #in the period after default the initial "income" is different depending on whether you've invested in the default period or not:
        # - if you didn't invest in the default period, your income after default to invest stays the same: 1000EC
        # - if you invested (something >0) in the default period, then going forward your income to invest is reduced by 30%.
        # - The new debt limit after default remains the sum of income of all investors.

        group.player_next_income    = round(group.player_income   * (1 - C.DEFAULT_PENALTY), 2)
        
    # Copy player_next_income from group to player var

    # wb: ---------------------------------------  modif
    for player in group.get_players():
        if group.defaulted_this_round == 1 or group.government_next_debt > group.default_limit :
            if player.input01 != 0 or player.input02 != 0 or player.input03 != 0 or player.input04 != 0 or player.input05 != 0 or player.input06 != 0 or player.input07 != 0  :
                player.player_next_income = round(player.player_income   * (1 - C.DEFAULT_PENALTY), 2)
            else:
                player.player_next_income = player.player_income
        else :
            player.player_next_income = player.player_income
    # wb: ---------------------------------------- modif (end)
    # wb: ---------------------------------------- original
    # for player in group.get_players():
    #     player.player_next_income = group.player_next_income

    # Managing player vars
    for player in group.get_players():
        # Calculating total bonds bid
        player.sum_input = player.input01 + player.input02 + player.input03 + player.input04 + player.input05 + player.input06 + player.input07
        
        # Calculating amount invested
        investment = 0
        player_inputs = [player.input01, player.input02, player.input03, player.input04, player.input05, player.input06, player.input07]
        for input, price in zip(player_inputs, C.PURCHASE_PRICE_BOND):
            investment = investment + (input * price)
        player.invested = round(investment, 2)
    
        # Storing bonds bought by every player
        if group.sum_input01: player.bought01 = round(player.input01 * (group.sum_bought01 / group.sum_input01))
        if group.sum_input02: player.bought02 = round(player.input02 * (group.sum_bought02 / group.sum_input02))
        if group.sum_input03: player.bought03 = round(player.input03 * (group.sum_bought03 / group.sum_input03))
        if group.sum_input04: player.bought04 = round(player.input04 * (group.sum_bought04 / group.sum_input04))
        if group.sum_input05: player.bought05 = round(player.input05 * (group.sum_bought05 / group.sum_input05))
        if group.sum_input06: player.bought06 = round(player.input06 * (group.sum_bought06 / group.sum_input06))
        if group.sum_input07: player.bought07 = round(player.input07 * (group.sum_bought07 / group.sum_input07))
        player.sum_bought = player.bought01 + player.bought02 + player.bought03 + player.bought04 + player.bought05 + player.bought06 + player.bought07
        
        # Calculating earnings of every player - wb : interest rate (return of investment by row)
        player.earned01   = round(player.bought01 * (1 - C.PURCHASE_PRICE_BOND[0]), 2)
        player.earned02   = round(player.bought02 * (1 - C.PURCHASE_PRICE_BOND[1]), 2)
        player.earned03   = round(player.bought03 * (1 - C.PURCHASE_PRICE_BOND[2]), 2)
        player.earned04   = round(player.bought04 * (1 - C.PURCHASE_PRICE_BOND[3]), 2)
        player.earned05   = round(player.bought05 * (1 - C.PURCHASE_PRICE_BOND[4]), 2)
        player.earned06   = round(player.bought06 * (1 - C.PURCHASE_PRICE_BOND[5]), 2)
        player.earned07   = round(player.bought07 * (1 - C.PURCHASE_PRICE_BOND[6]), 2)

        #-----------   wb: (start)
        if group.defaulted_this_round == 1:
            player.sum_earned = 0
        else:
            player.sum_earned = round(
                player.earned01 + player.earned02 + player.earned03 + player.earned04
                + player.earned05 + player.earned06 + player.earned07,2)
        #---------------wb: original
        #player.sum_earned = round(player.earned01 + player.earned02 + player.earned03 + player.earned04 + player.earned05 + player.earned06 + player.earned07, 2)
        # -----------   wb: original(end)


        # Check default to calculate total earnings of every player
        #wb:
        # new: Payoffs:  only the interest on the bonds purchased -
        # (in the original version we paid  1000 + interest).
        # If in one period they invest nothing, they get nothing

        # ---------------wb: (start)
        player.total_earned = round(player.sum_earned, 2)
        # ---------------wb: (end)
        # ---------------wb: original
        # if player.group.defaulted_this_round == 1:
        #     player.total_earned = round(player.player_income - player.invested, 2)
        # else:
        #     player.total_earned = round(player.player_income + player.sum_earned, 2)
        # ---------------wb: original (end)


        # Check if this is the selected round and period to get money_to_pay
        if (player.subsession.period == player.paid_period) and (player.subsession.round == player.paid_round):
            player.points_to_pay  = round(player.total_earned, 2)
            player.money_to_pay   = round(player.total_earned * C.PLAYER_CONVERSION, 1)
            player.money_with_fee = player.money_to_pay + C.SHOW_UP_FEE
            player.participant.vars['payoff'] = player.money_with_fee
        else:
            if player.round_number > 1:
                player.points_to_pay  = player.in_round(player.round_number - 1).points_to_pay
                player.money_to_pay   = player.in_round(player.round_number - 1).money_to_pay
                player.money_with_fee = player.in_round(player.round_number - 1).money_with_fee
                
        # Check if the player dropped and set payments to 0
        if player.player_dropped == 1:
            player.money_with_fee             = 0
            player.participant.vars['payoff'] = 0
                
def gen_graph_data(group):
    labels     = []
    debt_level = [C.GOVERN_INITIAL_DEBT]
    max_debt = [C.PLAYER_INITIAL_INCOME * C.PLAYERS_PER_GROUP *0.95] #wb:
    #max_debt   = [C.PLAYER_INITIAL_INCOME * C.PLAYERS_PER_GROUP]
    target_round = group.subsession.round
    for for_group in group.in_all_rounds():
        if for_group.subsession.round == target_round:
            debt_level.append(for_group.government_debt)
            max_debt.append(0.95 * for_group.player_income) #wb
            #max_debt.append(C.PLAYERS_PER_GROUP * for_group.player_income)
            # la variable group.player_income represente plus (sum player.palayer_income)
    for i in range(len(debt_level)):
        labels.append("Period " + str(i))
    
    return [labels, debt_level, max_debt]