import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
import joblib

# Carregar o dataset unificado
csv_path = "./unified_dataset.csv"  # Caminho relativo a partir da pasta src
try:
    df = pd.read_csv(csv_path)
    print("Dataset carregado com sucesso!")
except Exception as e:
    print(f"Erro ao carregar o dataset: {e}")
    exit()

# Verificar o dataset
print(df.head())
print(f"Tamanho do dataset: {df.shape}")

# Separar features (X) e labels (y)
X = df.drop(columns=["label"])  # Todas as colunas exceto 'label'
y = df["label"]  # Coluna 'label'

# Codificar as labels (transformar strings em números)
label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y)

# Dividir o dataset em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Normalizar as features (importante para MLP)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Criar e treinar a MLP
mlp = MLPClassifier(
    hidden_layer_sizes=(128, 64),  # Duas camadas ocultas com 128 e 64 neurônios
    activation="relu",             # Função de ativação ReLU
    solver="adam",                 # Otimizador Adam
    max_iter=500,                  # Número máximo de iterações
    random_state=42,
    verbose=True                   # Mostrar progresso durante o treinamento
)

print("Treinando a MLP...")
mlp.fit(X_train, y_train)

# Fazer previsões no conjunto de teste
y_pred = mlp.predict(X_test)

# Avaliar o modelo
print("\nRelatório de classificação:")
print(classification_report(y_test, y_pred, target_names=label_encoder.classes_))

print(f"Acurácia: {accuracy_score(y_test, y_pred):.4f}")

# Gerar a matriz de confusão
conf_matrix = confusion_matrix(y_test, y_pred)

# Plotar a matriz de confusão
plt.figure(figsize=(10, 7))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues",
            xticklabels=label_encoder.classes_,
            yticklabels=label_encoder.classes_)
plt.xlabel("Predito")
plt.ylabel("Verdadeiro")
plt.title("Matriz de Confusão")
plt.show()

# Extrair valores relevantes da matriz de confusão
print("\nValores relevantes da matriz de confusão:")

# Acurácia por classe
class_accuracy = conf_matrix.diagonal() / conf_matrix.sum(axis=1)
for i, accuracy in enumerate(class_accuracy):
    print(f"Acurácia da classe {label_encoder.classes_[i]}: {accuracy:.4f}")

# Erros mais comuns (maiores valores fora da diagonal)
conf_matrix_df = pd.DataFrame(conf_matrix, index=label_encoder.classes_, columns=label_encoder.classes_)
conf_matrix_df.values[np.diag_indices_from(conf_matrix_df)] = 0  # Zerar a diagonal para focar nos erros
most_common_errors = conf_matrix_df.stack().sort_values(ascending=False).head(5)

print("\nErros mais comuns:")
print(most_common_errors)

# Salvar o modelo
model_filename = "mlp_classifier.joblib"
joblib.dump(mlp, model_filename)
print(f"Modelo salvo como {model_filename}")

# Salvar o LabelEncoder (para decodificar as previsões)
label_encoder_filename = "label_encoder.joblib"
joblib.dump(label_encoder, label_encoder_filename)
print(f"LabelEncoder salvo como {label_encoder_filename}")