//! Generic Application Deployment Example
//!
//! This example shows how to deploy any containerized application using the
//! KubernetesManager convenience methods. This works for any Docker image.

use sal_kubernetes::KubernetesManager;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create Kubernetes manager
    let km = KubernetesManager::new("default").await?;

    // Example 1: Simple web server deployment
    println!("=== Example 1: Simple Nginx Web Server ===");

    km.deploy_application("web-server", "nginx:latest", 2, 80, None)
        .await?;
    println!("✅ Nginx web server deployed!");

    // Example 2: Node.js application with labels
    println!("\n=== Example 2: Node.js Application ===");

    let mut node_labels = HashMap::new();
    node_labels.insert("app".to_string(), "node-app".to_string());
    node_labels.insert("tier".to_string(), "backend".to_string());
    node_labels.insert("environment".to_string(), "production".to_string());

    km.deploy_application(
        "node-app",        // name
        "node:18-alpine",  // image
        3,                 // replicas - scale to 3 instances
        3000,              // port
        Some(node_labels), // labels
    )
    .await?;

    println!("✅ Node.js application deployed!");

    // Example 3: Database deployment (any database)
    println!("\n=== Example 3: MongoDB Database ===");

    let mut mongo_labels = HashMap::new();
    mongo_labels.insert("app".to_string(), "mongodb".to_string());
    mongo_labels.insert("type".to_string(), "database".to_string());
    mongo_labels.insert("engine".to_string(), "mongodb".to_string());

    km.deploy_application(
        "mongodb",          // name
        "mongo:6.0",        // image
        1,                  // replicas - single instance for simplicity
        27017,              // port
        Some(mongo_labels), // labels
    )
    .await?;

    println!("✅ MongoDB deployed!");

    // Check status of all deployments
    println!("\n=== Checking Deployment Status ===");

    let deployments = km.deployments_list().await?;

    for deployment in &deployments {
        if let Some(name) = &deployment.metadata.name {
            let total_replicas = deployment
                .spec
                .as_ref()
                .and_then(|s| s.replicas)
                .unwrap_or(0);
            let ready_replicas = deployment
                .status
                .as_ref()
                .and_then(|s| s.ready_replicas)
                .unwrap_or(0);

            println!(
                "{}: {}/{} replicas ready",
                name, ready_replicas, total_replicas
            );
        }
    }

    println!("\n🎉 All deployments completed!");
    println!("\n💡 Key Points:");
    println!("  • Any Docker image can be deployed using this simple interface");
    println!("  • Use labels to organize and identify your applications");
    println!(
        "  • The same method works for databases, web servers, APIs, and any containerized app"
    );
    println!("  • For advanced configuration, use the individual KubernetesManager methods");
    println!(
        "  • Environment variables and resource limits can be added via direct Kubernetes API"
    );

    Ok(())
}