import numpy as np, math, pandas as pd, itertools, functools
from collections import namedtuple

def reduce_concat(x, sep=""):
    return functools.reduce(lambda x, y: str(x) + sep + str(y), x)

##

def paste(*lists, sep=" ", collapse=None):
    result = map(lambda x: reduce_concat(x, sep=sep), zip(*lists))
    if collapse is not None:
        return reduce_concat(result, sep=collapse)
    return list(result)

##

def bandt_pompe_method(data, D = 4):
  if isinstance(data, pd.DataFrame):
        data = pd.DataFrame(data)
  #creating vector frequency
  frequency_vector = np.zeros(3211) #Maior valor possível de uma concatenação dos 4 primeiros inteiros não negativos
  x = np.arange(D) #Array de D elementos que vão de 0 a D-1
  permutations = list(itertools.permutations(x)) #Gera uma lista com todas a permutações possíveis de 0 a D-1

  # cria um vetor de D posicoes, de 0 a D-1
  ids = np.arange(D, dtype=object)
  # adiciona "ids" no comeco dele
  ids = np.insert(ids, 0, 'ids')

  # cria um vetor de D posicoes, zerado
  values = np.zeros(D, dtype=object)
  # adiciona "values" no comeco dele
  values = np.insert(values, 0, 'values')

  # junta os dois vetores em uma matriz e transpoe
  dados = np.array([ids, values]).T

  # cria um frame do panda com os dados
  possitions = pd.DataFrame(data=dados[1:,0:], columns=dados[0,0:])

  for i in range(1, len(data) - D + 1): # Admitindo que data seja uma string
      possitions.values = 4
      show = data[i:(i+D-1), : ]
      possitions.values = data[i:(i+D-1), : ]
      sort = possitions[sorted(possitions.values), : ]
      ordinal_pattern = paste(sort.ids, collapse="")
      frequency_vector[[ordinal_pattern]] = frequency_vector[[ordinal_pattern]] + 1

  frequencies = map(list, zip(*frequency_vector))
  probabilities = map(list, zip(*frequency_vector))/(len(data)[1]-D+1)
  output = pd.DataFrame(frequencies, probabilities) #Em que parte que frequency_vector recebe esses nomes?

  return output

##
##
##

def shannon_entropy(probs, normalized = False):
    p = np.where(probs > 1e+30) #Descarta os valores nulos do vetor de probabilidades
    entropy = 0.0
    for i in p:
        entropy -= probs[i]*math.log(probs[i]) #i assume os valores do vetor p
    if(normalized):
        entropy = entropy/math.log(len(probs))
    return entropy

##
##
##

def jensen_shannon(probs_1, probs_2):
    J = math.sqrt( shannon_entropy( (probs_1 + probs_2) / 2  ) - shannon_entropy(probs_1)/2 - shannon_entropy(probs_2)/2 )
    return J

##
##
##

def complexity(probs, entropy, Q_0): #Q_0 passa a ser parâmetro da função
    #p = which(probs > 1e-30)
    N = len(probs)
    P_e = np.repeat(1/N, times = N)
    J = shannon_entropy( (probs + P_e) / 2  ) - shannon_entropy(probs)/2 - shannon_entropy(P_e)/2
    #aux = (((N+1)/N) * math.log(N + 1) - 2*math.log(2*N) + math.log(N))
    #Q_0 = -2*(1/aux)
    Q = Q_0 * J
    complexity = Q*entropy
    return complexity

def main():

    data = {1.000000e-04, 1.000000e-04, 1.000000e-04,
 5.999999e-04, 1.000001e-04, 1.099900e-03,
 1.100000e-03, 1.000047e-04,  2.099300e-03}

    result = bandt_pompe_method(data, D=4)
    print(result)

    return 0

main()