import pandas as pd
from numpy import ndarray
from sklearn import preprocessing
from sklearn.neighbors import KNeighborsClassifier
from scipy import stats
from sklearn.naive_bayes import GaussianNB
import statistics
from sklearn.metrics import pairwise_distances_argmin_min
import numpy as np
from random import randint
import matplotlib.pyplot as plt
import cv2
from sklearn.decomposition import PCA
import glob
from sklearn.metrics import pairwise_distances_argmin_min
from sklearn.metrics import accuracy_score
from sklearn.metrics import jaccard_similarity_score
from operator import itemgetter
import math


# função que calcula a quantidade de elementos por classe
# a partir do data frame original, o nome da classe e a classificação

def quantidade_por_classe (dados, nome_classe, classe):
    cont = 0
    for x in range(len(dados.index)):
        if (dados[nome_classe].iloc[x] == classe):
            cont += 1
    return cont
# função de inicialização do algoritmo KNN , recebe o k
# e a distância que vai ser usada como referência

def inicializacao_KNN (k):

    knn = KNeighborsClassifier(n_neighbors=k, metric='euclidean')
    return knn


# função de normalização dos dados usando o modelo de
# normalização por reescala

def normalizar(dados):
    x = dados.values
    min_max_scaler = preprocessing.MinMaxScaler()
    x_scaled = min_max_scaler.fit_transform(x)
    dados_norm = pd.DataFrame(x_scaled)
    return dados_norm

# função que calcula os valores de média, moda , mediana e desvio padrão
# para os vetores de acerto de um algoritmo, recebe como parâmetro o vetor
# de acerto e o nome do algoritmo

def tendencia_central (nomeAlgoritmo, vetorAcerto, vetorTempo):
    print('________________________________________________\n')
    print(nomeAlgoritmo)
    print('Tempo Média = ', np.mean(vetorTempo))
    print('Tempo Desvio padrão = ', statistics.pstdev(vetorTempo))
    print('Tempo Moda = ', stats.mode(vetorTempo, axis=None))
    print('Tempo Mediana =', np.median(vetorTempo))
    print('----------------------------------------------')
    print('Acurácia Média = ', np.mean(vetorAcerto))
    print('Acurácia Desvio padrão = ', statistics.pstdev(vetorAcerto))
    print('Acurácia Moda = ', stats.mode(vetorAcerto, axis=None))
    print('Acurácia Mediana = ', np.median(vetorAcerto))

    print('________________________________________________\n')

# função que cria amostras estratificadas a partir
# dos Data frame, o tamanho desejado para a amostra
# e a classe dos dados

def amostra_estrat(dados, tamanho_amostra, classe):
    classes = dados[classe].unique()
    qtde_por_classe = round(tamanho_amostra / len(classes))
    amostras_por_classe = []
    for c in classes:
        indices_c = dados[classe] == c
        obs_c = dados[indices_c]
        amostra_c = obs_c.sample(qtde_por_classe)
        amostras_por_classe.append(amostra_c)

    amostra_estratificada = pd.concat(amostras_por_classe)
    return amostra_estratificada

# função que realiza o treinamento dos algoritmos usados na base de dados

def treinaralgoritmos(noclass_train, class_train , tree, knnp1 , knnp2 , knnp3, knn1 , knn2 , knn3, naive, svmlinear , svmrbf):

    knn1.fit(noclass_train, class_train)
    knn2.fit(noclass_train, class_train)
    knn3.fit(noclass_train, class_train)
    naive.fit(noclass_train, class_train)
    tree.fit(noclass_train, class_train)
    knnp1.fit(noclass_train, class_train)
    knnp2.fit(noclass_train, class_train)
    knnp3.fit(noclass_train, class_train)
    svmlinear.fit(noclass_train, class_train)
    svmrbf.fit(noclass_train, class_train)

# função de inicialização do algoritmo KNN Ponderado
# recebe como parâmentro o valor do k

def inicializando_KNNW (k):

    knnp = KNeighborsClassifier(n_neighbors=k, weights='distance', metric='euclidean')
    return knnp



def geneticlabels(dataframe,centers):
    return pairwise_distances_argmin_min(dataframe,centers,metric='minkowski')

def find_clusters(X, n_clusters, rng, max_it):

    i = rng.permutation(X.shape[0])[:n_clusters]
    centers = X[i]

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])


        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances

def accuracy_majority_vote(base, predict_labels, real_labels, n_clusters):

    classes = real_labels.unique()

    majority = []
    groups = []
    k = 0
    for i in range(n_clusters):
        group = []
        for a in range(len(base)):
            if predict_labels[a] == i:
                group.append(real_labels[a])
        groups.append(group)
        majority.append(initialize_dic_majority(classes))
        for real_label in group:
            majority[k][real_label] += 1
        k += 1

    label_groups = []
    for m in majority:
        label_groups.append(max(m.items(), key=itemgetter(1))[0])

    pred_labels = []
    true_labels = []
    for g in range(len(groups)):
        pred_labels = pred_labels + ([label_groups[g]]*len(groups[g]))
        true_labels = true_labels + [a for a in groups[g]]

    return accuracy_score(pred_labels, true_labels)


def find_clustersGENETIC(X, n_clusters, max_it, array):

    centers = array

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])


        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances

# Carregando fotos da pasta
def loadFiles(path, array):

    for i in glob.glob(path):

        img = cv2.imread(i)
        array.append(img)

    return array

# Função que aplic o filtro blur nas fotos do array
def blurConversion(arrayphotos ,val1, val2):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.GaussianBlur(arrayphotos[x],(val1,val1), val2)

    return arrayphotos

#Função que faz a binarização das fotos
def binaryConversion(arrayphotos,threshold,val1):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.adaptiveThreshold(arrayphotos[x],threshold,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,val1,10)

    return arrayphotos

#Função que inverte as fotos binárias
def invertConversion(arrayphotos):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.bitwise_not(arrayphotos[x])

    return arrayphotos

# Função que faz o filtro cinza nas fotos
def grayConversion(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = cv2.cvtColor(arrayphotos[x], cv2.COLOR_BGR2GRAY)

    return arrayphotos


def WCSSgenetic(x, population):

    arrayint = []
    for a in x:
        arrayint.append(int(a))

    print(arrayint)
    soma = 0
    for b in arrayint:
        labels, distances = pairwise_distances_argmin_min(population[b],population, metric='minkowski')
        for x in distances:
            soma += x**2
    return soma


def generatepopulation(X,numberpopu, K, rng):

    population = []

    for x in range(numberpopu):
        first = rng.permutation(X.shape[0])[:K]
        print(first)
        population.append(np.concatenate(X[first]))

    return population


def find_clustersgenetic(X, n_clusters, max_it, array):

    centers = array

    max_iterator = 0
    distances = []
    while True:

        labels,distance = pairwise_distances_argmin_min(X,centers,metric='minkowski')
        distances.append(distance)

        new_centers = np.array([X[labels == i].mean(0)
                                for i in range(n_clusters)])

        if np.all(centers == new_centers) or max_iterator > max_it:
            break
        centers = new_centers
        max_iterator += 1

    return centers, labels, distances


#FUNÇÃO DE NORMALIZAÇÃO


def normalize(df1):
    x = df1.values.astype(float)
    min_max_scaler = preprocessing.MinMaxScaler()
    scaled = min_max_scaler.fit_transform(x)
    df_normalized = pd.DataFrame(scaled)
    return df_normalized

def normalizearray(array):
    scaled = preprocessing.MinMaxScaler().fit_transform(array)
    return scaled

def normalizeArrayofArrays(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = preprocessing.MinMaxScaler().fit_transform(arrayphotos[x])

    return arrayphotos

def Turntogray(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = cv2.cvtColor(arrayphotos[x], cv2.COLOR_BGR2GRAY)

    return arrayphotos


def gaussianblurArray(arrayphotos,val1,val2):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.GaussianBlur(arrayphotos[x],(val1,val1), val2)

    return arrayphotos

def binaryadaptive(arrayphotos,threshold,val1):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.adaptiveThreshold(arrayphotos[x],threshold,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,val1,10)

    return arrayphotos

def initialize_dic_majority(classes):
    majority = {}
    for c in classes:
        majority[c] = 0

    return majority

def invertbinaryphotos(arrayphotos):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.bitwise_not(arrayphotos[x])

    return arrayphotos


def loadfolderimgs(path):

    arrayphotos = []

    for img in glob.glob(path):
        n = cv2.imread(img)
        arrayphotos.append(n)

    return arrayphotos


def imgtoarray(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = np.array(arrayphotos[x] , dtype=float)

    return arrayphotos

def gethumoments(arrayphotos):

    for x in range(len(arrayphotos)):

        arrayphotos[x] = cv2.HuMoments(cv2.moments(arrayphotos[x]), True).flatten()

    return arrayphotos

def WCSS2(distance):
    soma = 0
    for x in distance:
        soma += x ** 2

    return soma

def extratorCaracteristicas(arrayimgs):

    squarescarac = []


    for x in arrayimgs:

        aux = []

        im2, countours, hierachy = cv2.findContours(x, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        if len(countours) == 0:

            for b in range(0,45):

                aux.append(0)

        elif len(countours) > 0:
            peri = cv2.arcLength(countours[0], True)  # perimetro
            aux.append(peri)

            aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True)  # vertices
            vertc = len(aproxx)
            aux.append(vertc)

            area = cv2.contourArea(countours[0])  # area
            aux.append(area)

            if peri > 0:
                compactness = (4 * math.pi * area) / (peri ** 2)  # compacidade
                aux.append(compactness)
            elif peri == 0:
                aux.append(0)

            momentum = cv2.moments(x)
            momentum = list(dict.values(momentum))  # momentos
            for i in momentum:
                aux.append(i)

            moments = cv2.HuMoments(momentum, True).flatten()  # Hu moments

            for i in moments:
                aux.append(i)

            histogram = get_histogram(aproxx)  # Frequencia de angulos

            for h in histogram:
                aux.append(h)

        squarescarac.append(aux)


    return squarescarac

def niveisCinza(image):

    gray = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)

    return gray


def filtroGaussiano(image):

    gaussianb = cv2.GaussianBlur(image,(5,5),0)

    return gaussianb

def turnToBinary(image):

    binary = cv2.adaptiveThreshold(image,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,31,10)

    return binary

def inverterCores(image):

    invert = cv2.bitwise_not(image)

    return invert

def resizeImages(images,width,height):

    i = len(images)
    for x in range(0,i):

        images[x] = cv2.resize(images[x],(width,height))

    return images


def angle3pt(a, b, c):
    """Counterclockwise angle in degrees by turning from a to c around b
        Returns a float between 0.0 and 360.0"""
    ang = math.degrees(
        math.atan2(c[1] - b[1], c[0] - b[0]) - math.atan2(a[1] - b[1], a[0] - b[0]))

    return ang + 360 if ang < 0 else ang

def get_vertices(imagem):

    im2, countours, hierachy = cv2.findContours(imagem, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    peri = cv2.arcLength(countours[0], True)  # perimetro

    aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True)  # vertices

    return aproxx

def get_angle(p0, p1, p2):

    v0 = np.array(p0) - np.array(p1)
    v1 = np.array(p2) - np.array(p1)

    angle = np.math.atan2(np.linalg.det([v0, v1]), np.dot(v0, v1))
    return np.degrees(angle)


def get_histogram(aproxx):
    zero = []
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    #transformando em um array bidimensional
    retornopollyDP = np.reshape(aproxx, (aproxx.shape[0], (aproxx.shape[1] * aproxx.shape[2])))

    #checando se não é uma linha
    if (len(retornopollyDP) < 3):

        return zero

    arraysdeangulo = []

    for x in range(len(retornopollyDP)):
        # caso especial : quando a primeira posição do array for o angulo central
        if x == 0:

            bla3 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[len(retornopollyDP) - 1])
            arraysdeangulo.append(math.fabs(bla3))

        # caso especial : quando a última posição do array for o ângulo central
        if x == len(retornopollyDP) - 1:

            bla4 = get_angle(retornopollyDP[x - 1], retornopollyDP[x], retornopollyDP[0])
            arraysdeangulo.append(math.fabs(bla4))

        if x > 0 and x < len(retornopollyDP) - 1:

            bla5 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[x - 1])
            arraysdeangulo.append(math.fabs(bla5))

    hist, bins = np.histogram(arraysdeangulo, bins=[15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180])

    return hist

import pandas as pd
from numpy import ndarray
from sklearn import preprocessing
from sklearn.neighbors import KNeighborsClassifier
from scipy import stats
from sklearn.naive_bayes import GaussianNB
import statistics
from sklearn.metrics import pairwise_distances_argmin_min
import numpy as np
from random import randint
import matplotlib.pyplot as plt
import cv2
import glob
import math
import os
import random


'''

Funções para pré-processamento dos dados

'''
# Carregando fotos da pasta
def loadFiles(path, array):

    for i in glob.glob(path):

        img = cv2.imread(i)
        array.append(img)

    return array

# Função que faz o filtro cinza nas fotos
def grayConversion(arrayphotos):

    size = len(arrayphotos)
    for x in range (0,size):
        arrayphotos[x] = cv2.cvtColor(arrayphotos[x], cv2.COLOR_BGR2GRAY)

    return arrayphotos

# Função que aplic o filtro blur nas fotos do array
def blurConversion(arrayphotos ,val1, val2):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.GaussianBlur(arrayphotos[x],(val1,val1), val2)

    return arrayphotos

#Função que faz a binarização das fotos
def binaryConversion(arrayphotos,threshold,val1):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.adaptiveThreshold(arrayphotos[x],threshold,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,val1,10)

    return arrayphotos

#Função que inverte as fotos binárias
def invertConversion(arrayphotos):

    for x in range(len(arrayphotos)):
        arrayphotos[x] = cv2.bitwise_not(arrayphotos[x])

    return arrayphotos


# função de normalização dos dados usando o modelo de
# normalização por reescala

def normalizar(dados):
    x = dados.values
    min_max_scaler = preprocessing.MinMaxScaler()
    x_scaled = min_max_scaler.fit_transform(x)
    dados_norm = pd.DataFrame(x_scaled)
    return dados_norm



def extratorCaracteristicas(arrayimgs):

    squarescarac = []


    for x in arrayimgs:

        aux = []

        im2, countours, hierachy = cv2.findContours(x, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

        if len(countours) == 0:

            for b in range(0,45):

                aux.append(0)

        elif len(countours) > 0:

            momentum = cv2.moments(x)
            momentum = list(dict.values(momentum))  # momentos
            for i in momentum:
                aux.append(i)

            moments = cv2.HuMoments(momentum, True).flatten()  # Hu moments

            for i in moments:
                aux.append(i)

            area = cv2.contourArea(countours[0])  # area
            aux.append(area)

            peri = cv2.arcLength(countours[0], True)  # perimetro
            aux.append(peri)

            if peri > 0:
                compactness = (4 * math.pi * area) / (peri ** 2)  # compacidade
                aux.append(compactness)
            elif peri == 0:
                aux.append(0)

            aproxx = cv2.approxPolyDP(countours[0], 0.04 * peri, True)  # vertices
            vertc = len(aproxx)
            aux.append(vertc)

            histogram = get_histogram(aproxx)  # Histograma da Frequencia de angulos

            for h in histogram:
                aux.append(h)

        squarescarac.append(aux)


    return squarescarac


def resizeImages(images,width,height):

    i = len(images)
    for x in range(0,i):

        images[x] = cv2.resize(images[x],(width,height))

    return images


def get_angle(p0, p1, p2):

    v0 = np.array(p0) - np.array(p1)
    v1 = np.array(p2) - np.array(p1)

    angle = np.math.atan2(np.linalg.det([v0, v1]), np.dot(v0, v1))
    return np.degrees(angle)


def get_histogram(aproxx):
    zero = []
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)
    zero.append(0)

    #transformando em um array bidimensional
    retornopollyDP = np.reshape(aproxx, (aproxx.shape[0], (aproxx.shape[1] * aproxx.shape[2])))

    #checando se não é uma linha
    if (len(retornopollyDP) < 3):

        return zero

    arraysdeangulo = []

    for x in range(len(retornopollyDP)):
        # caso especial : quando a primeira posição do array for o angulo central
        if x == 0:

            bla3 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[len(retornopollyDP) - 1])
            arraysdeangulo.append(math.fabs(bla3))

        # caso especial : quando a última posição do array for o ângulo central
        if x == len(retornopollyDP) - 1:

            bla4 = get_angle(retornopollyDP[x - 1], retornopollyDP[x], retornopollyDP[0])
            arraysdeangulo.append(math.fabs(bla4))

        if x > 0 and x < len(retornopollyDP) - 1:

            bla5 = get_angle(retornopollyDP[x + 1], retornopollyDP[x], retornopollyDP[x - 1])
            arraysdeangulo.append(math.fabs(bla5))

    hist, bins = np.histogram(arraysdeangulo, bins=[0, 15, 30, 45, 60, 75, 90, 105, 120, 135, 150, 165, 180])

    return hist


# funcão que seleciona num quantidade de imagens aleatoriamente
# em um vetor e retorna um vetor auxiliar apenas com as imagens
# selecionadas

def seleciona_imagens (arrayImgs, num):
    tamanho = len(arrayImgs)
    selecionadas = []
    nao_selecionadas = []
    aux = []
    var = 0

    for x in range(0, num):

        if x == 0:

            var = randint(0, tamanho - 1)
            aux.append(var)
            selecionadas.append(arrayImgs[var])

        elif x > 0:

            var = randint(0, tamanho - 1)

            while np.isin(var ,aux):

                var = randint(0, tamanho - 1)

            selecionadas.append(arrayImgs[var])
            aux.append(var)

    for x in range(0, tamanho):
        if np.isin(x,aux):
            continue
        else:
            nao_selecionadas.append(arrayImgs[x])

    return selecionadas, nao_selecionadas


#função que salva as imagens na pasta dada como parâmetro
def save_images(images, path):
    cont = 0

    for i in images:
        y = str(cont)
        cv2.imwrite(path + y + '.jpg', i)
        cont += 1

    return 0


# função que retorna população de cromossomos e tem como parametros
# tamanho da população (número de cromossomos) e tamanho dos cromossomos
def create_population(size_population, size_chromossome):
    population = []

    for y in range(0, size_population):
        aux = []
        for i in range(0, size_chromossome):
            x = randint(0, 200)
            if x % 2 == 0:
                aux.append(0)
            elif x % 2 != 0:
                aux.append(1)
        population.append(aux)

    return population


# função que identifica o tamanho do cromossomo e retorna o vetor de características correspondente
def decode_chromossome(chromossome):

    images_class = []

    if chromossome[0] == 0 and chromossome[1] == 0:

        images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_16_s.csv')
        images_class = pd.DataFrame(images_class)

    elif chromossome[0] == 0 and chromossome[1] == 1:
        images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_32_s.csv')
        images_class = pd.DataFrame(images_class)

    elif chromossome[0] == 1 and chromossome[1] == 0:

        images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_64_s.csv')
        images_class = pd.DataFrame(images_class)

    elif chromossome[0] == 1 and chromossome[1] == 1:

        images_class = pd.read_csv('C:/Users/Auricelia/Desktop/DataSetsML/Images_128_s.csv')
        images_class = pd.DataFrame(images_class)

    return images_class

'''


def fitness(chromossome):

    if chromossome[0] == 0 and chromossome[1] == 0:

        #DOFITNESS

    elif chromossome[0] == 0 and chromossome[1] == 1:

        #DOFITNESS

    elif chromossome[0] == 1 and chromossome[1] == 0:

        #DOFITNESS

    elif chromossome[0] == 1 and chromossome[1] == 1:

        #DOFITNESS

'''

#fucção que retorna as posições do array que
#são usadas pelo cromossomo para a classificação
def positions_chromossome(chromossome):

    selected_pos = []

    for c in range(2,len(chromossome)):
        aux = []
        if chromossome[c] == 1:
            selected_pos.append(c)

        elif chromossome[c] == 0:
            continue

    return selected_pos



# função que retorna o array com características selecionadas
# pelo cromossomo passando as posicoes selecionadas
# e o vetor com as características
def carac_imagens(selected_position,array_images):
    arrayzao = []
    z = 0
    for j in range(0,len(array_images)):
        aux = []
        for i in range(0,len(selected_position)):
            z = selected_position[i]
            aux.append(array_images[j][z])

        arrayzao.append(aux)

    return arrayzao


#gera o conjunto dos dois melhores cromossomos para
#garantir o elitismo no algoritmo genético
def get_best_cromossomos(acuracias,cromossomos):
    index = []
    melhor = []
    best_acuracia = []

    print('index antes',index)
    index.append(acuracias.index(max(acuracias)))
    print('index melhor',acuracias.index(max(acuracias)))
    best_acuracia.append(max(acuracias))
    print('best acc',max(acuracias))
    acuracias[acuracias.index(max(acuracias))] = 0


    index.append(acuracias.index(max(acuracias)))
    print('index melhor',acuracias.index(max(acuracias)))
    best_acuracia.append(max(acuracias))
    print('best acc',max(acuracias))
    acuracias[acuracias.index(max(acuracias))] = 0

    print('index dpeois',index)

    for i in range(0,len(index)):
        melhor.append(cromossomos[index[i]])
        cromossomos[index[i]] = 0
        print('melhor',cromossomos[i])
    # melhor.append(cromossomos[index[0]])
    # melhor.append(cromossomos[index[1]])

    return melhor, best_acuracia, cromossomos


# seleção por torneio gera aleatoriamente dois
# cromossomos e retorna o melhor deles
def tournament_selection(acuracias, cromossomos):
    melhor = []
    aux =[]
    rand1 = randint(0,len(cromossomos)-1)
    rand2 = randint(0,len(cromossomos)-1)

    while rand2 == rand1:
        rand2 = randint(0,len(cromossomos)-1)

    aux.append(rand1)
    aux.append(rand2)


    if acuracias[rand1] > acuracias[rand2]:
        melhor.append(cromossomos[rand1])
        cromossomos[rand1] = 0

    elif acuracias[rand2] > acuracias[rand1]:
        melhor.append(cromossomos[rand2])
        cromossomos[rand2] = 0


    return melhor, cromossomos


#função que retorna o casal gerado a partir do torneio
def generate_parents(melhores):
    duplas = []
    usados = []

    for i in range(int(len(melhores)/2)):
        aux = []
        rand = randint(0, len(melhores)-1)
        if i == 0:

            aux.append(melhores[rand])
            usados.append(rand)
            rand2 = randint(0,len(melhores)-1)

            while usados.__contains__(rand2):
                rand2 = randint(0,len(melhores)-1)
            aux.append(melhores[rand2])

            usados.append(rand2)
            duplas.append(aux)


        elif i > 0:

            while usados.__contains__(rand):
                rand = randint(0,len(melhores)-1)

            aux.append(melhores[rand])
            usados.append(rand)

            rand2 = randint(0,len(melhores)-1)
            while usados.__contains__(rand2):
                rand2 = randint(0,len(melhores)-1)
            aux.append(melhores[rand2])

            usados.append(rand2)
            duplas.append(aux)


    return duplas


#função que realiza o crossover entre os dois cromossomos
#pais para a geração
def crossover(taxa_crossover, parents):

    offspring = []
    seed = random.uniform(0,1)


    if seed < taxa_crossover:
        cromo1_a = parents[0][:19]
        cromo1_b = parents[0][19:]
        cromo2_a = parents[1][:19]
        cromo2_b = parents[1][19:]
        offspring.append(cromo1_a+cromo2_b)
        offspring.append(cromo2_a+cromo1_b)

    elif seed > taxa_crossover or seed == taxa_crossover :
        offspring.append(parents[0].copy())
        offspring.append(parents[1].copy())

    return offspring


# função que inverte os bits de uma posição
# do cromossomo caso a seed seja superior à taxa de mutação
def mutation(taxa_mutation, offsp_1):
    seed = 0
    for i in range(0,len(offsp_1)):
        seed = random.uniform(0,1)
        if seed < taxa_mutation:

            if offsp_1[i] == 0:
                offsp_1[i] = 1

            elif offsp_1[i] == 1:
                offsp_1[i] = 0

        elif seed > taxa_mutation or seed == taxa_mutation:
            continue

    return offsp_1,

# função que calcula os valores de média, moda , mediana e desvio padrão
# para os vetores de acerto de um algoritmo, recebe como parâmetro o vetor
# de acerto e o nome do algoritmo

# def tendencia_central (nomeAlgoritmo, vetorAcerto, vetorTempo):
#     print('________________________________________________\n')
#     print(nomeAlgoritmo)
#     print('Tempo Média = ', np.mean(vetorTempo))
#     print('Tempo Desvio padrão = ', statistics.pstdev(vetorTempo))
#     print('Tempo Moda = ', stats.mode(vetorTempo, axis=None))
#     print('Tempo Mediana =', np.median(vetorTempo))
#     print('----------------------------------------------')
#     print('Acurácia Média = ', np.mean(vetorAcerto))
#     print('Acurácia Desvio padrão = ', statistics.pstdev(vetorAcerto))
#     print('Acurácia Moda = ', stats.mode(vetorAcerto, axis=None))
#     print('Acurácia Mediana = ', np.median(vetorAcerto))
#
#     print('________________________________________________\n')

def jaccard_index(receita1, receita2):

    index = jaccard_similarity_score(receita1, receita2)

    return index


def major_jaccard_index(receita1, dataframe):

    aux = []

    for receita in dataframe:

        jac = jaccard_index(receita1, receita)
        if jac > 0.5 or jac == 0.5:
            aux.append(jac)

    nearest = max(aux)
    posicao = aux.index(max(aux))
    classe = dataframe.at[posicao, 'Class']

    return nearest,classe

def mean_jaccard_index(receita1, dataframe):
    aux = []

    for receita in dataframe:
        jac = jaccard_index(receita1,receita)
        aux.append(jac)

    media = np.mean(aux)
    return media

# def get_probabilities():
#
#     for i in range(df_1.shape[0]):
#         soma = df_1[i].sum()
#         prob_ingrediente = soma / total_rec_1
#         p_ingrediente_1.append(prob_ingrediente)


def p_ingredientes(cromossomo, p_ingrediente_classe):

    aux = 1
    for i in range(len(cromossomo)):

        if cromossomo[i] == 1:
            aux *= p_ingrediente_classe[i]

        elif cromossomo[i] == 0:
            continue
    return aux

# função que decodifica os dois primeiros bits do cromossomo
# para identificar a sua classe
def decode_cromoossome_recipe(cromossomo):
    classe = -1
    if cromossomo[0] == 0 and cromossomo[1] == 0:
        classe = 1
    elif cromossomo[0] == 0 and cromossomo[1] == 1:
        classe = 2
    elif cromossomo[0] == 1 and cromossomo[1] == 0:
        classe = 3
    elif cromossomo[0] == 1 and cromossomo[1] == 1:
        classe = 4

    return classe


def total_ing_classe(p_ingrediente_classe):

    cont = 0

    for i in range(len(p_ingrediente_classe)):

        if p_ingrediente_classe[i] > 0:
            cont += 1

        elif p_ingrediente_classe == 0:
            continue

    return cont

def total_ing_receita(receita):

    cont = 0

    for i in range(len(receita)):

        if receita[i] == 1:
            cont += 1

        elif receita[i] == 0:
            continue

    return cont


# def fitness_receita(p_ingredientes, p_ingrediente_classe):
#     fitness = p_ingredientes *