vyctor 0.1.0

//! CLI integration tests
//!
//! These tests verify the CLI commands work correctly.
//! Tests that require VSS or API keys are skipped when not available.

mod common;

use assert_cmd::Command;
use common::TempProject;
use predicates::prelude::*;

/// Get a Command for the vyctor binary
#[allow(deprecated)]
fn vyctor() -> Command {
    Command::cargo_bin("vyctor").unwrap()
}

#[test]
fn test_cli_help() {
    vyctor()
        .arg("--help")
        .assert()
        .success()
        .stdout(predicate::str::contains("semantic file search"))
        .stdout(predicate::str::contains("init"))
        .stdout(predicate::str::contains("lookup"))
        .stdout(predicate::str::contains("sync"))
        .stdout(predicate::str::contains("watch"))
        .stdout(predicate::str::contains("status"));
}

#[test]
fn test_cli_version() {
    vyctor()
        .arg("--version")
        .assert()
        .success()
        .stdout(predicate::str::contains("vyctor"));
}

#[test]
fn test_init_help() {
    vyctor()
        .args(["init", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Initialize"));
}

#[test]
fn test_lookup_help() {
    vyctor()
        .args(["lookup", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Search"));
}

#[test]
fn test_sync_help() {
    vyctor()
        .args(["sync", "--help"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Synchronize"));
}

#[test]
fn test_status_help() {
    vyctor().args(["status", "--help"]).assert().success();
}

#[test]
fn test_config_help() {
    vyctor().args(["config", "--help"]).assert().success();
}

#[test]
fn test_init_creates_config_directory() {
    let project = TempProject::new();

    // Run init (without API key, it should still create the config)
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success()
        .stdout(predicate::str::contains("vyctor.config.toml"));

    // Verify config file was created in project root
    assert!(project.file_exists("vyctor.config.toml"));
}

#[test]
fn test_init_creates_gitignore() {
    let project = TempProject::new();

    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Verify .gitignore contains .vyctor
    assert!(project.file_exists(".gitignore"));
    let gitignore = project.read_file(".gitignore");
    assert!(gitignore.contains(".vyctor"));
}

#[test]
fn test_init_updates_existing_gitignore() {
    let project = TempProject::new();

    // Create an existing .gitignore
    project.create_file(".gitignore", "node_modules/\n*.log\n");

    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Verify original content is preserved and .vyctor is added
    let gitignore = project.read_file(".gitignore");
    assert!(gitignore.contains("node_modules/"));
    assert!(gitignore.contains("*.log"));
    assert!(gitignore.contains(".vyctor"));
}

#[test]
fn test_init_fails_if_already_exists() {
    let project = TempProject::new();

    // First init should succeed
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Second init should fail (without --force)
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .failure()
        .stderr(predicate::str::contains("already exists"));
}

#[test]
fn test_init_force_reinitializes() {
    let project = TempProject::new();

    // First init
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Modify config to verify it gets overwritten
    project.create_file("vyctor.config.toml", "# Modified config");

    // Force reinitialize
    vyctor()
        .current_dir(project.path())
        .args(["init", "--force"])
        .assert()
        .success();

    // Config should be reset to default
    let config = project.read_file("vyctor.config.toml");
    assert!(config.contains("[indexing]"));
    assert!(config.contains("[embedding]"));
}

#[test]
fn test_status_without_init() {
    let project = TempProject::new();

    // Status should fail if not initialized
    vyctor()
        .current_dir(project.path())
        .arg("status")
        .assert()
        .failure()
        .stderr(predicate::str::contains("vyctor.config.toml"));
}

#[test]
fn test_status_after_init() {
    let project = TempProject::new();

    // Initialize
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Status should work (may show errors about VSS but shouldn't crash)
    vyctor()
        .current_dir(project.path())
        .arg("status")
        .assert()
        .success()
        .stdout(predicate::str::contains("Configuration"));
}

#[test]
fn test_lookup_without_init() {
    let project = TempProject::new();

    // Lookup should fail if not initialized
    vyctor()
        .current_dir(project.path())
        .args(["lookup", "test query"])
        .assert()
        .failure();
}

#[test]
fn test_sync_without_init() {
    let project = TempProject::new();

    // Sync should fail if not initialized
    vyctor()
        .current_dir(project.path())
        .arg("sync")
        .assert()
        .failure();
}

#[test]
fn test_config_without_init() {
    let project = TempProject::new();

    // Config should fail if not initialized
    vyctor()
        .current_dir(project.path())
        .arg("config")
        .assert()
        .failure();
}

#[test]
fn test_config_shows_config() {
    let project = TempProject::new();

    // Initialize
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Config should show the configuration
    vyctor()
        .current_dir(project.path())
        .arg("config")
        .assert()
        .success()
        .stdout(predicate::str::contains("[indexing]"))
        .stdout(predicate::str::contains("[embedding]"));
}

#[test]
fn test_init_shows_configuration_summary() {
    let project = TempProject::new();

    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success()
        .stdout(predicate::str::contains("Embedding provider"))
        .stdout(predicate::str::contains("Chunk size"));
}

#[test]
fn test_lookup_count_flag() {
    let project = TempProject::new();
    project.init_vyctor();

    // Test that -n flag is accepted
    vyctor()
        .current_dir(project.path())
        .args(["lookup", "test", "-n", "10"])
        .assert()
        // Will fail without VSS but should parse args correctly
        .stderr(
            predicate::str::contains("")
                .not()
                .or(predicate::str::contains("")),
        );
}

#[test]
fn test_lookup_folder_flag() {
    let project = TempProject::new();
    project.init_vyctor();

    // Test that --folder flag is accepted
    let _ = vyctor()
        .current_dir(project.path())
        .args(["lookup", "test", "--folder", "src/"])
        .assert();
}

#[test]
fn test_sync_force_flag() {
    let project = TempProject::new();
    project.init_vyctor();

    // Test that --force flag is accepted
    let _ = vyctor()
        .current_dir(project.path())
        .args(["sync", "--force"])
        .assert();
}

#[test]
fn test_init_from_subdirectory() {
    let project = TempProject::new();
    project.create_dir("src/nested");

    // Initialize from root
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Status should work from subdirectory
    vyctor()
        .current_dir(project.path().join("src/nested"))
        .arg("status")
        .assert()
        .success();
}

#[test]
fn test_config_file_format() {
    let project = TempProject::new();

    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Verify config is valid TOML with expected sections
    let config = project.read_file("vyctor.config.toml");

    // Parse as TOML to verify format
    let parsed: toml::Value = toml::from_str(&config).expect("Config should be valid TOML");

    assert!(
        parsed.get("indexing").is_some(),
        "Should have [indexing] section"
    );
    assert!(
        parsed.get("embedding").is_some(),
        "Should have [embedding] section"
    );
}

#[test]
fn test_invalid_command() {
    vyctor().arg("nonexistent").assert().failure();
}

#[test]
fn test_lookup_requires_query() {
    let project = TempProject::new();
    project.init_vyctor();

    // Lookup without query should fail
    vyctor()
        .current_dir(project.path())
        .arg("lookup")
        .assert()
        .failure();
}

// Tests that require VSS extension

#[test]
fn test_full_workflow_with_vss() {
    if !common::vss_available() {
        eprintln!("Skipping test: VSS extension not available");
        return;
    }

    // This test would require a mock API or actual API key
    // For now, we just verify the commands don't crash

    let project = TempProject::with_sample_files();

    // Initialize
    vyctor()
        .current_dir(project.path())
        .arg("init")
        .assert()
        .success();

    // Status should work
    vyctor()
        .current_dir(project.path())
        .arg("status")
        .assert()
        .success();
}