src/events/segmentation.py

"""
Mejoras D y E — Segmentación temporal mejorada.

Reemplaza la función segmentar_cluster_por_picos
con dos mejoras clave:
  - Mejora D: Jaccard suavizado de entidades (en lugar de Jaccard = 0 estricto)

Uso típico en Colab:
    from src.events.segmentation import segmentar_cluster_v2, consolidar_micro_eventos
    segmentos, scores, contadores = segmentar_cluster_v2(df_cluster, embeddings)
"""

from __future__ import annotations

import ast
import logging
from typing import Optional

import numpy as np
import pandas as pd
from scipy.ndimage import gaussian_filter1d
from scipy.signal import find_peaks
from sklearn.metrics.pairwise import cosine_similarity

logger = logging.getLogger(__name__)

# ── Parámetros globales (sobreescribibles por argumento) ─────────────────────
GAP_TEMPORAL_MIN      = 30    # días → división forzada
JACCARD_ENT_THRESHOLD = 0.15  # Mejora D: umbral de similitud de entidades (bajo = más divisiones)
ENT_TYPES_SEGM        = {'PER', 'ORG', 'LOC'}


# ─────────────────────────────────────────────────────────────────────────────
# Utilidades de entidades
# ─────────────────────────────────────────────────────────────────────────────
def _extract_entity_set(df_segment: pd.DataFrame, col: str = 'named_entities_stanza') -> set[str]:
    """
    Extrae el conjunto de entidades PER/ORG/LOC normalizadas de un segmento.
    Solo incluye entidades que aparecen en ≥ 2 artículos del segmento (para
    filtrar menciones accidentales de un solo artículo).
    """
    if col not in df_segment.columns:
        return set()

    entity_counts: dict[str, int] = {}

    for raw in df_segment[col]:
        if raw is None or (isinstance(raw, float) and np.isnan(raw)):
            continue
        if isinstance(raw, str):
            try:
                raw = ast.literal_eval(raw)
            except Exception:
                continue
        if not isinstance(raw, (list, tuple)):
            continue
        seen_in_row: set[str] = set()
        for e in raw:
            if not isinstance(e, dict):
                continue
            if e.get('type', '') not in ENT_TYPES_SEGM:
                continue
            key = e.get('text', '').lower().strip()
            if key and key not in seen_in_row:
                seen_in_row.add(key)
                entity_counts[key] = entity_counts.get(key, 0) + 1

    return {k for k, v in entity_counts.items() if v >= 2}


def _jaccard_similarity(set_a: set, set_b: set) -> float:
    """Jaccard suavizado: |A∩B| / |A∪B|. Devuelve 1.0 si ambos están vacíos."""
    if not set_a and not set_b:
        return 1.0
    union = set_a | set_b
    if not union:
        return 1.0
    return len(set_a & set_b) / len(union)


# ─────────────────────────────────────────────────────────────────────────────
# Validación de cortes (triple criterio mejorado)
# ─────────────────────────────────────────────────────────────────────────────
def _validar_division(
    df_antes: pd.DataFrame,
    df_despues: pd.DataFrame,
    embeddings_matrix: np.ndarray,
    idx_antes: list[int],
    idx_despues: list[int],
    centroide_cluster: np.ndarray,
    umbral_similitud: float,
    jaccard_threshold: float = JACCARD_ENT_THRESHOLD,
) -> tuple[bool, float, str]:
    """
    Aplica el triple criterio de validación para decidir si mantener un corte.

    Criterios (en orden de prioridad):
      1. Gap temporal ≥ GAP_TEMPORAL_MIN → división forzada (score=NaN)
      2. Coseno residual < umbral_similitud → división semántica
      3. Jaccard de entidades PER/ORG/LOC < jaccard_threshold → división factual

    Returns
    -------
    (dividir: bool, score: float, motivo: str)
        score = NaN si la división es por gap, valor coseno residual si es semántica.
    """
    if not idx_antes or not idx_despues:
        return False, 1.0, 'insuficiente'

    # ── Criterio 1: gap temporal ─────────────────────────────────────────────
    fecha_fin_antes   = df_antes['fecha_limpia'].max()
    fecha_inicio_desp = df_despues['fecha_limpia'].min()
    gap_dias = (fecha_inicio_desp - fecha_fin_antes).days

    if gap_dias >= GAP_TEMPORAL_MIN:
        return True, float('nan'), 'gap'

    # ── Criterio 2: coseno residual ──────────────────────────────────────────
    emb_antes   = embeddings_matrix[idx_antes]
    emb_despues = embeddings_matrix[idx_despues]

    res_antes   = emb_antes   - centroide_cluster
    res_despues = emb_despues - centroide_cluster

    c_antes   = res_antes.mean(axis=0, keepdims=True)
    c_despues = res_despues.mean(axis=0, keepdims=True)

    score = float(cosine_similarity(c_antes, c_despues)[0, 0])

    if score < umbral_similitud:
        return True, score, 'coseno'

    # ── Criterio 3: Jaccard suavizado de entidades ───────────────────────────
    ents_antes   = _extract_entity_set(df_antes)
    ents_despues = _extract_entity_set(df_despues)

    # Solo aplica si ambos segmentos tienen ≥ 2 entidades específicas
    if len(ents_antes) >= 2 and len(ents_despues) >= 2:
        jac = _jaccard_similarity(ents_antes, ents_despues)
        if jac < jaccard_threshold:
            return True, score, 'entidades'

    return False, score, 'pausa'


# ─────────────────────────────────────────────────────────────────────────────
# NOTA: La fusión ciega de segmentos pequeños fue eliminada para evitar la 
# recapacitación de ruido estructural (beat journalism).
# Los trozos separados por el coseno residual se mantendrán aislados como eventos atómicos.
# ─────────────────────────────────────────────────────────────────────────────


# ─────────────────────────────────────────────────────────────────────────────
# Función principal (drop-in replacement de segmentar_cluster_por_picos)
# ─────────────────────────────────────────────────────────────────────────────
def segmentar_cluster_v2(
    df_cluster: pd.DataFrame,
    embeddings_matrix: np.ndarray,
    sigma: float = 1.0,
    prominence: float = 0.5,
    umbral_similitud: float = 0.05,
    jaccard_threshold: float = JACCARD_ENT_THRESHOLD,
    entity_col: str = 'named_entities_stanza',
) -> tuple[list[pd.DataFrame], list[float], dict]:
    """
    Versión mejorada de segmentar_cluster_por_picos con Mejoras D.

    Cambios respecto a la versión original:
      - Mejora D: Jaccard de entidades suavizado (< jaccard_threshold, no == 0).
      - Muerte a la Fusión Ciega: Se aceptan micro-eventos puramente atómicos.

    Parámetros
    ----------
    df_cluster        : Sub-dataframe del cluster a segmentar.
    embeddings_matrix : Array (N_total, D) de embeddings del dataset completo.
    sigma             : Suavizado Gaussiano para la señal temporal.
    prominence        : Prominencia mínima para detección de picos.
    umbral_similitud  : Umbral coseno residual bajo el que se divide.
    jaccard_threshold : Umbral Jaccard bajo el que se divide por entidades.
    entity_col        : Columna de entidades en df_cluster.

    Returns
    -------
    (segmentos, scores, contadores)
    """
    contadores = {'gap': 0, 'coseno': 0, 'entidades': 0}

    df_sorted = df_cluster.sort_values('fecha_limpia').copy()
    
    # ── NUEVA LÓGICA: Generar puntos de corte candidatos desde 3 frentes ──
    puntos_de_corte: set[pd.Timestamp] = set()
    
    # 1. Valles entre picos (Señal Gaussiana)
    serie_diaria = df_sorted.groupby('fecha_limpia').size()
    if not serie_diaria.empty:
        rango = pd.date_range(start=serie_diaria.index.min(), end=serie_diaria.index.max())
        serie_diaria = serie_diaria.reindex(rango, fill_value=0)
        valores = gaussian_filter1d(serie_diaria.values.astype(float), sigma=sigma)
        picos, _ = find_peaks(valores, prominence=prominence)
        if len(picos) > 1:
            for i in range(len(picos) - 1):
                inicio, fin = picos[i], picos[i + 1]
                idx_min = inicio + int(np.argmin(valores[inicio:fin]))
                puntos_de_corte.add(serie_diaria.index[idx_min])
                
    # 2. Gaps temporales estrictos (>= 7 días)
    GAP_MAX_DIAS = 7
    fechas_list = df_sorted['fecha_limpia'].tolist()
    for i in range(1, len(fechas_list)):
        gap = (fechas_list[i] - fechas_list[i-1]).days
        if gap >= GAP_MAX_DIAS:
            corte = fechas_list[i-1] + pd.Timedelta(days=gap//2)
            puntos_de_corte.add(corte)

    # 3. Lifespan máximo FALLBACK
    # Si detectamos un fragmento continuo sin cortes naturales de más de 15 días, 
    # insertamos cortes intermedios cada 10 días para forzar evaluación semántica.
    puntos_lista = sorted(list(puntos_de_corte)) if puntos_de_corte else []
    marcadores = [fechas_list[0]] + puntos_lista + [fechas_list[-1]]
    if fechas_list:
        for i in range(len(marcadores) - 1):
            if (marcadores[i+1] - marcadores[i]).days > 15:
                fecha_actual = marcadores[i]
                while fecha_actual + pd.Timedelta(days=10) < marcadores[i+1]:
                    fecha_actual += pd.Timedelta(days=10)
                    puntos_de_corte.add(fecha_actual)

    if not puntos_de_corte:
        return [df_cluster], [], contadores

    puntos_de_corte = sorted(list(puntos_de_corte))

    # Centroide del cluster completo
    idx_all = df_cluster.index.tolist()
    centroide = embeddings_matrix[idx_all].mean(axis=0)

    fechas_corte_finales: list[pd.Timestamp] = []
    scores: list[float] = []

    for fecha_corte in puntos_de_corte:
        df_antes   = df_sorted[df_sorted['fecha_limpia'] <= fecha_corte]
        df_despues = df_sorted[df_sorted['fecha_limpia'] >  fecha_corte]

        if df_antes.empty or df_despues.empty:
            continue

        idx_a = df_antes.index.tolist()
        idx_d = df_despues.index.tolist()

        dividir, score, motivo = _validar_division(
            df_antes, df_despues,
            embeddings_matrix, idx_a, idx_d,
            centroide, umbral_similitud, jaccard_threshold,
        )

        scores.append(score)

        if dividir:
            fechas_corte_finales.append(fecha_corte)
            contadores[motivo] = contadores.get(motivo, 0) + 1

    # 5. Construir segmentos
    if not fechas_corte_finales:
        return [df_cluster], scores, contadores

    segmentos: list[pd.DataFrame] = []
    df_restante = df_sorted.copy()

    for fecha in sorted(fechas_corte_finales):
        seg_actual  = df_restante[df_restante['fecha_limpia'] <= fecha]
        df_restante = df_restante[df_restante['fecha_limpia'] >  fecha]
        if not seg_actual.empty:
            segmentos.append(seg_actual)

    if not df_restante.empty:
        segmentos.append(df_restante)

    # 6. No fusionamos los segmentos generados (Atomicidad estricta)
    return segmentos, scores, contadores


# ─────────────────────────────────────────────────────────────────────────────
# Función de consolidación (reemplaza el bucle de Fase 2)
# ─────────────────────────────────────────────────────────────────────────────
def consolidar_micro_eventos(
    df_ruta_a: pd.DataFrame,
    df_ruta_b: pd.DataFrame,
    embeddings_matrix: np.ndarray,
    candidatos_temporales: list[int],
    sigma: float = 1.0,
    prominence: float = 0.5,
    umbral_similitud: float = 0.05,
    jaccard_threshold: float = JACCARD_ENT_THRESHOLD,
) -> tuple[pd.DataFrame, dict]:
    """
    Aplica segmentar_cluster_v2 a todos los candidatos de Ruta A y
    consolida el resultado con Ruta B en un único DataFrame.

    Retorna (df_final, stats) donde stats contiene los contadores globales.
    """
    lista_dfs: list[pd.DataFrame] = []
    stats = {
        'total_gap': 0, 'total_coseno': 0,
        'total_entidades': 0, 'n_divididos': 0, 'all_scores': [],
    }

    print(f"Procesando {len(candidatos_temporales)} clusters de Ruta A...")
    print(f"Parámetros: σ={sigma}, prom={prominence}, "
          f"cos={umbral_similitud}, jaccard={jaccard_threshold}\n")

    for topic_id in candidatos_temporales:
        df_actual = df_ruta_a[df_ruta_a['micro_topic_final'] == topic_id]

        segmentos, scores, contadores = segmentar_cluster_v2(
            df_actual, embeddings_matrix,
            sigma=sigma, prominence=prominence,
            umbral_similitud=umbral_similitud,
            jaccard_threshold=jaccard_threshold,
        )
        stats['all_scores'].extend(scores)
        stats['total_gap']       += contadores['gap']
        stats['total_coseno']    += contadores['coseno']
        stats['total_entidades'] += contadores['entidades']

        if len(segmentos) > 1:
            stats['n_divididos'] += 1

        for i, seg in enumerate(segmentos):
            sub = seg.copy()
            sub['micro_event_id'] = f"{topic_id}_{i}" if len(segmentos) > 1 else str(topic_id)
            lista_dfs.append(sub)

    # Ruta B: micro-eventos atómicos
    df_b = df_ruta_b.copy()
    df_b['micro_event_id'] = df_b['micro_topic_final'].astype(str)
    lista_dfs.append(df_b)

    df_final = pd.concat(lista_dfs, ignore_index=True)

    # Resumen
    total_scores = len(stats['all_scores'])
    if total_scores > 0:
        print("─" * 55)
        print(f"  Cortes candidatos evaluados : {total_scores}")
        print(f"  Gap temporal (≥{GAP_TEMPORAL_MIN}d)       : "
              f"{stats['total_gap']} ({stats['total_gap']/total_scores*100:.1f}%)")
        print(f"  Coseno residual             : "
              f"{stats['total_coseno']} ({stats['total_coseno']/total_scores*100:.1f}%)")
        print(f"  Jaccard entidades (<{jaccard_threshold}) : "
              f"{stats['total_entidades']} ({stats['total_entidades']/total_scores*100:.1f}%)")
        print("─" * 55)

    n_eventos = df_final['micro_event_id'].nunique()
    med_art = df_final.groupby('micro_event_id').size().median()
    print(f"\nMicro-eventos totales : {n_eventos}")
    print(f"Mediana artículos/ev  : {med_art}")

    return df_final, stats