import pandas as pd
import numpy as np
from datetime import date, datetime, timedelta
# web scrapping
from functools import reduce
# matplotlib
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import seaborn as sns
import networkx as nx
from ipysigma import Sigma
from pyvis.network import Network
import requests
from bs4 import BeautifulSoup
from io import StringIO
from dbconnection import MySQLDatabase
# sklearn
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import KernelPCA
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from scipy.spatial import ConvexHull
import warnings
import math

from utils import selKmeans
warnings.filterwarnings("ignore", category=UserWarning, module="pandas")
sns.set_theme()

db = MySQLDatabase("delitos")

# selecionamos el año
anio = '2024'
#tipodelito = 'Homicidio'

query = f"""   
    SELECT 
        a.id,
        a.Anio,
        a.Mes,
        a.CVE_ENT,
        b.NOM_ENT,
        a.CVE_MUN,
        b.NOM_MUN,
        b.POB_TOTAL,
        a.Tipo_delito,
        a.Total
    FROM Total_delitos as a
    LEFT JOIN geo_mun as b
    ON a.CVE_ENT = b.CVE_ENT AND a.CVE_MUN = b.CVE_MUN
    WHERE a.Anio = {anio};
"""
# ejecutamos consulta
df = db.execute_query(query)

print(f"Shape: {df.shape}")

df.head()

# Convertir POB_TOTAL a numérico
df['POB_TOTAL'] = pd.to_numeric(df['POB_TOTAL'], errors='coerce')

# Agrupar por entidad y tipo de delito, sumar los delitos
df_ent = df.groupby(['CVE_ENT', 'NOM_ENT', 'Tipo_delito'], as_index=False).agg({'Total':'sum'})

# Pivotear: tipos de delito a columnas
df_pivot = df_ent.pivot_table(
    index=['CVE_ENT', 'NOM_ENT'],  # Solo estos índices, NO POB_TOTAL
    columns='Tipo_delito',
    values='Total',
    aggfunc='sum',
    fill_value=0
).reset_index()

# Unir la población al pivot
print(df_pivot['CVE_ENT'].nunique())

# Eliminamos datos no numéricos
X = df_pivot.drop(columns=['CVE_ENT', 'NOM_ENT']) # 'CVE_MUN','CVE_MUN'
# estandarización
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# kernel PCA
# se pueden probar distintos kernels: 'rbf', 'poly', 'sigmoid', 'cosine'
kpca = KernelPCA(n_components=2, kernel='rbf', gamma=0.05, random_state=42)
X_kpca = kpca.fit_transform(X_scaled)

# Guardamos en el DataFrame para graficar
df_pivot['kpca1'] = X_kpca[:, 0]
df_pivot['kpca2'] = X_kpca[:, 1]

n_points = X_kpca.shape[0]
colors = cm.tab20(np.linspace(0, 1, n_points)) 
plt.figure(figsize=(14, 6))

for i in range(n_points):
    plt.scatter(X_kpca[i, 0], X_kpca[i, 1], color=colors[i], s=80)
    plt.text(X_kpca[i, 0] + 0.02, X_kpca[i, 1] + 0.02, df_pivot['NOM_ENT'][i], fontsize=9, alpha=0.85)

plt.xlabel('Kernel PCA 1', fontsize=13)
plt.ylabel('Kernel PCA 2', fontsize=13)
plt.title('Kernel PCA: PC1 vs PC2 (Entidades)', fontsize=15)
plt.grid(True, linestyle='--', alpha=0.4)
plt.tight_layout()
plt.show()

# selecciona mejor kmeans
class selKmeans():
    
    def __init__(self, X, krange=[2,20]):
        self.X = X
        self.kmin = krange[0]
        self.kmax = krange[1]
        self.inertias = []
        self.silhouettes = []
        
    # metodo retorna mejor k
    def best(self):
        
        k_range = range(self.kmin, self.kmax)
        self.inertias.clear()
        self.silhouettes.clear()
        for k in k_range:
            kmeans = KMeans(n_clusters=k, random_state=42)
            labels = kmeans.fit_predict(self.X)
            self.inertias.append(kmeans.inertia_)
            self.silhouettes.append(silhouette_score(self.X, labels))
        # k best con 
        best_k = k_range[np.argmax(self.silhouettes)]
        return best_k
    
    # Gráfica Método del Codo
    def plot_elbow(self):
        self.best()
        k_range = range(self.kmin, self.kmax)
        plt.figure(figsize=(12,4))
        plt.plot(k_range, self.inertias, 'o-', label='Inertia (codo)')
        plt.xlabel('Número de clusters (k)')
        plt.ylabel('Inercia')
        plt.title('Método del Codo')
        plt.grid(True, linestyle='--', alpha=0.4)
    
        return plt
    
    def plot_silhouette(self):
        self.best()
        k_range = range(self.kmin, self.kmax)
        # --- Silhouette Score
        plt.figure(figsize=(12,4))
        plt.plot(k_range, self.silhouettes, 'o-', color='orange', label='Silhouette')
        plt.xlabel('Número de clusters (k)')
        plt.ylabel('Silhouette Score')
        plt.title('Evaluación del número óptimo de clusters')
        plt.grid(True, linestyle='--', alpha=0.4)
        
        return plt

sel = selKmeans(X_kpca, krange=[2,20])

best_k = sel.best()
print(f" Mejor número de clusters según Silhouette: {best_k}")

# gráfico codo
plt = sel.plot_elbow()
plt.show()

# grpafico de silhouette
plt = sel.plot_silhouette()
plt.show()

# Clustering con el mejor K
kmeans_final = KMeans(n_clusters=best_k, random_state=42)
clusters = kmeans_final.fit_predict(X_kpca)
df_pivot['Cluster'] = clusters

#print(df_pivot['CVE_ENT'].nunique())
plt.figure(figsize=(14, 6))
colors = plt.cm.tab10(np.linspace(0, 1, best_k))  # paleta de colores

for k, color in zip(range(best_k), colors):
    grupo = df_pivot[df_pivot['Cluster'] == k]
    plt.scatter(grupo['kpca1'], grupo['kpca2'], color=color, s=40, label=f'Cluster {k}')
    # Calcular y dibujar el polígono si hay suficientes puntos
    if len(grupo) >= 3:
        puntos = grupo[['kpca1', 'kpca2']].values
        hull = ConvexHull(puntos)
        for simplex in hull.simplices:
            plt.plot(puntos[simplex, 0], puntos[simplex, 1], color=color, linewidth=1.5)
        # sombrear el interior
        plt.fill(puntos[hull.vertices, 0], puntos[hull.vertices, 1],
                    color=color, alpha=0.15)
# Etiquetas de texto (se puede usar NOM_ENT o NOM_MUN)
for i in range(len(df_pivot)):
    plt.annotate(df_pivot['NOM_ENT'][i], (df_pivot['kpca1'][i]+0.01, df_pivot['kpca2'][i]+0.01), fontsize=8, alpha=0.8)

plt.xlabel("Componente Principal 1")
plt.ylabel("Componente Principal  2")
plt.title(f"Kernel PCA + KMeans (k={best_k}) por Tipo de Delito [{anio}]")
plt.grid(True, linestyle='--', alpha=0.4)
plt.show()

# Agrupar por cluster y obtener la lista de entidades únicas por cluster
entidades_por_cluster = df_pivot.groupby('Cluster')['NOM_ENT'].unique()

# Imprime
for c, entidades in entidades_por_cluster.items():
    print(f"\n🔹 Cluster {c} ({len(entidades)} entidades):")
    print(entidades)

# definicmos colores
colors = ['skyblue', 'lightgreen', 'salmon', 'green', 'cyan', 'magenta','lightblue']

# graficamos
plt.figure(figsize=(14, 6))
for c, entidades in entidades_por_cluster.items():
    # posiciones en y
    y_pos = range(len(entidades))
    # scatter: x = cluster, y = entidad
    plt.scatter([c]*len(entidades), y_pos, s=200, color=colors[c], label=f'Cluster {c}')

    # Añadir etiquetas de entidad
    for i, ent in enumerate(entidades):
        plt.text(c + 0.05, i, ent, va='center', fontsize=10)

plt.xticks([0, 1, 2,3,4,5,6], [f"Cluster {x}" for x in range(7)])

plt.yticks([])  # ocultamos los ticks del eje y

plt.xlabel("Clusters")
plt.title("Distribución de Entidades por Cluster")
plt.legend()
plt.tight_layout()
plt.show()

# Columnas de delitos
delitos_cols = df_pivot.columns[2:-3]  

# Promedio de cada delito por cluster
cluster_summary = df_pivot.groupby('Cluster')[delitos_cols].mean().round(2)
print(cluster_summary)

# Número de clusters
n_clusters = len(cluster_summary.index)
# Definir número de filas y columnas
n_cols = 2
n_rows = math.ceil(n_clusters / n_cols)
# Crear figura
fig, axes = plt.subplots(n_rows, n_cols, figsize=(8 * n_cols, 8 * n_rows))
axes = axes.flatten()  # convertir a lista 1D
# Graficar cada cluster
for i, c in enumerate(cluster_summary.index):
    ax = axes[i]
    # Top 10 variables del cluster
    top10 = cluster_summary.loc[c].sort_values(ascending=False).head(10)
    delitos = [x.split('_')[0] for x in top10.index[::-1]]
    valores = top10.values[::-1]
    # Colores distintos por barra
    colors = cm.tab10(np.linspace(0, 1, len(valores)))
    # Crear barras
    bars = ax.barh(delitos, valores, color=colors)
    # Agregar texto al final de cada barra
    for bar in bars:
        width = bar.get_width()
        ax.text(
            width + max(valores) * 0.01,
            bar.get_y() + bar.get_height() / 2,
            f'{width:.1f}',
            va='center',
            ha='left',
            fontsize=12,
            color='black'
        )
    ax.set_title(f'Cluster {c}', fontsize=16, weight='bold')
    ax.set_xlabel('Cantidad promedio', fontsize=13)
    ax.tick_params(axis='y', labelsize=13)
# Eliminar ejes vacíos (si hay más espacios que clusters)
for j in range(i + 1, len(axes)):
    fig.delaxes(axes[j])
plt.tight_layout()
plt.show()