#!/usr/bin/env python3
"""
GHOJUALAMANCHU v3 — CLI
Main command-line interface for the brain system.
Usage: ghoju-v3 <command> [args]
"""
import sys
import json
import argparse
from pathlib import Path

# Setup path
CLI_DIR = Path(__file__).parent
GHOJU_DIR = CLI_DIR.parent
sys.path.insert(0, str(GHOJU_DIR))

from brain.state import load_state, load_lifecycle, load_memory, recent_absences, recent_presence, list_signals
from brain.thalamus import process_signal
from brain import amygdala, hippocampus, corpus, akashic, lethe, rcomplex

def format_signal(signal, verbose=False):
    """Format a signal for human-readable output."""
    parts = []
    amy = signal.get("amygdala", {})
    cor = signal.get("cortex", {})
    hyp = signal.get("hippocampus", {})

    parts.append(f"[{signal.get('signal_id', '?')[:12]}]")

    if amy.get("emotional_tags"):
        parts.append(f"Mood: {', '.join(amy['emotional_tags'][:3])}")
    parts.append(f"Salience: {amy.get('salience', 0):.2f}")

    if cor.get("intent"):
        parts.append(f"Intent: {cor['intent']}")
    if cor.get("topics"):
        parts.append(f"Topics: {', '.join(cor['topics'][:4])}")
    if hyp.get("should_encode"):
        parts.append(f"→ Memory encoded ({hyp.get('memory_id', '?')[:8]})")

    if verbose:
        print(json.dumps(signal, indent=2))
    else:
        print(" | ".join(parts))

def cmd_stimulate(args):
    """Start medulla heartbeat."""
    import subprocess
    log_file = GHOJU_DIR / "data" / "medulla.log"
    print(f"Stimulating medulla (7.83 Hz)... log: {log_file}")

    # Start medulla in daemon mode
    proc = subprocess.Popen(
        [sys.executable, str(GHOJU_DIR / "brain" / "medulla.py"), "--daemon"],
        stdout=open(log_file, "a"),
        stderr=subprocess.STDOUT
    )
    print(f"Medulla PID: {proc.pid}")

    # Verify it started
    import time
    time.sleep(1)
    state = load_state()
    lc = load_lifecycle()
    if state.get("active"):
        print(f"✓ Medulla alive — beat {state.get('current_beat', 0):,}")
        print(f"✓ Lifecycle: {lc.get('stage', '?')} | {lc.get('biological_age', 0):,} beats")
    else:
        print("✗ Medulla did not start — check medulla.log")

def cmd_status(args):
    """Show vital signs."""
    state = load_state()
    lc = load_lifecycle()

    active = state.get("active", False)
    torpor = state.get("torpor", True)
    beat = state.get("current_beat", 0)
    resp = state.get("respiratory_phase", "unknown")
    hz = state.get("medulla_hz", 7.83)
    last = state.get("last_signal_at", "never")

    print("╔══════════════════════════════════════╗")
    print("║     GHOJUALAMANCHU v3 — STATUS       ║")
    print("╠══════════════════════════════════════╣")
    print(f"║  Medulla   : {'ACTIVE ✓' if active else 'INACTIVE ✗':25} ║")
    print(f"║  Torpor    : {'YES (dormant)' if torpor else 'NO (awake)':25} ║")
    print(f"║  Heartbeat : {hz} Hz{' (Schumann)':20} ║")
    print(f"║  Beat      : {beat:>12,}              ║")
    print(f"║  Breath    : {resp.upper():25} ║")
    print(f"║  Last Sig  : {str(last)[:25]:25} ║")
    print("╠══════════════════════════════════════╣")
    print(f"║  Lifecycle : Gen {lc.get('generation', 1)} | {lc.get('stage', 'unknown'):10s}        ║")
    print(f"║  Age       : {lc.get('biological_age', 0):>12,} beats    ║")
    print(f"║  Plasticity: {lc.get('plasticity', 1.0):>5.2f}                      ║")
    print("╚══════════════════════════════════════╝")

def cmd_signal(args):
    """Route a signal through the brain."""
    state = load_state()
    if not state.get("active"):
        print("Medulla inactive. Run: ghoju-v3 stimulate")
        return

    if not args.text:
        print("Usage: ghoju-v3 signal \"your message\" [--json]")
        return

    raw = " ".join(args.text)
    signal = process_signal(raw, source="user", priority=args.priority or "normal")

    if args.json:
        print(json.dumps(signal, indent=2))
    else:
        format_signal(signal)

def cmd_recall(args):
    """Recall recent memories."""
    memory = load_memory()
    episodic = memory.get("episodic", [])
    n = args.n or 5
    print(f"=== RECENT MEMORIES ({len(episodic)} total) ===")
    for i, mem in enumerate(episodic[:n]):
        preview = mem.get("content_preview", mem.get("content", ""))[:70]
        tags = mem.get("emotional_tags", [])
        sal = mem.get("salience", 0)
        print(f"  [{i+1}] (salience {sal:.2f}) {preview}")

def cmd_search(args):
    """Search memory."""
    if not args.query:
        print("Usage: ghoju-v3 search \"query\"")
        return
    query = " ".join(args.query)
    results = hippocampus.search_memory(query)
    print(f"=== MEMORY SEARCH: \"{query}\" ({len(results)} results) ===")
    for r in results[:10]:
        if r.get("type") == "semantic":
            print(f"  [semantic] {r.get('content', {}).get('fact', '')}")
        else:
            print(f"  [{r.get('id', '?')}] {r.get('content_preview', r.get('content', ''))[:70]}")

def cmd_amygdala_cmd(args):
    """Show amygdala state."""
    state = load_state()
    if not state.get("active"):
        print("Medulla inactive.")
        return
    signal = process_signal("system amygdala check", source="system")
    amy = signal["amygdala"]
    print("=== AMYGDALA ===")
    print(f"  Salience : {amy['salience']:.3f}")
    print(f"  Valence  : {amy['valence']}")
    print(f"  Arousal  : {amy['arousal']}")
    print(f"  Tags     : {', '.join(amy['emotional_tags'])}")

def cmd_lethe_cmd(args):
    """Show lethe absence log."""
    absences = recent_absences(args.n or 10)
    print(f"=== LETHE ({len(absences)} recent absences) ===")
    for a in absences:
        cat = a.get("category", "?")
        reason = a.get("reason", a.get("noted_at", ""))
        print(f"  [{cat}] {reason[:65]}")

def cmd_corpus_cmd(args):
    """Show corpus planetary phase."""
    phase = corpus.get_planetary_phase()
    bias = corpus.cross_scale_bias({})
    print("=== CORPUS ===")
    print(f"  Planetary Phase : {phase}")
    print(f"  Cortical Bias   : {bias.get('cortex_bias', 'unknown')}")
    print(f"  Amygdala Δ      : {bias.get('amygdala_increment', 0)}")

def cmd_hibernate(args):
    """Enter torpor (low-power dormant state)."""
    state = load_state()
    state["torpor"] = True
    state["active"] = False  # Medulla will stop on next beat check
    from brain.state import save_state
    save_state(state)
    print(f"Torpor entered at beat {state.get('current_beat', 0):,}")

def cmd_wake(args):
    """Exit torpor, restart medulla."""
    cmd_stimulate(args)

def cmd_pulse(args):
    """Run a specific number of medulla beats."""
    import subprocess
    beats = args.beats or 1
    print(f"Running {beats} medulla beat(s) at 7.83 Hz...")
    result = subprocess.run(
        [sys.executable, str(GHOJU_DIR / "brain" / "medulla.py"), "--beats", str(beats)],
        capture_output=True, text=True
    )
    print(result.stdout)
    if result.stderr:
        print(result.stderr, file=sys.stderr)

def main():
    parser = argparse.ArgumentParser(description="GHOJUALAMANCHU v3 CLI")
    sub = parser.add_subparsers(dest="command")

    # stimulate
    stim_parser = sub.add_parser("stimulate", help="Start medulla heartbeat (7.83 Hz)")
    stim_parser.set_defaults(func=cmd_stimulate)

    # status
    stat_parser = sub.add_parser("status", help="Show vital signs")
    stat_parser.set_defaults(func=cmd_status)

    # signal
    sig_parser = sub.add_parser("signal", help="Route a signal through the brain")
    sig_parser.add_argument("text", nargs="*", help="Signal text")
    sig_parser.add_argument("--json", action="store_true", help="Output full JSON")
    sig_parser.add_argument("--priority", choices=["low", "normal", "high", "critical"])
    sig_parser.set_defaults(func=cmd_signal)

    # recall
    rec_parser = sub.add_parser("recall", help="Recall recent memories")
    rec_parser.add_argument("-n", type=int, help="Number of memories (default: 5)")
    rec_parser.set_defaults(func=cmd_recall)

    # search
    sea_parser = sub.add_parser("search", help="Search memory")
    sea_parser.add_argument("query", nargs="*", help="Search query")
    sea_parser.set_defaults(func=cmd_search)

    # amygdala
    amy_parser = sub.add_parser("amygdala", help="Show amygdala state")
    amy_parser.set_defaults(func=cmd_amygdala_cmd)

    # lethe
    let_parser = sub.add_parser("lethe", help="Show absence log")
    let_parser.add_argument("-n", type=int, help="Number of entries")
    let_parser.set_defaults(func=cmd_lethe_cmd)

    # corpus
    cor_parser = sub.add_parser("corpus", help="Show planetary phase")
    cor_parser.set_defaults(func=cmd_corpus_cmd)

    # hibernate
    hib_parser = sub.add_parser("hibernate", help="Enter torpor")
    hib_parser.set_defaults(func=cmd_hibernate)

    # wake
    wake_parser = sub.add_parser("wake", help="Exit torpor, restart medulla")
    wake_parser.set_defaults(func=cmd_wake)

    # pulse
    pul_parser = sub.add_parser("pulse", help="Run n medulla beats")
    pul_parser.add_argument("beats", type=int, nargs="?", default=1)
    pul_parser.set_defaults(func=cmd_pulse)

    args = parser.parse_args()

    if hasattr(args, "func"):
        args.func(args)
    else:
        parser.print_help()

if __name__ == "__main__":
    main()