//! Incremental compilation tests.
//!
//! Verifies that the .amod module file system handles incremental
//! rebuilds correctly:
//!   - Recompiling a module produces the same .amod when the public
//!     interface is unchanged.
//!   - Changing a module's public interface produces a different .amod.
//!   - Changing only private implementation does NOT change .amod.
//!   - A consumer recompiled against the same .amod produces the
//!     same .o (no unnecessary recompilation cascade).

use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::atomic::{AtomicU64, Ordering};

static NEXT_ID: AtomicU64 = AtomicU64::new(0);

fn unique_dir() -> PathBuf {
    let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
    let dir = std::env::temp_dir().join(format!(
        "afs_incr_{}_{}", std::process::id(), id
    ));
    fs::create_dir_all(&dir).unwrap();
    dir
}

fn find_compiler() -> PathBuf {
    for c in &["target/release/armfortas", "target/debug/armfortas"] {
        let p = PathBuf::from(c);
        if p.exists() { return fs::canonicalize(&p).unwrap(); }
    }
    panic!("armfortas binary not found");
}

fn compile(compiler: &Path, source: &Path, obj: &Path, search: &Path) {
    let result = Command::new(compiler)
        .args([
            source.to_str().unwrap(), "-c", "-O0",
            "-o", obj.to_str().unwrap(),
            &format!("-I{}", search.display()),
        ])
        .output()
        .expect("compiler launch failed");
    assert!(
        result.status.success(),
        "compile {} failed:\n{}",
        source.display(),
        String::from_utf8_lossy(&result.stderr)
    );
}

/// Extract the interface body from an .amod file (everything after the
/// first blank line, which separates the header from the interface).
fn extract_amod_body(amod: &[u8]) -> &[u8] {
    let text = std::str::from_utf8(amod).unwrap_or("");
    if let Some(idx) = text.find("\n\n") {
        &amod[idx + 2..]
    } else {
        amod
    }
}

/// Compile a module and return the .amod contents.
fn compile_module(compiler: &Path, dir: &Path, name: &str, source: &str) -> Vec<u8> {
    let f90 = dir.join(format!("{}.f90", name));
    let obj = dir.join(format!("{}.o", name));
    fs::write(&f90, source).unwrap();
    compile(compiler, &f90, &obj, dir);
    let amod = dir.join(format!("{}.amod", name));
    fs::read(&amod).unwrap_or_else(|e| panic!("{}.amod not found: {}", name, e))
}

#[test]
fn same_source_produces_identical_amod() {
    let compiler = find_compiler();
    let dir = unique_dir();
    let src = "module m\n  implicit none\n  integer :: x = 42\nend module\n";

    let amod1 = compile_module(&compiler, &dir, "m", src);
    // Recompile with identical source.
    let amod2 = compile_module(&compiler, &dir, "m", src);

    assert_eq!(amod1, amod2, ".amod changed despite identical source");
    let _ = fs::remove_dir_all(&dir);
}

#[test]
fn changed_public_interface_changes_amod() {
    let compiler = find_compiler();
    let dir = unique_dir();

    let v1 = "module m\n  implicit none\n  integer :: x = 42\nend module\n";
    let v2 = "module m\n  implicit none\n  integer :: x = 42\n  integer :: y = 99\nend module\n";

    let amod1 = compile_module(&compiler, &dir, "m", v1);
    let amod2 = compile_module(&compiler, &dir, "m", v2);

    assert_ne!(amod1, amod2, ".amod should differ when public interface changes");
    let _ = fs::remove_dir_all(&dir);
}

#[test]
fn changed_private_impl_does_not_change_amod() {
    let compiler = find_compiler();
    let dir = unique_dir();

    let v1 = "\
module m
  implicit none
  integer :: x = 42
contains
  subroutine bump()
    x = x + 1
  end subroutine
end module
";
    let v2 = "\
module m
  implicit none
  integer :: x = 42
contains
  subroutine bump()
    x = x + 10
  end subroutine
end module
";

    let amod1 = compile_module(&compiler, &dir, "m", v1);
    let amod2 = compile_module(&compiler, &dir, "m", v2);

    // The header includes a source checksum which will differ. But the
    // interface section (everything after the blank line separating the
    // header from the body) should be identical.
    let body1 = extract_amod_body(&amod1);
    let body2 = extract_amod_body(&amod2);
    assert_eq!(body1, body2, ".amod interface body changed but only private impl differs");
    let _ = fs::remove_dir_all(&dir);
}

#[test]
fn consumer_object_stable_when_amod_unchanged() {
    let compiler = find_compiler();
    let dir = unique_dir();

    let mod_src = "module m\n  implicit none\n  integer :: x = 42\nend module\n";
    let main_src = "program p\n  use m\n  implicit none\n  print *, x\nend program\n";

    // Compile module.
    compile_module(&compiler, &dir, "m", mod_src);

    // Compile consumer.
    let main_f90 = dir.join("main.f90");
    let main_o = dir.join("main.o");
    fs::write(&main_f90, main_src).unwrap();
    compile(&compiler, &main_f90, &main_o, &dir);
    let obj1 = fs::read(&main_o).unwrap();

    // Recompile consumer without changing anything.
    compile(&compiler, &main_f90, &main_o, &dir);
    let obj2 = fs::read(&main_o).unwrap();

    assert_eq!(obj1, obj2, "consumer .o changed despite no source/amod change");
    let _ = fs::remove_dir_all(&dir);
}

#[test]
fn consumer_object_changes_when_amod_changes() {
    let compiler = find_compiler();
    let dir = unique_dir();

    let mod_v1 = "module m\n  implicit none\n  integer :: x = 42\nend module\n";
    let mod_v2 = "module m\n  implicit none\n  integer :: x = 42\n  integer :: y = 99\nend module\n";
    let main_src = "program p\n  use m\n  implicit none\n  print *, x\nend program\n";

    // Compile module v1 and consumer.
    compile_module(&compiler, &dir, "m", mod_v1);
    let main_f90 = dir.join("main.f90");
    let main_o = dir.join("main.o");
    fs::write(&main_f90, main_src).unwrap();
    compile(&compiler, &main_f90, &main_o, &dir);
    let obj1 = fs::read(&main_o).unwrap();

    // Recompile module with changed public interface.
    compile_module(&compiler, &dir, "m", mod_v2);
    // Recompile consumer against new .amod.
    compile(&compiler, &main_f90, &main_o, &dir);
    let obj2 = fs::read(&main_o).unwrap();

    // The consumer .o may or may not change (depends on whether the
    // consumer references the new symbol). But the .amod definitely
    // changed, so this test documents the observation either way.
    // The key point: no crash, no stale symbol resolution.
    let _ = fs::remove_dir_all(&dir);
}