# interface.py (hotfix)
import gradio as gr
from app import run_simulation
from registry_utils import append_to_registry
from registry_viewer import display_registry
from mutation_designer import build_mutation
from lineage_tracker import register_lineage
from lineage_visualizer import render_lineage_tree
from waveform_renderer import render_waveform
from leaderboard import generate_leaderboard
from codex.formulas import GVU_FORMULAS, rft_invariants

# --- Safety guard to ensure agent has required keys ---
def ensure_agent_shape(agent: dict, mutation_profile: dict) -> dict:
    if not isinstance(agent, dict):
        agent = {}

    agent.setdefault("id", mutation_profile.get("agent_id", "Agent_Unknown"))
    agent.setdefault("tier", mutation_profile.get("tier_drift", "Tier_1"))
    agent.setdefault("symbolic_operators", mutation_profile.get("symbolic_operators", ["R", "O", "T", "P"]))
    agent.setdefault("emotional_resonance", mutation_profile.get("emotional_resonance", False))

    overlay = agent.get("collapse_overlay", {})
    if not isinstance(overlay, dict):
        overlay = {}
    overlay.setdefault("tau_eff", 1.8 if mutation_profile.get("collapse_torque") == "Gen6508_M5" else 1.2)
    overlay.setdefault("beta_band", 0.65 if mutation_profile.get("collapse_torque") == "Gen6508_M5" else 0.4)
    overlay.setdefault("operator_weights", {("R","O"): 0.9, ("T","P"): 0.7})
    agent["collapse_overlay"] = overlay

    return agent

# --- Simulation ---
def simulate(agent_id, collapse_torque, emotional_resonance, tier_drift):
    mutation_profile = build_mutation(agent_id, collapse_torque, tier_drift, emotional_resonance)
    agent, sha512 = run_simulation(agent_id, mutation_profile)
    agent = ensure_agent_shape(agent, mutation_profile)

    # Try scoring and rendering safely
    try:
        score = GVU_FORMULAS["Formula_20"].evaluate(agent)
        invariants = rft_invariants(agent)
    except Exception as e:
        err = f"<div style='color:#c0392b'><b>Error scoring agent:</b> {e}</div>"
        return err, err, err, err, err

    fields = {
        "Φᵢ": f"<div><b>Φᵢ Awareness</b><br>Tier={agent.get('tier')} τ_eff={invariants['tau_eff']}</div>",
        "Kᵢⱼ": f"<div><b>Kᵢⱼ Coupling</b><br>Operators={invariants['operator_count']}</div>",
        "Φ_col": f"<div><b>Φ_col Collective</b><br>Score={score}</div>"
    }

    append_to_registry(agent_id, collapse_torque, tier_drift, emotional_resonance, score, sha512)

    summary = (
        f"📊 <b>Fitness (GVU):</b> {score}<br>"
        f"🧷 <b>Invariants:</b> τ_eff={invariants['tau_eff']}, β={invariants['beta_band']}, "
        f"|K|={invariants['operator_count']}, tier={invariants['tier_level']}<br>"
        f"🔐 <b>SHA-512:</b> <code>{sha512}</code>"
    )
    # Safe waveform render
    try:
        wf = render_waveform(agent, score)
    except Exception as e:
        wf = f"<div style='color:#c0392b'><b>Error rendering waveform:</b> {e}</div>"

    return fields["Φᵢ"], fields["Kᵢⱼ"], fields["Φ_col"], wf, summary

# --- Forge ---
def forge_agent(parent_id, new_id, collapse_torque, emotional_resonance, tier_drift, max_depth):
    mutation_profile = build_mutation(new_id, collapse_torque, tier_drift, emotional_resonance)
    agent, _ = run_simulation(new_id, mutation_profile)
    agent = ensure_agent_shape(agent, mutation_profile)
    register_lineage(parent_id, new_id, {
        "tier_drift": tier_drift,
        "collapse_torque": collapse_torque,
        "symbolic_operators": agent.get("symbolic_operators", [])
    })
    return render_lineage_tree(parent_id, max_depth=max_depth)

# --- Interface Layout ---
with gr.Blocks() as demo:
    gr.Markdown("# 🧠 RFT Codex Sovereign")
    gr.Markdown("Rendered Frame Theory simulation, lineage, and GVU sealing. Author: Liam Grinstead.")

    # Compact CSS to prevent clipping
    gr.Markdown("""
    <style>
      .gr-column { gap: 8px; }
      .gradio-container { padding-bottom: 24px; }
      .output-grid .wrap { max-height: 200px; overflow-y: auto; }
    </style>
    """)

    # Simulation Tab
    with gr.Tab("Simulate Agent"):
        with gr.Row():
            agent_id = gr.Dropdown(["Agent_5","Agent_7","Agent_1032"], label="Agent ID")
            collapse_torque = gr.Dropdown(["Gen6508_M5","Gen26_M23"], label="Collapse Torque Overlay")
            emotional_resonance = gr.Checkbox(label="Inject Emotional Resonance")
            tier_drift = gr.Dropdown(["Tier_1","Tier_2","Tier_6"], label="Tier Drift")
        simulate_btn = gr.Button("Run Simulation")

        # Split outputs into two rows to avoid overflow
        with gr.Row():
            phi_i = gr.HTML(label="Φᵢ Awareness Field")
            k_ij = gr.HTML(label="Kᵢⱼ Correlation Kernel")
        with gr.Row():
            phi_col = gr.HTML(label="Φ_col Coherence Field")
            waveform = gr.HTML(label="Collapse Torque Waveform")

        summary = gr.HTML(label="Simulation Summary")
        simulate_btn.click(
            simulate,
            inputs=[agent_id, collapse_torque, emotional_resonance, tier_drift],
            outputs=[phi_i, k_ij, phi_col, waveform, summary]
        )

    # Registry Tab
    with gr.Tab("View Registry"):
        registry_output = gr.Textbox(label="Codex Registry", lines=20)
        refresh_btn = gr.Button("Refresh Registry")
        refresh_btn.click(display_registry, outputs=registry_output)

    # Forge Tab
    with gr.Tab("Codex Forge"):
        gr.Markdown("### 🧬 Evolve a New Agent from a Parent")
        parent_id = gr.Dropdown(["Agent_5","Agent_7","Agent_1032"], label="Parent Agent")
        new_id = gr.Textbox(label="New Agent ID")
        forge_torque = gr.Dropdown(["Gen6508_M5","Gen26_M23"], label="Collapse Torque")
        forge_resonance = gr.Checkbox(label="Inject Emotional Resonance")
        forge_tier = gr.Dropdown(["Tier_1","Tier_2","Tier_6"], label="Tier Drift")
        max_depth = gr.Slider(1, 8, value=5, step=1, label="Lineage depth")
        forge_btn = gr.Button("Forge Agent")
        lineage_svg_output = gr.HTML(label="Lineage Visualization")
        forge_btn.click(
            forge_agent,
            inputs=[parent_id, new_id, forge_torque, forge_resonance, forge_tier, max_depth],
            outputs=lineage_svg_output
        )

    # Leaderboard Tab
    with gr.Tab("Leaderboard"):
        leaderboard_output = gr.Textbox(label="Top Agents", lines=15)
        refresh_leaderboard = gr.Button("Refresh Leaderboard")
        refresh_leaderboard.click(generate_leaderboard, outputs=leaderboard_output)

demo.launch()