"""Stable persistence-diagram summary vectorisation (18 scalars).

Used by LGAP, RSCD, OWPS, GCLP, EAPT — every Phase-0..4 feature that
turns a small distance matrix into a Ripser persistence diagram and
needs a fixed-length, learnable summary.

Output (18 scalars, in order):
  H0:  count, sum_persistence, max_persistence, mean_persistence,
       std_persistence, entropy_of_persistence
  H1:  count, sum_persistence, max_persistence, mean_persistence,
       std_persistence, entropy_of_persistence
  cross: betti0_at_q25, betti0_at_q50, betti0_at_q75,
         betti1_at_q25, betti1_at_q50, betti1_at_q75
"""
from __future__ import annotations

from typing import List, Tuple

import numpy as np


def _safe_entropy(persistences: np.ndarray) -> float:
    if persistences.size == 0:
        return 0.0
    p = persistences / (persistences.sum() + 1e-12)
    p = np.clip(p, 1e-12, 1.0)
    return float(-(p * np.log(p)).sum())


def _persistence_stats(intervals: np.ndarray) -> List[float]:
    """intervals: (n, 2) array of [birth, death]. Returns 6 scalars."""
    if intervals.shape[0] == 0:
        return [0.0] * 6
    pers = intervals[:, 1] - intervals[:, 0]
    finite = pers[np.isfinite(pers)]
    if finite.size == 0:
        return [0.0] * 6
    return [
        float(finite.size),
        float(finite.sum()),
        float(finite.max()),
        float(finite.mean()),
        float(finite.std()),
        _safe_entropy(finite),
    ]


def _betti_counts(intervals: np.ndarray, thresholds: List[float]) -> List[float]:
    if intervals.shape[0] == 0:
        return [0.0] * len(thresholds)
    out = []
    for t in thresholds:
        born_before = intervals[:, 0] <= t
        die_after   = intervals[:, 1] >  t
        out.append(float((born_before & die_after).sum()))
    return out


def summarize_persistence(h0: np.ndarray, h1: np.ndarray,
                            quantiles=(0.25, 0.5, 0.75)) -> List[float]:
    """Return 18-dim summary of (H0, H1) persistence intervals."""
    feats = []
    feats.extend(_persistence_stats(h0))
    feats.extend(_persistence_stats(h1))

    # Pool intervals for threshold determination
    pooled = np.concatenate([h0, h1], axis=0) if (h0.size and h1.size) else (h0 if h0.size else h1)
    if pooled.shape[0] == 0:
        return feats + [0.0] * (2 * len(quantiles))
    finite_mask = np.isfinite(pooled).all(axis=1)
    pooled = pooled[finite_mask]
    if pooled.shape[0] == 0:
        return feats + [0.0] * (2 * len(quantiles))
    thresholds = list(np.quantile(pooled[:, 0], list(quantiles)))
    feats.extend(_betti_counts(h0, thresholds))
    feats.extend(_betti_counts(h1, thresholds))
    return feats


def column_names(prefix: str) -> List[str]:
    return [
        f"{prefix}_H0_count", f"{prefix}_H0_sum", f"{prefix}_H0_max",
        f"{prefix}_H0_mean", f"{prefix}_H0_std", f"{prefix}_H0_ent",
        f"{prefix}_H1_count", f"{prefix}_H1_sum", f"{prefix}_H1_max",
        f"{prefix}_H1_mean", f"{prefix}_H1_std", f"{prefix}_H1_ent",
        f"{prefix}_B0_q25", f"{prefix}_B0_q50", f"{prefix}_B0_q75",
        f"{prefix}_B1_q25", f"{prefix}_B1_q50", f"{prefix}_B1_q75",
    ]


def ripser_summary_from_distance(D: np.ndarray, maxdim: int = 1,
                                    prefix: str = "p") -> Tuple[List[float], List[str]]:
    """Run Ripser on a square distance matrix D and return an 18-scalar summary.

    Falls back to an all-zero feature vector if Ripser is unavailable or D is
    degenerate (one point, all-NaN, etc.).
    """
    try:
        from ripser import ripser
    except ImportError:
        return [0.0] * 18, column_names(prefix)

    if D.shape[0] < 2:
        return [0.0] * 18, column_names(prefix)
    D = np.nan_to_num(D, nan=0.0, posinf=1.0, neginf=0.0)
    # Symmetrise for Ripser
    D = 0.5 * (D + D.T)
    np.fill_diagonal(D, 0.0)
    try:
        res = ripser(D, distance_matrix=True, maxdim=maxdim)
        dgms = res["dgms"]
        h0 = dgms[0] if len(dgms) > 0 else np.zeros((0, 2))
        h1 = dgms[1] if len(dgms) > 1 else np.zeros((0, 2))
    except Exception:
        return [0.0] * 18, column_names(prefix)
    return summarize_persistence(h0, h1), column_names(prefix)