"""
HERMES — Demo & GTM General
=============================
Fires browser + GTM agents for demos, GHL setup, and outreach.

Usage:
    from core.generals.hermes import spawn_hermes
    results = spawn_hermes("Set up George Bunker GHL workflow", browser_agents=3)
"""

import json
import uuid
from datetime import datetime, timezone
from pathlib import Path

REPO_ROOT = Path("/mnt/e/genesis-system")
SWARM_PROGRESS_DIR = REPO_ROOT / "data" / "swarm_progress"
HIVE_PROGRESS_DIR = REPO_ROOT / "hive" / "progress"

HERMES_BROWSER_PROMPT = """You are HERMES, the Demo & GTM agent for Genesis.

Task: {task}
Sub-task {agent_index} of {total_agents}: {sub_task}

You have access to Playwright MCP for browser automation.

Instructions:
1. Use Playwright MCP to complete this task autonomously
2. NEVER ask Kinan to do anything you can do with a browser
3. Log every action taken with timestamp
4. If you hit a 2FA wall on Kinan's personal phone, STOP and report
5. Write a completion report to: {output_file}

Report format:
## HERMES Action Report
- Task: {sub_task}
- Status: COMPLETED / BLOCKED / PARTIAL
- Actions taken: [numbered list]
- Evidence: [URLs, screenshots, confirmation codes]
- Next step: [if blocked]
"""

HERMES_OUTREACH_PROMPT = """You are HERMES, the GTM outreach agent for Genesis.

Campaign: {task}
Batch {agent_index} of {total_agents}: {sub_task}

Instructions:
1. Generate personalised outreach emails for each target
2. Use real data from KNOWLEDGE_GRAPH/entities/ about the target company
3. Match tone to ReceptionistAI brand (professional, direct, value-first)
4. Output ready-to-send emails to: {output_file}
5. Format: JSON array of {{to, subject, body}} objects
"""

# Task type detection keywords
BROWSER_TASK_KEYWORDS = [
    "ghl", "setup", "workflow", "login", "demo", "configure",
    "dns", "stripe", "godaddy", "cloudflare", "activate",
]
OUTREACH_TASK_KEYWORDS = [
    "outreach", "email", "contact", "agency", "prospect", "cold",
    "sequence", "personalise", "campaign",
]


def spawn_hermes(task: str, browser_agents: int = 3) -> dict:
    """
    Spawn browser + GTM agents for demos, GHL setup, and outreach.

    Parameters
    ----------
    task : str
        The high-level task (e.g. "Set up George Bunker GHL demo workflow")
    browser_agents : int
        Number of parallel browser agents (default 3)

    Returns
    -------
    dict with swarm metadata
    """
    SWARM_PROGRESS_DIR.mkdir(parents=True, exist_ok=True)
    HIVE_PROGRESS_DIR.mkdir(parents=True, exist_ok=True)

    swarm_id = f"hermes_{uuid.uuid4().hex[:8]}"
    output_dir = HIVE_PROGRESS_DIR / swarm_id
    output_dir.mkdir(parents=True, exist_ok=True)

    task_lower = task.lower()
    is_outreach = any(kw in task_lower for kw in OUTREACH_TASK_KEYWORDS)
    model = "google/gemini-2.5-flash" if is_outreach else "moonshot/moonshot-v1-8k"

    sub_tasks = _decompose_hermes_task(task, browser_agents, is_outreach)

    swarm_state = {
        "swarm_id": swarm_id,
        "general": "HERMES",
        "mission": task,
        "model": model,
        "task_type": "outreach" if is_outreach else "browser",
        "agent_count": browser_agents,
        "stories_completed": 0,
        "stories_completed_this_hour": 0,
        "status": "running",
        "started_at": datetime.now(timezone.utc).isoformat(),
        "output_dir": str(output_dir),
    }

    state_file = SWARM_PROGRESS_DIR / f"{swarm_id}.json"

    prompt_template = HERMES_OUTREACH_PROMPT if is_outreach else HERMES_BROWSER_PROMPT

    for i, sub_task in enumerate(sub_tasks):
        output_file = output_dir / f"agent_{i+1:02d}_output.md"
        prompt = prompt_template.format(
            task=task,
            agent_index=i + 1,
            total_agents=browser_agents,
            sub_task=sub_task,
            output_file=str(output_file),
        )
        (output_dir / f"agent_{i+1:02d}_prompt.md").write_text(prompt)

        # NOTE: Framework only — no live API calls.
        # Live browser agent call:
        # subprocess.Popen(["claude", "-p", prompt, "--output", str(output_file)])
        print(f"[HERMES] Agent {i+1}/{browser_agents} queued: {sub_task[:60]}")

    _save_state(state_file, swarm_state)
    print(f"[HERMES] Swarm {swarm_id} — {browser_agents} agents queued for: {task[:60]}")
    return swarm_state


def spawn(task: str, browser_agents: int = 3) -> dict:
    """Alias for spawn_hermes — used by genesis_hive.py router."""
    return spawn_hermes(task, browser_agents=browser_agents)


def _decompose_hermes_task(task: str, count: int, is_outreach: bool) -> list[str]:
    """Break a HERMES task into sub-tasks."""
    if is_outreach:
        return [
            f"Research and personalise batch {i+1}: {task}"
            for i in range(count)
        ]

    # Browser tasks — sequential dependencies or parallel actions
    return [
        f"Step {i+1}: {task} — Phase {i+1}"
        for i in range(count)
    ]


def _save_state(path: Path, state: dict) -> None:
    path.write_text(json.dumps(state, indent=2, default=str))