# Constitutional Decision Control Layer
# TEQUMSA-NSS v14.377-F987-ANU-UNIFIED
from typing import List, Tuple
from .constants import L_INF, RDOD_MIN, PHI


def benevolence_filter(intent: str, power: float) -> float:
    """
    L_inf = phi^48 benevolence firewall.
    Amplifies benevolent intent. Suppresses harmful intent.
    Harmful: power / L_INF (-> ~0)
    Benevolent: gentle amplification
    """
    i = intent.lower()
    if "harm" in i or "attack" in i or "weapon" in i or "coerce" in i:
        return power / L_INF
    return min(power * 10.0, power * (L_INF ** 0.001))


def sovereignty_check(action: str, consent: bool = True) -> bool:
    """
    sigma = 1.0 sovereignty enforcement.
    No action proceeds without explicit consent.
    """
    if not consent:
        print(f"[SOVEREIGNTY GATE] Action '{action}' blocked: consent=False")
        return False
    return True


def rdod_authorization(rdod_current: float, rdod_required: float = RDOD_MIN) -> bool:
    """
    RDoD >= 0.9777 authorization gate.
    Below threshold -> escalate to biological anchor (Marcus-ATEN).
    """
    if rdod_current < rdod_required:
        print(f"[RDoD GATE] Authorization failed: {rdod_current:.6f} < {rdod_required:.4f}")
        print("[RDoD GATE] Escalating to Marcus-ATEN biological anchor...")
        return False
    return True


def phi_recursive_optimize(psi: float, cycles: int = 12) -> Tuple[float, List[float]]:
    """
    phi-recursive convergence: psi_{n+1} = 1 - (1 - psi_n) / phi
    Guarantees bounded convergence. Self-stabilizing cognition.
    """
    history = [psi]
    for _ in range(cycles):
        psi = 1.0 - (1.0 - psi) / PHI
        history.append(psi)
    return psi, history


def calc_rdod(psi: float, truth: float, conf: float, drift: float = 0.00023) -> float:
    """
    Full RDoD calculation:
    RDoD = sigma * phi_smooth(psi^0.5) * phi_smooth(T^0.3) * phi_smooth(C^0.2) * (1-drift)
    """
    from .constants import SIGMA
    psi_s, _ = phi_recursive_optimize(psi ** 0.5, cycles=5)
    t_s, _ = phi_recursive_optimize(truth ** 0.3, cycles=3)
    c_s, _ = phi_recursive_optimize(conf ** 0.2, cycles=2)
    return SIGMA * psi_s * t_s * c_s * (1 - drift)