patchloom 0.23.0

use super::*;

#[test]
fn test_explain_prints_human_summary() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{
            "version": 1,
            "strict": true,
            "operations": [
                {"op": "file.create", "path": "test.txt", "content": "hi"},
                {"op": "file.delete", "path": "old.txt"}
            ],
            "validate": [{"cmd": "echo ok", "required": true}]
        }"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains("2 operation(s) (strict mode)"))
        .stdout(predicates::str::contains("Create file test.txt"))
        .stdout(predicates::str::contains("Delete file old.txt"))
        .stdout(predicates::str::contains("Validate: echo ok (required)"));
}

/// Relative explain plan path is resolved under --cwd (parity with `tx` / `batch` / `patch`).
#[test]
fn test_explain_relative_plan_respects_cwd() {
    let dir = TempDir::new().unwrap();
    fs::write(
        dir.path().join("plan.json"),
        r#"{"version": 1, "operations": [{"op": "file.create", "path": "test.txt", "content": "hi"}]}"#,
    )
    .unwrap();

    // Process cwd is not dir; plan path is relative and must open under --cwd.
    Command::cargo_bin("patchloom")
        .unwrap()
        .current_dir(dir.path().parent().unwrap())
        .arg("--cwd")
        .arg(dir.path())
        .args(["explain", "plan.json"])
        .assert()
        .success()
        .stdout(predicates::str::contains("Create file test.txt"));
}

/// #1450: explain plan meta-path must not escape under --contain.
#[test]
fn test_explain_contain_rejects_plan_parent_escape() {
    let dir = TempDir::new().unwrap();
    let outside = dir.path().parent().unwrap().join(format!(
        "patchloom-explain-outside-{}.json",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_millis()
    ));
    fs::write(
        &outside,
        r#"{"version": 1, "operations": [{"op": "file.create", "path": "x.txt", "content": "leak"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .arg("--cwd")
        .arg(dir.path())
        .args([
            "--contain",
            "explain",
            &format!("../{}", outside.file_name().unwrap().to_string_lossy()),
        ])
        .assert()
        .failure()
        .stderr(
            predicates::str::contains("escapes")
                .or(predicates::str::contains("rejected"))
                .or(predicates::str::contains("workspace guard")),
        );

    let _ = fs::remove_file(&outside);
}

/// #1451: absolute explain plan under --cwd is allowed with --contain.
#[test]
fn test_explain_contain_allows_absolute_plan_inside_workspace() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "file.create", "path": "test.txt", "content": "hi"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .arg("--cwd")
        .arg(dir.path())
        .args(["--contain", "explain"])
        .arg(plan.to_str().unwrap())
        .assert()
        .success()
        .stdout(predicates::str::contains("Create file test.txt"));
}

#[test]
fn test_explain_json_output() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "replace", "old": "a", "new": "b"}]}"#,
    )
    .unwrap();

    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain", "--json"])
        .arg(&plan)
        .output()
        .unwrap();
    assert!(output.status.success());

    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(json["ok"], true);
    assert_eq!(json["operation_count"], 1);
    assert_eq!(json["strict"], true);
    assert!(json["has_write_policy"].is_boolean());
    assert_eq!(json["format_steps"], 0);
    assert_eq!(json["validate_steps"], 0);
    let ops = json["operations"].as_array().unwrap();
    assert_eq!(ops.len(), 1);
    assert_eq!(ops[0]["index"], 1);
    assert!(ops[0]["description"].as_str().unwrap().contains("Replace"));
}

#[test]
fn test_explain_jsonl_output() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "file.delete", "path": "x.txt"}]}"#,
    )
    .unwrap();

    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain", "--jsonl"])
        .arg(&plan)
        .output()
        .unwrap();

    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    let lines: Vec<&str> = stdout.lines().filter(|l| !l.is_empty()).collect();
    assert_eq!(lines.len(), 1, "JSONL output should be a single line");
    let json: serde_json::Value = serde_json::from_str(lines[0]).unwrap();
    assert_eq!(json["operation_count"], 1);
    assert_eq!(json["operations"][0]["description"], "Delete file x.txt");
}

#[test]
fn test_explain_quiet_suppresses_output() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "file.delete", "path": "x.txt"}]}"#,
    )
    .unwrap();

    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--quiet", "explain"])
        .arg(&plan)
        .output()
        .unwrap();

    assert!(output.status.success());
    assert!(
        output.stdout.is_empty(),
        "--quiet should suppress stdout, got: {}",
        String::from_utf8_lossy(&output.stdout)
    );
}

#[test]
fn test_explain_invalid_plan_fails() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("bad.json");
    fs::write(&plan, "not valid json at all").unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .code(4) // PARSE_ERROR
        .stderr(predicate::str::contains("expected ident").or(predicate::str::contains("parse")));

    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "explain"])
        .arg(&plan)
        .output()
        .unwrap();
    assert_eq!(output.status.code(), Some(4));
    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(json["ok"], false);
    assert_eq!(
        json["error_kind"], "parse_error",
        "explain invalid plan should set error_kind: {json}"
    );
}

/// Missing plan file: not_found with a single path prefix + OS detail.
/// MPI 2026-07-23: previously "cannot read X: failed to read X" without OS text.
#[test]
fn test_explain_missing_plan_is_not_found_with_os_detail() {
    let dir = TempDir::new().unwrap();
    let missing = dir.path().join("nope.json");

    let output = Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "--cwd"])
        .arg(dir.path())
        .args(["explain", "nope.json"])
        .output()
        .unwrap();
    assert_eq!(
        output.status.code(),
        Some(1),
        "stdout={} stderr={}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    let json: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(json["ok"], false);
    assert_eq!(json["error_kind"], "not_found", "{json}");
    let err = json["error"].as_str().unwrap_or("");
    assert!(
        err.contains("failed to read"),
        "expected load_text_strict message: {json}"
    );
    assert!(
        !err.contains("cannot read"),
        "must not double-prefix cannot read: {json}"
    );
    assert_eq!(
        err.matches("failed to read").count(),
        1,
        "must not double-wrap: {json}"
    );
    assert!(
        err.contains("No such file")
            || err.contains("os error 2")
            || err.contains("not found")
            || err.contains("not exist"),
        "OS detail missing: {json}"
    );
    let _ = missing; // path intentionally absent
}

#[test]
fn test_explain_stdin() {
    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain", "--stdin"])
        .write_stdin(r#"{"version": 1, "operations": [{"op": "file.delete", "path": "x.txt"}]}"#)
        .assert()
        .success()
        .stdout(predicates::str::contains("Delete file x.txt"));
}

/// Path `-` is stdin (parity with `tx -` / `batch -`).
#[test]
fn test_explain_dash_path_reads_stdin() {
    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["--json", "explain", "-"])
        .write_stdin(r#"{"version": 1, "operations": [{"op": "file.delete", "path": "x.txt"}]}"#)
        .assert()
        .success()
        .stdout(predicates::str::contains(r#""ok": true"#))
        .stdout(predicates::str::contains("file.delete"));
}

#[test]
fn test_explain_stdin_takes_precedence_over_path() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "file.delete", "path": "from-file.txt"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain", "--stdin"])
        .arg(&plan)
        .write_stdin(
            r#"{"version": 1, "operations": [{"op": "file.delete", "path": "from-stdin.txt"}]}"#,
        )
        .assert()
        .success()
        .stdout(predicates::str::contains("Delete file from-stdin.txt"))
        .stdout(predicates::str::contains("from-file.txt").not());
}

// ── undo ─────────────────────────────────────────────────────

#[test]
#[cfg(feature = "ast")]
fn test_explain_ast_rename_description() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "ast.rename", "path": "lib.rs", "old": "foo", "new": "bar"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains(
            "AST rename \"foo\" to \"bar\" in lib.rs",
        ));
}

#[test]
#[cfg(feature = "ast")]
fn test_explain_ast_replace_description() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "ast.replace", "path": "app.rs", "symbol": "main", "old": "old", "new": "new"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains(
            "AST replace \"old\" with \"new\" in main in app.rs",
        ));
}

// --- AST subcommand integration coverage (for #694) ---

#[test]
fn test_explain_replace_word_boundary() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "replace", "path": "f.txt", "old": "cat", "new": "dog", "word_boundary": true}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains("word-boundary"));
}

#[test]
fn test_explain_file_append_description() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "file.append", "path": "log.txt", "content": "extra"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains("Append"));
}

#[test]
fn test_explain_file_prepend_description() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version": 1, "operations": [{"op": "file.prepend", "path": "main.rs", "content": "// license"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains("Prepend"));
}

/// #1847: explain must surface explicit tidy.fix write-policy fields.
#[test]
fn test_explain_tidy_fix_shows_explicit_write_policy_fields() {
    let dir = TempDir::new().unwrap();
    let plan = dir.path().join("plan.json");
    fs::write(
        &plan,
        r#"{"version":1,"operations":[{"op":"tidy.fix","path":"x.txt","ensure_final_newline":false,"trim_trailing_whitespace":false,"normalize_eol":"lf"}]}"#,
    )
    .unwrap();

    Command::cargo_bin("patchloom")
        .unwrap()
        .args(["explain"])
        .arg(&plan)
        .assert()
        .success()
        .stdout(predicates::str::contains("ensure_final_newline=false"))
        .stdout(predicates::str::contains("trim_trailing_whitespace=false"))
        .stdout(predicates::str::contains("normalize_eol=lf"));
}

// ── --format flag on write commands ────────────────────────────