tinterm 0.2.0

use std::io::{self, Write};
use std::thread;
use std::time::Duration;
use tinterm::*;

fn main() {
    println!(
        "{}",
        "🔧 CLI Tools with Tinterm 🔧".gradient(Color::CYAN, Color::BLUE, None)
    );
    println!();

    // Simulate various CLI tool outputs
    simulate_git_status();
    println!();

    simulate_build_process();
    println!();

    simulate_test_runner();
    println!();

    simulate_deployment();
    println!();

    simulate_monitoring_dashboard();
}

fn simulate_git_status() {
    println!("{}", "Git Status Simulation".bold().color(Color::WHITE));
    println!("{}", "=".repeat(50).color(Color::GRAY));

    println!(
        "{} {}",
        "On branch".color(Color::WHITE),
        "main".color(Color::GREEN)
    );
    println!(
        "{}",
        "Your branch is up to date with 'origin/main'.".color(Color::WHITE)
    );
    println!();

    println!("{}", "Changes to be committed:".color(Color::GREEN));
    println!(
        "  {} {}",
        "modified:".color(Color::GREEN),
        "src/lib.rs".color(Color::WHITE)
    );
    println!(
        "  {} {}",
        "new file:".color(Color::GREEN),
        "examples/shimmer.rs".color(Color::WHITE)
    );
    println!();

    println!("{}", "Changes not staged for commit:".color(Color::RED));
    println!(
        "  {} {}",
        "modified:".color(Color::RED),
        "README.md".color(Color::WHITE)
    );
    println!(
        "  {} {}",
        "deleted:".color(Color::RED),
        "old_example.rs".color(Color::WHITE)
    );
    println!();

    println!("{}", "Untracked files:".color(Color::YELLOW));
    println!("  {}", "temp.txt".color(Color::YELLOW));
}

fn simulate_build_process() {
    println!("{}", "Build Process Simulation".bold().color(Color::WHITE));
    println!("{}", "=".repeat(50).color(Color::GRAY));

    let steps = vec![
        ("Checking dependencies", Color::BLUE, "✓"),
        ("Compiling core modules", Color::YELLOW, "✓"),
        ("Running optimizations", Color::ORANGE, "✓"),
        ("Linking binaries", Color::GREEN, "✓"),
        ("Generating documentation", Color::PURPLE, "✓"),
    ];

    for (step, color, check) in steps {
        print!(
            "{} {}... ",
            "[BUILD]".color(Color::BLUE),
            step.color(Color::WHITE)
        );
        io::stdout().flush().unwrap();
        thread::sleep(Duration::from_millis(800));
        println!("{}", check.color(color));
    }

    println!();
    println!(
        "{} {}",
        "Build completed successfully!".color(Color::GREEN).bold(),
        "✨".color(Color::YELLOW)
    );
}

fn simulate_test_runner() {
    println!("{}", "Test Runner Simulation".bold().color(Color::WHITE));
    println!("{}", "=".repeat(50).color(Color::GRAY));

    let tests = vec![
        ("test_color_creation", true),
        ("test_gradient_application", true),
        ("test_shimmer_effects", true),
        ("test_text_modifiers", true),
        ("test_hex_color_parsing", false),
        ("test_chaining_methods", true),
        ("test_multiline_gradients", true),
    ];

    println!("{}", "Running tests...".color(Color::CYAN));
    println!();

    let mut passed = 0;
    let mut failed = 0;

    for (test_name, success) in tests {
        print!("test {} ... ", test_name.color(Color::WHITE));
        io::stdout().flush().unwrap();
        thread::sleep(Duration::from_millis(300));

        if success {
            println!("{}", "ok".color(Color::GREEN));
            passed += 1;
        } else {
            println!("{}", "FAILED".color(Color::RED));
            failed += 1;
        }
    }

    println!();
    if failed == 0 {
        println!(
            "test result: {}. {} passed; {} failed",
            "ok".color(Color::GREEN),
            passed.to_string().color(Color::GREEN),
            failed.to_string().color(Color::RED)
        );
    } else {
        println!(
            "test result: {}. {} passed; {} failed",
            "FAILED".color(Color::RED),
            passed.to_string().color(Color::GREEN),
            failed.to_string().color(Color::RED)
        );
    }
}

fn simulate_deployment() {
    println!("{}", "Deployment Simulation".bold().color(Color::WHITE));
    println!("{}", "=".repeat(50).color(Color::GRAY));

    let stages = vec![
        ("Preparing deployment", Color::BLUE),
        ("Building Docker image", Color::PURPLE),
        ("Pushing to registry", Color::ORANGE),
        ("Updating configuration", Color::YELLOW),
        ("Rolling out to servers", Color::GREEN),
    ];

    for (stage, color) in stages {
        let shimmer = format!("🚀 {}", stage).shimmer(color, None).speed(100);
        print!("   ");
        shimmer.animate(2);
        thread::sleep(Duration::from_millis(500));
    }

    println!();
    println!(
        "{}",
        "🎉 Deployment successful! 🎉"
            .glow(Color::GREEN, 255)
            .static_render()
    );
}

fn simulate_monitoring_dashboard() {
    println!("{}", "Monitoring Dashboard".bold().color(Color::WHITE));
    println!("{}", "=".repeat(50).color(Color::GRAY));

    // System status
    println!("{}", "System Status:".color(Color::CYAN).bold());
    println!(
        "  CPU Usage:     {} {}%",
        "●".color(Color::GREEN),
        "23".color(Color::WHITE)
    );
    println!(
        "  Memory Usage:  {} {}%",
        "●".color(Color::YELLOW),
        "67".color(Color::WHITE)
    );
    println!(
        "  Disk Usage:    {} {}%",
        "●".color(Color::RED),
        "89".color(Color::WHITE)
    );
    println!("  Network:       {} Active", "●".color(Color::GREEN));
    println!();

    // Service status
    println!("{}", "Services:".color(Color::CYAN).bold());
    let services = vec![
        ("Web Server", Color::GREEN, "Running"),
        ("Database", Color::GREEN, "Running"),
        ("Cache", Color::YELLOW, "Warning"),
        ("Queue", Color::GREEN, "Running"),
        ("API Gateway", Color::RED, "Error"),
    ];

    for (service, color, status) in services {
        println!(
            "  {:<15} {} {}",
            service.color(Color::WHITE),
            "●".color(color),
            status.color(color)
        );
    }
    println!();

    // Performance metrics with visual bars
    println!("{}", "Performance Metrics:".color(Color::CYAN).bold());

    let metrics = vec![
        ("Requests/sec", 85, Color::GREEN),
        ("Response time", 45, Color::YELLOW),
        ("Error rate", 15, Color::RED),
        ("Throughput", 92, Color::GREEN),
    ];

    for (metric, value, color) in metrics {
        let bars = "█".repeat(value / 5);
        let empty = "░".repeat(20 - value / 5);
        println!(
            "  {:<15} [{}{}] {}%",
            metric.color(Color::WHITE),
            bars.color(color),
            empty.color(Color::DARK_GRAY),
            value.to_string().color(color)
        );
    }

    println!();

    // Alert simulation
    let alert = "🚨 High memory usage detected! 🚨".glow(Color::RED, 255);
    println!("{}", alert.static_render());

    println!();
    println!(
        "{}",
        "Dashboard updated"
            .shimmer(Color::CYAN, None)
            .static_render()
    );
}