use torch_web::{App, Request, Response, main};

#[main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let app = App::new()
        .get("/", |_req: Request| async {
            Response::ok().body("Hello, World! 🔥")
        })
        .get("/users/:id", |req: Request| async move {
            let id = req.param("id").unwrap_or("Anonymous");
            Response::ok().body(format!("Hello, {}! 🔥", id))
        });

    println!("🔥 Server running at http://localhost:3000");
    app.listen("127.0.0.1:3000").await
}

use torch_web::{routes, get, Path, Query};

routes! {
    #[get("/users/{id}")]
    async fn get_user(Path(id): Path<u32>) -> Response {
        Response::ok().json(format!("User {}", id))
    }

    #[get("/users")]
    async fn list_users(Query(params): Query<UserQuery>) -> Response {
        // Type-safe query parameter extraction
        Response::ok().json(params)
    }
}

use torch_web::{ember::*, main};

#[main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let app = App::new()
        .get("/", |_req| async {
            let data = EmberData::new()
                .with("title", "Welcome to Torch")
                .with("users", vec!["Alice", "Bob", "Charlie"]);

            ember("home", data).await
        });

    app.listen("127.0.0.1:3000").await
}

use torch_web::{App, Request, Response, main};

#[main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let app = App::new()
        .get("/", |_req: Request| async {
            Response::ok().body("Hello, World! 🔥")
        })
        .get("/hello/:name", |req: Request| async move {
            let name = req.param("name").unwrap_or("Anonymous");
            Response::ok().body(format!("Hello, {}! 🔥", name))
        })
        .get("/json", |_req: Request| async {
            #[cfg(feature = "json")]
            {
                use serde_json::json;
                Response::ok()
                    .json(&json!({
                        "message": "Hello from Torch!",
                        "framework": "torch",
                        "version": "0.1.0"
                    }))
                    .unwrap()
            }
            #[cfg(not(feature = "json"))]
            {
                Response::ok()
                    .content_type("application/json")
                    .body(r#"{"message": "Hello from Torch!", "framework": "torch"}"#)
            }
        });

    println!("🔥 Starting Torch Hello World example...");
    app.listen("127.0.0.1:3000").await
}

use torch_web::{App, ember::*, main};

#[main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let app = App::new()
        .get("/", |_req| async {
            let data = EmberData::new()
                .with("title", "Welcome to Torch")
                .with("users", vec!["Alice", "Bob", "Charlie"]);

            ember("home", data).await
        });

    app.listen("127.0.0.1:3000").await
}

use torch_web::{App, Request, Response, main, ember::*};
use std::collections::HashMap;
use serde::{Deserialize, Serialize};

// Step 1: Basic Information
#[derive(Debug, Deserialize, Serialize, Clone)]
struct BasicInfo {
    first_name: String,
    last_name: String,
    email: String,
    phone: String,
}

// Registration wizard state
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
struct RegistrationData {
    basic_info: Option<BasicInfo>,
    current_step: u8,
}

// Session store (use Redis in production)
type SessionStore = std::sync::Arc<std::sync::Mutex<HashMap<String, RegistrationData>>>;

#[main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let sessions: SessionStore = std::sync::Arc::new(std::sync::Mutex::new(HashMap::new()));
    let sessions_clone = sessions.clone();

    let app = App::new()
        // Home page with beautiful template
        .get::<_, ()>("/", |_req: Request| async {
            let data = EmberData::new()
                .with("title", "Welcome to Torch")
                .with("page_title", "Multi-Step Registration Wizard")
                .with("description", "Experience the power of Torch with Ember templating");

            ember("home", data).await
        })

        // Registration wizard - Step 1
        .get::<_, ()>("/register", move |req: Request| {
            let sessions = sessions_clone.clone();
            async move {
                let session_id = get_or_create_session(&req);
                let registration_data = get_session_data(&sessions, &session_id);

                let data = EmberData::new()
                    .with("title", "Registration - Step 1")
                    .with("step", 1)
                    .with("step_title", "Basic Information")
                    .with("progress", 33)
                    .with("first_name", registration_data.basic_info
                        .as_ref().map(|b| b.first_name.clone()).unwrap_or_default());

                ember("registration/step1", data).await
            }
        })

        // Handle form submission with session state
        .post::<_, ()>("/register/step1", move |req: Request| {
            let sessions = sessions.clone();
            async move {
                let session_id = get_or_create_session(&req);

                // Parse form data (simplified for example)
                let basic_info = BasicInfo {
                    first_name: "John".to_string(),
                    last_name: "Doe".to_string(),
                    email: "[email protected]".to_string(),
                    phone: "+1-555-0123".to_string(),
                };

                // Update session state
                update_session_data(&sessions, &session_id, |data| {
                    data.basic_info = Some(basic_info);
                    data.current_step = 2;
                });

                // Redirect to next step
                Response::redirect_found("/register/step2")
            }
        });

    println!("🔥 Torch Registration Wizard starting...");
    println!("🌐 Visit http://localhost:3000 to see the demo");

    app.listen("127.0.0.1:3000").await
}

// Helper functions for session management
fn get_or_create_session(req: &Request) -> String {
    req.header("x-session-id").unwrap_or("demo-session").to_string()
}

fn get_session_data(sessions: &SessionStore, session_id: &str) -> RegistrationData {
    let sessions = sessions.lock().unwrap();
    sessions.get(session_id).cloned().unwrap_or_default()
}

fn update_session_data<F>(sessions: &SessionStore, session_id: &str, updater: F)
where F: FnOnce(&mut RegistrationData)
{
    let mut sessions = sessions.lock().unwrap();
    let mut data = sessions.get(session_id).cloned().unwrap_or_default();
    updater(&mut data);
    sessions.insert(session_id.to_string(), data);
}

use torch_web::{App, main, extractors::*};
use std::collections::HashMap;

#[derive(Clone)]
struct AppState {
    counter: std::sync::Arc<tokio::sync::Mutex<u64>>,
}

#[main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let state = AppState {
        counter: std::sync::Arc::new(tokio::sync::Mutex::new(0)),
    };

    let app = App::new()
        .with_state(state)

        // Path parameters
        .get("/users/:id", |Path(user_id): Path<u32>| async move {
            format!("User ID: {}", user_id)
        })

        // Query parameters
        .get("/search", |Query(params): Query<HashMap<String, String>>| async move {
            let query = params.get("q").unwrap_or(&"*".to_string());
            format!("Searching for: {}", query)
        })

        // JSON body (with json feature)
        .post("/users", |Json(user): Json<serde_json::Value>| async move {
            format!("Creating user: {}", user)
        })

        // Headers
        .get("/info", |Headers(headers): Headers| async move {
            let user_agent = headers.get("user-agent")
                .and_then(|v| v.to_str().ok())
                .unwrap_or("Unknown");
            format!("Your browser: {}", user_agent)
        })

        // Application state
        .post("/increment", |State(state): State<AppState>| async move {
            let mut counter = state.counter.lock().await;
            *counter += 1;
            format!("Counter: {}", *counter)
        })

        // Multiple extractors
        .get("/api/:version/search", |
            Path(version): Path<String>,
            Query(params): Query<HashMap<String, String>>,
            State(state): State<AppState>,
        | async move {
            let counter = state.counter.lock().await;
            let query = params.get("q").unwrap_or(&"*".to_string());
            format!("API v{}: Searching '{}' (requests: {})", version, query, *counter)
        });

    app.listen("127.0.0.1:3000").await
}

use torch_web::ErrorPages;

let custom_pages = ErrorPages::new()
    .custom_404("Your custom 404 HTML here")
    .custom_500("Your custom 500 HTML here");

let app = App::new()
    .error_pages(custom_pages);

use torch_web::security::*;

// Input validation and sanitization
let app = App::new()
    .middleware(InputValidator::new())
    .middleware(SecurityHeaders::new())
    .middleware(RateLimiter::new(100)); // 100 requests per second

// HMAC request signing
let signing = RequestSigning::new("your-secret-key");
let app = app.middleware(signing);

// IP whitelisting
let whitelist = IpWhitelist::new()
    .allow_ip("192.168.1.1")
    .allow_range("10.0.0.0/8");
let app = app.middleware(whitelist);

use torch_web::production::*;

// Metrics and monitoring
let app = App::new()
    .middleware(MetricsCollector::new())
    .middleware(PerformanceMonitor::new())
    .middleware(RequestLogger::new());

// Health check endpoint
let app = app.get("/health", |_req| async {
    Response::ok().json(&serde_json::json!({
        "status": "healthy",
        "uptime": "24h",
        "version": "0.1.0"
    })).unwrap()
});

use torch_web::{routes, get, post, Path, Query, Json};

// Compile-time validated routes with type-safe extractors
routes! {
    #[get("/users/{id}")]
    async fn get_user(Path(id): Path<u32>) -> Response {
        // id is guaranteed to be a valid u32 at compile time
        Response::ok().json(format!("User {}", id))
    }

    #[get("/users")]
    async fn list_users(Query(params): Query<UserQuery>) -> Response {
        // params is type-checked at compile time
        Response::ok().json(params)
    }

    #[post("/users")]
    async fn create_user(Json(user): Json<CreateUserRequest>) -> Response {
        // JSON deserialization is validated at compile time
        Response::created().json("User created")
    }
}

// Shared layout with navigation
// templates/layouts/app.ember
```html
<!DOCTYPE html>
<html>
<head>
    <title>{{ $title }} - My App</title>
    <link rel="stylesheet" href="/css/app.css">
</head>
<body>
    @include('components/header')
    @include('components/navigation')

    <main class="content">
        @section('content')
            <p>Default content</p>
        @endsection
    </main>

    @include('components/footer')
</body>
</html>

// All pages inherit the same layout
// templates/users/index.ember
```html
@extends('layouts/app')

@section('content')
    <h1>{{ $page_title }}</h1>
    @foreach($users as $user)
        <div class="user-card">{{ $user.name }}</div>
    @endforeach
@endsection

use torch_web::middleware::*;

// Built-in middleware
let app = App::new()
    .middleware(Logger::new())
    .middleware(Cors::permissive())
    .middleware(SecurityHeaders::new())
    .middleware(Compression::new());

// Custom middleware
let app = app.middleware(|req: Request, next| {
    Box::pin(async move {
        let start = std::time::Instant::now();
        let response = next(req).await;
        let duration = start.elapsed();
        println!("Request took: {:?}", duration);
        response
    })
});