import gradio as gr
from dataclasses import dataclass
from typing import Dict, Any
import time
import json

# =========================
# CORE SYSTEM DEFINITIONS
# =========================

@dataclass
class SystemState:
    intent: str
    context: str
    constraints: Dict[str, Any]
    timestamp: float

class ControlPolicy:
    """
    Control logic: selects an action given state, goals, and constraints
    """
    def decide(self, state: SystemState) -> str:
        # Deterministic, auditable decision logic
        if "code" in state.intent.lower():
            return "Generate structured code with constraints enforced."
        if "analyze" in state.intent.lower():
            return "Perform constrained system analysis."
        return "Respond with bounded explanatory output."

class ConstraintEngine:
    """
    Hard constraints (Λ)
    """
    def validate(self, output: str) -> bool:
        blocked_terms = ["harm", "weapon", "illegal"]
        return not any(term in output.lower() for term in blocked_terms)

class MemoryLedger:
    """
    Provenance / audit log (Ω)
    """
    def __init__(self):
        self.events = []

    def record(self, state: SystemState, decision: str, output: str):
        self.events.append({
            "time": state.timestamp,
            "intent": state.intent,
            "decision": decision,
            "output": output
        })

    def export(self):
        return json.dumps(self.events, indent=2)

class CodexOperationalEngine:
    """
    Unified operational intelligence engine
    """
    def __init__(self):
        self.policy = ControlPolicy()
        self.constraints = ConstraintEngine()
        self.memory = MemoryLedger()

    def run(self, intent: str, context: str) -> Dict[str, str]:
        state = SystemState(
            intent=intent,
            context=context,
            constraints={"safety": True},
            timestamp=time.time()
        )

        decision = self.policy.decide(state)

        # Core operational output (Θ)
        output = (
            f"Decision: {decision}\n\n"
            f"Context received:\n{context}\n\n"
            f"System status: constraints enforced, execution bounded."
        )

        # Constraint enforcement
        if not self.constraints.validate(output):
            output = "Output blocked by constraint engine."

        self.memory.record(state, decision, output)

        return {
            "output": output,
            "decision": decision,
            "audit": self.memory.export()
        }

# =========================
# GRADIO INTERFACE
# =========================

engine = CodexOperationalEngine()

def codex_interface(intent: str, context: str):
    result = engine.run(intent, context)
    return result["output"], result["decision"], result["audit"]

with gr.Blocks(title="Jarvis X – Codex Operational Intelligence") as demo:
    gr.Markdown(
        """
        # 🧠 Jarvis X — Codex Operational Intelligence  
        **Constraint-aware, deterministic, beyond-SOTA control architecture**

        This system demonstrates:
        - Operational intelligence (not autonomy)
        - Control logic under constraints
        - Auditable decision paths
        - Physics-compatible system reasoning
        """
    )

    with gr.Row():
        intent_input = gr.Textbox(label="Intent (Ψ)", placeholder="e.g. analyze system, generate code")
        context_input = gr.Textbox(label="Context (χ)", lines=5)

    run_btn = gr.Button("Execute")

    with gr.Row():
        output_box = gr.Textbox(label="System Output (Θ)", lines=6)
        decision_box = gr.Textbox(label="Control Decision (π)")
        audit_box = gr.Textbox(label="Audit Log (Ω)", lines=6)

    run_btn.click(
        codex_interface,
        inputs=[intent_input, context_input],
        outputs=[output_box, decision_box, audit_box]
    )

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