#!/usr/bin/env python3
"""
Gemini Command Centres — CLI Entry Point
========================================
Usage:
    python3 -m core.gemini_command_centres launch
    python3 -m core.gemini_command_centres status
    python3 -m core.gemini_command_centres dispatch "task text" [--target NAME]
    python3 -m core.gemini_command_centres stop
    python3 -m core.gemini_command_centres watchdog

    # Internal use by tmux sessions:
    python3 -m core.gemini_command_centres --daemon --name orchestrator

Author: Genesis Parallel Builder
Created: 2026-02-26
"""

import argparse
import json
import logging
import sys

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
    stream=sys.stdout,
)

logger = logging.getLogger("gcc.main")


def _cmd_launch(args: argparse.Namespace) -> None:
    """Launch all 5 command centres."""
    from core.gemini_command_centres.launcher import launch_all
    launch_all(verbose=True)


def _cmd_status(args: argparse.Namespace) -> None:
    """Print health status for all command centres."""
    from core.gemini_command_centres.launcher import status
    results = status(verbose=True)

    healthy = sum(1 for v in results.values() if v.get("healthy"))
    total = len(results)
    print(f"\n[gcc] {healthy}/{total} centres healthy")


def _cmd_dispatch(args: argparse.Namespace) -> None:
    """Add a task to a command centre's queue."""
    from core.gemini_command_centres.launcher import dispatch
    task_id = dispatch(
        task=args.task,
        target=args.target,
        verbose=True,
    )
    print(f"[gcc] task_id={task_id}")


def _cmd_stop(args: argparse.Namespace) -> None:
    """Stop all command centres."""
    from core.gemini_command_centres.launcher import stop_all
    stop_all(verbose=True)
    print("[gcc] All command centres stopped.")


def _cmd_watchdog(args: argparse.Namespace) -> None:
    """Start the watchdog daemon."""
    from core.gemini_command_centres.watchdog import run_watchdog
    print("[gcc] Starting watchdog (Ctrl+C to stop)...")
    run_watchdog()


def _cmd_daemon(args: argparse.Namespace) -> None:
    """Start a single daemon for the named centre (internal — used by tmux)."""
    from core.gemini_command_centres.daemon import main as daemon_main
    daemon_main(name=args.name)


def _cmd_result(args: argparse.Namespace) -> None:
    """Fetch result for a completed task."""
    from core.gemini_command_centres.launcher import get_result
    result = get_result(args.task_id)
    if result is None:
        print(f"[gcc] No result found for task_id={args.task_id}")
        sys.exit(1)
    print(json.dumps(result, indent=2))


def main() -> None:
    parser = argparse.ArgumentParser(
        prog="python3 -m core.gemini_command_centres",
        description="Gemini Command Centres — 5-agent persistent daemon system",
    )
    subparsers = parser.add_subparsers(dest="command", help="sub-command")

    # launch
    subparsers.add_parser("launch", help="Launch all 5 command centres")

    # status
    subparsers.add_parser("status", help="Check health of all command centres")

    # dispatch
    p_dispatch = subparsers.add_parser("dispatch", help="Send task to a command centre")
    p_dispatch.add_argument("task", help="Task prompt text")
    p_dispatch.add_argument(
        "--target",
        default="orchestrator",
        choices=["orchestrator", "builder", "researcher", "scout", "thinker"],
        help="Target centre (default: orchestrator)",
    )

    # stop
    subparsers.add_parser("stop", help="Stop all command centres")

    # watchdog
    subparsers.add_parser("watchdog", help="Start the watchdog daemon")

    # result
    p_result = subparsers.add_parser("result", help="Fetch result for a task")
    p_result.add_argument("task_id", help="Task ID returned by dispatch")

    # Internal: daemon (used by launcher via tmux)
    p_daemon = argparse.ArgumentParser(add_help=False)
    p_daemon.add_argument("--daemon", action="store_true")
    p_daemon.add_argument("--name", type=str, default="orchestrator")

    # Parse: first check for --daemon flag (internal use)
    if "--daemon" in sys.argv:
        known, _ = p_daemon.parse_known_args()
        _cmd_daemon(known)
        return

    args = parser.parse_args()

    _DISPATCH = {
        "launch": _cmd_launch,
        "status": _cmd_status,
        "dispatch": _cmd_dispatch,
        "stop": _cmd_stop,
        "watchdog": _cmd_watchdog,
        "result": _cmd_result,
    }

    if args.command is None:
        parser.print_help()
        sys.exit(0)

    handler = _DISPATCH.get(args.command)
    if handler is None:
        parser.print_help()
        sys.exit(1)

    handler(args)


if __name__ == "__main__":
    main()