// Comprehensive MCP server example covering every feature exposed by `vlib/mcp`:
// tools (with annotations), concrete resources, resource templates, prompts,
// per-argument completions, RFC 5424 logging, cooperative cancellation,
// progress notifications, subscriptions, and server-initiated requests.
//
// Usage:
//   v run examples/mcp/server.v                            # stdio transport (default)
//   v run examples/mcp/server.v -- --http                  # HTTP transport on 127.0.0.1:8080
//   v run examples/mcp/server.v -- --http 127.0.0.1:9000   # HTTP transport on 127.0.0.1:9000
//
// Connect a client (e.g. Claude Desktop / Cursor / a custom MCP client) to the
// command above for stdio, or POST to `http://127.0.0.1:8080/mcp` for HTTP.
module main

import json
import mcp
import os
import time

struct CountArgs {
    n int
}

const supported_languages = ['rust', 'python', 'go', 'v', 'typescript', 'zig']!
const welcome_text = 'Welcome to the V MCP showcase server.'

fn main() {
    mut server := mcp.new_server(
        name:           'v.mcp.showcase'
        version:        '1.0.0'
        title:          'V MCP Showcase'
        description:    'Reference server for vlib/mcp covering every capability of the 2025-11-25 spec.'
        website_url:    'https://vlang.io'
        icons:          [
            mcp.Icon{
                src:       'https://vlang.io/img/v-logo.png'
                mime_type: 'image/png'
                sizes:     ['256x256']
            },
        ]
        instructions:   'Demo server exercising every MCP capability shipped by vlib/mcp.'
        enable_logging: true
        // `*` only for the demo; tighten this for real deployments.
        allowed_origins: ['*']
    )
    register_tools(mut server)!
    register_resources(mut server)!
    register_prompts(mut server)!
    register_completions(mut server)!

    // Strip a leading `--` so the same binary works whether launched as
    // `./v run server.v -- --http :8080` (V's run forwards `--`) or as the
    // pre-compiled binary `./server --http :8080`.
    args := os.args[1..].filter(it != '--')
    if args.len > 0 && args[0] == '--http' {
        addr := if args.len > 1 { args[1] } else { '127.0.0.1:8080' }
        eprintln('mcp showcase listening on http://${addr}/mcp')
        server.serve_http(addr)!
    } else {
        server.serve_stdio()!
    }
}

fn register_tools(mut server mcp.Server) ! {
    // `echo` — pure, idempotent, read-only. Demonstrates annotations + icons.
    server.add_tool(mcp.Tool{
        name:         'echo'
        title:        'Echo'
        description:  'Return the provided text unchanged.'
        input_schema: '{"type":"object","required":["text"],"properties":{"text":{"type":"string"}}}'
        icons:        [
            mcp.Icon{
                src:       'https://vlang.io/img/echo.svg'
                mime_type: 'image/svg+xml'
            },
        ]
        annotations:  mcp.ToolAnnotations{
            title:           'Echo input'
            read_only_hint:  true
            idempotent_hint: true
            open_world_hint: false
        }
    }, fn (_ mcp.Context, arguments string) !mcp.ToolResult {
        // `arguments` is a JSON string the caller may decode. Keep it simple here.
        return mcp.tool_text_result(arguments)
    })!

    // `count_to` — long-running tool that reports progress and is cancellable.
    server.add_tool(mcp.Tool{
        name:         'count_to'
        title:        'Counter'
        description:  'Count up to N with progress notifications. Cooperatively cancellable.'
        input_schema: '{"type":"object","required":["n"],"properties":{"n":{"type":"integer","minimum":1,"maximum":50}}}'
    }, fn (ctx mcp.Context, arguments string) !mcp.ToolResult {
        args := json.decode(CountArgs, arguments) or {
            return mcp.tool_text_result('invalid arguments: ${err.msg()}')
        }
        if args.n < 1 || args.n > 50 {
            return mcp.tool_text_result('n must be in [1, 50]')
        }
        for i in 1 .. args.n + 1 {
            if ctx.is_cancelled() {
                return mcp.tool_text_result('cancelled at ${i - 1}')
            }
            ctx.notify_progress(f64(i), f64(args.n), 'tick ${i}')
            time.sleep(50 * time.millisecond)
        }
        return mcp.tool_text_result('counted to ${args.n}')
    })!

    // `delete_record` — destructive; a host can warn the user before invoking.
    server.add_tool(mcp.Tool{
        name:        'delete_record'
        title:       'Delete record (demo)'
        description: 'Demonstration only — does not delete anything.'
        annotations: mcp.ToolAnnotations{
            destructive_hint: true
            idempotent_hint:  false
        }
    }, fn (_ mcp.Context, _ string) !mcp.ToolResult {
        return mcp.tool_text_result('record removed (no-op)')
    })!
}

fn register_resources(mut server mcp.Server) ! {
    server.add_resource(mcp.Resource{
        uri:         'demo://welcome.txt'
        name:        'welcome'
        title:       'Welcome message'
        description: 'A static welcome string.'
        mime_type:   'text/plain'
        size:        welcome_text.len
        annotations: mcp.Annotations{
            audience: ['user']
            priority: 0.5
        }
    }, fn (_ mcp.Context, uri string) !mcp.ReadResourceResult {
        return mcp.ReadResourceResult{
            contents: [
                mcp.ResourceContents{
                    uri:       uri
                    mime_type: 'text/plain'
                    text:      welcome_text
                },
            ]
        }
    })!

    server.add_resource_template(mcp.ResourceTemplate{
        uri_template: 'demo://greet/{language}'
        name:         'greet'
        title:        'Localised greeting'
        description:  'Returns a greeting in {language}.'
        mime_type:    'text/plain'
    })!
}

fn register_prompts(mut server mcp.Server) ! {
    server.add_prompt(mcp.Prompt{
        name:        'review'
        title:       'Code review'
        description: 'Ask the assistant to review a snippet in the requested language.'
        arguments:   [
            mcp.PromptArgument{
                name:        'language'
                description: 'Source language of the snippet.'
                required:    true
            },
            mcp.PromptArgument{
                name:        'snippet'
                description: 'The code to review.'
                required:    true
            },
        ]
    }, fn (_ mcp.Context, arguments string) !mcp.GetPromptResult {
        return mcp.GetPromptResult{
            description: 'Code review prompt'
            messages:    [
                mcp.prompt_text_message('user',
                    'Please review the following code. Arguments: ${arguments}'),
            ]
        }
    })!
}

fn register_completions(mut server mcp.Server) ! {
    // Auto-complete the prompt argument `language` against a known list.
    server.add_completion(mcp.CompletionRef{
        ref_type: 'ref/prompt'
        name:     'review'
    }, 'language', fn (_ mcp.Context, current_value string, _ string) !mcp.CompletionResult {
        matches := supported_languages.filter(it.starts_with(current_value.to_lower()))
        return mcp.CompletionResult{
            values:   matches
            total:    matches.len
            has_more: false
        }
    })!

    // Auto-complete the resource template variable `language` similarly.
    server.add_completion(mcp.CompletionRef{
        ref_type: 'ref/resource'
        uri:      'demo://greet/{language}'
    }, 'language', fn (_ mcp.Context, current_value string, _ string) !mcp.CompletionResult {
        matches := supported_languages.filter(it.starts_with(current_value.to_lower()))
        return mcp.CompletionResult{
            values: matches
        }
    })!
}