from ._builtin import Page, WaitPage
from .models import Constants
from .models import BasePlayer
from .models import Player
from. models import Subsession
import json
import random
from numpy.random import choice

class Consent(Page):
    pass


class Introduction(Page):
    pass

class Start(Page):
    pass


class Lottery(Page):
    form_model = 'player'
    form_fields = ['choice',
                   'default_side_hidden',
                   'default_deck_letter_hidden',
                   'exp_deck_seen_hidden',
                   'length_exp_deck_seen_hidden',
                   'real_lottery_win_hidden',
                   'page_time_hidden',]
                   # 'page_refresh_hidden',
    live_method = 'live_data'

    def vars_for_template(self):
        order = self.player.participant.vars['order']
        round_number = self.round_number
        choice_pairs = self.player.participant.vars['choice_pairs']
        new_trial = json.loads(self.player.new_trial)
        trial = json.loads(self.player.trial)



        # Read out the Game variables out of the new randomized trial list: new_trial
        # [[['0.18', '-19'], ['0.82', '73']], [['0.06', '-54'], ['0.94', '58']]]
        # A1_prob, A1_outcome, A2_prob, A2_outcome, B1_prob, B1_outcome,  B2_prob1, B2_outcome
        # >> Create single Variables to be assigned within the game
        a1_prob = float(new_trial[0][0][0])
        self.player.a1_prob = a1_prob ## alle hier berechneten Variablen auch noch einmal zu player.models zuordnen,
        # damit sie im data export abgespeichert werden
        a1_outcome = int(new_trial[0][0][1]) ## outcomes muessen keine floats sein. sonst steht da 32.0
        self.player.a1_outcome = a1_outcome

        a2_prob = float(new_trial[0][1][0])
        self.player.a2_prob = a2_prob
        a2_outcome = int(new_trial[0][1][1])
        self.player.a2_outcome = a2_outcome

        b1_prob = float(new_trial[1][0][0])
        self.player.b1_prob = b1_prob
        b1_outcome = int(new_trial[1][0][1])
        self.player.b1_outcome = b1_outcome

        b2_prob = float(new_trial[1][1][0])
        self.player.b2_prob = b2_prob
        b2_outcome = int(new_trial[1][1][1])
        self.player.b2_outcome = b2_outcome

        class MakeDeck:
            """Creating the card decks/lotteries that Players will see (experience deck)... """
            """...and play (real lotteries)"""

            def __init__(self, p_gamble1, outcome_gamble1, p_gamble2, outcome_gamble2, k_draws):
                """Initialize probability and number of draws attributes"""
                self.outcomes = [outcome_gamble1, outcome_gamble2]
                self.p_gamble1 = p_gamble1  # our low prob weights to be passed to each instance
                self.p_gamble2 = p_gamble2  # our high prob weights to be passed to each instance
                self.k_draws = k_draws  # number of chosen outcomes (bzw outcomes fuer die Liste) that we pass to each instance of CardDeck
                # draw k number of outcomes with weighted probs to build CardDeck
                self.make_session_array = choice(self.outcomes, k_draws, p=[p_gamble1, p_gamble2])
                self.deck_array = self.make_session_array.tolist()  # convert numpy array to a list
                # Make single choice for real lottery gamble
                self.lottery = (choice(self.outcomes, k_draws, p=[p_gamble1, p_gamble2]))

        exp_deck = MakeDeck(a1_prob, a1_outcome, a2_prob, a2_outcome, 450)  # Create instances of class CardDeck with special probabilities that we pass

        # Create real lottery outcomes
        exp_lottery_win = MakeDeck(a1_prob, a1_outcome, a2_prob, a2_outcome, 1)
        desc_lottery_win = MakeDeck(b1_prob, b1_outcome, b2_prob, b2_outcome, 1)

        # Debug Variables printed to terminal:
        print(exp_deck.deck_array)

        print('If player chooses exp-lottery:', exp_lottery_win.lottery.item())
        print('If player chooses description-lottery:', desc_lottery_win.lottery.item())
        print('Player Order is:', order)
        print('Player Table-Order is:', self.player.table_order)
        print('self.round number is', self.round_number)
        print('player.round number is', self.player.round_number)

        self.player.exp_deck = json.dumps(exp_deck.deck_array)

        # Spielt die echte Lottery ein einziges Mal fuer beide Decks und speichert als integer
        self.player.exp_lottery_win = exp_lottery_win.lottery.item() # das .item() macht aus dem Array ein Integer
        self.player.desc_lottery_win = desc_lottery_win.lottery.item()

        return dict(
            participant_treatment=self.player.participant.vars['treatment'],
            player_treatment=self.player.treatment,
            order=order,
            table_order=self.player.participant.vars['table_order'],
            round_number=round_number,
            trial=trial,
            new_trial=new_trial,
            a1_prob=int(a1_prob*100),
            a1_outcome=a1_outcome,
            a2_prob=int(a2_prob*100),
            a2_outcome=a2_outcome,
            b1_prob=int(b1_prob*100),
            b1_outcome=b1_outcome,
            b2_prob=int(b2_prob*100),
            b2_outcome=b2_outcome,
            z_choice_pairs=choice_pairs, # z damit es im Debug unten steht
            z_exp_deck=exp_deck.deck_array, # z damit es im Debug unten steht
        )

    def js_vars(self):

        return dict(
             order=self.player.participant.vars['order'],
             trial=self.player.trial,
             table_order=self.player.participant.vars['table_order'],
             exp_deck=json.loads(self.player.exp_deck),
             exp_lottery_win=self.player.exp_lottery_win,
             desc_lottery_win=self.player.desc_lottery_win,
        )



class Results(Page):
    pass


page_sequence = [Lottery]