from otree.api import *
# importing dependency
import math
import numpy as np
import random as rand
import matplotlib.pyplot as plt
import itertools
import ast
from scipy.stats import gaussian_kde

class Subsession(BaseSubsession):
    N = models.IntegerField()
    K = models.IntegerField()
    a = models.IntegerField()
    nk = models.StringField()
    dep = models.StringField()
    max = models.FloatField()
    min = models.FloatField()
    max_score = models.FloatField()
    max_sol = models.StringField()
    l_shape = models.StringField()


    def dependency_structure(N,K):
        dep = {}
        for i in np.arange(N):
            indi = list(range(N))
            indi.remove(i)
            dep[i] = np.random.choice(indi, K, replace=False).tolist()
        return dep

    def nk_landscape(N,K):
        nk = np.random.rand(N, 2 ** (K + 1), N)
        return nk

    def max_score_func(N,K,dep,nk):

        def cal_fit_raw(N, K, dep, nk, bit_str):
            if len(bit_str) == N:

                score = 0
                ind_dict = list(itertools.product(range(2), repeat=K + 1))
                for i in range(len(bit_str)):
                    dep_bit = dep[i].copy()
                    dep_bit.append(i)
                    inter_bits = tuple([bit_str[x] for x in dep_bit])
                    ind = ind_dict.index(inter_bits)
                    score += nk[i][ind][i]
                return score
            else:
                return print('The length of bit string should be equal to the length of N')

        sol_list = list(itertools.product(range(2), repeat=N))
        max_score = 0
        for sol in sol_list:
            if cal_fit_raw(N, K, dep, nk,sol) > max_score:
                max_score = cal_fit_raw(sol)
                max_sol = sol
        return max_score, max_sol

    def cal_fit(max_score,a, N, K, dep, nk, bit_str):

        def cal_fit_raw(N, K, dep, nk, bit_str):
            if len(bit_str) == N:

                score = 0
                ind_dict = list(itertools.product(range(2), repeat=K + 1))
                for i in range(len(bit_str)):
                    dep_bit = dep[i].copy()
                    dep_bit.append(i)
                    inter_bits = tuple([bit_str[x] for x in dep_bit])
                    ind = ind_dict.index(inter_bits)
                    score += nk[i][ind][i]
                return score
            else:
                return print('The length of bit string should be equal to the length of N')


        raw_over_max = cal_fit_raw(N, K, dep, nk, bit_str) / max_score
        return math.pow(raw_over_max, a)




def creating_session(subsession: Subsession):

    subsession.N = 8
    subsession.a = 8
    if subsession.session.config['complexity']=="Low":
        subsession.K = 2
    if subsession.session.config['complexity'] == "Medium":
        subsession.K = 4
    if subsession.session.config['complexity']=="High":
        subsession.K = 5

    landscape = C.nk_landscape(subsession.N,subsession.K)
    subsession.l_shape = str(landscape.shape)
    subsession.nk = str(dict(enumerate(landscape.flatten(), 1)))
    subsession.dep = str(C.dependency_structure(subsession.N,subsession.K))
    subsession.max = landscape.max
    subsession.min = landscape.min
    subsession.max_score, subsession.max_sol = C.max_score_func(subsession.N,subsession.K, ast.literal_eval(subsession.dep), np.fromiter(ast.literal_eval(d).values(), dtype=float).reshape(ast.literal_eval(subsession.l_shape)) )



d = dict(enumerate(model.nk.flatten(), 1))
d = str(d) ## save as str
m = ast.literal_eval(d) ### bring back dict

m = np.fromiter(m.values(), dtype=float).reshape(6,32,6) ## convert m to nparray



import json
k = json.load(open("C:\\Users\\amar\\Downloads\\Config.json"))