oauth-db-cli 0.1.0

use assert_cmd::Command;
use predicates::prelude::*;
use serial_test::serial;
use std::fs;
use std::path::PathBuf;
use std::sync::Mutex;

// Global lock to ensure tests don't interfere with each other
static CONFIG_LOCK: Mutex<()> = Mutex::new(());

/// Helper to get real config directory for testing
fn get_real_config_dir() -> PathBuf {
    directories::ProjectDirs::from("com", "oauth-db", "oauth-db-cli")
        .expect("Failed to get config dir")
        .config_dir()
        .to_path_buf()
}

/// Backup existing config if it exists
fn backup_config() -> Option<String> {
    let config_path = get_real_config_dir().join("config.toml");
    if config_path.exists() {
        fs::read_to_string(&config_path).ok()
    } else {
        None
    }
}

/// Restore config from backup
fn restore_config(backup: Option<String>) {
    let config_path = get_real_config_dir().join("config.toml");
    if let Some(content) = backup {
        fs::write(&config_path, content).ok();
    } else {
        fs::remove_file(&config_path).ok();
    }
}

/// Setup a logged-in test account with valid token
fn setup_test_account() {
    let config_dir = get_real_config_dir();
    fs::create_dir_all(&config_dir).unwrap();
    let config = r#"
[server]
url = "http://localhost:28080"

[output]
format = "table"
color = true

[log]
level = "info"

[[accounts]]
name = "testuser@localhost"
server = "http://localhost:28080"
username = "testuser"
token = "test_valid_token"
default = true
"#;
    fs::write(config_dir.join("config.toml"), config).unwrap();
}

/// Generate unique app name for testing
fn generate_app_name() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};
    let timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs();
    format!("test_app_{}", timestamp)
}

/// Test creating an application
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_create() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let app_name = generate_app_name();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main,analytics")
        .arg("--max-users")
        .arg("100")
        .arg("--storage-quota")
        .arg("50")
        .assert()
        .success()
        .stdout(predicates::str::contains("App created successfully"))
        .stdout(predicates::str::contains("App ID:"))
        .stdout(predicates::str::contains("App Token:"))
        .stdout(predicates::str::contains(&app_name));

    restore_config(backup);
}

/// Test listing applications
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_list() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("list")
        .assert()
        .success()
        .stdout(predicates::str::contains("APP ID").or(predicates::str::contains("No applications found")));

    restore_config(backup);
}

/// Test listing applications with status filter
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_list_with_status() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("list")
        .arg("--status")
        .arg("active")
        .assert()
        .success();

    restore_config(backup);
}

/// Test listing applications with pagination
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_list_with_pagination() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("list")
        .arg("--page")
        .arg("1")
        .arg("--page-size")
        .arg("10")
        .assert()
        .success()
        .stdout(predicates::str::contains("page"));

    restore_config(backup);
}

/// Test showing application details
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_show() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app to show
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    // Extract app_id from output (format: "App ID: app_xxx")
    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Show app details
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains("Application Details"))
            .stdout(predicates::str::contains("App ID:"))
            .stdout(predicates::str::contains("Name:"))
            .stdout(predicates::str::contains("Database Configuration:"))
            .stdout(predicates::str::contains("Quotas:"))
            .stdout(predicates::str::contains(&app_name));
    }

    restore_config(backup);
}

/// Test showing application details in JSON format
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_show_json() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Show app in JSON format
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .arg("--output")
            .arg("json")
            .assert()
            .success()
            .stdout(predicates::str::contains("app_id"))
            .stdout(predicates::str::contains("app_name"))
            .stdout(predicates::str::contains("default_database"));
    }

    restore_config(backup);
}

/// Test updating an application
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_update() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Update app
        let new_name = format!("{}_updated", app_name);
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("update")
            .arg(app_id)
            .arg("--name")
            .arg(&new_name)
            .arg("--max-users")
            .arg("20")
            .assert()
            .success()
            .stdout(predicates::str::contains("App updated successfully"))
            .stdout(predicates::str::contains("Updated Fields:"));
    }

    restore_config(backup);
}

/// Test updating application with multiple fields
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_update_multiple_fields() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Update multiple fields
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("update")
            .arg(app_id)
            .arg("--max-users")
            .arg("50")
            .arg("--storage-quota")
            .arg("100")
            .arg("--max-connections")
            .arg("20")
            .assert()
            .success()
            .stdout(predicates::str::contains("App updated successfully"));
    }

    restore_config(backup);
}

/// Test enabling and disabling an application
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_enable_disable() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Disable app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("disable")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains("App disabled successfully"));

        // Verify status changed by showing app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains("Status: disabled"));

        // Enable app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("enable")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains("App enabled successfully"));

        // Verify status changed back
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains("Status: active"));
    }

    restore_config(backup);
}

/// Test deleting an application with force flag
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_delete() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Delete app with force flag (skip confirmation)
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("delete")
            .arg(app_id)
            .arg("--force")
            .assert()
            .success()
            .stdout(predicates::str::contains("App deleted successfully"));

        // Verify app no longer exists
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .assert()
            .failure();
    }

    restore_config(backup);
}

/// Test deleting non-existent application
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_delete_not_found() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("delete")
        .arg("app_nonexistent")
        .arg("--force")
        .assert()
        .failure()
        .stderr(predicates::str::contains("not found").or(predicates::str::contains("does not exist")));

    restore_config(backup);
}

/// Test resetting application token
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server and interactive input
async fn test_app_reset_token() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // Note: This test requires interactive confirmation
        // In real E2E environment, you would need to provide input
        // For now, we just verify the command structure
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("reset-token")
            .arg(app_id)
            .write_stdin("yes\n")
            .assert()
            .success()
            .stdout(predicates::str::contains("App token reset successfully").or(predicates::str::contains("New Token:")));
    }

    restore_config(backup);
}

/// Test viewing application statistics
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_stats() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // View app statistics
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("stats")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains("Application Statistics"))
            .stdout(predicates::str::contains("Total Users:"))
            .stdout(predicates::str::contains("Active Users:"))
            .stdout(predicates::str::contains("Total Storage:"))
            .stdout(predicates::str::contains("Active Connections:"));
    }

    restore_config(backup);
}

/// Test viewing application statistics in JSON format
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_stats_json() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    // First create an app
    let app_name = generate_app_name();
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .output()
        .unwrap();

    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // View stats in JSON format
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("stats")
            .arg(app_id)
            .arg("--output")
            .arg("json")
            .assert()
            .success()
            .stdout(predicates::str::contains("app_id"))
            .stdout(predicates::str::contains("user_count"))
            .stdout(predicates::str::contains("total_storage_mb"));
    }

    restore_config(backup);
}

/// Test app operations when not logged in
#[tokio::test]
#[serial(config)]
async fn test_app_operations_not_logged_in() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();

    // Setup empty config (no accounts)
    let config_dir = get_real_config_dir();
    fs::create_dir_all(&config_dir).unwrap();
    let config = r#"
[server]
url = "http://localhost:28080"

[output]
format = "table"
color = true

[log]
level = "info"
"#;
    fs::write(config_dir.join("config.toml"), config).unwrap();

    // Try to list apps without login
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("list")
        .assert()
        .failure()
        .stderr(
            predicates::str::contains("Not logged in")
                .or(predicates::str::contains("Config"))
                .or(predicates::str::contains("Error"))
        );

    restore_config(backup);
}

/// Test complete app lifecycle workflow
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_lifecycle_workflow() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let app_name = generate_app_name();

    // 1. Create app
    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    let output = cmd
        .arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main,analytics")
        .arg("--max-users")
        .arg("100")
        .arg("--storage-quota")
        .arg("50")
        .output()
        .unwrap();

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);

    if let Some(app_id) = stdout
        .lines()
        .find(|line| line.contains("App ID:"))
        .and_then(|line| line.split(':').nth(1))
        .map(|s| s.trim())
    {
        // 2. List apps and verify it appears
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("list")
            .assert()
            .success()
            .stdout(predicates::str::contains(app_id));

        // 3. Show app details
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .assert()
            .success()
            .stdout(predicates::str::contains(&app_name));

        // 4. Update app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("update")
            .arg(app_id)
            .arg("--max-users")
            .arg("200")
            .assert()
            .success();

        // 5. Disable app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("disable")
            .arg(app_id)
            .assert()
            .success();

        // 6. Enable app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("enable")
            .arg(app_id)
            .assert()
            .success();

        // 7. View stats
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("stats")
            .arg(app_id)
            .assert()
            .success();

        // 8. Delete app
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("delete")
            .arg(app_id)
            .arg("--force")
            .assert()
            .success();

        // 9. Verify app is deleted
        let mut cmd = Command::cargo_bin("oauth-db").unwrap();
        cmd.arg("app")
            .arg("show")
            .arg(app_id)
            .assert()
            .failure();
    }

    restore_config(backup);
}

/// Test app creation with minimal parameters
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_create_minimal() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let app_name = generate_app_name();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main")
        .arg("--max-users")
        .arg("10")
        .arg("--storage-quota")
        .arg("10")
        .assert()
        .success()
        .stdout(predicates::str::contains("App created successfully"));

    restore_config(backup);
}

/// Test app creation with all parameters
#[tokio::test]
#[serial(config)]
#[ignore] // Requires real backend server
async fn test_app_create_full() {
    let _lock = CONFIG_LOCK.lock().unwrap();
    let backup = backup_config();
    setup_test_account();

    let app_name = generate_app_name();

    let mut cmd = Command::cargo_bin("oauth-db").unwrap();
    cmd.arg("app")
        .arg("create")
        .arg(&app_name)
        .arg("--default-db")
        .arg("main")
        .arg("--allowed-dbs")
        .arg("main,analytics,logs")
        .arg("--max-users")
        .arg("1000")
        .arg("--storage-quota")
        .arg("500")
        .arg("--max-connections")
        .arg("50")
        .arg("--qps-limit")
        .arg("1000")
        .assert()
        .success()
        .stdout(predicates::str::contains("App created successfully"));

    restore_config(backup);
}