///| MCPServer - Main Server Implementation

///|
priv enum ReplyHandle {
  Stdio(@aqueue.Queue[String])
  Http(@async.Queue[String])
}

///|
priv struct ServerRequest {
  message : String
  reply : ReplyHandle
}

///|
async fn ReplyHandle::send(
  self : ReplyHandle,
  response : String,
) -> Unit raise @types.TransportError {
  match self {
    Stdio(queue) =>
      queue.put(response) catch {
        e => raise @types.WriteError(e.to_string())
      }
    Http(queue) =>
      queue.put(response) catch {
        e => raise @types.WriteError(e.to_string())
      }
  }
}

///|
pub struct MCPServer {
  name : String
  version : String
  title : String?
  description : String?
  instructions : String?
  mut log_level : String?
  auth_config : @transport.AuthConfig?
  registry : ToolRegistry
  resource_registry : ResourceRegistry
  prompt_registry : PromptRegistry
}

///|
pub fn MCPServer::new(name : String, version : String) -> MCPServer {
  {
    name,
    version,
    title: None,
    description: None,
    instructions: None,
    log_level: None,
    auth_config: None,
    registry: ToolRegistry::new(),
    resource_registry: ResourceRegistry::new(),
    prompt_registry: PromptRegistry::new(),
  }
}

///|
fn MCPServer::register_tool(
  self : MCPServer,
  name : String,
  description : String,
  input_schema : Json,
  handler : async (Json) -> Result[@tool.ToolResult, @types.MCPError],
) -> Unit {
  self.registry.register(name, description, input_schema, handler)
}

///|
fn[T : @tool.Tool] MCPServer::register_trait_tool(
  self : MCPServer,
  tool : T,
) -> Unit {
  self.registry.register_trait_tool(tool)
}

///|
fn MCPServer::register_resource(
  self : MCPServer,
  uri : String,
  name : String,
  description : String,
  mime_type : String,
  handler : async () -> Result[@resource.ResourceReadResult, @types.MCPError],
) -> Unit {
  self.resource_registry.register(uri, name, description, mime_type, handler)
}

///|
fn[T : @resource.Resource] MCPServer::register_trait_resource(
  self : MCPServer,
  resource : T,
) -> Unit {
  self.resource_registry.register_trait_resource(resource)
}

///|
fn MCPServer::register_prompt(
  self : MCPServer,
  name : String,
  description : String,
  arguments : Array[@types.PromptArgument],
  handler : async (Json) -> Result[@types.GetPromptResult, @types.MCPError],
) -> Unit {
  self.prompt_registry.register(name, description, arguments, handler)
}

///|
fn[T : @prompt.Prompt] MCPServer::register_trait_prompt(
  self : MCPServer,
  prompt : T,
) -> Unit {
  self.prompt_registry.register_trait_prompt(prompt)
}

///|
pub async fn MCPServer::handle_request(
  self : MCPServer,
  request_json : String,
) -> String {
  match parse_request_message(request_json) {
    Ok(request) => self.handle_parsed_request(request)
    Err(response) => response
  }
}

///|
fn parse_request_message(
  request_json : String,
) -> Result[@types.JsonRpcRequest, String] {
  let parsed = @json.parse(request_json) catch {
    _ =>
      return Err(
        jsonrpc_error_str(@types.RequestId::Int(0), -32700, "Parse error"),
      )
  }
  match @types.JsonRpcRequest::from_json(parsed) {
    Ok(request) => Ok(request)
    Err(e) =>
      Err(
        jsonrpc_error_str(
          @types.RequestId::Int(0),
          e.to_error_code(),
          e.message(),
        ),
      )
  }
}

///|
fn is_fast_method(method_name : String) -> Bool {
  method_name == "initialize" ||
  method_name == "ping" ||
  method_name == "tools/list" ||
  method_name == "resources/list" ||
  method_name == "prompts/list"
}

///|
async fn MCPServer::handle_parsed_request(
  self : MCPServer,
  request : @types.JsonRpcRequest,
) -> String {
  match request.method_name {
    "initialize" => handle_initialize(self, request.id)
    "ping" => handle_ping(request.id)
    "tools/list" => handle_tools_list(self, request.id)
    "tools/call" => handle_tools_call(self, request.id, request.params)
    "resources/list" => handle_resources_list(self, request.id)
    "resources/read" => handle_resources_read(self, request.id, request.params)
    "resources/subscribe" =>
      handle_resources_subscribe(self, request.id, request.params)
    "resources/unsubscribe" =>
      handle_resources_unsubscribe(self, request.id, request.params)
    "prompts/list" => handle_prompts_list(self, request.id)
    "prompts/get" => handle_prompts_get(self, request.id, request.params)
    "logging/setLevel" => handle_set_level(self, request.id, request.params)
    _ =>
      jsonrpc_error_str(
        request.id,
        -32601,
        "Method not found: " + request.method_name,
      )
  }
}

///|
fn internal_error_response(id : @types.RequestId) -> String {
  jsonrpc_error_str(id, -32603, "Internal server error")
}

///|
async fn MCPServer::handle_server_request(
  self : MCPServer,
  request : ServerRequest,
  group : @async.TaskGroup[Unit],
) -> Unit {
  match parse_request_message(request.message) {
    Err(response) => request.reply.send(response) catch { _ => () }
    Ok(parsed_request) =>
      if is_fast_method(parsed_request.method_name) {
        let response = self.handle_parsed_request(parsed_request) catch {
          _ => internal_error_response(parsed_request.id)
        }
        request.reply.send(response) catch {
          _ => ()
        }
      } else {
        group.spawn_bg(() => {
          let response = self.handle_parsed_request(parsed_request) catch {
            _ => internal_error_response(parsed_request.id)
          }
          request.reply.send(response) catch {
            _ => ()
          }
        })
      }
  }
}

///|
async fn MCPServer::run_stdio_transport(
  self : MCPServer,
  transport : @transport.StdioTransport,
  group : @async.TaskGroup[Unit],
) -> Unit raise @types.TransportError {
  let response_queue : @aqueue.Queue[String] = @aqueue.Queue(
    kind=@aqueue.Kind::Unbounded,
  )
  group.spawn_bg(() => {
    while true {
      let response = response_queue.get() catch { _ => break }
      transport.send(response) catch {
        _ => ()
      }
    }
  })

  while true {
    match transport.receive() {
      None => {
        response_queue.close()
        transport.close()
        break
      }
      Some(message) =>
        self.handle_server_request(
          { message, reply: ReplyHandle::Stdio(response_queue) },
          group,
        ) catch {
          _ => ()
        }
    }
  }
}

///|
async fn MCPServer::run_http_transport(
  self : MCPServer,
  transport : @transport.HttpTransport,
  group : @async.TaskGroup[Unit],
) -> Unit raise @types.TransportError {
  while true {
    match transport.receive_request() {
      None => {
        transport.close()
        break
      }
      Some((message, reply_queue)) =>
        self.handle_server_request(
          { message, reply: ReplyHandle::Http(reply_queue) },
          group,
        ) catch {
          _ => ()
        }
    }
  }
}

///|
async fn MCPServer::run_with_transport(
  self : MCPServer,
  transport : @transport.AnyTransport,
  group : @async.TaskGroup[Unit],
) -> Unit raise @types.TransportError {
  match transport {
    Stdio(stdio) => self.run_stdio_transport(stdio, group)
    Http(http) => self.run_http_transport(http, group)
    _ =>
      raise @types.InvalidState(
        "MCPServer::run requires a server transport (stdio or http)",
      )
  }
}

///|
pub fn[T : @tool.Tool] MCPServer::with_tool(
  self : MCPServer,
  tool : T,
) -> MCPServer {
  self.register_trait_tool(tool)
  self
}

///|
pub fn MCPServer::tool(
  self : MCPServer,
  name : String,
  description : String,
  input_schema : Json,
  handler : async (Json) -> Result[@tool.ToolResult, @types.MCPError],
) -> MCPServer {
  self.register_tool(name, description, input_schema, handler)
  self
}

///|
pub fn[T : @resource.Resource] MCPServer::with_resource(
  self : MCPServer,
  resource : T,
) -> MCPServer {
  self.register_trait_resource(resource)
  self
}

///|
pub fn MCPServer::resource(
  self : MCPServer,
  uri : String,
  name : String,
  description : String,
  mime_type : String,
  handler : async () -> Result[@resource.ResourceReadResult, @types.MCPError],
) -> MCPServer {
  self.register_resource(uri, name, description, mime_type, handler)
  self
}

///|
pub fn[T : @prompt.Prompt] MCPServer::with_prompt(
  self : MCPServer,
  prompt : T,
) -> MCPServer {
  self.register_trait_prompt(prompt)
  self
}

///|
pub fn MCPServer::prompt(
  self : MCPServer,
  name : String,
  description : String,
  arguments : Array[@types.PromptArgument],
  handler : async (Json) -> Result[@types.GetPromptResult, @types.MCPError],
) -> MCPServer {
  self.register_prompt(name, description, arguments, handler)
  self
}

///|
pub fn MCPServer::with_title(self : MCPServer, title : String) -> MCPServer {
  { ..self, title: Some(title) }
}

///|
pub fn MCPServer::with_description(
  self : MCPServer,
  description : String,
) -> MCPServer {
  { ..self, description: Some(description) }
}

///|
pub fn MCPServer::with_instructions(
  self : MCPServer,
  instructions : String,
) -> MCPServer {
  { ..self, instructions: Some(instructions) }
}

///|
pub fn MCPServer::with_auth(
  self : MCPServer,
  auth : @transport.AuthConfig,
) -> MCPServer {
  { ..self, auth_config: Some(auth) }
}

///|
pub async fn MCPServer::run_stdio(
  self : MCPServer,
) -> Unit raise @types.TransportError {
  let transport = @transport.AnyTransport::Stdio(
    @transport.StdioTransport::new(),
  )
  @async.with_task_group(group => self.run_with_transport(transport, group)) catch {
    e => raise @types.ReadError("TaskGroup error: " + e.to_string())
  }
}

///|
pub async fn MCPServer::run_http(
  self : MCPServer,
  port? : Int = 4240,
  path? : String = "/mcp",
) -> Unit raise @types.TransportError {
  @async.with_task_group(group => {
    let http = @transport.HttpTransport::new(port~, endpoint_path=path)
    let http = match self.auth_config {
      Some(auth) => http.with_auth(auth)
      None => http
    }
    group.spawn_bg(async fn() { http.start() })
    let transport = @transport.AnyTransport::Http(http)
    self.run_with_transport(transport, group)
  }) catch {
    e => raise @types.ReadError("TaskGroup error: " + e.to_string())
  }
}

///|
pub fn mcp_server(name~ : String, version~ : String) -> MCPServer {
  MCPServer::new(name, version)
}