use mcp_framework::prelude::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    mcp_framework::load_env();

    let client = McpClient::new("http://localhost:3000");
    let llm = AnthropicAdapter::from_env("claude-sonnet-4-5-20250929".to_string())?;
    let mut agent = Agent::new(client, Arc::new(llm), AgentConfig::default());

    let response = agent.run("What is 15 + 27?").await?;
    println!("{}", response);

    Ok(())
}

use mcp_framework::prelude::*;
use mcp_framework::server::{McpServer, ServerConfig, ToolHandler};
use std::sync::Arc;

struct MyToolHandler;

#[async_trait::async_trait]
impl ToolHandler for MyToolHandler {
    async fn execute(&self, name: &str, arguments: serde_json::Value)
        -> Result<Vec<ResultContent>> {
        match name {
            "greet" => Ok(vec![ResultContent::Text {
                text: format!("Hello, {}!", arguments.get("name").and_then(|v| v.as_str()).unwrap_or("stranger"))
            }]),
            _ => Err(Error::ToolNotFound(name.to_string())),
        }
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    let config = ServerConfig {
        name: "My Server".to_string(),
        version: "1.0.0".to_string(),
        capabilities: ServerCapabilities {
            tools: Some(ToolsCapability { list_changed: Some(false) }),
            resources: None,  // Not implemented yet
            prompts: None,    // Not implemented yet
        },
    };

    let server = McpServer::new(config, Arc::new(MyToolHandler));

    server.register_tool(Tool {
        name: "greet".to_string(),
        description: Some("Greet someone".to_string()),
        input_schema: None,
    });

    Ok(())
}

use mcp_framework::prelude::*;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<()> {
    let client = McpClient::new("http://localhost:3000");

    // List all tools
    let tools = client.list_tools().await?;
    println!("Available tools: {:?}", tools);

    // Call a tool
    let result = client.call_tool("echo", json!({
        "message": "Hello, MCP!"
    })).await?;
    println!("Result: {:?}", result);

    Ok(())
}

let config = ServerConfig {
    name: "My Server".to_string(),
    version: "1.0.0".to_string(),
    capabilities: ServerCapabilities {
        tools: Some(ToolsCapability { list_changed: Some(false) }),
        resources: None,  // Not implemented yet
        prompts: None,    // Not implemented yet
    },
};

let handler = Arc::new(MyToolHandler);
let server = McpServer::new(config, handler);

use std::collections::HashMap;
use serde_json::json;

let mut properties = HashMap::new();
properties.insert("param".to_string(), json!({"type": "string"}));

server.register_tool(Tool {
    name: "my_tool".to_string(),
    description: Some("Does something useful".to_string()),
    input_schema: Some(ToolInputSchema {
        schema_type: "object".to_string(),
        properties,
        required: Some(vec!["param".to_string()]),
    }),
});

#[async_trait::async_trait]
impl ToolHandler for MyHandler {
    async fn execute(&self, name: &str, arguments: Value)
        -> Result<Vec<ResultContent>> {
        match name {
            "my_tool" => {
                // Extract and validate arguments
                let param = arguments.get("param")
                    .and_then(|v| v.as_str())?;

                // Implement your logic
                let result = do_something(param);

                Ok(vec![ResultContent::Text {
                    text: result.to_string()
                }])
            }
            _ => Err(Error::ToolNotFound(name.to_string())),
        }
    }
}

use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<()> {
    mcp_framework::load_env();

    let client = McpClient::new("http://localhost:3000");
    let llm = AnthropicAdapter::from_env("claude-sonnet-4-5-20250929".to_string())?;

    let mut agent = Agent::new(client, Arc::new(llm), AgentConfig {
        max_iterations: 10,
        max_tokens: Some(2048),
    });

    let response = agent.run("Your query here").await?;
    println!("Response: {}", response);

    Ok(())
}

let client = McpClient::new("http://localhost:3000");

// List available tools
let tools = client.list_tools().await?;

// Call a tool
let result = client.call_tool("echo", json!({
    "message": "Hello!"
})).await?;