//! E2E regression pin for #53 — a monomorphic `(new T args)` over a
//! user-defined ADT that declares a `new` fn must build, not just check.
//!
//! Property protected: for a single-module program with `(data Counter
//! (ctor MkCounter (con Int)))`, a `(fn new …)` constructing it, and a
//! `main` that calls `(new Counter 42)`, the whole pipeline
//! (`ail check` AND `ail build --alloc=rc`) succeeds and the binary
//! runs. The monomorphic `(new T …)` form carries no `NewArg::Type`, so
//! the `Term::New` desugar lowers it to `(app T.new <values…>)` — a
//! type-scoped `Var` callee `Counter.new` (desugar.rs:1091-1097). The
//! checker's TypeDef-first ladder resolves that callee, so `ail check`
//! is clean; codegen's call-lowering does not, so the call falls through
//! to the indirect path and aborts with `unknown variable: `Counter.new``
//! (CodegenError::UnknownVar, ailang-codegen/src/lib.rs:1712). The check
//! pass and the codegen pass disagree on whether `Counter.new` resolves
//! — a check↔codegen mismatch on the monomorphic dotted constructor
//! callee.
//!
//! This is distinct-root from #51: #51 was the polymorphic
//! `(new T <elem> …)` leg (a dropped `NewArg::Type`); the #51 fix left
//! the monomorphic app-lowering path deliberately unchanged. This pin
//! covers the monomorphic-over-user-ADT path.
//!
//! The fixture is inline and autonomous (single module, no imports, no
//! shared file, no kernel-tier RawBuf), minimised from the 3-module
//! 35-symbol `kem_2_counter_new.ail` reproducer: the match/print
//! scaffolding is dropped because the crash is at the `(new Counter 42)`
//! call-site lowering, independent of how the result is consumed.

use std::path::Path;
use std::process::Command;

fn ail_bin() -> &'static str {
    env!("CARGO_BIN_EXE_ail")
}

fn write_tmp(src: &str) -> std::path::PathBuf {
    let dir = std::env::temp_dir().join(format!(
        "user_adt_new_mono_{}",
        std::process::id()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let p = dir.join("user_adt_new_mono.ail");
    std::fs::write(&p, src).unwrap();
    p
}

/// The minimal autonomous trigger: a user ADT + a `new` fn + a `main`
/// that calls `(new Counter 42)` and binds the result.
const PROG: &str = r#"(module user_adt_new_mono

  (data Counter
    (ctor MkCounter (con Int)))

  (fn new
    (doc "Build a Counter initialised to the given value.")
    (type (fn-type (params (own (con Int))) (ret (own (con Counter)))))
    (params n)
    (body (term-ctor Counter MkCounter n)))

  (fn main
    (type (fn-type (params) (ret (own (con Unit))) (effects IO)))
    (params)
    (body
      (let c (new Counter 42)
        (do io/print_str "ok\n")))))
"#;

#[test]
fn mono_new_over_user_adt_builds_and_runs() {
    let src = write_tmp(PROG);

    // `ail check` is clean today — the TypeDef-first ladder resolves
    // `Counter.new`. This half already passes; it documents that the
    // bug is NOT a check-layer rejection.
    let check = Command::new(ail_bin())
        .args(["check", src.to_str().unwrap()])
        .output()
        .expect("ail check failed to run");
    assert!(
        check.status.success(),
        "ail check must accept `(new Counter 42)` over a user ADT; got:\n{}",
        String::from_utf8_lossy(&check.stderr)
    );

    // The failing half (#53): `ail build --alloc=rc` aborts with
    // `unknown variable: `Counter.new``. Once fixed, the build must
    // succeed and the binary must run cleanly.
    let out = std::env::temp_dir().join(format!("user_adt_new_mono_bin_{}", std::process::id()));
    let build = Command::new(ail_bin())
        .args(["build", src.to_str().unwrap(), "--alloc=rc", "-o"])
        .arg(&out)
        .output()
        .expect("ail build failed to run");
    assert!(
        build.status.success(),
        "ail build --alloc=rc must compile a monomorphic `(new Counter 42)` over a \
         user ADT, but it failed (regression #53 — check↔codegen mismatch on the \
         `Counter.new` dotted constructor callee):\n{}",
        String::from_utf8_lossy(&build.stderr)
    );

    assert!(Path::new(&out).exists(), "build reported success but produced no binary");

    let run = Command::new(&out).output().expect("execute compiled binary");
    assert!(
        run.status.success(),
        "the compiled binary must run cleanly; stderr:\n{}",
        String::from_utf8_lossy(&run.stderr)
    );
    assert_eq!(
        String::from_utf8_lossy(&run.stdout),
        "ok\n",
        "the program prints `ok` after constructing the Counter"
    );
}
