"""Four equivalent tool results; a bounded, modern-only stdio fixture."""
import json
import sys

VERSION = "2026-07-28"
URI = "search://results/demo-v1"
DATA = {
    "query": "MCP", "total": 2,
    "hits": [
        {"id": "d1", "title": "MCP guide", "snippet": "Tool results contain data."},
        {"id": "d2", "title": "Report design", "snippet": "Use explicit resource URIs."},
    ],
}
BODY = json.dumps(DATA, ensure_ascii=False, separators=(",", ":"))
OUTPUT = {
    "type": "object", "additionalProperties": False,
    "required": ["query", "total", "hits"],
    "properties": {
        "query": {"type": "string"},
        "total": {"type": "integer", "minimum": 0},
        "hits": {"type": "array", "items": {
            "type": "object", "additionalProperties": False,
            "required": ["id", "title", "snippet"],
            "properties": {key: {"type": "string"}
                           for key in ("id", "title", "snippet")},
        }},
    },
}
INPUT = {"type": "object", "required": ["q"], "additionalProperties": False,
         "properties": {"q": {"type": "string", "const": "MCP"}}}
TOOLS = [{"name": "search_" + mode, "inputSchema": INPUT,
          "description": "Fixed MCP search demo; " + mode + " result."
                         + (" Read search://results/demo-v1 via resources/read."
                            if mode == "link" else ""),
          **({"outputSchema": OUTPUT} if mode == "structured" else {})}
         for mode in ("text", "structured", "embedded", "link")]


def complete(**fields):
    return {"resultType": "complete", **fields}


def cache(**fields):
    return complete(ttlMs=0, cacheScope="private", **fields)


def resource():
    return {"uri": URI, "mimeType": "application/json", "text": BODY}


def tool_result(mode):
    text = {"type": "text", "text": BODY}
    if mode == "text":
        return complete(content=[text])
    if mode == "structured":
        return complete(content=[text], structuredContent=DATA)
    if mode == "embedded":
        return complete(content=[{"type": "resource", "resource": resource()}])
    if mode == "link":
        return complete(content=[{"type": "resource_link", "uri": URI,
                                  "name": "search-demo-v1.json",
                                  "mimeType": "application/json",
                                  "size": len(BODY.encode("utf-8"))}])
    raise ValueError("unknown mode")


def dispatch(request):
    req_id = request.get("id")
    params = request.get("params", {})
    method = request.get("method")

    def error(code, message):
        return {"jsonrpc": "2.0", "id": req_id,
                "error": {"code": code, "message": message}}

    if request.get("jsonrpc") != "2.0" or req_id is None:
        return error(-32600, "Invalid request")
    meta = params.get("_meta", {})
    if meta.get("io.modelcontextprotocol/protocolVersion") != VERSION:
        return error(-32022, "This demo supports only " + VERSION)
    if "io.modelcontextprotocol/clientCapabilities" not in meta:
        return error(-32602, "Missing clientCapabilities")
    if method == "server/discover":
        result = cache(supportedVersions=[VERSION],
                       capabilities={"tools": {}, "resources": {}},
                       _meta={"io.modelcontextprotocol/serverInfo":
                              {"name": "result-fixture", "version": "1.0.0"}})
    elif method == "tools/list":
        result = cache(tools=TOOLS)
    elif method == "tools/call":
        tool = next((t for t in TOOLS if t["name"] == params.get("name")), None)
        if tool is None:
            return error(-32602, "Unknown tool")
        if params.get("arguments") != {"q": "MCP"}:
            result = complete(content=[{"type": "text", "text": "Use q=MCP"}],
                              isError=True)
        else:
            result = tool_result(tool["name"].removeprefix("search_"))
    elif method in ("resources/list", "resources/templates/list"):
        result = cache(**{"resources" if method == "resources/list"
                          else "resourceTemplates": []})
    elif method == "resources/read":
        if params.get("uri") != URI:
            return error(-32602, "Resource not found")
        result = cache(contents=[resource()])
    else:
        return error(-32601, "Method not found")
    return {"jsonrpc": "2.0", "id": req_id, "result": result}


if __name__ == "__main__":
    # Test fixture: one JSON-RPC request per line; no production hardening.
    for line in sys.stdin:
        request = json.loads(line)
        if "id" in request:  # Notifications have no response.
            print(json.dumps(dispatch(request), ensure_ascii=False), flush=True)