//! End-to-end tests for the Eq/Ord prelude shipped in milestone 23.
//!
//! These tests compile a `.ail.json` workspace via the `ail build`
//! subcommand, run the resulting native binary, and assert on stdout.
//! Together they protect:
//!
//! 1. Polymorphic-helper composition over the prelude free fns at
//!    three primitive types (`eq_ord_polymorphic_runs_end_to_end`).
//!    Property: a user-defined `forall a. Ord a => …` helper that
//!    calls `gt`/`not` is monomorphised correctly at Int / Bool / Str.
//! 2. User-ADT integration with the unified mono pass
//!    (`eq_ord_user_adt_runs_end_to_end`). Property: `instance Eq T`
//!    plus `instance Ord T` for a user-defined `T` produces working
//!    mono symbols when invoked through the prelude.
//! 3. Mono-symbol body-hash stability for `eq__IntBox`
//!    (`eq_ord_user_adt_eq_intbox_hash_stable`). Property: the user
//!    instance body that the unified pass emits for IntBox is
//!    bit-stable across refactors; drift here means either a
//!    legitimate emission change (re-record) or a regression
//!    (investigate). Mirrors `crates/ail/tests/mono_hash_stability.rs`.

use ailang_check::{check_workspace, monomorphise_workspace};
use ailang_core::ast::Def;
use ailang_core::hash::def_hash;
use ailang_surface::load_workspace;
use std::path::PathBuf;
use std::process::Command;

fn fixture_path(name: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../../examples")
        .join(name)
}

fn build_and_run(fixture: &str) -> String {
    let src = fixture_path(fixture);
    let out = std::env::temp_dir().join(format!("ail_{}.bin", fixture.replace('.', "_")));

    let build = Command::new(env!("CARGO_BIN_EXE_ail"))
        .args(["build", src.to_str().unwrap(), "-o", out.to_str().unwrap()])
        .output()
        .expect("ail build");
    assert!(
        build.status.success(),
        "ail build failed:\nstdout: {}\nstderr: {}",
        String::from_utf8_lossy(&build.stdout),
        String::from_utf8_lossy(&build.stderr),
    );

    let run = Command::new(&out).output().expect("run binary");
    assert!(
        run.status.success(),
        "binary exited non-zero:\nstdout: {}\nstderr: {}",
        String::from_utf8_lossy(&run.stdout),
        String::from_utf8_lossy(&run.stderr),
    );
    String::from_utf8_lossy(&run.stdout).trim().to_string()
}

#[test]
fn eq_ord_polymorphic_runs_end_to_end() {
    let stdout = build_and_run("eq_ord_polymorphic.ail");
    // Helper `at_most(3, 5)` at Int = true → 1
    // `at_most(true, false)` at Bool = false → 0
    // `at_most("abc", "abd")` at Str = true → 1
    // Polymorphic `print` for Int routes through `show` + `io/print_str`,
    // emitting one int per line, so stdout is "1\n0\n1" after `.trim()`
    // strips the trailing newline.
    assert_eq!(stdout, "1\n0\n1", "expected 1\\n0\\n1, got {stdout:?}");
}

#[test]
fn eq_ord_user_adt_runs_end_to_end() {
    let stdout = build_and_run("eq_ord_user_adt.ail");
    // eq(MkIntBox 3, MkIntBox 3) = true → 1
    // eq(MkIntBox 3, MkIntBox 5) = false → 0
    // Polymorphic `print` for Int emits one int per line; trimmed stdout is "1\n0".
    assert_eq!(stdout, "1\n0", "expected 1\\n0, got {stdout:?}");
}

#[test]
fn eq_ord_user_adt_eq_intbox_hash_stable() {
    let ws = load_workspace(&fixture_path("eq_ord_user_adt.ail")).expect("load");
    let diags = check_workspace(&ws);
    assert!(diags.is_empty(), "typecheck failed: {diags:#?}");
    let mono = monomorphise_workspace(&ws).expect("mono");

    // The mono symbol for `eq` at a user-defined ADT uses the
    // `<method>__<8-hex-prefix>` mangling (mangling is code-SoT —
    // see the `mangling` row in design/INDEX.md / the
    // crates/ailang-codegen/src/lib.rs //! header) (primitives use
    // the bare type name; compound
    // / user-defined types use the 8-hex BLAKE3 prefix of the
    // canonical type bytes). We look up the single `eq__` symbol
    // synthesised at `IntBox` — there is only one user instance,
    // so the find-by-prefix is unambiguous in this fixture.
    let eq_intbox = mono
        .modules
        .values()
        .flat_map(|m| m.defs.iter())
        .find_map(|d| match d {
            Def::Fn(f) if f.name.starts_with("eq__") && f.name != "eq__Int"
                && f.name != "eq__Bool" && f.name != "eq__Str" =>
            {
                Some(f)
            }
            _ => None,
        })
        .expect("eq__<IntBox-hash> not synthesised");

    // The 8-hex-prefix in the mono-symbol name is the BLAKE3 prefix
    // of the canonical IntBox type bytes (mangling is code-SoT — see
    // the `mangling` row in design/INDEX.md). Drift here means either
    // the canonical-form encoding
    // changed or the type's canonical bytes changed — both warrant
    // investigation before re-pinning.
    assert_eq!(
        eq_intbox.name, "eq__cde77856",
        "eq__IntBox mono-symbol name drifted — type-mangling regression?"
    );

    // The body hash pins the unified mono pass's IntBox eq emission.
    // Drift means either a legitimate refactor (re-record) or a
    // regression in user-instance body propagation (investigate).
    //
    // 2026-05-14 bugfix-print-leak-show-ret-mode: hash re-pinned
    // (from `9daaffa7528d2a1c` to `3c4cf040cb4e8bb2`) because
    // `substitute_rigids` now preserves `param_modes`/`ret_mode`
    // through rigid substitution. Eq's class method declares
    // `param_modes: ["borrow", "borrow"]` — the user-instance
    // mono synthesis used to silently strip those.
    //
    // 2026-05-21 operator-routing-eq-ord re-pinned (prior:
    // 3c4cf040cb4e8bb2): the user-instance body's inner `(app == ai bi)`
    // migrates to `(app eq ai bi)` per the operator-name deletion
    // sweep — the call site symbol name shifts, body hash follows.
    let h = def_hash(&Def::Fn(eq_intbox.clone()));
    assert_eq!(
        h, "e639d41fc49b1524",
        "eq__IntBox body hash drifted — see mono_hash_stability.rs for the resolution pattern; captured: {h}"
    );
}