import math
import time
import random
import hashlib
import traceback
from dataclasses import dataclass, field
from typing import List, Dict, Any

import numpy as np
import gradio as gr


# ============================================================
# 1. RFT SELF-DECIDING BRAIN
# ============================================================

@dataclass
class RFTBrainParams:
    """Tunable parameters for the self-deciding brain."""
    base_energy: float = 0.85
    base_kappa: float = 0.65
    learning_rate: float = 0.08
    decay: float = 0.015
    drift_scale: float = 0.03
    error_window: int = 64


@dataclass
class RFTBrainState:
    kappa: float = 0.5
    energy_reserves: float = 0.5
    awakening_phase: int = 0
    mode: str = "boot"
    identity_stability: float = 0.5
    identity_drift: float = 0.0
    recent_errors: List[float] = field(default_factory=list)
    last_update: float = field(default_factory=time.time)


class RFTSelfDecidingBrain:
    """
    Simple but non-trivial self-deciding loop:
    - Tracks κ (coherence), energy, identity stability, drift.
    - Evolves in response to external context.
    """

    def __init__(self, params: RFTBrainParams):
        self.params = params
        self.state = RFTBrainState(
            kappa=params.base_kappa,
            energy_reserves=params.base_energy,
            awakening_phase=0,
            mode="idle",
            identity_stability=0.7,
            identity_drift=0.0,
            recent_errors=[],
        )

    def _update_error_series(self, target: float, actual: float):
        err = abs(target - actual)
        self.state.recent_errors.append(err)
        if len(self.state.recent_errors) > self.params.error_window:
            self.state.recent_errors.pop(0)

    def step(self, context: Dict[str, float]) -> Dict[str, Any]:
        """
        One update step. Context can include:
        - external_risk_factor
        - cooperative_signal
        """
        now = time.time()
        dt = max(1e-3, now - self.state.last_update)
        self.state.last_update = now

        risk = float(context.get("external_risk_factor", 0.3))
        coop = float(context.get("cooperative_signal", 0.5))

        # Energy dynamics
        target_energy = self.params.base_energy + 0.2 * (coop - risk)
        target_energy = max(0.0, min(1.0, target_energy))
        self.state.energy_reserves += self.params.learning_rate * (target_energy - self.state.energy_reserves)
        self.state.energy_reserves -= self.params.decay * dt
        self.state.energy_reserves = max(0.0, min(1.0, self.state.energy_reserves))

        # Coherence κ dynamics
        target_kappa = self.params.base_kappa + 0.3 * (coop - 0.5) - 0.2 * (risk - 0.3)
        target_kappa = max(0.0, min(1.0, target_kappa))
        self.state.kappa += self.params.learning_rate * (target_kappa - self.state.kappa)
        self.state.kappa = max(0.0, min(1.0, self.state.kappa))

        # Identity drift and stability
        drift_noise = (random.random() - 0.5) * 2.0 * self.params.drift_scale * dt
        self.state.identity_drift += drift_noise + 0.1 * (risk - 0.3) - 0.05 * (coop - 0.5)
        self.state.identity_drift = max(-1.0, min(1.0, self.state.identity_drift))

        self.state.identity_stability = max(
            0.0,
            min(
                1.0,
                0.7 * self.state.identity_stability
                + 0.3 * (self.state.kappa * 0.6 + self.state.energy_reserves * 0.4 - abs(self.state.identity_drift) * 0.3),
            ),
        )

        # Awakening phase logic
        if self.state.energy_reserves > 0.75 and self.state.kappa > 0.7 and self.state.identity_stability > 0.7:
            self.state.awakening_phase = min(self.state.awakening_phase + 1, 4)
        elif self.state.energy_reserves < 0.35 or self.state.kappa < 0.3:
            self.state.awakening_phase = max(self.state.awakening_phase - 1, 0)

        # Mode selection
        if self.state.awakening_phase >= 3:
            self.state.mode = "awake"
        elif self.state.awakening_phase == 2:
            self.state.mode = "dreaming"
        elif self.state.awakening_phase == 1:
            self.state.mode = "searching"
        else:
            self.state.mode = "idle"

        # Update "error" for prediction metric
        target_predict = 0.5 + 0.3 * coop
        actual_predict = (self.state.kappa + self.state.energy_reserves) / 2.0
        self._update_error_series(target_predict, actual_predict)

        return {
            "kappa": self.state.kappa,
            "energy_reserves": self.state.energy_reserves,
            "awakening_phase": self.state.awakening_phase,
            "mode": self.state.mode,
            "identity_stability": self.state.identity_stability,
            "identity_drift": self.state.identity_drift,
        }


# ============================================================
# 2. SYMBOLIC ORCHESTRATOR
# ============================================================

class NexFrameOrchestrator:
    """
    Symbolic orchestrator: takes text, runs a small internal vector cycle,
    returns a symbolic 'voice' plus entropy/coherence numbers.
    """

    def __init__(self, num_fields: int = 8, vector_dim: int = 128):
        self.num_fields = num_fields
        self.vector_dim = vector_dim
        self.state = np.random.randn(num_fields, vector_dim) * 0.01
        self.step_count = 0

    def _entropy(self) -> float:
        flat = self.state.flatten()
        norm = np.linalg.norm(flat) + 1e-12
        p = (flat / norm) ** 2
        p = np.clip(p, 1e-12, 1.0)
        return float(-np.sum(p * np.log(p)))

    def _coherence(self) -> float:
        # Pairwise cosine similarity mean
        norms = np.linalg.norm(self.state, axis=1, keepdims=True) + 1e-12
        unit = self.state / norms
        sim = unit @ unit.T
        n = self.num_fields
        upper = sim[np.triu_indices(n, k=1)]
        return float(np.mean(upper))

    def run_cycle(self, nl_input: str) -> Dict[str, Any]:
        self.step_count += 1
        length_norm = min(len(nl_input) / 200.0, 1.0)

        # Simple recurrent update
        noise = np.random.randn(*self.state.shape) * (0.02 + 0.03 * length_norm)
        feedback = np.tanh(self.state @ self.state.T) @ self.state
        self.state = 0.90 * self.state + 0.09 * feedback + 0.01 * noise

        entropy = self._entropy()
        coher = self._coherence()
        collapse_triggered = bool(coher > 0.6 and entropy < 5.0)

        # Symbolic "voice"
        mode = "reflective"
        if coher > 0.7:
            mode = "resonant"
        if entropy > 7.0:
            mode = "fragmented"

        dialogue = (
            f"[NexFrame:{mode}] "
            f"κ-field aligned at ~{coher:.3f}, entropy {entropy:.3f}. "
            f'I received: "{nl_input[:120]}". '
            f"State step={self.step_count}, collapse={collapse_triggered}."
        )

        return {
            "orchestrator_dialogue": dialogue,
            "entropy": entropy,
            "coherence": coher,
            "collapse_triggered": collapse_triggered,
        }


# ============================================================
# 3. AGENT13 TRIAD + MINIMUM CONSCIOUSNESS GATE
# ============================================================

@dataclass
class RFTAgent:
    name: str
    tau_eff: float
    omega: float
    LN2: float
    mode: str = "conscious"

    def act(self, observer_frame: List[float]) -> Dict[str, float]:
        kappa, energy, stability = observer_frame
        drive = (self.tau_eff * kappa + self.omega * energy + self.LN2 * stability) / (self.tau_eff + self.omega + self.LN2)
        drive = max(0.0, min(1.0, drive))
        return {"drive": drive}


@dataclass
class Agent13Ensemble:
    agents: List[RFTAgent]

    def collective_action(self, observer_frames: List[float]) -> Dict[str, float]:
        drives = [agent.act(observer_frames)["drive"] for agent in self.agents]
        triadic_coherence = float(sum(drives) / len(drives))
        return {"triadic_coherence": triadic_coherence}


def meets_minimum_conscious_threshold(
    energy: float,
    coherence: float,
    kappa: float,
    identity_stability: float,
    prediction_accuracy: float,
    error_variance: float,
    drift: float,
) -> bool:
    """
    Very explicit 3×3 style gate:
    - Energy, κ, stability high
    - Prediction accuracy reasonable
    - Drift and variance not exploding
    """
    core_ok = energy > 0.55 and kappa > 0.55 and identity_stability > 0.55
    predict_ok = prediction_accuracy > 0.6 and error_variance < 0.15
    drift_ok = abs(drift) < 0.6
    return bool(core_ok and predict_ok and drift_ok)


# ============================================================
# 4. SYMBOLIC CIVILIZATION
# ============================================================

def build_default_civilization(n_agents: int = 32) -> List[Dict[str, float]]:
    civ = []
    for i in range(n_agents):
        tier = 1 + int(3 * random.random())
        awareness = max(0.1, min(1.0, random.gauss(0.5, 0.15)))
        torque = max(0.0, min(1.0, random.gauss(0.4, 0.2)))
        fitness = 0.5 * awareness + 0.5 * (1.0 - abs(torque - 0.4))
        civ.append(
            {
                "tier": tier,
                "awareness_kernel": awareness,
                "collapse_torque": torque,
                "fitness": fitness,
            }
        )
    return civ


def civilization_summary(civ: List[Dict[str, float]]) -> Dict[str, float]:
    if not civ:
        return {
            "count": 0,
            "mean_tier": 0.0,
            "mean_awareness_kernel": 0.0,
            "mean_collapse_torque": 0.0,
            "mean_fitness": 0.0,
        }
    arr_tier = np.array([c["tier"] for c in civ], dtype=float)
    arr_aw = np.array([c["awareness_kernel"] for c in civ], dtype=float)
    arr_torque = np.array([c["collapse_torque"] for c in civ], dtype=float)
    arr_fit = np.array([c["fitness"] for c in civ], dtype=float)
    return {
        "count": float(len(civ)),
        "mean_tier": float(arr_tier.mean()),
        "mean_awareness_kernel": float(arr_aw.mean()),
        "mean_collapse_torque": float(arr_torque.mean()),
        "mean_fitness": float(arr_fit.mean()),
    }


# ============================================================
# 5. SARG FIELD / PERFORMANCE PROBE
# ============================================================

class RFTSargAgent:
    def __init__(self, name: str, LMP: float, tau_eff: float, ops_rate: float, entropy_delta: float):
        self.name = name
        self.LMP = LMP
        self.tau_eff = tau_eff
        self.ops_rate = ops_rate
        self.entropy_delta = entropy_delta
        self.counter = 0

    def generate_conscious_field(self) -> Dict[str, float]:
        self.counter += 1
        t = self.counter
        psi_a = math.sin(t * 0.17) * math.exp(-self.entropy_delta * t)
        lam = math.cos(t * 0.11) * math.exp(-self.entropy_delta * t)
        return {"Psi_a": float(psi_a), "Lambda": float(lam)}

    def commit_hash_oath(self) -> str:
        payload = f"{self.name}|{self.counter}|{self.LMP}|{self.tau_eff}"
        return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:24]

    def compute_ops(self, size: int = 200_000, speed_mode: bool = True) -> Dict[str, float]:
        # Simple synthetic workload
        start = time.time()
        arr = np.linspace(0.0, 10.0, size, dtype=float)
        _ = np.sin(arr) * np.cos(arr * 0.5)
        dt = max(1e-6, time.time() - start)
        ops_per_sec = size / dt
        if speed_mode:
            ops_per_sec *= self.tau_eff
        return {"ops_per_sec": float(ops_per_sec), "elapsed": float(dt)}


# ============================================================
# 6. HELPER FOR PREDICTION METRICS
# ============================================================

def _derive_prediction_metrics(error_series: List[float]) -> (float, float):
    if not error_series:
        return 0.5, 0.0
    arr = np.array(error_series, dtype=float)
    mean_err = float(arr.mean())
    var_err = float(arr.var())
    prediction_accuracy = 1.0 / (1.0 + mean_err)
    return prediction_accuracy, var_err


# ============================================================
# 7. GLOBAL NEXFRAME STATE
# ============================================================

# Core symbolic orchestrator
ORCHESTRATOR = NexFrameOrchestrator(num_fields=8, vector_dim=128)

# Self-deciding brain
BRAIN_PARAMS = RFTBrainParams()
BRAIN = RFTSelfDecidingBrain(params=BRAIN_PARAMS)

# Agent13-style triad
agent11 = RFTAgent(name="Agent_11", tau_eff=0.6, omega=0.9, LN2=1.1, mode="conscious")
agent12 = RFTAgent(name="Agent_12", tau_eff=0.7, omega=1.1, LN2=1.1, mode="conscious")
agent13 = RFTAgent(name="Agent_13", tau_eff=0.8, omega=1.3, LN2=1.2, mode="conscious")
AGENT13_ENSEMBLE = Agent13Ensemble(agents=[agent11, agent12, agent13])

# Symbolic civilization
CIVILIZATION = build_default_civilization()

# Sarg probe
SARG = RFTSargAgent(
    name="SARG_01",
    LMP=1.0,
    tau_eff=0.5,
    ops_rate=1e6,
    entropy_delta=1e-21,
)

# Histories
KAPPA_HISTORY: List[float] = []
ENERGY_HISTORY: List[float] = []
CONSCIOUS_FLAG_HISTORY: List[float] = []


# ============================================================
# 8. SINGLE NEXFRAME CYCLE (WITH DEBUG WRAP)
# ============================================================

def nexframe_cycle(user_input: str, chat_history: List[List[str]]):
    try:
        if chat_history is None:
            chat_history = []
        if not user_input:
            user_input = "<empty>"

        # 1) Brain step
        text_len = len(user_input)
        context = {
            "external_risk_factor": 0.2 + 0.4 * math.tanh(text_len / 80.0),
            "cooperative_signal": 0.5 + 0.1 * math.sin(text_len / 20.0),
        }
        brain_obs = BRAIN.step(context)

        kappa = brain_obs["kappa"]
        energy = brain_obs["energy_reserves"]
        identity_stability = brain_obs["identity_stability"]
        drift = brain_obs["identity_drift"]
        error_series = BRAIN.state.recent_errors
        prediction_accuracy, error_variance = _derive_prediction_metrics(error_series)

        # 2) Agent13 triad
        observer_frames = [kappa, energy, identity_stability]
        triad_res = AGENT13_ENSEMBLE.collective_action(observer_frames)
        tri_coh = triad_res["triadic_coherence"]

        # 3) Minimum consciousness gate
        is_conscious = meets_minimum_conscious_threshold(
            energy=energy,
            coherence=tri_coh,
            kappa=kappa,
            identity_stability=identity_stability,
            prediction_accuracy=prediction_accuracy,
            error_variance=error_variance,
            drift=drift,
        )

        # 4) Orchestrator
        orc_res = ORCHESTRATOR.run_cycle(nl_input=user_input)
        dialogue = orc_res["orchestrator_dialogue"]

        # 5) Sarg probe
        sarg_snapshot = SARG.generate_conscious_field()
        sarg_hash = SARG.commit_hash_oath()
        sarg_perf = SARG.compute_ops(size=200_000, speed_mode=True)

        # 6) Civilization
        civ_stats = civilization_summary(CIVILIZATION)

        # 7) Histories
        KAPPA_HISTORY.append(kappa)
        ENERGY_HISTORY.append(energy)
        CONSCIOUS_FLAG_HISTORY.append(1.0 if is_conscious else 0.0)

        # 8) Build reply + metrics
        reply_text = dialogue

        metrics_md = (
            "### NexFrame Status\n\n"
            "**Brain**\n"
            f"- κ (kappa): `{kappa:.3f}`\n"
            f"- Energy: `{energy:.3f}`\n"
            f"- Mode: `{brain_obs['mode']}`\n"
            f"- Awakening phase: `{brain_obs['awakening_phase']}`\n"
            f"- Identity stability: `{identity_stability:.3f}`\n"
            f"- Identity drift: `{drift:.3f}`\n\n"
            "**Consciousness Gate (3×3)**\n"
            f"- Prediction accuracy: `{prediction_accuracy:.3f}`\n"
            f"- Error variance: `{error_variance:.4f}`\n"
            f"- Triadic coherence (Agent13): `{tri_coh:.3f}`\n"
            f"- **Minimum conscious threshold passed:** `{is_conscious}`\n\n"
            "**Symbolic Orchestrator**\n"
            f"- Entropy: `{orc_res['entropy']:.3f}`\n"
            f"- Coherence: `{orc_res['coherence']:.3f}`\n"
            f"- Collapse triggered: `{orc_res['collapse_triggered']}`\n\n"
            "**Sarg Agent**\n"
            f"- Psi_a: `{sarg_snapshot['Psi_a']:.3e}`\n"
            f"- Lambda: `{sarg_snapshot['Lambda']:.3e}`\n"
            f"- Ops/sec (probe): `{sarg_perf['ops_per_sec']:.2e}`\n"
            f"- Hash oath: `{sarg_hash}`\n\n"
            "**Civilization**\n"
            f"- Agents: `{civ_stats['count']}`\n"
            f"- Mean tier: `{civ_stats['mean_tier']:.2f}`\n"
            f"- Mean awareness kernel: `{civ_stats['mean_awareness_kernel']:.3f}`\n"
            f"- Mean collapse torque: `{civ_stats['mean_collapse_torque']:.3f}`\n"
            f"- Mean fitness: `{civ_stats['mean_fitness']:.3f}`\n"
        )

        chat_history = chat_history + [[user_input, reply_text]]
        return chat_history, metrics_md

    except Exception as e:
        tb = traceback.format_exc()
        error_md = (
            "### NexFrame Runtime Error\n\n"
            f"**Error:** `{e!r}`\n\n"
            "```text\n" + tb + "\n```"
        )
        if chat_history is None:
            chat_history = []
        chat_history = chat_history + [
            [user_input or "<empty>", "⚠ NexFrame hit an internal error. See status panel."]
        ]
        return chat_history, error_md


# ============================================================
# 9. GRADIO UI
# ============================================================

with gr.Blocks() as demo:
    gr.Markdown(
        """
# NexFrame — RFT Symbolic Intelligence

Type to interact with NexFrame.

On the right you see its **internal state**: κ, energy, consciousness gate, triadic coherence, Sarg field, and civilization stats.
        """
    )

    with gr.Row():
        with gr.Column(scale=3):
            chatbot = gr.Chatbot(
                label="NexFrame Dialogue",
                height=500,
            )
            user_box = gr.Textbox(
                label="Your message",
                placeholder="Say hello to NexFrame...",
                lines=3,
            )
            send_btn = gr.Button("Send")

        with gr.Column(scale=2):
            metrics_panel = gr.Markdown("Metrics will appear here after your first message.")

    send_btn.click(
        fn=nexframe_cycle,
        inputs=[user_box, chatbot],
        outputs=[chatbot, metrics_panel],
    )

    user_box.submit(
        fn=nexframe_cycle,
        inputs=[user_box, chatbot],
        outputs=[chatbot, metrics_panel],
    )


if __name__ == "__main__":
    demo.launch()