use turbomcp::prelude::*;

#[derive(Clone)]
struct Calculator;

#[server(
    name = "calculator-server",
    version = "1.0.0",
    description = "A simple calculator"
)]
impl Calculator {
    #[tool("Add two numbers")]
    async fn add(&self, a: i32, b: i32) -> McpResult<i32> {
        Ok(a + b)
    }

    #[tool("Get server status")]
    async fn status(&self, ctx: Context) -> McpResult<String> {
        ctx.info("Status requested").await?;
        Ok("Server running".to_string())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    Calculator.run_stdio().await?;
    Ok(())
}

use turbomcp::prelude::*;

#[server]
impl AudioServer {
    #[tool("Process audio data")]
    async fn process_audio(&self, audio_data: String) -> McpResult<Content> {
        Ok(Content::Audio(AudioContent {
            data: audio_data,           // Base64 encoded audio
            mime_type: "audio/wav".to_string(),
            annotations: Some(Annotations {
                audience: Some(vec!["user".to_string()]),
                priority: Some(0.8),
                last_modified: Some("2025-06-18T12:00:00Z".to_string()),
            }),
            meta: Some(enhanced_metadata),
        }))
    }
}

let annotations = Annotations {
    audience: Some(vec!["user".to_string(), "assistant".to_string()]),
    priority: Some(0.9),                    // Priority weighting
    last_modified: Some(iso8601_timestamp), // ISO 8601 compliance
};

#[server(
    name = "mcp-2025-server",           // Programmatic identifier
    title = "MCP 2025 Feature Server",  // Human-readable title
    version = "1.0.8"
)]
impl ModernServer { /* ... */ }

use turbomcp::elicitation::*;

let schema = ElicitationSchema::new()
    .add_property("user_name".to_string(),
        string("Your Name").min_length(2).max_length(50))
    .add_property("email".to_string(),
        string("Email Address").format("email"))
    .require(vec!["user_name".to_string(), "email".to_string()]);

let response = ctx.elicit("Please provide your details", schema).await?;

use turbomcp_transport::{AxumMcpExt, McpServerConfig};

// Production security configuration  
let config = McpServerConfig::production()
    .with_cors_origins(vec!["https://app.example.com".to_string()])
    .with_custom_csp("default-src 'self'; connect-src 'self' wss:")
    .with_rate_limit(120, 20)  // 120 requests/minute, 20 burst
    .with_jwt_auth("your-secret-key".to_string());

let app = Router::new()
    .route("/api/status", get(status_handler))
    .merge(Router::<()>::turbo_mcp_routes_for_merge(mcp_service, config));

use turbomcp::prelude::*;
use turbomcp::auth::*;

#[derive(Clone)]
pub struct AuthenticatedServer {
    oauth_providers: Arc<RwLock<HashMap<String, OAuth2Provider>>>,
}

#[server]
impl AuthenticatedServer {
    #[tool("Get authenticated user profile")]
    async fn get_user_profile(&self, ctx: Context) -> McpResult<String> {
        if let Some(user_id) = ctx.user_id() {
            Ok(format!("Authenticated user: {}", user_id))
        } else {
            Err(mcp_error!("Authentication required"))
        }
    }

    #[tool("Start OAuth flow")]
    async fn start_oauth_flow(&self, provider: String) -> McpResult<String> {
        let providers = self.oauth_providers.read().await;
        if let Some(oauth_provider) = providers.get(&provider) {
            let auth_result = oauth_provider.start_authorization().await?;
            Ok(format!("Visit: {}", auth_result.auth_url))
        } else {
            Err(mcp_error!("Unknown provider: {}", provider))
        }
    }
}

#[server]
impl ProductionServer {
    #[tool("Process with full observability")]
    async fn process_data(&self, ctx: Context, data: String) -> McpResult<String> {
        // Context provides:
        // - Request correlation and distributed tracing  
        // - Structured logging with metadata
        // - Performance monitoring and metrics
        // - Dependency injection container access
        
        ctx.info(&format!("Processing: {}", data)).await?;
        
        let start = std::time::Instant::now();
        let result = self.database.process(&data).await?;
        
        ctx.info(&format!("Completed in {:?}", start.elapsed())).await?;
        Ok(result)
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = Calculator::new();

    match std::env::var("TRANSPORT").as_deref() {
        // High-performance TCP with session management
        Ok("tcp") => {
            server.run_tcp("127.0.0.1:8080").await?
        },
        // Unix socket with Tokio best practices
        Ok("unix") => {
            server.run_unix("/tmp/mcp.sock").await?
        },
        // HTTP/SSE with streaming support
        Ok("http") => {
            server.run_http("127.0.0.1:8080").await?
        },
        // WebSocket for real-time communication
        Ok("websocket") => {
            server.run_websocket("127.0.0.1:8081").await?
        },
        // STDIO for Claude Desktop (default)
        _ => {
            // CRITICAL: No logging for STDIO - pure JSON-RPC only
            server.run_stdio().await?
        }
    }
    Ok(())
}

use tokio::signal;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = MyServer::new();
    let (server, shutdown_handle) = server.into_server_with_shutdown()?;
    
    let server_task = tokio::spawn(async move {
        server.run_stdio().await
    });
    
    signal::ctrl_c().await?;
    // NOTE: For STDIO transport, avoid logging to prevent JSON-RPC pollution
    // For other transports, you could use: tracing::info!("Shutdown signal received");

    shutdown_handle.shutdown().await;
    server_task.await??;
    
    Ok(())
}

use turbomcp::prelude::*;

// Method 1: Using macro attributes (recommended)
#[server(
    name = "filesystem-server",
    version = "1.0.0",
    root = "file:///workspace:Project Workspace",
    root = "file:///tmp:Temporary Files",
    root = "file:///Users/shared:Shared Documents"
)]
impl FileSystemServer {
    #[tool("List files in directory")]
    async fn list_files(&self, ctx: Context, path: String) -> McpResult<Vec<String>> {
        ctx.info(&format!("Listing files in: {}", path)).await?;
        // File operations are bounded by configured roots
        Ok(vec!["file1.txt".to_string(), "file2.txt".to_string()])
    }
}

// Method 2: Using ServerBuilder API
use turbomcp_server::ServerBuilder;
use turbomcp_protocol::types::Root;

let server = ServerBuilder::new()
    .name("filesystem-server")
    .version("1.0.0")
    .root("file:///workspace", Some("Workspace".to_string()))
    .roots(vec![
        Root { uri: "file:///tmp".to_string(), name: Some("Temp".to_string()) }
    ])
    .build();

use turbomcp::prelude::*;
use turbomcp::elicitation_api::{ElicitationResult, text, checkbox, integer_field};
use turbomcp_macros::elicit;

#[tool("Configure deployment")]
async fn deploy(&self, ctx: Context, project: String) -> McpResult<String> {
    // Simple elicit macro for quick prompts
    let confirmation = elicit!(ctx, "Deploy to production?")?;
    if matches!(confirmation, ElicitationResult::Decline(_)) {
        return Ok("Deployment cancelled".to_string());
    }

    // Advanced form with beautiful ergonomic builders
    let config = elicit("Configure deployment")
        .field("environment", text("Environment").options(&["dev", "staging", "production"]))
        .field("auto_scale", checkbox("Enable Auto-scaling").default(true))
        .field("replicas", integer_field("Replica Count").range(1.0, 10.0))
        .require(vec!["environment"])
        .send(&ctx.request)
        .await?;
    
    match config {
        ElicitationResult::Accept(data) => {
            let env = data.get::<String>("environment")?;
            let replicas = data.get::<i64>("replicas").unwrap_or(1);
            Ok(format!("Deployed {} to {} with {} replicas", project, env, replicas))
        }
        _ => Err(mcp_error!("Deployment cancelled"))
    }
}

#[tool("Process user data")]
async fn process_user(
    &self,
    #[description("User's email address")]
    email: String,
    #[description("User's age in years")] 
    age: u8,
) -> McpResult<UserProfile> {
    // Schema automatically generated and validated
    Ok(UserProfile { email, age })
}

#[resource("file://{path}")]
async fn read_file(&self, path: String) -> McpResult<String> {
    tokio::fs::read_to_string(&path).await
        .map_err(|e| mcp_error!("Resource error: {}", e))
}