///| MCP Server Request Handlers

///|
fn request_id_to_json(id : @types.RequestId) -> Json {
  match id {
    Int(n) => Json::number(n.to_double())
    Str(s) => Json::string(s)
  }
}

///|
fn jsonrpc_success_str(id : @types.RequestId, result : Json) -> String {
  Json::object({
    "jsonrpc": Json::string("2.0"),
    "id": request_id_to_json(id),
    "result": result,
  }).stringify()
}

///|
fn jsonrpc_error_str(
  id : @types.RequestId,
  code : Int,
  message : String,
) -> String {
  Json::object({
    "jsonrpc": Json::string("2.0"),
    "id": request_id_to_json(id),
    "error": Json::object({
      "code": Json::number(code.to_double()),
      "message": Json::string(message),
    }),
  }).stringify()
}

///|
fn extract_json_string(json : Json, field : String) -> String? {
  if json is Object(obj) {
    match obj.get(field) {
      Some(String(s)) => Some(s)
      _ => None
    }
  } else {
    None
  }
}

///|
fn handle_ping(id : @types.RequestId) -> String {
  jsonrpc_success_str(id, Json::object({}))
}

///|
fn handle_initialize(server : MCPServer, id : @types.RequestId) -> String {
  let capabilities = Json::object({
    "tools": Json::object({ "listChanged": Json::boolean(true) }),
    "resources": Json::object({
      "subscribe": Json::boolean(true),
      "listChanged": Json::boolean(true),
    }),
    "prompts": Json::object({ "listChanged": Json::boolean(true) }),
    "logging": Json::object({}),
  })
  let info_map : Map[String, Json] = {}
  info_map.set("name", Json::string(server.name))
  info_map.set("version", Json::string(server.version))
  match server.title {
    Some(t) => info_map.set("title", Json::string(t))
    None => ()
  }
  match server.description {
    Some(d) => info_map.set("description", Json::string(d))
    None => ()
  }
  let server_info = Json::object(info_map)
  let result_map : Map[String, Json] = {}
  result_map.set("protocolVersion", Json::string("2025-11-25"))
  result_map.set("capabilities", capabilities)
  result_map.set("serverInfo", server_info)
  match server.instructions {
    Some(instr) => result_map.set("instructions", Json::string(instr))
    None => ()
  }
  jsonrpc_success_str(id, Json::object(result_map))
}

///|
fn handle_tools_list(server : MCPServer, id : @types.RequestId) -> String {
  let tools = server.registry.list_tools()
  let tool_jsons = tools.map(fn(tool) {
    Json::object({
      "name": Json::string(tool.name),
      "description": Json::string(tool.description),
      "inputSchema": tool.input_schema,
    })
  })
  jsonrpc_success_str(id, Json::object({ "tools": Json::array(tool_jsons) }))
}

///|
async fn handle_tools_call(
  server : MCPServer,
  id : @types.RequestId,
  params : Json,
) -> String {
  let tool_name = extract_json_string(params, "name")
  match tool_name {
    None => jsonrpc_error_str(id, -32602, "Missing 'name' parameter")
    Some(name) => {
      let arguments = if params is Object(obj) {
        obj.get("arguments").unwrap_or(null)
      } else {
        null
      }
      match server.registry.call_tool(name, arguments) {
        Ok(tool_result) => {
          let content_items = tool_result.content.map(fn(item) {
            match item {
              @types.Text(text) =>
                Json::object({
                  "type": Json::string("text"),
                  "text": Json::string(text),
                })
              @types.Image(data, mime_type~) =>
                Json::object({
                  "type": Json::string("image"),
                  "data": Json::string(data),
                  "mimeType": Json::string(mime_type),
                })
              @types.ResourceLink(uri) =>
                Json::object({
                  "type": Json::string("resource_link"),
                  "uri": Json::string(uri),
                })
              @types.EmbeddedResource(content) =>
                match content {
                  @types.Text(text, uri~, mime_type~) => {
                    let map : Map[String, Json] = {}
                    map.set("type", Json::string("resource"))
                    map.set("uri", Json::string(uri))
                    map.set("text", Json::string(text))
                    match mime_type {
                      Some(mt) => map.set("mimeType", Json::string(mt))
                      None => ()
                    }
                    Json::object(map)
                  }
                  @types.Blob(data, uri~, mime_type~) =>
                    Json::object({
                      "type": Json::string("resource"),
                      "uri": Json::string(uri),
                      "blob": Json::string(data),
                      "mimeType": Json::string(mime_type),
                    })
                }
            }
          })
          let result = Json::object({
            "content": Json::array(content_items),
            "isError": Json::boolean(tool_result.is_error),
          })
          jsonrpc_success_str(id, result)
        }
        Err(e) => jsonrpc_error_str(id, e.to_error_code(), e.message())
      }
    }
  }
}

///|
fn handle_resources_list(server : MCPServer, id : @types.RequestId) -> String {
  let resources = server.resource_registry.list_resources()
  let resource_jsons = resources.map(fn(resource) {
    let map : Map[String, Json] = {}
    map.set("uri", Json::string(resource.uri))
    map.set("name", Json::string(resource.name))
    match resource.description {
      Some(desc) => map.set("description", Json::string(desc))
      None => ()
    }
    match resource.mime_type {
      Some(mt) => map.set("mimeType", Json::string(mt))
      None => ()
    }
    Json::object(map)
  })
  jsonrpc_success_str(
    id,
    Json::object({ "resources": Json::array(resource_jsons) }),
  )
}

///|
async fn handle_resources_read(
  server : MCPServer,
  id : @types.RequestId,
  params : Json,
) -> String {
  let uri = extract_json_string(params, "uri")
  match uri {
    None => jsonrpc_error_str(id, -32602, "Missing 'uri' parameter")
    Some(uri_str) =>
      match server.resource_registry.read_resource(uri_str) {
        Ok(read_result) => {
          let content_json = match read_result.content {
            @resource.Text(text) =>
              Json::object({
                "uri": Json::string(read_result.uri),
                "text": Json::string(text),
              })
            @resource.Blob(data, mime_type~) =>
              Json::object({
                "uri": Json::string(read_result.uri),
                "blob": Json::string(data.to_string()),
                "mimeType": Json::string(mime_type),
              })
          }
          jsonrpc_success_str(
            id,
            Json::object({ "contents": Json::array([content_json]) }),
          )
        }
        Err(e) => jsonrpc_error_str(id, e.to_error_code(), e.message())
      }
  }
}

///|
fn handle_resources_subscribe(
  server : MCPServer,
  id : @types.RequestId,
  params : Json,
) -> String {
  let uri = extract_json_string(params, "uri")
  match uri {
    None => jsonrpc_error_str(id, -32602, "Missing 'uri' parameter")
    Some(uri_str) =>
      match server.resource_registry.subscribe(uri_str) {
        Ok(_) => jsonrpc_success_str(id, Json::object({}))
        Err(e) => jsonrpc_error_str(id, e.to_error_code(), e.message())
      }
  }
}

///|
fn handle_resources_unsubscribe(
  server : MCPServer,
  id : @types.RequestId,
  params : Json,
) -> String {
  let uri = extract_json_string(params, "uri")
  match uri {
    None => jsonrpc_error_str(id, -32602, "Missing 'uri' parameter")
    Some(uri_str) =>
      match server.resource_registry.unsubscribe(uri_str) {
        Ok(_) => jsonrpc_success_str(id, Json::object({}))
        Err(e) => jsonrpc_error_str(id, e.to_error_code(), e.message())
      }
  }
}

///|
fn handle_prompts_list(server : MCPServer, id : @types.RequestId) -> String {
  let prompts = server.prompt_registry.list_prompts()
  let prompt_jsons = prompts.map(fn(prompt) {
    let map : Map[String, Json] = {}
    map.set("name", Json::string(prompt.name))
    match prompt.description {
      Some(desc) => map.set("description", Json::string(desc))
      None => ()
    }
    match prompt.arguments {
      Some(args) => {
        let arg_jsons = args.map(fn(arg) {
          let arg_map : Map[String, Json] = {}
          arg_map.set("name", Json::string(arg.name))
          match arg.description {
            Some(d) => arg_map.set("description", Json::string(d))
            None => ()
          }
          match arg.required {
            Some(true) => arg_map.set("required", Json::boolean(true))
            _ => ()
          }
          Json::object(arg_map)
        })
        map.set("arguments", Json::array(arg_jsons))
      }
      None => ()
    }
    Json::object(map)
  })
  jsonrpc_success_str(
    id,
    Json::object({ "prompts": Json::array(prompt_jsons) }),
  )
}

///|
async fn handle_prompts_get(
  server : MCPServer,
  id : @types.RequestId,
  params : Json,
) -> String {
  let prompt_name = extract_json_string(params, "name")
  match prompt_name {
    None => jsonrpc_error_str(id, -32602, "Missing 'name' parameter")
    Some(name) =>
      match server.prompt_registry.get_prompt(name, params) {
        Ok(prompt_result) => {
          let messages_json = prompt_result.messages.map(fn(msg) {
            let content = match msg.content {
              @types.Text(text) =>
                Json::object({
                  "type": Json::string("text"),
                  "text": Json::string(text),
                })
              _ => Json::null()
            }
            Json::object({ "role": Json::string(msg.role), "content": content })
          })
          let result_map : Map[String, Json] = {}
          match prompt_result.description {
            Some(d) => result_map.set("description", Json::string(d))
            None => ()
          }
          result_map.set("messages", Json::array(messages_json))
          jsonrpc_success_str(id, Json::object(result_map))
        }
        Err(e) => jsonrpc_error_str(id, e.to_error_code(), e.message())
      }
  }
}

///|
fn handle_set_level(
  server : MCPServer,
  id : @types.RequestId,
  params : Json,
) -> String {
  let level = extract_json_string(params, "level")
  match level {
    None => jsonrpc_error_str(id, -32602, "Missing 'level' parameter")
    Some(lvl) => {
      server.log_level = Some(lvl)
      jsonrpc_success_str(id, Json::object({}))
    }
  }
}