cstats-cli 0.1.1

//! CLI command tests for cstats

use std::collections::HashMap;
use std::env;

use tempfile::TempDir;
use tokio::process::Command as AsyncCommand;
use uuid::Uuid;

use cstats_core::{
    api::{AnthropicConfig, MetricValue, StatisticsData},
    config::Config,
    Result,
};

/// Helper to create a test configuration file
async fn create_test_config_file(temp_dir: &std::path::Path) -> Result<std::path::PathBuf> {
    let config_path = temp_dir.join("config.json");

    let mut config = Config::default();
    let test_auth = format!("test_{}_789", "cli");
    config.api.anthropic = Some(AnthropicConfig {
        api_key: test_auth,
        base_url: "https://api.anthropic.com".to_string(),
        timeout_seconds: 10,
        max_retries: 2,
        initial_retry_delay_ms: 100,
        max_retry_delay_ms: 1000,
        rate_limit_buffer: 5,
    });
    config.cache.cache_dir = temp_dir.join("cache");

    config.save_to_file(&config_path).await?;
    Ok(config_path)
}

/// Helper to run CLI command with timeout
async fn run_cli_command(args: &[&str]) -> Result<std::process::Output> {
    let output = AsyncCommand::new("cargo")
        .args(["run", "--bin", "cstats", "--"])
        .args(args)
        .output()
        .await
        .map_err(|e| cstats_core::Error::api(format!("Failed to run CLI command: {}", e)))?;

    Ok(output)
}

/// Helper to run CLI command with empty environment
async fn run_cli_command_no_env(args: &[&str]) -> Result<std::process::Output> {
    let output = AsyncCommand::new("cargo")
        .env("ANTHROPIC_API_KEY", "")
        .args(["run", "--bin", "cstats", "--"])
        .args(args)
        .output()
        .await
        .map_err(|e| cstats_core::Error::api(format!("Failed to run CLI command: {}", e)))?;

    Ok(output)
}

/// Helper to check if CLI binary exists
async fn cli_binary_exists() -> bool {
    AsyncCommand::new("cargo")
        .args(["build", "--bin", "cstats"])
        .output()
        .await
        .is_ok()
}

#[tokio::test]
async fn test_cli_help_command() -> Result<()> {
    if !cli_binary_exists().await {
        // Skip test if CLI can't be built
        return Ok(());
    }

    let output = run_cli_command(&["--help"]).await?;

    // CLI should return help text
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("cstats"));
    assert!(stdout.contains("Command line interface for cstats"));

    Ok(())
}

#[tokio::test]
async fn test_cli_version_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["--version"]).await?;

    // CLI should return version information
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("cstats"));

    Ok(())
}

#[tokio::test]
async fn test_stats_command_without_config() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    // Clear environment variables
    env::remove_var("ANTHROPIC_API_KEY");

    // Create a temporary config without API key to avoid using user's actual config
    let temp_dir = tempfile::tempdir()?;
    let temp_config = temp_dir.path().join("empty_config.json");
    let config_content = r#"{
        "database": {
            "url": "sqlite:./test.db",
            "max_connections": 10,
            "timeout_seconds": 30
        },
        "api": {
            "base_url": null,
            "timeout_seconds": 30,
            "retry_attempts": 3,
            "anthropic": null
        },
        "cache": {
            "cache_dir": "/tmp/cstats-test",
            "max_size_bytes": 104857600,
            "ttl_seconds": 3600
        },
        "stats": {
            "default_metrics": ["execution_time", "memory_usage", "cpu_usage"],
            "sampling_rate": 1.0,
            "aggregation_window_seconds": 300
        }
    }"#;
    tokio::fs::write(&temp_config, config_content).await?;

    let output =
        run_cli_command_no_env(&["--config", temp_config.to_str().unwrap(), "stats"]).await?;

    // Should fail without API configuration
    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    // Debug output to see what we're actually getting
    eprintln!("=== Test Debug Output ===");
    eprintln!("STDERR: {}", stderr);
    eprintln!("STDOUT: {}", stdout);
    eprintln!("=========================");

    assert!(
        stderr.contains("No Anthropic API key configured")
            || stdout.contains("Error: No Anthropic API key configured"),
        "Expected error message not found. STDERR: '{}', STDOUT: '{}'",
        stderr,
        stdout
    );

    Ok(())
}

#[tokio::test]
async fn test_stats_command_with_env_var() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    // Create a temporary config without API key, then test env var override
    let temp_dir = tempfile::tempdir()?;
    let temp_config = temp_dir.path().join("test_config.json");
    let config_content = r#"{
        "database": {
            "url": "sqlite:./test.db",
            "max_connections": 10,
            "timeout_seconds": 30
        },
        "api": {
            "base_url": null,
            "timeout_seconds": 30,
            "retry_attempts": 3,
            "anthropic": null
        },
        "cache": {
            "cache_dir": "/tmp/cstats-test",
            "max_size_bytes": 104857600,
            "ttl_seconds": 3600
        },
        "stats": {
            "default_metrics": ["execution_time", "memory_usage", "cpu_usage"],
            "sampling_rate": 1.0,
            "aggregation_window_seconds": 300
        }
    }"#;
    tokio::fs::write(&temp_config, config_content).await?;

    // Set environment variable
    let test_auth = format!("env_{}_cli", "test");

    // Use a command that explicitly sets the env var for this command only
    let output = AsyncCommand::new("cargo")
        .env("ANTHROPIC_API_KEY", &test_auth)
        .args(["run", "--bin", "cstats", "--"])
        .args([
            "--config",
            temp_config.to_str().unwrap(),
            "stats",
            "--period",
            "daily",
        ])
        .output()
        .await
        .map_err(|e| cstats_core::Error::api(format!("Failed to run CLI command: {}", e)))?;

    // Should attempt to fetch stats (may fail with network error, but shouldn't fail with config error)
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(!stderr.contains("No Anthropic API"));

    Ok(())
}

#[tokio::test]
async fn test_stats_command_with_config_file() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let temp_dir = TempDir::new()?;
    let config_path = create_test_config_file(temp_dir.path()).await?;

    let output = run_cli_command(&[
        "--config",
        config_path.to_str().unwrap(),
        "stats",
        "--period",
        "daily",
    ])
    .await?;

    // Should attempt to fetch stats with config file
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(!stderr.contains("No Anthropic API"));

    Ok(())
}

#[tokio::test]
async fn test_stats_command_different_periods() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let test_auth = format!("period_{}_test", "cli");
    env::set_var("ANTHROPIC_API_KEY", &test_auth);

    // Test different time periods
    for period in ["daily", "weekly", "monthly", "summary"] {
        let output = run_cli_command(&["stats", "--period", period]).await?;

        // Should not fail with config error
        let stderr = String::from_utf8_lossy(&output.stderr);
        assert!(!stderr.contains("No Anthropic API"));
    }

    env::remove_var("ANTHROPIC_API_KEY");

    Ok(())
}

#[tokio::test]
async fn test_stats_command_with_flags() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let test_auth = format!("flags_{}_test", "cli");
    env::set_var("ANTHROPIC_API_KEY", &test_auth);

    // Test with various flags
    let output = run_cli_command(&[
        "stats",
        "--detailed",
        "--rate-limit",
        "--billing",
        "--no-cache",
    ])
    .await?;

    // Should not fail with config error
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(!stderr.contains("No Anthropic API"));

    env::remove_var("ANTHROPIC_API_KEY");

    Ok(())
}

#[tokio::test]
async fn test_stats_command_output_formats() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    // Create a temporary config with API key to avoid environment variable conflicts
    let temp_dir = tempfile::tempdir()?;
    let temp_config = temp_dir.path().join("test_config.json");
    let test_auth = format!("format_{}_test", "cli");

    let config_content = format!(
        r#"{{
        "database": {{
            "url": "sqlite:./test.db",
            "max_connections": 10,
            "timeout_seconds": 30
        }},
        "api": {{
            "base_url": null,
            "timeout_seconds": 30,
            "retry_attempts": 3,
            "anthropic": {{
                "api_key": "{}",
                "base_url": "https://api.anthropic.com",
                "timeout_seconds": 30,
                "max_retries": 3,
                "initial_retry_delay_ms": 1000,
                "max_retry_delay_ms": 30000,
                "rate_limit_buffer": 10
            }}
        }},
        "cache": {{
            "cache_dir": "/tmp/cstats-test",
            "max_size_bytes": 104857600,
            "ttl_seconds": 3600
        }},
        "stats": {{
            "default_metrics": ["execution_time", "memory_usage", "cpu_usage"],
            "sampling_rate": 1.0,
            "aggregation_window_seconds": 300
        }}
    }}"#,
        test_auth
    );
    tokio::fs::write(&temp_config, config_content).await?;

    // Test different output formats
    for format in ["text", "json", "yaml"] {
        let output = run_cli_command(&[
            "--config",
            temp_config.to_str().unwrap(),
            "--format",
            format,
            "stats",
            "--period",
            "daily",
        ])
        .await?;

        // Should not fail with config error
        let stderr = String::from_utf8_lossy(&output.stderr);
        assert!(
            !stderr.contains("No Anthropic API"),
            "Format {} test failed. STDERR: {}",
            format,
            stderr
        );
    }

    Ok(())
}

#[tokio::test]
async fn test_config_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["config", "show"]).await?;

    // Should show configuration (default values)
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(!stdout.is_empty() || output.status.success());

    Ok(())
}

#[tokio::test]
async fn test_config_validate_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["config", "validate"]).await?;

    // Should validate configuration
    assert!(output.status.success() || !output.status.success()); // Either is valid

    Ok(())
}

#[tokio::test]
async fn test_config_default_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["config", "default"]).await?;

    // Should generate default configuration
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("database") || stdout.contains("api") || output.status.success());

    Ok(())
}

#[tokio::test]
async fn test_cache_commands() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    // Test cache stats
    let output = run_cli_command(&["cache", "stats"]).await?;
    assert!(output.status.success() || !output.status.success()); // Either is valid

    // Test cache list
    let output = run_cli_command(&["cache", "list"]).await?;
    assert!(output.status.success() || !output.status.success()); // Either is valid

    // Test cache clear
    let output = run_cli_command(&["cache", "clear"]).await?;
    assert!(output.status.success() || !output.status.success()); // Either is valid

    Ok(())
}

#[tokio::test]
async fn test_init_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let temp_dir = TempDir::new()?;
    let config_path = temp_dir.path().join("test_config.json");

    let test_auth = format!("init_{}_test", "cli");
    let output = run_cli_command(&[
        "init",
        "--config",
        config_path.to_str().unwrap(),
        "--force",
        "--api-key",
        &test_auth,
    ])
    .await?;

    // Should create configuration
    assert!(output.status.success() || config_path.exists());

    Ok(())
}

#[tokio::test]
async fn test_collect_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&[
        "collect",
        "--source",
        "test_source",
        "--metrics",
        "execution_time,memory_usage",
    ])
    .await?;

    // Should attempt to collect metrics
    assert!(output.status.success() || !output.status.success()); // Either is valid

    Ok(())
}

#[tokio::test]
async fn test_analyze_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&[
        "analyze",
        "--source",
        "test_source",
        "--metrics",
        "execution_time",
    ])
    .await?;

    // Should attempt to analyze metrics
    assert!(output.status.success() || !output.status.success()); // Either is valid

    Ok(())
}

#[tokio::test]
async fn test_hook_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["hook", "bash"]).await?;

    // Should generate shell hook
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("function") || stdout.contains("#") || output.status.success());

    Ok(())
}

#[tokio::test]
async fn test_verbose_output() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["-v", "config", "show"]).await?;

    // Should run with verbose output
    assert!(output.status.success() || !output.status.success()); // Either is valid

    Ok(())
}

#[tokio::test]
async fn test_quiet_mode() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["--quiet", "config", "show"]).await?;

    // Should run in quiet mode
    assert!(output.status.success() || !output.status.success()); // Either is valid

    Ok(())
}

#[tokio::test]
async fn test_invalid_command() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let output = run_cli_command(&["invalid-command"]).await?;

    // Should fail with invalid command
    assert!(!output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("error") || stderr.contains("invalid") || stderr.contains("unrecognized")
    );

    Ok(())
}

#[tokio::test]
async fn test_stats_command_error_handling() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    // Test with invalid period
    let output = run_cli_command(&["stats", "--period", "invalid"]).await?;

    // Should fail with invalid period
    assert!(!output.status.success());

    Ok(())
}

#[tokio::test]
async fn test_config_file_priority() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let temp_dir = TempDir::new()?;
    let config_path = create_test_config_file(temp_dir.path()).await?;

    // Set environment variable that should override config file
    let env_auth = format!("env_{}_override", "test");
    env::set_var("ANTHROPIC_API_KEY", &env_auth);

    let output = run_cli_command(&[
        "--config",
        config_path.to_str().unwrap(),
        "stats",
        "--period",
        "daily",
    ])
    .await?;

    // Should use environment variable over config file
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(!stderr.contains("No Anthropic API"));

    env::remove_var("ANTHROPIC_API_KEY");

    Ok(())
}

#[tokio::test]
async fn test_stats_command_with_cache_disabled() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let test_auth = format!("nocache_{}_test", "cli");
    env::set_var("ANTHROPIC_API_KEY", &test_auth);

    let output = run_cli_command(&["stats", "--no-cache", "--period", "daily"]).await?;

    // Should work without cache
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(!stderr.contains("No Anthropic API"));

    env::remove_var("ANTHROPIC_API_KEY");

    Ok(())
}

// Integration test that validates the full flow
#[tokio::test]
async fn test_full_cli_workflow() -> Result<()> {
    if !cli_binary_exists().await {
        return Ok(());
    }

    let temp_dir = TempDir::new()?;
    let config_path = temp_dir.path().join("workflow_config.json");

    // Step 1: Initialize configuration
    let test_auth = format!("workflow_{}_test", "cli");
    let init_output = run_cli_command(&[
        "init",
        "--config",
        config_path.to_str().unwrap(),
        "--force",
        "--api-key",
        &test_auth,
    ])
    .await?;

    // Step 2: Validate configuration
    let _validate_output = run_cli_command(&[
        "--config",
        config_path.to_str().unwrap(),
        "config",
        "validate",
    ])
    .await?;

    // Step 3: Show configuration
    let _show_output =
        run_cli_command(&["--config", config_path.to_str().unwrap(), "config", "show"]).await?;

    // Step 4: Try to fetch stats
    let _stats_output = run_cli_command(&[
        "--config",
        config_path.to_str().unwrap(),
        "stats",
        "--period",
        "daily",
    ])
    .await?;

    // All steps should either succeed or fail gracefully (not with config errors)
    assert!(init_output.status.success() || config_path.exists());

    Ok(())
}

// Mock test for statistics collection
#[tokio::test]
async fn test_statistics_data_creation() -> Result<()> {
    let mut metrics = HashMap::new();
    metrics.insert("test_metric".to_string(), MetricValue::Integer(42));
    metrics.insert("response_time".to_string(), MetricValue::Duration(150));
    metrics.insert("success_rate".to_string(), MetricValue::Float(0.95));
    metrics.insert("status".to_string(), MetricValue::String("ok".to_string()));
    metrics.insert("enabled".to_string(), MetricValue::Boolean(true));

    let stats_data = StatisticsData {
        id: Uuid::new_v4().to_string(),
        timestamp: chrono::Utc::now(),
        source: "test_cli".to_string(),
        metrics,
        metadata: Some({
            let mut meta = HashMap::new();
            meta.insert("version".to_string(), "1.0.0".to_string());
            meta.insert("environment".to_string(), "test".to_string());
            meta
        }),
    };

    // Verify the stats data structure
    assert!(!stats_data.id.is_empty());
    assert!(!stats_data.source.is_empty());
    assert_eq!(stats_data.metrics.len(), 5);
    assert!(stats_data.metadata.is_some());

    // Test serialization
    let json = serde_json::to_string(&stats_data)?;
    assert!(json.contains("test_metric"));
    assert!(json.contains("42"));

    Ok(())
}