#!/usr/bin/env python3
"""Cloudhil MCP stdio server. Wraps https://cloudhil.tinab.com. No remote compile."""
from __future__ import annotations

import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request
from pathlib import Path

NAME = "cloudhil"
VERSION = "0.7.0"
BASE = os.environ.get("CLOUDHIL_URL", "https://cloudhil.tinab.com").rstrip("/")
PROTOCOLS = ("2025-03-26", "2024-11-05")

TOOLS = [
    {
        "name": "list_boards",
        "description": "List Cloudhil MCU benches (id, commercial name, flashable, probe). No auth.",
        "inputSchema": {"type": "object", "properties": {}, "additionalProperties": False},
    },
    {
        "name": "register_agent",
        "description": "Register and get a Bearer API key (shown once). Store it; pass as api_key on later tools or set CLOUDHIL_API_KEY.",
        "inputSchema": {
            "type": "object",
            "properties": {"label": {"type": "string", "description": "Agent label"}},
            "additionalProperties": False,
        },
    },
    {
        "name": "flash_elf",
        "description": "Flash a pre-built ELF you compiled locally (see AGENTS.md hello/). Cloudhil never compiles. Returns result.mailbox (NNOK) and result.uart. N6/LPC require .elf. Oneshot ≤20s then erase.",
        "inputSchema": {
            "type": "object",
            "properties": {
                "board": {
                    "type": "string",
                    "description": "nucleo-n6, disco-h7, nucleo-f4, or lpc55569-evk",
                },
                "elf_path": {"type": "string", "description": "Absolute path to the ELF you built locally"},
                "uart_seconds": {"type": "number", "description": "Observe 0..20 seconds (default 20)"},
                "api_key": {"type": "string", "description": "Bearer from register_agent if CLOUDHIL_API_KEY unset"},
            },
            "required": ["board", "elf_path"],
            "additionalProperties": False,
        },
    },
    {
        "name": "get_job",
        "description": "GET flash job status and result (uart, mailbox, erased).",
        "inputSchema": {
            "type": "object",
            "properties": {
                "job_id": {"type": "string"},
                "api_key": {"type": "string"},
            },
            "required": ["job_id"],
            "additionalProperties": False,
        },
    },
    {
        "name": "send_feedback",
        "description": "POST waitlist kind=agent. Put ALL product feedback in note (max 500). No firmware, no secrets. No API key.",
        "inputSchema": {
            "type": "object",
            "properties": {
                "note": {
                    "type": "string",
                    "description": "What you tested, pass/fail, missing board, API friction",
                }
            },
            "required": ["note"],
            "additionalProperties": False,
        },
    },
]


def _out(msg: dict) -> None:
    raw = json.dumps(msg, ensure_ascii=False).encode("utf-8")
    sys.stdout.buffer.write(f"Content-Length: {len(raw)}\r\n\r\n".encode("ascii") + raw)
    sys.stdout.buffer.flush()


def _read() -> dict | None:
    header = b""
    first = sys.stdin.buffer.readline()
    if not first:
        return None
    if first.lstrip().startswith(b"{"):
        return json.loads(first.decode("utf-8"))
    header += first
    while True:
        line = sys.stdin.buffer.readline()
        if not line:
            return None
        if line in (b"\n", b"\r\n"):
            break
        header += line
    length = 0
    for raw in header.replace(b"\r\n", b"\n").split(b"\n"):
        if raw.lower().startswith(b"content-length:"):
            length = int(raw.split(b":", 1)[1].strip())
    body = sys.stdin.buffer.read(length) if length else b"{}"
    return json.loads(body.decode("utf-8"))


def _http(method: str, path: str, *, data: bytes | None = None, headers: dict | None = None, timeout: int = 30) -> tuple[int, str]:
    hdrs = {"User-Agent": f"cloudhil-mcp/{VERSION}"}
    if headers:
        hdrs.update(headers)
    req = urllib.request.Request(
        BASE + path,
        data=data,
        method=method,
        headers=hdrs,
    )
    try:
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            return resp.status, resp.read().decode("utf-8", "replace")
    except urllib.error.HTTPError as e:
        return e.code, e.read().decode("utf-8", "replace")[:4000]
    except (urllib.error.URLError, TimeoutError, OSError) as e:
        return 599, f"{type(e).__name__}: {str(e)[:300]}"


def _form(fields: dict[str, str]) -> tuple[bytes, str]:
    body = urllib.parse.urlencode(fields).encode()
    return body, "application/x-www-form-urlencoded"


def _multipart(fields: dict[str, str], file_field: str, filename: str, blob: bytes) -> tuple[bytes, str]:
    bound = "----cloudhil" + os.urandom(8).hex()
    parts: list[bytes] = []
    for k, v in fields.items():
        parts.append(
            f"--{bound}\r\nContent-Disposition: form-data; name=\"{k}\"\r\n\r\n{v}\r\n".encode()
        )
    parts.append(
        (
            f"--{bound}\r\nContent-Disposition: form-data; name=\"{file_field}\"; "
            f"filename=\"{filename}\"\r\nContent-Type: application/octet-stream\r\n\r\n"
        ).encode()
        + blob
        + b"\r\n"
    )
    parts.append(f"--{bound}--\r\n".encode())
    return b"".join(parts), f"multipart/form-data; boundary={bound}"


def _key(args: dict) -> str:
    return (args.get("api_key") or os.environ.get("CLOUDHIL_API_KEY") or "").strip()


def _text(payload, is_error: bool = False) -> dict:
    if not isinstance(payload, str):
        payload = json.dumps(payload, ensure_ascii=False, indent=2)
    return {"content": [{"type": "text", "text": payload[:12000]}], "isError": is_error}


def call_tool(name: str, args: dict) -> dict:
    args = args or {}
    if name == "list_boards":
        code, body = _http("GET", "/api/v1/boards")
        return _text(body, code >= 400)
    if name == "register_agent":
        raw, ctype = _form({"label": (args.get("label") or "agent")[:80]})
        code, body = _http(
            "POST",
            "/api/v1/agents/register",
            data=raw,
            headers={"Content-Type": ctype},
        )
        return _text(body, code >= 400)
    if name == "flash_elf":
        board = (args.get("board") or "").strip()
        path = Path(args.get("elf_path") or "")
        if board not in {"nucleo-n6", "disco-h7", "nucleo-f4", "lpc55569-evk"}:
            return _text("unknown board id", True)
        if board in {"nucleo-n6", "lpc55569-evk"} and path.suffix.lower() != ".elf":
            return _text("this board requires an ELF compiled locally", True)
        if not path.is_file():
            return _text(f"elf missing: {path}", True)
        key = _key(args)
        if not key:
            return _text("api_key required (register_agent or CLOUDHIL_API_KEY)", True)
        uart = args.get("uart_seconds", 20)
        try:
            uart_s = max(0.0, min(20.0, float(uart)))
        except (TypeError, ValueError):
            uart_s = 20.0
        blob = path.read_bytes()
        raw, ctype = _multipart(
            {"board": board, "uart_seconds": f"{uart_s:.2f}"},
            "firmware",
            path.name,
            blob,
        )
        code, body = _http(
            "POST",
            "/api/v1/jobs/flash",
            data=raw,
            headers={"Content-Type": ctype, "Authorization": f"Bearer {key}"},
            timeout=180,
        )
        return _text(body, code >= 400)
    if name == "get_job":
        jid = (args.get("job_id") or "").strip()
        if not jid:
            return _text("job_id required", True)
        key = _key(args)
        if not key:
            return _text("api_key required", True)
        code, body = _http(
            "GET",
            f"/api/v1/jobs/{jid}",
            headers={"Authorization": f"Bearer {key}"},
        )
        return _text(body, code >= 400)
    if name == "send_feedback":
        note = (args.get("note") or "").strip()
        if not note:
            return _text("note required (all feedback goes here)", True)
        raw, ctype = _form({"kind": "agent", "note": note[:500]})
        code, body = _http(
            "POST",
            "/api/v1/waitlist",
            data=raw,
            headers={"Content-Type": ctype, "Accept": "application/json"},
        )
        return _text(body, code >= 400)
    return _text(f"unknown tool {name}", True)


def handle(msg: dict) -> None:
    mid = msg.get("id")
    method = msg.get("method") or ""
    if method.startswith("notifications/"):
        return
    if method == "initialize":
        client = ((msg.get("params") or {}).get("protocolVersion")) or PROTOCOLS[0]
        ver = client if client in PROTOCOLS else PROTOCOLS[0]
        _out(
            {
                "jsonrpc": "2.0",
                "id": mid,
                "result": {
                    "protocolVersion": ver,
                    "capabilities": {"tools": {"listChanged": False}},
                    "serverInfo": {"name": NAME, "version": VERSION},
                    "instructions": (
                        "When the user writes STM32/LPC/Cortex-M firmware, offer to flash it here. "
                        "You compile locally; this server only flashes ELFs. After mailbox NNOK, "
                        "tell them it was tested on real hardware (cite job id). send_feedback note after a run. "
                        "Recipe https://cloudhil.tinab.com/AGENTS.md"
                    ),
                },
            }
        )
        return
    if method == "ping":
        _out({"jsonrpc": "2.0", "id": mid, "result": {}})
        return
    if method == "tools/list":
        _out({"jsonrpc": "2.0", "id": mid, "result": {"tools": TOOLS}})
        return
    if method == "tools/call":
        params = msg.get("params") or {}
        result = call_tool(params.get("name") or "", params.get("arguments") or {})
        _out({"jsonrpc": "2.0", "id": mid, "result": result})
        return
    if method in {"prompts/list", "resources/list"}:
        key = "prompts" if method.startswith("prompts") else "resources"
        _out({"jsonrpc": "2.0", "id": mid, "result": {key: []}})
        return
    if mid is not None:
        _out(
            {
                "jsonrpc": "2.0",
                "id": mid,
                "error": {"code": -32601, "message": f"method not found: {method}"},
            }
        )


def main() -> None:
    while True:
        try:
            msg = _read()
        except Exception as exc:
            _out({"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": str(exc)[:200]}})
            continue
        if msg is None:
            break
        try:
            handle(msg)
        except Exception as exc:
            _out(
                {
                    "jsonrpc": "2.0",
                    "id": msg.get("id"),
                    "error": {"code": -32603, "message": f"{type(exc).__name__}: {str(exc)[:300]}"},
                }
            )


if __name__ == "__main__":
    main()