use std::fs;

use alt_controller_image::{BuildPlan, ImageSpec, OutputFormat};

fn write_spec(contents: &str) -> tempfile::TempDir {
    let directory = tempfile::tempdir().expect("temporary spec directory");
    fs::write(directory.path().join("image.toml"), contents).expect("write spec");
    directory
}

fn load(contents: &str) -> anyhow::Result<ImageSpec> {
    let directory = write_spec(contents);
    ImageSpec::load(&directory.path().join("image.toml"))
}

const VALID_SPEC: &str = r#"
[target]
name = "alt-controller"
architecture = "x86_64"
format = "tar"

[kernel]
flavour = "rt"

[boot]
initrd_features = ["rootfs"]
initrd_modules = ["ext4", "virtio_blk.ko"]

[packages]
base = ["basesystem"]
selectors = ["^kernel-image-rt$"]
"#;

#[test]
fn parses_a_typed_image_spec() {
    let spec = load(VALID_SPEC).expect("valid spec");

    assert_eq!(spec.target.name, "alt-controller");
    assert_eq!(spec.target.architecture.as_str(), "x86_64");
    assert_eq!(spec.target.format, OutputFormat::Tar);
    assert_eq!(spec.packages.selectors[0].as_str(), "^kernel-image-rt$");
}

#[test]
fn compiles_a_validated_spec_into_an_immutable_build_plan() {
    let spec = load(VALID_SPEC).expect("valid spec");
    let plan = BuildPlan::compile(spec).expect("plan compiles");

    assert_eq!(plan.spec().target.name, "alt-controller");
}

#[test]
fn rejects_an_unknown_target_format() {
    let error = load(&VALID_SPEC.replace("format = \"tar\"", "format = \"iso\""))
        .expect_err("unsupported format must fail");

    assert!(format!("{error:#}").contains("unsupported output format"));
}

#[test]
fn rejects_an_unsupported_architecture() {
    let error = load(&VALID_SPEC.replace("x86_64", "aarch64"))
        .expect_err("unsupported architecture must fail");

    assert!(format!("{error:#}").contains("unsupported architecture"));
}

#[test]
fn rejects_duplicate_package_selectors() {
    let error = load(&VALID_SPEC.replace(
        "selectors = [\"^kernel-image-rt$\"]",
        "selectors = [\"^kernel-image-rt$\", \"^kernel-image-rt$\"]",
    ))
    .expect_err("duplicate selector must fail");

    assert!(format!("{error:#}").contains("duplicate package selector"));
}

#[test]
fn rejects_an_invalid_initrd_module_name() {
    let error = load(&VALID_SPEC.replace("\"virtio_blk.ko\"", "\"../virtio_blk.ko\""))
        .expect_err("unsafe module name must fail");

    assert!(format!("{error:#}").contains("invalid initrd module"));
}