"""Synchronous diagnostics requests, for servers that answer "what is wrong with this file now" directly.

typescript-language-server publishes diagnostics asynchronously and stays silent when a file's
diagnostics are unchanged, so waiting for a push costs the push latency (hundreds of ms after an edit)
or the whole wait budget (a clean edit never publishes).  It also forwards raw tsserver requests through
``workspace/executeCommand typescript.tsserverRequest``: ``syntacticDiagnosticsSync`` +
``semanticDiagnosticsSync`` answer for the text last synced, in about 10ms on a warm project.  The edit
check (``agent.lsp.edit_check``) asks this module first and falls back to the push/pull wait when the
server has no synchronous request or the request fails.

Returned diagnostics use the shape typescript-language-server pushes (0-based range, numeric severity,
``source`` "typescript"), so a sync verdict and a pushed baseline compare equal by
``agent.lsp.client._diagnostic_key``.
"""
from __future__ import annotations

import logging
from typing import Any, Optional

from agent.lsp.protocol import LSPProtocolError, LSPRequestError

logger = logging.getLogger("agent.lsp.sync_diagnostics")

# tsserver category -> LSP DiagnosticSeverity, as typescript-language-server maps it.
_TS_SEVERITY = {"error": 1, "warning": 2, "message": 3, "suggestion": 4}
_TS_SERVERS = frozenset({"typescript"})
_TS_COMMANDS = ("syntacticDiagnosticsSync", "semanticDiagnosticsSync")
_UNSUPPORTED = "_hermes_sync_diagnostics_unsupported"


def supported(client: Any) -> bool:
    return client.server_id in _TS_SERVERS and not getattr(client, _UNSUPPORTED, False)


async def request(client: Any, abs_path: str, *, timeout: float) -> Optional[list[dict[str, Any]]]:
    """Diagnostics for the text last synced to ``client`` for ``abs_path``, or None when the server has
    no synchronous request (it failed): wait for a push then.  Raises ``TimeoutError`` when the server
    did not answer within ``timeout`` (a cold project still loading): there is no verdict in budget,
    and a push wait after it would only hold the next check of the file longer."""
    if not supported(client) or timeout <= 0:
        return None
    out: list[dict[str, Any]] = []
    for command in _TS_COMMANDS:
        try:
            reply = await client._send_request_with_retry("workspace/executeCommand", {
                "command": "typescript.tsserverRequest",
                "arguments": [command, {"file": abs_path, "includeLinePosition": True}, {"executionTarget": 0}],
            }, timeout=timeout)
        except TimeoutError:
            raise TimeoutError(f"{command} did not answer in {timeout:.1f}s") from None
        except LSPRequestError as e:  # the server rejects the command: use the push wait from now on
            logger.debug("[%s] %s rejected: %s", client.server_id, command, e)
            setattr(client, _UNSUPPORTED, True)
            return None
        except LSPProtocolError as e:  # connection trouble: the push wait reports it
            logger.debug("[%s] %s failed: %s", client.server_id, command, e)
            return None
        body = reply.get("body") if isinstance(reply, dict) and reply.get("success", True) else None
        if not isinstance(body, list):
            setattr(client, _UNSUPPORTED, True)
            return None
        out.extend(d for d in (_from_tsserver(item) for item in body) if d is not None)
    return out


def _from_tsserver(item: Any) -> Optional[dict[str, Any]]:
    if not isinstance(item, dict):
        return None
    start, end = item.get("startLocation"), item.get("endLocation")
    if not isinstance(start, dict) or not isinstance(end, dict):
        return None
    diag: dict[str, Any] = {
        "range": {"start": {"line": start.get("line", 1) - 1, "character": start.get("offset", 1) - 1},
                  "end": {"line": end.get("line", 1) - 1, "character": end.get("offset", 1) - 1}},
        "message": str(item.get("message") or ""),
        "severity": _TS_SEVERITY.get(str(item.get("category") or "error"), 1),
        "source": item.get("source") or "typescript",
    }
    if item.get("code") is not None:
        diag["code"] = item["code"]
    return diag


__all__ = ["request", "supported"]