//! Tests for work directory preservation functionality

use std::fs;
use std::process::Command;
use tempfile::TempDir;

#[test]
fn test_preserve_work_on_failure_disabled_by_default() {
    // Create a failing test
    let temp_dir = TempDir::new().unwrap();
    let testdata_dir = temp_dir.path().join("testdata");
    fs::create_dir(&testdata_dir).unwrap();

    let test_content = r#"exec echo "hello"
stdout "goodbye"
"#;

    fs::write(testdata_dir.join("failing_test.txt"), test_content).unwrap();

    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy()).execute();

    // Should fail
    assert!(result.is_err());

    // Work directory should be cleaned up (we can't easily test this since TempDir cleanup is automatic)
}

#[test]
fn test_preserve_work_on_failure_enabled() {
    // Create a failing test
    let temp_dir = TempDir::new().unwrap();
    let testdata_dir = temp_dir.path().join("testdata");
    fs::create_dir(&testdata_dir).unwrap();

    let test_content = r#"exec echo "hello"
stdout "goodbye"

-- test_file.txt --
This is test content
"#;

    fs::write(testdata_dir.join("failing_test.txt"), test_content).unwrap();

    // We need to capture stderr to see the preservation message
    // Since we can't easily capture stderr from the current process,
    // we'll create a subprocess that runs our test
    let output = Command::new("cargo")
        .args(["run", "--example", "test_runner"])
        .current_dir("/home/runner/work/testscript-rs/testscript-rs")
        .env(
            "TESTSCRIPT_TEST_DIR",
            testdata_dir.to_string_lossy().as_ref(),
        )
        .env("TESTSCRIPT_PRESERVE_WORK", "true")
        .output();

    if let Ok(output) = output {
        let stderr = String::from_utf8_lossy(&output.stderr);
        // Should contain preservation message
        assert!(stderr.contains("Work directory preserved at:"));
    } else {
        // Fallback test - just ensure the API works
        let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
            .preserve_work_on_failure(true)
            .execute();

        assert!(result.is_err());
    }
}

#[test]
fn test_preserve_work_on_success_no_preservation() {
    // Create a passing test
    let temp_dir = TempDir::new().unwrap();
    let testdata_dir = temp_dir.path().join("testdata");
    fs::create_dir(&testdata_dir).unwrap();

    let test_content = r#"exec echo "hello"
stdout "hello"

-- test_file.txt --
This is test content
"#;

    fs::write(testdata_dir.join("passing_test.txt"), test_content).unwrap();

    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
        .preserve_work_on_failure(true)
        .execute();

    // Should succeed and not preserve directory
    assert!(result.is_ok());
}

#[test]
fn test_preserve_work_with_skip() {
    // Create a test that skips
    let temp_dir = TempDir::new().unwrap();
    let testdata_dir = temp_dir.path().join("testdata");
    fs::create_dir(&testdata_dir).unwrap();

    let test_content = r#"skip this test is skipped

-- test_file.txt --
This is test content
"#;

    fs::write(testdata_dir.join("skip_test.txt"), test_content).unwrap();

    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
        .preserve_work_on_failure(true)
        .execute();

    // Should fail due to skip, but this tests that the preserve logic handles skip correctly
    assert!(result.is_err());
    if let Err(e) = result {
        // The error might be wrapped in script context, so just check for skip-related content
        let error_str = e.to_string();
        assert!(
            error_str.contains("SKIP")
                || error_str.contains("Test skipped")
                || error_str.contains("skip")
        );
    }
}

#[test]
fn test_preserve_work_with_background_process_failure() {
    // Create a test that fails during background process cleanup
    let temp_dir = TempDir::new().unwrap();
    let testdata_dir = temp_dir.path().join("testdata");
    fs::create_dir(&testdata_dir).unwrap();

    let test_content = r#"exec sleep 10 &
wait sleep
"#;

    fs::write(testdata_dir.join("bg_test.txt"), test_content).unwrap();

    // We don't assert success/failure here since sleep behavior varies, but the test exercises the code
    let _result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
        .preserve_work_on_failure(true)
        .execute();

    // We don't assert success/failure here since sleep behavior varies, but the test exercises the code
}

#[test]
fn test_builder_preserve_work_method_exists() {
    // Test that the API exists and can be chained
    let temp_dir = TempDir::new().unwrap();
    let testdata_dir = temp_dir.path().join("testdata");
    fs::create_dir(&testdata_dir).unwrap();

    let test_content = r#"exec echo "hello"
stdout "hello"
"#;

    fs::write(testdata_dir.join("simple_test.txt"), test_content).unwrap();

    let result = testscript_rs::testscript::run(testdata_dir.to_string_lossy())
        .preserve_work_on_failure(true)
        .preserve_work_on_failure(false) // Can be chained and overridden
        .execute();

    assert!(result.is_ok());
}