import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix, classification_report
from sklearn.model_selection import train_test_split

# Función para aplicar Min-Max a cada columna
def min_max_normalize(column):
    return (column - column.min()) / (column.max() - column.min())

# Función para aplicar Normax
def normax_normalize(column):
    return column / column.max()

# Cargar el archivo de Excel desde la ruta especificada
file_path = r"C:\Users\USUARIO\Documents\Indonecia\Rice_Spectral.xlsx"
data = pd.read_excel(file_path, sheet_name="Spectral")

# Asegurarse de que los valores de "Location" sean numéricos
data['Location'] = pd.to_numeric(data['Location'], errors='coerce')

# Separar los datos de los números de onda (Wavenumbers)
wavenumbers = data['Location'].dropna()  # Eliminar posibles NaN en wavenumbers

# Filtrar las columnas que pertenecen a Java y Bangka Belitung
java_columns = [col for col in data.columns if "Java" in col]
belitung_columns = [col for col in data.columns if "Bangka Belitung" in col]

# Asegurarse de que todas las columnas de datos sean numéricas
data[java_columns] = data[java_columns].apply(pd.to_numeric, errors='coerce')
data[belitung_columns] = data[belitung_columns].apply(pd.to_numeric, errors='coerce')

# Aplicar normalización Min-Max y Normax
data_minmax = data.copy()
data_normax = data.copy()

data_minmax[java_columns] = data_minmax[java_columns].apply(min_max_normalize)
data_minmax[belitung_columns] = data_minmax[belitung_columns].apply(min_max_normalize)

data_normax[java_columns] = data_normax[java_columns].apply(normax_normalize)
data_normax[belitung_columns] = data_normax[belitung_columns].apply(normax_normalize)

# Preparar los datos para PCA y t-SNE
all_columns = java_columns + belitung_columns

# Normalización de datos (Min-Max)
spectral_data_minmax = data_minmax[all_columns].dropna().transpose()

# Estandarización de datos
scaler = StandardScaler()
spectral_data_standardized = scaler.fit_transform(spectral_data_minmax)

# Calcular el valor máximo permitido para n_components
n_samples, n_features = spectral_data_minmax.shape
n_components = min(n_samples, n_features)

# PCA para reducir a un máximo de n_components antes de t-SNE
pca_50_standardized = PCA(n_components=n_components).fit_transform(spectral_data_standardized)

# t-SNE después de reducir a n_components con PCA
tsne_standardized = TSNE(n_components=2, random_state=42).fit_transform(pca_50_standardized)

# Asignar etiquetas a las muestras: 0 para Java y 1 para Bangka Belitung
labels = [0] * len(java_columns) + [1] * len(belitung_columns)

# Dividir los datos t-SNE en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(tsne_standardized, labels, test_size=0.3, random_state=42)

# Entrenar un modelo SVM
svm_model = SVC(kernel='linear')
svm_model.fit(X_train, y_train)

# Realizar predicciones
y_pred = svm_model.predict(X_test)

# Calcular las métricas
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)

# Mostrar resultados
print(f"Accuracy: {accuracy * 100:.2f}%")
print(f"Precision: {precision:.2f}")
print(f"Recall: {recall:.2f}")
print(f"F1-Score: {f1:.2f}")
print("\nMatriz de Confusión:")
print(conf_matrix)
print("\nReporte de Clasificación:")
print(class_report)

# Visualización de la matriz de confusión
plt.figure(figsize=(6, 4))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=['Java', 'Bangka Belitung'], yticklabels=['Java', 'Bangka Belitung'])
plt.title('Matriz de Confusión')
plt.ylabel('Etiqueta Real')
plt.xlabel('Etiqueta Predicha')
plt.show()