module mcp

import json
import io
import net.http
import os
import rand
import time

const default_server_name = 'v.mcp.server'
const default_server_version = 'dev'
const default_http_path = '/mcp'
const default_list_page_size = 50
const stdio_session_id = 'stdio'
const event_stream_content_type = 'text/event-stream'

// SessionTransport identifies how an MCP session is connected.
pub enum SessionTransport {
	stdio
	http
}

// Context provides request-scoped server metadata to handlers.
pub struct Context {
pub:
	session_id          string @[json: sessionId]
	request_id          string @[json: requestId]
	method              string
	transport           SessionTransport
	protocol_version    string         @[json: protocolVersion]
	client_info         Implementation @[json: clientInfo]
	client_capabilities string         @[json: clientCapabilities; raw]
}

// Tool describes an MCP tool exposed by the server.
pub struct Tool {
pub:
	name          string
	title         string @[omitempty]
	description   string @[omitempty]
	input_schema  string = default_tool_input_schema @[json: inputSchema; raw]
	output_schema string @[json: outputSchema; omitempty; raw]
}

// Resource describes a concrete MCP resource exposed by the server.
pub struct Resource {
pub:
	uri         string
	name        string
	title       string @[omitempty]
	description string @[omitempty]
	mime_type   string @[json: mimeType; omitempty]
}

// ResourceTemplate describes a parameterized MCP resource URI template.
pub struct ResourceTemplate {
pub:
	uri_template string @[json: uriTemplate]
	name         string
	title        string @[omitempty]
	description  string @[omitempty]
	mime_type    string @[json: mimeType; omitempty]
}

// ResourceContents contains the result of `resources/read`.
pub struct ResourceContents {
pub:
	uri       string
	mime_type string @[json: mimeType; omitempty]
	text      string @[omitempty]
	blob      string @[omitempty]
}

// ReadResourceResult is returned by `resources/read`.
pub struct ReadResourceResult {
pub:
	contents []ResourceContents
}

// PromptArgument describes one prompt argument.
pub struct PromptArgument {
pub:
	name        string
	description string @[omitempty]
	required    bool
}

// Prompt describes an MCP prompt exposed by the server.
pub struct Prompt {
pub:
	name        string
	title       string @[omitempty]
	description string @[omitempty]
	arguments   []PromptArgument
}

// PromptMessage is one message returned by `prompts/get`.
pub struct PromptMessage {
pub:
	role    string
	content string @[raw]
}

// GetPromptResult is returned by `prompts/get`.
pub struct GetPromptResult {
pub:
	description string @[omitempty]
	messages    []PromptMessage
}

// ToolResult is returned by `tools/call`.
pub struct ToolResult {
pub:
	content            string @[omitempty; raw]
	structured_content string @[json: structuredContent; omitempty; raw]
	is_error           bool   @[json: isError]
}

// ToolHandler handles `tools/call` for a registered tool.
pub type ToolHandler = fn (ctx Context, arguments string) !ToolResult

// ResourceHandler handles `resources/read` for a registered resource URI.
pub type ResourceHandler = fn (ctx Context, uri string) !ReadResourceResult

// PromptHandler handles `prompts/get` for a registered prompt.
pub type PromptHandler = fn (ctx Context, arguments string) !GetPromptResult

// ServerConfig configures an MCP server instance.
@[params]
pub struct ServerConfig {
pub:
	name             string
	version          string
	protocol_version string = protocol_version
	capabilities     string
	instructions     string
	http_path        string = default_http_path
}

struct RegisteredTool {
	tool    Tool
	handler ToolHandler = unsafe { nil }
}

struct RegisteredResource {
	resource Resource
	handler  ResourceHandler = unsafe { nil }
}

struct RegisteredPrompt {
	prompt  Prompt
	handler PromptHandler = unsafe { nil }
}

struct Session {
mut:
	id                  string
	transport           SessionTransport
	protocol_version    string
	client_info         Implementation
	client_capabilities string
	initialize_complete bool
	initialized         bool
}

struct ServerState {
mut:
	sessions map[string]Session
}

struct DispatchResult {
	has_response bool
	response     string
	session_id   string
}

struct HandledRequest {
	response   Response
	session_id string
}

struct ProtocolError {
	response_error ResponseError
	request_id     string
}

fn (err ProtocolError) msg() string {
	return err.response_error.message
}

fn (err ProtocolError) code() int {
	return err.response_error.code
}

struct CursorParams {
	cursor string
}

struct ToolCallParams {
	name      string
	arguments string @[raw]
}

struct ReadResourceParams {
	uri string
}

struct GetPromptParams {
	name      string
	arguments string @[raw]
}

struct ListToolsResult {
	tools       []Tool
	next_cursor string @[json: nextCursor; omitempty]
}

struct ListResourcesResult {
	resources   []Resource
	next_cursor string @[json: nextCursor; omitempty]
}

struct ListResourceTemplatesResult {
	resource_templates []ResourceTemplate @[json: resourceTemplates]
	next_cursor        string             @[json: nextCursor; omitempty]
}

struct ListPromptsResult {
	prompts     []Prompt
	next_cursor string @[json: nextCursor; omitempty]
}

const default_tool_input_schema = '{"type":"object","additionalProperties":false}'

// Server handles MCP protocol requests for stdio and HTTP transports.
@[heap]
pub struct Server {
mut:
	server_info           Implementation
	protocol_version      string
	capabilities_override string
	instructions          string
	http_path             string
	http_server           &http.Server = unsafe { nil }
	tools                 map[string]RegisteredTool
	tool_names            []string
	resources             map[string]RegisteredResource
	resource_uris         []string
	resource_templates    map[string]ResourceTemplate
	resource_template_ids []string
	prompts               map[string]RegisteredPrompt
	prompt_names          []string
	state                 shared ServerState
}

// new_server constructs a new MCP server.
pub fn new_server(config ServerConfig) Server {
	return Server{
		server_info:           normalize_server_info(config.name, config.version)
		protocol_version:      normalize_protocol_version(config.protocol_version)
		capabilities_override: config.capabilities.trim_space()
		instructions:          config.instructions
		http_path:             normalize_http_path(config.http_path)
		tools:                 map[string]RegisteredTool{}
		resources:             map[string]RegisteredResource{}
		resource_templates:    map[string]ResourceTemplate{}
		prompts:               map[string]RegisteredPrompt{}
		state:                 ServerState{}
	}
}

// add_tool registers a tool and its handler.
pub fn (mut s Server) add_tool(tool Tool, handler ToolHandler) ! {
	validate_tool_name(tool.name)!
	if tool.name in s.tools {
		return error('mcp.Server.add_tool: duplicate tool `${tool.name}`')
	}
	normalized := Tool{
		name:          tool.name
		title:         tool.title
		description:   tool.description
		input_schema:  normalize_tool_input_schema(tool.input_schema)
		output_schema: tool.output_schema.trim_space()
	}
	s.tools[tool.name] = RegisteredTool{
		tool:    normalized
		handler: handler
	}
	s.tool_names << tool.name
}

// add_resource registers a concrete resource and its read handler.
pub fn (mut s Server) add_resource(resource Resource, handler ResourceHandler) ! {
	if resource.uri.trim_space() == '' {
		return error('mcp.Server.add_resource: empty uri')
	}
	if resource.uri in s.resources {
		return error('mcp.Server.add_resource: duplicate resource `${resource.uri}`')
	}
	s.resources[resource.uri] = RegisteredResource{
		resource: resource
		handler:  handler
	}
	s.resource_uris << resource.uri
}

// add_resource_template registers a resource template exposed by `resources/templates/list`.
pub fn (mut s Server) add_resource_template(template ResourceTemplate) ! {
	if template.uri_template.trim_space() == '' {
		return error('mcp.Server.add_resource_template: empty uri template')
	}
	if template.uri_template in s.resource_templates {
		return error('mcp.Server.add_resource_template: duplicate resource template `${template.uri_template}`')
	}
	s.resource_templates[template.uri_template] = template
	s.resource_template_ids << template.uri_template
}

// add_prompt registers a prompt and its handler.
pub fn (mut s Server) add_prompt(prompt Prompt, handler PromptHandler) ! {
	if prompt.name.trim_space() == '' {
		return error('mcp.Server.add_prompt: empty prompt name')
	}
	if prompt.name in s.prompts {
		return error('mcp.Server.add_prompt: duplicate prompt `${prompt.name}`')
	}
	s.prompts[prompt.name] = RegisteredPrompt{
		prompt:  prompt
		handler: handler
	}
	s.prompt_names << prompt.name
}

// serve_stdio starts serving MCP messages over stdio using Content-Length framing.
pub fn (mut s Server) serve_stdio() ! {
	mut stdin := os.stdin()
	mut stdout := os.stdout()
	s.serve_framed_transport(mut stdin, mut stdout, stdio_session_id, .stdio)!
}

// serve_http starts serving MCP over a single HTTP endpoint.
pub fn (mut s Server) serve_http(addr string) ! {
	if addr.trim_space() == '' {
		return error('mcp.Server.serve_http: empty address')
	}
	mut handler := HttpHandler{
		server: s
	}
	mut http_server := &http.Server{
		addr:                 addr
		handler:              handler
		accept_timeout:       100 * time.millisecond
		show_startup_message: false
	}
	s.http_server = http_server
	http_server.listen_and_serve()
}

// close stops the HTTP server if it is running.
pub fn (mut s Server) close() {
	if !isnil(s.http_server) {
		s.http_server.close()
	}
}

// wait_till_running waits until the HTTP server transitions to the running state.
pub fn (mut s Server) wait_till_running(params http.WaitTillRunningParams) !int {
	mut retries := 0
	for isnil(s.http_server) && retries < params.max_retries {
		time.sleep(params.retry_period_ms * time.millisecond)
		retries++
	}
	if isnil(s.http_server) {
		return error('mcp.Server.wait_till_running: HTTP server is not running')
	}
	remaining_retries := if params.max_retries > retries { params.max_retries - retries } else { 0 }
	if remaining_retries == 0 {
		return error('mcp.Server.wait_till_running: HTTP server is not running')
	}
	retry_count := s.http_server.wait_till_running(
		max_retries:     remaining_retries
		retry_period_ms: params.retry_period_ms
	)!
	return retries + retry_count
}

// text_content creates a raw MCP text content item.
pub fn text_content(text string) string {
	return '{"type":"text","text":${json.encode(text)}}'
}

// prompt_text_message creates a prompt message with text content.
pub fn prompt_text_message(role string, text string) PromptMessage {
	return PromptMessage{
		role:    role
		content: text_content(text)
	}
}

// tool_text_result wraps plain text in an MCP tool result.
pub fn tool_text_result(text string) ToolResult {
	return ToolResult{
		content: '[${text_content(text)}]'
	}
}

fn tool_error_result(text string) ToolResult {
	return ToolResult{
		content:  '[${text_content(text)}]'
		is_error: true
	}
}

fn response_with_json(request_id string, result_json string) Response {
	return Response{
		id:     request_id
		result: result_json
	}
}

fn encode_initialize_result(result InitializeResult) string {
	mut fields := [
		'"protocolVersion":${json.encode(result.protocol_version)}',
		'"capabilities":${normalize_capabilities(result.capabilities)}',
		'"serverInfo":${json.encode(result.server_info)}',
	]
	if result.instructions != '' {
		fields << '"instructions":${json.encode(result.instructions)}'
	}
	return '{${fields.join(',')}}'
}

fn encode_tools_list_result(result ListToolsResult) string {
	mut fields := ['"tools":[${result.tools.map(encode_tool).join(',')}]']
	if result.next_cursor != '' {
		fields << '"nextCursor":${json.encode(result.next_cursor)}'
	}
	return '{${fields.join(',')}}'
}

fn encode_tool(tool Tool) string {
	mut fields := ['"name":${json.encode(tool.name)}',
		'"inputSchema":${normalize_tool_input_schema(tool.input_schema)}']
	if tool.title != '' {
		fields << '"title":${json.encode(tool.title)}'
	}
	if tool.description != '' {
		fields << '"description":${json.encode(tool.description)}'
	}
	if tool.output_schema.trim_space() != '' {
		fields << '"outputSchema":${tool.output_schema.trim_space()}'
	}
	return '{${fields.join(',')}}'
}

fn encode_tool_result(result ToolResult) string {
	mut fields := ['"isError":${result.is_error.str()}']
	if result.content.trim_space() != '' {
		fields << '"content":${result.content.trim_space()}'
	}
	if result.structured_content.trim_space() != '' {
		fields << '"structuredContent":${result.structured_content.trim_space()}'
	}
	return '{${fields.join(',')}}'
}

fn encode_prompt_result(result GetPromptResult) string {
	mut fields := [
		'"messages":[${result.messages.map(encode_prompt_message).join(',')}]',
	]
	if result.description != '' {
		fields << '"description":${json.encode(result.description)}'
	}
	return '{${fields.join(',')}}'
}

fn encode_prompt_message(message PromptMessage) string {
	return '{"role":${json.encode(message.role)},"content":${message.content}}'
}

fn (mut s Server) serve_framed_transport(mut reader io.Reader, mut writer io.Writer, session_id string, transport SessionTransport) ! {
	mut buffer := ''
	for {
		frame := try_extract_framed_message(buffer) or {
			if err.msg() != NoFrameError{}.msg() {
				error_response := Response{
					error: normalize_response_error(err)
				}.encode()
				writer.write(encode_framed_message(error_response).bytes())!
				return err
			}
			FrameExtraction{}
		}
		if frame.message.len != 0 {
			buffer = frame.remaining
			dispatch_result := s.dispatch_message(frame.message, session_id, transport) or {
				error_response := Response{
					error: normalize_response_error(err)
				}.encode()
				writer.write(encode_framed_message(error_response).bytes())!
				continue
			}
			if dispatch_result.has_response {
				writer.write(encode_framed_message(dispatch_result.response).bytes())!
			}
			continue
		}
		mut chunk := []u8{len: 4096}
		bytes_read := reader.read(mut chunk) or {
			if err is os.Eof {
				return
			}
			if err is io.Eof {
				return
			}
			return err
		}
		if bytes_read == 0 {
			return
		}
		buffer += chunk[..bytes_read].bytestr()
	}
}

fn (mut s Server) dispatch_message(raw string, session_id string, transport SessionTransport) !DispatchResult {
	trimmed := raw.trim_space()
	if trimmed.len == 0 || trimmed[0] == `[` {
		return ProtocolError{
			response_error: invalid_request
		}
	}
	envelope := decode_envelope(trimmed) or {
		return ProtocolError{
			response_error: parse_error
		}
	}
	return s.dispatch_envelope(envelope, session_id, transport)
}

fn (mut s Server) dispatch_envelope(envelope MessageEnvelope, session_id string, transport SessionTransport) !DispatchResult {
	if envelope.method.len == 0 {
		return DispatchResult{}
	}
	if envelope.id.len == 0 || envelope.id == null.str() {
		s.handle_notification(Notification{
			method: envelope.method
			params: envelope.params
		}, session_id, transport)!
		return DispatchResult{}
	}
	req := Request{
		id:     envelope.id
		method: envelope.method
		params: envelope.params
	}
	handled := s.handle_request(req, session_id, transport)
	return DispatchResult{
		has_response: true
		response:     handled.response.encode()
		session_id:   handled.session_id
	}
}

fn (mut s Server) handle_request(req Request, session_id string, transport SessionTransport) HandledRequest {
	return s.handle_request_impl(req, session_id, transport) or {
		return HandledRequest{
			response: error_response_for(req.id, err)
		}
	}
}

fn (mut s Server) handle_request_impl(req Request, session_id string, transport SessionTransport) !HandledRequest {
	if req.method == 'ping' {
		return HandledRequest{
			response: response_with_json(req.id, empty_object.str())
		}
	}
	if req.method == 'initialize' {
		return s.handle_initialize(req, session_id, transport)
	}
	session := s.session_for_request(session_id, transport) or {
		return ProtocolError{
			response_error: server_not_initialized
			request_id:     req.id
		}
	}
	if !session.initialize_complete || !session.initialized {
		return ProtocolError{
			response_error: server_not_initialized
			request_id:     req.id
		}
	}
	ctx := s.context_from_session(req, session)
	match req.method {
		'tools/list' {
			return s.handle_tools_list(req)
		}
		'tools/call' {
			return s.handle_tools_call(req, ctx)
		}
		'resources/list' {
			return s.handle_resources_list(req)
		}
		'resources/read' {
			return s.handle_resources_read(req, ctx)
		}
		'resources/templates/list' {
			return s.handle_resource_templates_list(req)
		}
		'prompts/list' {
			return s.handle_prompts_list(req)
		}
		'prompts/get' {
			return s.handle_prompts_get(req, ctx)
		}
		else {
			return ProtocolError{
				response_error: method_not_found
				request_id:     req.id
			}
		}
	}

	return ProtocolError{
		response_error: method_not_found
		request_id:     req.id
	}
}

fn (mut s Server) handle_initialize(req Request, session_id string, transport SessionTransport) !HandledRequest {
	params := req.decode_params[InitializeParams]() or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	mut session := s.ensure_session_for_initialize(session_id, transport)
	if session.initialize_complete {
		return ProtocolError{
			response_error: invalid_request
			request_id:     req.id
		}
	}
	session.protocol_version = if params.protocol_version == s.protocol_version {
		s.protocol_version
	} else {
		s.protocol_version
	}
	session.client_info = normalize_client_info(params.client_info)
	session.client_capabilities = normalize_capabilities(params.capabilities)
	session.initialize_complete = true
	session.initialized = false
	s.store_session(session)
	result := InitializeResult{
		protocol_version: session.protocol_version
		capabilities:     s.capabilities_json()
		server_info:      s.server_info
		instructions:     s.instructions
	}
	return HandledRequest{
		response:   response_with_json(req.id, encode_initialize_result(result))
		session_id: if transport == .http { session.id } else { '' }
	}
}

fn (mut s Server) handle_tools_list(req Request) !HandledRequest {
	params := decode_optional_params[CursorParams](req.params) or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	start, end, next_cursor := paginate_bounds(s.tool_names.len, params.cursor)!
	mut tools := []Tool{cap: end - start}
	for name in s.tool_names[start..end] {
		tools << s.tools[name].tool
	}
	return HandledRequest{
		response: response_with_json(req.id, encode_tools_list_result(ListToolsResult{
			tools:       tools
			next_cursor: next_cursor
		}))
	}
}

fn (mut s Server) handle_tools_call(req Request, ctx Context) !HandledRequest {
	params := decode_optional_params[ToolCallParams](req.params) or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	if params.name !in s.tools {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	entry := s.tools[params.name]
	result := entry.handler(ctx, json_object_or_empty(params.arguments)) or {
		if err is ProtocolError {
			return err
		}
		if err is ResponseError {
			return err
		}
		return HandledRequest{
			response: response_with_json(req.id, encode_tool_result(tool_error_result(err.msg())))
		}
	}
	return HandledRequest{
		response: response_with_json(req.id, encode_tool_result(result))
	}
}

fn (mut s Server) handle_resources_list(req Request) !HandledRequest {
	params := decode_optional_params[CursorParams](req.params) or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	start, end, next_cursor := paginate_bounds(s.resource_uris.len, params.cursor)!
	mut resources := []Resource{cap: end - start}
	for uri in s.resource_uris[start..end] {
		resources << s.resources[uri].resource
	}
	return HandledRequest{
		response: response_with_json(req.id, encode_value(ListResourcesResult{
			resources:   resources
			next_cursor: next_cursor
		}))
	}
}

fn (mut s Server) handle_resources_read(req Request, ctx Context) !HandledRequest {
	params := req.decode_params[ReadResourceParams]() or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	if params.uri !in s.resources {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	entry := s.resources[params.uri]
	result := entry.handler(ctx, params.uri) or { return err }
	return HandledRequest{
		response: response_with_json(req.id, encode_value(result))
	}
}

fn (mut s Server) handle_resource_templates_list(req Request) !HandledRequest {
	params := decode_optional_params[CursorParams](req.params) or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	start, end, next_cursor := paginate_bounds(s.resource_template_ids.len, params.cursor)!
	mut templates := []ResourceTemplate{cap: end - start}
	for uri_template in s.resource_template_ids[start..end] {
		templates << s.resource_templates[uri_template]
	}
	return HandledRequest{
		response: response_with_json(req.id, encode_value(ListResourceTemplatesResult{
			resource_templates: templates
			next_cursor:        next_cursor
		}))
	}
}

fn (mut s Server) handle_prompts_list(req Request) !HandledRequest {
	params := decode_optional_params[CursorParams](req.params) or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	start, end, next_cursor := paginate_bounds(s.prompt_names.len, params.cursor)!
	mut prompts := []Prompt{cap: end - start}
	for name in s.prompt_names[start..end] {
		prompts << s.prompts[name].prompt
	}
	return HandledRequest{
		response: response_with_json(req.id, encode_value(ListPromptsResult{
			prompts:     prompts
			next_cursor: next_cursor
		}))
	}
}

fn (mut s Server) handle_prompts_get(req Request, ctx Context) !HandledRequest {
	params := decode_optional_params[GetPromptParams](req.params) or {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	if params.name !in s.prompts {
		return ProtocolError{
			response_error: invalid_params
			request_id:     req.id
		}
	}
	entry := s.prompts[params.name]
	result := entry.handler(ctx, json_object_or_empty(params.arguments)) or { return err }
	return HandledRequest{
		response: response_with_json(req.id, encode_prompt_result(result))
	}
}

fn (mut s Server) handle_notification(notification Notification, session_id string, transport SessionTransport) ! {
	match notification.method {
		'notifications/initialized' {
			mut session := s.session_for_request(session_id, transport) or {
				return ProtocolError{
					response_error: server_not_initialized
				}
			}
			if !session.initialize_complete {
				return ProtocolError{
					response_error: server_not_initialized
				}
			}
			session.initialized = true
			s.store_session(session)
		}
		'notifications/cancelled' {}
		else {}
	}
}

fn (s &Server) capabilities_json() string {
	if s.capabilities_override != '' {
		return normalize_capabilities(s.capabilities_override)
	}
	mut parts := []string{}
	if s.tool_names.len != 0 {
		parts << '"tools":{}'
	}
	if s.resource_uris.len != 0 || s.resource_template_ids.len != 0 {
		parts << '"resources":{}'
	}
	if s.prompt_names.len != 0 {
		parts << '"prompts":{}'
	}
	return '{${parts.join(',')}}'
}

fn (mut s Server) ensure_session_for_initialize(session_id string, transport SessionTransport) Session {
	if transport == .stdio {
		return s.ensure_session(stdio_session_id, .stdio)
	}
	if session_id != '' {
		return s.ensure_session(session_id, .http)
	}
	return s.create_http_session()
}

fn (mut s Server) ensure_session(session_id string, transport SessionTransport) Session {
	if session := s.get_session(session_id) {
		return session
	}
	session := Session{
		id:               session_id
		transport:        transport
		protocol_version: s.protocol_version
	}
	s.store_session(session)
	return session
}

fn (mut s Server) create_http_session() Session {
	for {
		session_id := rand.uuid_v7()
		if !s.session_exists(session_id) {
			session := Session{
				id:               session_id
				transport:        .http
				protocol_version: s.protocol_version
			}
			s.store_session(session)
			return session
		}
	}
	return Session{}
}

fn (s &Server) session_for_request(session_id string, transport SessionTransport) ?Session {
	if transport == .stdio {
		return s.get_session(stdio_session_id)
	}
	if session_id == '' {
		return none
	}
	return s.get_session(session_id)
}

fn (mut s Server) store_session(session Session) {
	lock s.state {
		s.state.sessions[session.id] = session
	}
}

fn (s &Server) get_session(session_id string) ?Session {
	mut session := Session{}
	mut found := false
	rlock s.state {
		if session_id in s.state.sessions {
			session = s.state.sessions[session_id]
			found = true
		}
	}
	if !found {
		return none
	}
	return session
}

fn (s &Server) session_exists(session_id string) bool {
	mut found := false
	rlock s.state {
		found = session_id in s.state.sessions
	}
	return found
}

fn (mut s Server) delete_session(session_id string) bool {
	mut deleted := false
	lock s.state {
		if session_id in s.state.sessions {
			s.state.sessions.delete(session_id)
			deleted = true
		}
	}
	return deleted
}

fn (s &Server) context_from_session(req Request, session Session) Context {
	return Context{
		session_id:          session.id
		request_id:          req.id
		method:              req.method
		transport:           session.transport
		protocol_version:    session.protocol_version
		client_info:         session.client_info
		client_capabilities: session.client_capabilities
	}
}

fn decode_optional_params[T](raw string) !T {
	trimmed := raw.trim_space()
	if trimmed.len == 0 || trimmed == null.str() {
		return T{}
	}
	return decode_value[T](trimmed)
}

fn json_object_or_empty(raw string) string {
	trimmed := raw.trim_space()
	if trimmed.len == 0 || trimmed == null.str() {
		return '{}'
	}
	return trimmed
}

fn paginate_bounds(total int, cursor string) !(int, int, string) {
	mut start := 0
	if cursor.trim_space() != '' {
		start = cursor.int()
		if start < 0 || start > total || (start == 0 && cursor != '0') {
			return ProtocolError{
				response_error: invalid_params
			}
		}
	}
	mut end := start + default_list_page_size
	if end > total {
		end = total
	}
	next_cursor := if end < total { end.str() } else { '' }
	return start, end, next_cursor
}

fn validate_tool_name(name string) ! {
	trimmed := name.trim_space()
	if trimmed.len == 0 || trimmed.len > 128 {
		return error('mcp.Server.add_tool: invalid tool name `${name}`')
	}
	for ch in trimmed {
		if ch.is_letter() || ch.is_digit() || ch in [`_`, `-`, `.`] {
			continue
		}
		return error('mcp.Server.add_tool: invalid tool name `${name}`')
	}
}

fn normalize_tool_input_schema(input_schema string) string {
	trimmed := input_schema.trim_space()
	return if trimmed.len == 0 { default_tool_input_schema } else { trimmed }
}

fn normalize_server_info(name string, version string) Implementation {
	return Implementation{
		name:    if name.trim_space() == '' { default_server_name } else { name.trim_space() }
		version: if version.trim_space() == '' {
			default_server_version
		} else {
			version.trim_space()
		}
	}
}

fn normalize_http_path(path string) string {
	trimmed := path.trim_space()
	if trimmed == '' {
		return default_http_path
	}
	return if trimmed.starts_with('/') { trimmed } else { '/' + trimmed }
}

fn error_response_for(request_id string, err IError) Response {
	mut response_id := request_id
	response_error := normalize_response_error(err)
	if err is ProtocolError && err.request_id != '' {
		response_id = err.request_id
	}
	return Response{
		id:    response_id
		error: response_error
	}
}

fn normalize_response_error(err IError) ResponseError {
	if err is ProtocolError {
		return err.response_error
	}
	if err is ResponseError {
		return err
	}
	return ResponseError{
		code:    internal_error.code
		message: err.msg()
	}
}

fn build_sse_response(message string) string {
	mut lines := []string{}
	for line in message.split('\n') {
		lines << 'data: ${line}'
	}
	return lines.join('\n') + '\n\n'
}

fn accepts_event_stream_only(header http.Header) bool {
	accept := header.get(.accept) or { '' }
	if accept == '' {
		return false
	}
	accept_lower := accept.to_lower()
	return accept_lower.contains(event_stream_content_type)
		&& !accept_lower.contains(default_content_type)
}

fn json_http_response(status http.Status, body string, content_type string) http.Response {
	mut header := http.new_header()
	if content_type != '' {
		header.set(.content_type, content_type)
	}
	mut response := http.Response{
		body:   body
		header: header
	}
	response.set_status(status)
	return response
}

struct HttpHandler {
mut:
	server &Server = unsafe { nil }
}

fn (mut h HttpHandler) handle(req http.Request) http.Response {
	return h.server.handle_http_request(req)
}

fn (mut s Server) handle_http_request(req http.Request) http.Response {
	if req.url.all_before('?') != s.http_path {
		return json_http_response(.not_found, '', '')
	}
	session_id := req.header.get_custom(mcp_session_id_header) or { '' }
	match req.method {
		.delete {
			if session_id == '' {
				return json_http_response(.bad_request, '', '')
			}
			if !s.delete_session(session_id) {
				return json_http_response(.not_found, '', '')
			}
			return json_http_response(.ok, '', '')
		}
		.get {
			return json_http_response(.method_not_allowed, '', '')
		}
		.post {}
		else {
			return json_http_response(.method_not_allowed, '', '')
		}
	}

	trimmed := req.data.trim_space()
	if trimmed.len == 0 || trimmed[0] == `[` {
		return json_http_response(.bad_request, Response{
			error: invalid_request
		}.encode(), default_content_type)
	}
	envelope := decode_envelope(trimmed) or {
		return json_http_response(.bad_request, Response{
			error: parse_error
		}.encode(), default_content_type)
	}
	if session_id != '' && !s.session_exists(session_id) {
		return json_http_response(.not_found, '', '')
	}
	if envelope.method != 'initialize' && envelope.method.len != 0 && session_id == '' {
		return json_http_response(.bad_request, Response{
			error: server_not_initialized
		}.encode(), default_content_type)
	}
	dispatch_result := s.dispatch_envelope(envelope, session_id, .http) or {
		return json_http_response(.bad_request, Response{
			error: normalize_response_error(err)
		}.encode(), default_content_type)
	}
	if !dispatch_result.has_response {
		return json_http_response(.accepted, '', '')
	}
	body := if accepts_event_stream_only(req.header) {
		build_sse_response(dispatch_result.response)
	} else {
		dispatch_result.response
	}
	content_type := if accepts_event_stream_only(req.header) {
		event_stream_content_type
	} else {
		default_content_type
	}
	mut response := json_http_response(.ok, body, content_type)
	if dispatch_result.session_id != '' {
		response.header.set_custom(mcp_session_id_header, dispatch_result.session_id) or {}
	}
	return response
}