"""Routes for remote execution via the local executive agent."""
import time
from typing import Any

import requests
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel

from agents.auto_heal_agent import AutoHealAgent
from agents.memory_agent import MemoryAgent
from agents.supervisor_agent import SupervisorAgent
from agents.tool_selector_agent import ToolSelectorAgent
from api.deps import get_executor_headers, get_executor_url, get_logger, is_remote_brain_only, load_config

router = APIRouter()
logger = get_logger("kapo.brain.execute")


class ExecuteRequest(BaseModel):
    request_id: str
    plan: dict[str, Any] | list[dict[str, Any]]
    auth_token: str | None = None
    timestamp: float | None = None
    executor_url: str | None = None


def _normalize_executor_url(url: str | None) -> str:
    if not url:
        return ""
    value = url.strip()
    if not value:
        return ""
    if "://" not in value:
        value = f"http://{value}"
    return value.rstrip("/")


def _extract_steps(plan: dict[str, Any] | list[dict[str, Any]]) -> list[dict[str, Any]]:
    if isinstance(plan, list):
        return [_normalize_step(step, index) for index, step in enumerate(plan, start=1)]
    if isinstance(plan, dict):
        steps = plan.get("steps")
        if isinstance(steps, list):
            return [_normalize_step(step, index) for index, step in enumerate(steps, start=1)]
    return []


def _normalize_step(step: dict[str, Any], index: int) -> dict[str, Any]:
    if not isinstance(step, dict):
        return {"id": f"step-{index}", "action": "execute", "input": str(step), "tool_hint": "python"}
    normalized = dict(step)
    if not str(normalized.get("id", "")).strip():
        normalized["id"] = f"step-{index}"
    if not str(normalized.get("input", "")).strip():
        for key in ("description", "title", "summary", "task", "prompt"):
            value = str(normalized.get(key, "")).strip()
            if value:
                normalized["input"] = value
                break
    if not str(normalized.get("action", "")).strip():
        normalized["action"] = "execute"
    if not str(normalized.get("tool_hint", "")).strip():
        normalized["tool_hint"] = "python"
    return normalized


@router.post("/execute")
async def execute(req: ExecuteRequest):
    cfg = load_config()
    tool_selector = ToolSelectorAgent()
    supervisor = SupervisorAgent()
    auto_heal = AutoHealAgent()
    memory = MemoryAgent()

    base_exec_url = _normalize_executor_url(req.executor_url) or get_executor_url(cfg)
    exec_url = f"{base_exec_url}/execute"
    exec_headers = get_executor_headers(cfg)
    timeout = int(cfg.get("REQUEST_TIMEOUT_SEC", 20) or 20)
    retries = int(cfg.get("REQUEST_RETRIES", 2) or 2)

    try:
        results: list[dict[str, Any]] = []
        for step in _extract_steps(req.plan):
            tool = tool_selector.select_tool(step)
            payload = {
                "request_id": req.request_id,
                "step_id": step.get("id"),
                "command": tool.get("command"),
                "files": tool.get("files", {}),
                "env": tool.get("env", {}),
                "timestamp": time.time(),
            }
            attempt = 0
            last_err = None
            while attempt <= retries:
                try:
                    response = requests.post(exec_url, json=payload, headers=exec_headers, timeout=timeout)
                    if response.status_code == 200:
                        item = response.json()
                        item["selected_tool"] = tool.get("tool")
                        results.append(item)
                        last_err = None
                        break
                    last_err = response.text
                except Exception as exc:
                    last_err = str(exc)
                attempt += 1

            if last_err:
                results.append({"error": last_err, "step": step, "auto_heal": auto_heal.suggest(last_err, step)})

        report = supervisor.review(results)
        snapshot = {"execution": results, "report": report}
        if not is_remote_brain_only():
            memory.write_short_term(req.request_id, snapshot)

        return {"status": "ok", "results": results, "report": report, "timestamp": time.time()}
    except Exception as exc:
        logger.exception("Execution failed")
        raise HTTPException(status_code=500, detail=str(exc))