double-o 0.10.1

use super::*;
use crate::classify::Classification;
use std::ffi::OsString;

fn s(s: &str) -> OsString {
    OsString::from(s)
}

// ---------------------------------------------------------------------------
// parse_action: patterns subcommand (Part 3)
// ---------------------------------------------------------------------------

#[test]
fn test_parse_action_patterns() {
    assert!(matches!(parse_action(&[s("patterns")]), Action::Patterns));
}

#[test]
fn test_parse_action_rewrite_with_command() {
    let args = vec![s("rewrite"), s("cargo test")];
    assert!(matches!(parse_action(&args), Action::Rewrite(c) if c == "cargo test"));
}

#[test]
fn test_parse_action_rewrite_multi_word_joins() {
    let args = vec![s("rewrite"), s("cd src"), s("&&"), s("cargo build")];
    assert!(matches!(parse_action(&args), Action::Rewrite(c) if c == "cd src && cargo build"));
}

#[test]
fn test_parse_action_rewrite_no_arg_is_empty() {
    assert!(matches!(parse_action(&[s("rewrite")]), Action::Rewrite(c) if c.is_empty()));
}

#[test]
fn test_cmd_rewrite_no_pattern_returns_1() {
    assert_eq!(cmd_rewrite("git log --stat"), 1);
    assert_eq!(cmd_rewrite("ls -la"), 1);
}

#[test]
fn test_cmd_rewrite_empty_and_blank_returns_1() {
    assert_eq!(cmd_rewrite(""), 1);
    assert_eq!(cmd_rewrite("   "), 1);
}

// ---------------------------------------------------------------------------
// cmd_patterns (Part 3)
// ---------------------------------------------------------------------------

#[test]
fn test_cmd_patterns_empty_dir() {
    let dir = tempfile::TempDir::new().unwrap();
    // Non-existent patterns dir → "no learned patterns yet"
    let code = cmd_patterns_in(dir.path().join("patterns").as_path());
    assert_eq!(code, 0, "empty patterns dir must exit 0");
}

#[test]
fn test_cmd_patterns_valid_toml() {
    let dir = tempfile::TempDir::new().unwrap();
    let patterns_dir = dir.path().join("patterns");
    std::fs::create_dir_all(&patterns_dir).unwrap();
    std::fs::write(
        patterns_dir.join("pytest.toml"),
        "command_match = \"^pytest\"\n[success]\npattern = '(?P<n>\\d+) passed'\nsummary = \"{n} passed\"\n",
    )
    .unwrap();
    let code = cmd_patterns_in(&patterns_dir);
    assert_eq!(code, 0, "valid pattern file must exit 0");
}

#[test]
fn test_learn_config_default_has_provider() {
    // Validates LearnConfig::default() returns a usable config even without env vars.
    // The provider field is accessed directly (provider_name_from_config was inlined).
    let config = learn::LearnConfig::default();
    assert!(
        !config.provider.is_empty(),
        "default config must have a provider"
    );
    assert!(!config.model.is_empty(), "default config must have a model");
}

#[test]
fn test_parse_action_no_args_is_help() {
    assert!(matches!(parse_action(&[]), Action::Help(None)));
}

#[test]
fn test_parse_action_recall_single_word() {
    let args = vec![s("recall"), s("cargo")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query == "cargo" && !full)
    );
}

#[test]
fn test_parse_action_recall_multi_word_joins() {
    let args = vec![s("recall"), s("hello"), s("world")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query == "hello world" && !full)
    );
}

#[test]
fn test_parse_action_recall_empty_query() {
    let args = vec![s("recall")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query.is_empty() && !full)
    );
}

#[test]
fn test_parse_action_recall_full_flag_before_query() {
    let args = vec![s("recall"), s("--full"), s("hello")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query == "hello" && full)
    );
}

#[test]
fn test_parse_action_recall_full_flag_after_query() {
    let args = vec![s("recall"), s("hello"), s("--full")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query == "hello" && full)
    );
}

#[test]
fn test_parse_action_recall_full_flag_mid_query() {
    let args = vec![s("recall"), s("hello"), s("--full"), s("world")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query == "hello world" && full)
    );
}

#[test]
fn test_parse_action_recall_full_alone_is_empty_query() {
    let args = vec![s("recall"), s("--full")];
    assert!(
        matches!(parse_action(&args), Action::Recall { query, full } if query.is_empty() && full)
    );
}

#[test]
fn test_parse_action_forget() {
    assert!(matches!(parse_action(&[s("forget")]), Action::Forget));
}

#[test]
fn test_parse_action_learn() {
    let args = vec![s("learn"), s("cargo"), s("test")];
    assert!(matches!(parse_action(&args), Action::Learn(a, None) if a == vec!["cargo", "test"]));
}

#[test]
fn test_parse_action_learn_no_subargs() {
    let args = vec![s("learn")];
    assert!(matches!(parse_action(&args), Action::Learn(a, None) if a.is_empty()));
}

#[test]
fn test_parse_action_learn_with_hint() {
    let args = vec![
        s("learn"),
        s("--hint"),
        s("keep last 10 lines"),
        s("cargo"),
        s("test"),
    ];
    assert!(
        matches!(parse_action(&args), Action::Learn(a, Some(h)) if a == vec!["cargo", "test"] && h == "keep last 10 lines")
    );
}

#[test]
fn test_parse_action_learn_hint_missing_value() {
    // When --hint is the last argument with no value, treat as no hint
    let args = vec![s("learn"), s("--hint")];
    assert!(matches!(parse_action(&args), Action::Learn(a, None) if a.is_empty()));
}

#[test]
fn test_parse_action_learn_with_hint_followed_by_command() {
    // When --hint is followed by a value, use it as the hint
    let args = vec![
        s("learn"),
        s("--hint"),
        s("capture summary only"),
        s("cargo"),
        s("test"),
    ];
    assert!(
        matches!(parse_action(&args), Action::Learn(a, Some(h)) if a == vec!["cargo", "test"] && h == "capture summary only")
    );
}

#[test]
fn test_parse_action_learn_hint_multiple_words() {
    let args = vec![
        s("learn"),
        s("--hint"),
        s("show summary line and keep last 5 on failure"),
        s("pytest"),
    ];
    assert!(
        matches!(parse_action(&args), Action::Learn(a, Some(h)) if a == vec!["pytest"] && h == "show summary line and keep last 5 on failure")
    );
}

#[test]
fn test_parse_action_version() {
    assert!(matches!(parse_action(&[s("version")]), Action::Version));
}

#[test]
fn test_parse_action_help_no_cmd() {
    assert!(matches!(parse_action(&[s("help")]), Action::Help(None)));
}

#[test]
fn test_parse_action_help_with_cmd() {
    let args = vec![s("help"), s("ls")];
    assert!(matches!(parse_action(&args), Action::Help(Some(c)) if c == "ls"));
}

#[test]
fn test_parse_action_init() {
    assert!(matches!(
        parse_action(&[s("init")]),
        Action::Init(InitMode::Format(InitFormat::Claude))
    ));
}

#[test]
fn test_parse_action_init_format_claude() {
    let args = vec![s("init"), s("--format"), s("claude")];
    assert!(matches!(
        parse_action(&args),
        Action::Init(InitMode::Format(InitFormat::Claude))
    ));
}

#[test]
fn test_parse_action_init_format_generic() {
    let args = vec![s("init"), s("--format"), s("generic")];
    assert!(matches!(
        parse_action(&args),
        Action::Init(InitMode::Format(InitFormat::Generic))
    ));
}

#[test]
fn test_parse_action_init_agent_pi() {
    let args = vec![s("init"), s("--agent"), s("pi")];
    assert!(matches!(
        parse_action(&args),
        Action::Init(InitMode::Pi { global: false })
    ));
}

#[test]
fn test_parse_action_init_agent_pi_global() {
    let args = vec![s("init"), s("--agent"), s("pi"), s("--global")];
    assert!(matches!(
        parse_action(&args),
        Action::Init(InitMode::Pi { global: true })
    ));
}

#[test]
fn test_parse_action_init_agent_pi_global_first() {
    let args = vec![s("init"), s("--global"), s("--agent"), s("pi")];
    assert!(matches!(
        parse_action(&args),
        Action::Init(InitMode::Pi { global: true })
    ));
}

/// `--agent` and `--format` are mutually exclusive (issue #171, operator
/// decision 1): passing both is a parse-time error — it names the conflict
/// and nothing is written (the error is produced before any init work).
#[test]
fn test_parse_action_init_agent_and_format_mutually_exclusive() {
    let args = vec![
        s("init"),
        s("--agent"),
        s("pi"),
        s("--format"),
        s("generic"),
    ];
    let init_args: Vec<String> = args[1..]
        .iter()
        .map(|a| a.to_string_lossy().into_owned())
        .collect();
    let err = parse_init_mode(&init_args).expect_err("combining --agent and --format must error");
    assert!(
        err.contains("--agent and --format"),
        "error must name the conflicting flags: {err:?}"
    );

    // Flag order must not matter.
    let args = vec![s("init"), s("--format"), s("claude"), s("--agent"), s("pi")];
    let init_args: Vec<String> = args[1..]
        .iter()
        .map(|a| a.to_string_lossy().into_owned())
        .collect();
    let err = parse_init_mode(&init_args).expect_err("order must not matter");
    assert!(
        err.contains("--agent and --format"),
        "error must name the conflicting flags: {err:?}"
    );
}

#[test]
fn test_parse_action_run_unknown() {
    let args = vec![s("echo"), s("hi")];
    assert!(matches!(parse_action(&args), Action::Run(a) if a[0] == "echo"));
}

#[test]
fn test_parse_action_run_hyphen_arg() {
    let args = vec![s("ls"), s("-la")];
    assert!(
        matches!(parse_action(&args), Action::Run(a) if a == vec![OsString::from("ls"), OsString::from("-la")])
    );
}

fn make_output(exit_code: i32, stdout: &str) -> exec::CommandOutput {
    exec::CommandOutput {
        stdout: stdout.as_bytes().to_vec(),
        stderr: Vec::new(),
        exit_code,
    }
}

#[test]
fn test_classify_passthrough_small() {
    let out = make_output(0, "hello\n");
    let result = classify::classify(&out, "echo hello", &[]);
    assert!(matches!(result, Classification::Passthrough { output } if output == "hello\n"));
}

#[test]
fn test_classify_failure_no_pattern() {
    let out = make_output(1, "something went wrong\n");
    let result = classify::classify(&out, "bad_cmd", &[]);
    assert!(matches!(result, Classification::Failure { label, .. } if label == "bad_cmd"));
}

#[test]
fn test_classify_large_no_pattern() {
    let out = make_output(0, &"x\n".repeat(3000));
    let result = classify::classify(&out, "some_tool", &[]);
    // Unknown category with large output → Bounded (indexed, byte-bounded display)
    match result {
        Classification::Bounded {
            output,
            display,
            size,
            ..
        } => {
            assert_eq!(size, 6000);
            assert!(display.len() <= classify::DISPLAY_CAP + 200);
            assert!(output.len() > classify::DISPLAY_CAP);
        }
        _ => panic!("expected Bounded for unknown command with large output"),
    }
}

#[test]
fn test_classify_success_with_pattern() {
    let patterns = pattern::builtins();
    let big = format!("{}47 passed in 3.2s\n", ".\n".repeat(3000));
    let out = make_output(0, &big);
    let result = classify::classify(&out, "pytest tests/", patterns);
    assert!(
        matches!(result, Classification::Success { summary, .. } if summary.contains("47 passed"))
    );
}

#[test]
fn test_classify_failure_with_pattern() {
    let patterns = pattern::builtins();
    let fail_output: String = (0..50).map(|i| format!("error line {i}\n")).collect();
    let out = make_output(1, &fail_output);
    match classify::classify(&out, "pytest -x", patterns) {
        Classification::Failure { label, output, .. } => {
            assert_eq!(label, "pytest");
            assert!(output.contains("error line 49"));
        }
        _ => panic!("expected Failure"),
    }
}

#[test]
fn test_cmd_recall_empty_query_returns_1() {
    assert_eq!(cmd_recall("", false), 1);
    assert_eq!(cmd_recall("", true), 1);
}

#[test]
fn test_cmd_recall_returns_valid_exit_code() {
    // Verifies cmd_recall returns a valid exit code (0 or 1).
    // OO_DATA_DIR isolates the store so this never reads the developer's
    // real index.
    let dir = tempfile::tempdir().unwrap();
    let _guard = crate::store::set_test_data_dir(dir.path());
    let code = cmd_recall("unique_recall_test_content_xyz_42", false);
    assert!(
        code == 0 || code == 1,
        "cmd_recall must return 0 or 1, got: {code}"
    );
}

#[test]
fn test_cmd_learn_no_args_returns_1() {
    assert_eq!(cmd_learn(&[], None), 1);
}

#[test]
fn test_cmd_run_empty_args_returns_1() {
    assert_eq!(cmd_run(&[]), 1);
}

#[test]
fn test_cmd_run_echo_exits_zero() {
    assert_eq!(cmd_run(&[s("echo"), s("hello")]), 0);
}

#[test]
fn test_cmd_run_false_exits_nonzero() {
    assert_ne!(cmd_run(&[s("false")]), 0);
}

#[test]
fn test_cmd_run_nonexistent_command_returns_1() {
    // Exec failure → Err branch → exit code 1
    assert_eq!(cmd_run(&[s("__oo_no_such_command_xyz__")]), 1);
}

#[test]
fn test_cmd_help_empty_cmd_returns_1() {
    assert_eq!(cmd_help(""), 1);
}

#[test]
fn test_classify_large_with_pattern_no_summary_match() {
    // Pattern exists but success regex doesn't match
    // pytest is Status category → returns Success with empty summary instead of Large
    let patterns = pattern::builtins();
    let out = make_output(0, &"x\n".repeat(3000));
    assert!(matches!(
        classify::classify(&out, "pytest tests/", patterns),
        Classification::Success { summary, .. } if summary.is_empty()
    ));
}

#[test]
fn test_classify_failure_pattern_extract_failure() {
    let patterns = pattern::builtins();
    let fail: String = (0..30).map(|i| format!("FAILED test{i}\n")).collect();
    let out = make_output(1, &fail);
    assert!(matches!(
        classify::classify(&out, "pytest -v", patterns),
        Classification::Failure { .. }
    ));
}

#[test]
fn test_try_index_no_panic() {
    // OO_DATA_DIR isolates the store so this test does not write to the
    // developer's real index.
    let dir = tempfile::tempdir().unwrap();
    let _guard = crate::store::set_test_data_dir(dir.path());
    let _ = try_index("test command", "some output content");
}

#[test]
fn test_cmd_forget_returns_valid_exit_code() {
    // Verifies cmd_forget returns a valid exit code (0 or 1).
    // OO_DATA_DIR isolates the store so the project-scoped delete (issue
    // #168) never wipes the developer's real index.
    let dir = tempfile::tempdir().unwrap();
    let _guard = crate::store::set_test_data_dir(dir.path());
    let code = cmd_forget();
    assert!(
        code == 0 || code == 1,
        "cmd_forget must return 0 or 1, got: {code}"
    );
}

#[test]
fn test_cmd_learn_passthrough_small_output() {
    // cmd_learn with a command that produces small output (< 4 KiB) → Passthrough branch.
    // spawn_background will fail (no binary in PATH during test), but that is non-fatal.
    // We only care that the exit code matches the command's actual exit code.
    let code = cmd_learn(&[s("echo"), s("hello_learn_test")], None);
    assert_eq!(code, 0, "echo must succeed, got: {code}");
}

#[test]
fn test_cmd_learn_failure_branch() {
    // cmd_learn with a command that fails → Failure branch in classification.
    let code = cmd_learn(&[s("false")], None);
    assert_ne!(
        code, 0,
        "false must produce non-zero exit code, got: {code}"
    );
}

// ---------------------------------------------------------------------------
// savings_suffix / render_classification: compression savings reporting
// ---------------------------------------------------------------------------

/// Golden: the exact `format_size(saved, BINARY)` string is pinned for a
/// fixed synthetic size (success-with-summary form).
#[test]
fn test_savings_suffix_golden_success_line() {
    // original 5000 B, base line "✓ pytest (47 passed)" (22 B: ✓ is 3 bytes)
    // -> 4978 saved -> "4.86 KiB".
    let line = "\u{2713} pytest (47 passed)";
    assert_eq!(line.len(), 22);
    assert_eq!(
        savings_suffix(5000, line.len()).as_deref(),
        Some(" [saved 4.86 KiB]")
    );
}

/// Golden: quiet success (empty summary) — the quiet `✓ {label}` form is
/// the largest compression win in the product and must carry the figure.
#[test]
fn test_savings_suffix_quiet_success_golden() {
    let line = "\u{2713} cargo build";
    assert_eq!(
        savings_suffix(100_000, line.len()).as_deref(),
        Some(" [saved 97.64 KiB]")
    );
}

/// Golden: the Failure indicator line is `✗ {label}` — the filtered output
/// lines that follow are NOT part of the displayed byte count.
#[test]
fn test_savings_suffix_failure_arm_golden() {
    let line = "\u{2717} pytest";
    assert_eq!(
        savings_suffix(50_000, line.len()).as_deref(),
        Some(" [saved 48.82 KiB]")
    );
}

/// Boundary: `saved == MIN_SAVINGS` exactly → no suffix (suppression is
/// `saved <= MIN_SAVINGS`, not `<`).
#[test]
fn test_savings_suffix_suppressed_at_or_below_threshold() {
    assert_eq!(savings_suffix(4096, 0), None);
    // just below
    assert_eq!(savings_suffix(5120, 1032), None);
}

/// Boundary: `saved == MIN_SAVINGS + 1` → suffix appears.
#[test]
fn test_savings_suffix_positive_just_above_threshold() {
    assert_eq!(
        savings_suffix(4097, 0).as_deref(),
        Some(" [saved 4.00 KiB]")
    );
}

/// Non-positive delta: summary nearly as long as the input (or longer) →
/// no suffix, no panic (saturating arithmetic).
#[test]
fn test_savings_suffix_non_positive_saving_is_suppressed() {
    assert_eq!(savings_suffix(5000, 5000), None);
    assert_eq!(savings_suffix(100, 200), None);
}

/// Non-UTF-8 input: `merged_lossy()` replaces invalid bytes with the
/// U+FFFD replacement char (3 bytes each), so the lossy byte length is what
/// feeds the suffix — the helper must not panic and must measure from the
/// lossy length, not the raw vec length.
#[test]
fn test_savings_suffix_non_utf8_no_panic() {
    // 1000 bytes of 0xff (invalid UTF-8) followed by 5000 valid bytes:
    // lossy length is 1000 * 3 + 5000 = 8000, NOT 6000.
    let mut raw = vec![0xffu8; 1000];
    raw.extend(std::iter::repeat(b'x').take(5000));
    let out = exec::CommandOutput {
        stdout: raw,
        stderr: Vec::new(),
        exit_code: 0,
    };
    let merged = out.merged_lossy();
    let merged_len = merged.len();
    assert_eq!(
        merged_len, 8000,
        "lossy length must account for replacement chars"
    );

    // line (10) + " [saved " (8) + "7.80 KiB" (8) + "]" (1) = 27 bytes
    // displayed, so the suffix must render exactly "7.80 KiB".
    let line = "\u{2713} cargo";
    let suffix = savings_suffix(merged_len, line.len()).expect("8 KiB must exceed MIN_SAVINGS");
    assert_eq!(suffix, " [saved 7.80 KiB]");
    assert_eq!(merged_len - (line.len() + suffix.len()), 7974,);
}

/// Passthrough: small output classifies as Passthrough — no indicator line,
/// so no suffix applies regardless of `original_size`.
#[test]
fn test_savings_passthrough_unchanged() {
    let c = classify::classify(&make_output(0, "hello\n"), "echo hi", &[]);
    assert!(matches!(c, Classification::Passthrough { .. }));
}

/// Regression lock: the Large arm's `size` field is carried through
/// unchanged — its `indexed N` wording must not gain a `[saved …]` figure.
#[test]
fn test_savings_large_arm_wording_unchanged() {
    let c = classify::classify(&make_output(0, &"x\n".repeat(3000)), "gh api x", &[]);
    match c {
        Classification::Large { size, .. } => assert_eq!(size, 6000),
        _ => panic!("expected Large for Data-category command with large output"),
    }
}

// ---------------------------------------------------------------------------
// Issue #149 — end-to-end test through cmd_run (the cmd_run entry point)
// ---------------------------------------------------------------------------
//
// The #151 refactor unified classification: both cmd_run and cmd_learn call
// `classify::classify`. This test exercises the cmd_run path specifically —
// `cmd_run` joins args with spaces, loads builtin patterns, runs the command,
// classifies, and renders. The command `cargo nextest run` has no matching
// builtin pattern and >4KB output, so the category fallback must fire:
// detect_category returns Status → Success (quiet) → "✓ cargo" display.
//
// `run_command_args` returns the classification directly so the test can
// assert on the exact variant — the no-op "exit code is 0" guard that the
// pre-#149 version of this test relied on is replaced by an assertion on
// the classification itself. If the #149 fix is absent, detect_category
// returns Unknown → Bounded, which this test must fail on.
// ---------------------------------------------------------------------------

#[test]
fn test_cmd_run_cargo_nextest_run_quiet_success() {
    // `oo cargo nextest run` — cmd_run path. The command is joined as
    // "cargo nextest run" by cmd_run; with the #149 fix, detect_category
    // returns Status, so a large successful run produces a quiet Success
    // ("✓ cargo") instead of a Bounded/Passthrough of the full output.
    //
    // `cargo nextest` requires nextest installed. In environments where it
    // is missing, the command exits non-zero and the Failure arm is taken
    // (still a legitimate classification — the test asserts the failure
    // label is "cargo", not a Bounded/Large arm). In environments where it
    // is present and the output is >4KB, the Success(quiet) arm is taken.
    // Both arms are asserted here; the Bounded/Large arms (the regression
    // the #149 fix eliminates) are not.
    let (code, classification) = run_command_args(&[s("cargo"), s("nextest"), s("run")]);
    let Some(classification) = classification else {
        panic!("run_command_args must return Some(classification) on the success path");
    };
    match classification {
        Classification::Success { label, summary } => {
            assert_eq!(label, "cargo");
            assert!(summary.is_empty(), "quiet success must have empty summary");
        }
        Classification::Failure { label, .. } => {
            assert_eq!(label, "cargo");
            assert_ne!(code, 0, "Failure arm implies non-zero exit code");
        }
        Classification::Passthrough { .. } => {
            // Small output (≤ 4 KiB) — e.g. a "command not found" or similar
            // short error. Still not Bounded/Large, so acceptable.
            assert_ne!(
                code, 0,
                "Passthrough implies small output; nextest likely missing"
            );
        }
        other => panic!(
            "cmd_run with 'cargo nextest run' must not fall through to Bounded/Large (got {other:?}) — the #149 fix must classify this as Status"
        ),
    }
}