//! Integration tests for `cph_model::load`, driven by static fixtures under
//! `tests/fixtures/`. The fixtures double as documentation of the ADR-0008
//! on-disk format.

use std::path::PathBuf;

use cph_diag::DiagCode;
use cph_model::load;

/// Absolute path to a fixture engineering-file root.
fn fixture(name: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/fixtures")
        .join(name)
}

#[test]
fn valid_two_part_lesson_loads_in_order_with_no_errors() {
    let (lesson, diags) = load(&fixture("valid"));

    let lesson = lesson.expect("valid fixture must produce a Lesson");
    assert!(
        diags.is_empty(),
        "valid fixture must have no diagnostics, got: {diags:?}"
    );

    assert_eq!(lesson.project.id, "fixture-valid");
    assert_eq!(lesson.project.name, "valid-2-part");
    assert_eq!(lesson.info.title, "测试课：两个部件");
    assert_eq!(lesson.info.author.as_deref(), Some("范式教育教研组"));

    // Parts preserve declared order: segment first, lemma second.
    assert_eq!(lesson.parts.len(), 2);
    assert_eq!(lesson.parts[0].kind, "segment");
    assert_eq!(lesson.parts[0].path, PathBuf::from("segments/intro"));
    assert_eq!(lesson.parts[0].descriptor.kind, "segment");
    assert_eq!(lesson.parts[1].kind, "lemma");
    assert_eq!(lesson.parts[1].path, PathBuf::from("lemmas/young"));
    assert_eq!(lesson.parts[1].descriptor.kind, "lemma");

    // `source` scalar survives on the lemma descriptor; `kind` is removed.
    let scalars = &lesson.parts[1].descriptor.scalars;
    assert_eq!(
        scalars.get("source").and_then(|v| v.as_str()),
        Some("测试引理")
    );
    assert!(scalars.get("kind").is_none());

    // Targets are collected from [targets.*], in declared order.
    assert_eq!(lesson.target_names(), vec!["student", "teacher"]);
    // Empty `[targets.x]` bodies → all-default build config, no diagnostics:
    // single-file artifact at build/<name>.pdf + one typst-compile step.
    for target in &lesson.targets {
        assert_eq!(
            target.artifact,
            cph_model::Artifact::SingleFile {
                filepath: PathBuf::from(format!("build/{}.pdf", target.name)),
            }
        );
        assert_eq!(
            target.steps,
            vec![cph_model::Step::TypstCompile {
                template: PathBuf::from(format!("exports/{}.typ", target.name)),
            }]
        );
    }

    // Descriptor dir is absolute, anchored under the root.
    assert!(lesson.parts[0].descriptor.dir.is_absolute());
    assert_eq!(
        lesson.parts[0].descriptor.dir,
        lesson.root.join("segments/intro")
    );
}

#[test]
fn missing_part_folder_yields_part_path_missing() {
    let (lesson, diags) = load(&fixture("missing-part"));

    // Still produces a Lesson (loader stays best-effort).
    let lesson = lesson.expect("missing-part fixture must still produce a Lesson");
    assert_eq!(lesson.parts.len(), 2, "both parts are recorded for order");

    let missing: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::PartPathMissing)
        .collect();
    assert_eq!(
        missing.len(),
        1,
        "exactly one PartPathMissing expected, got diags: {diags:?}"
    );
    assert_eq!(missing[0].severity, cph_diag::Severity::Error);
}

#[test]
fn kind_mismatch_yields_unknown_kind_diagnostic() {
    let (lesson, diags) = load(&fixture("kind-mismatch"));

    let lesson = lesson.expect("kind-mismatch fixture must still produce a Lesson");
    assert_eq!(lesson.parts.len(), 1);

    let mismatch: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::UnknownKind)
        .collect();
    assert_eq!(
        mismatch.len(),
        1,
        "exactly one kind-mismatch diagnostic expected, got: {diags:?}"
    );
    assert!(
        mismatch[0].message.contains("segment") && mismatch[0].message.contains("lemma"),
        "message should name both kinds, got: {}",
        mismatch[0].message
    );
}

#[test]
fn malformed_manifest_is_a_hard_failure() {
    let (lesson, diags) = load(&fixture("malformed-manifest"));

    assert!(
        lesson.is_none(),
        "malformed manifest must be a hard failure (None)"
    );
    assert_eq!(diags.len(), 1, "one hard-failure diagnostic expected");
    assert_eq!(diags[0].code, DiagCode::SchemaViolation);
    assert_eq!(diags[0].severity, cph_diag::Severity::Error);
}

#[test]
fn missing_manifest_is_a_hard_failure() {
    // A directory with no manifest.toml at all.
    let (lesson, diags) = load(&fixture("does-not-exist-at-all"));
    assert!(lesson.is_none());
    assert_eq!(diags.len(), 1);
    assert_eq!(diags[0].code, DiagCode::SchemaViolation);
}

#[test]
fn structured_target_configs_parse_into_typed_builds() {
    use cph_model::{Artifact, Step};

    let (lesson, diags) = load(&fixture("target-configs"));
    let lesson = lesson.expect("target-configs fixture must produce a Lesson");
    assert!(
        diags.is_empty(),
        "well-formed target configs must have no diagnostics, got: {diags:?}"
    );

    // Declared order is preserved.
    assert_eq!(lesson.target_names(), vec!["student", "archive", "teacher"]);

    // student: explicit single-file artifact (with filepath) + one
    // typst-compile step (with template).
    let student = &lesson.targets[0];
    assert_eq!(student.name, "student");
    assert_eq!(
        student.artifact,
        Artifact::SingleFile {
            filepath: PathBuf::from("build/student.pdf"),
        }
    );
    assert_eq!(
        student.steps,
        vec![Step::TypstCompile {
            template: PathBuf::from("exports/student.typ"),
        }]
    );

    // archive: file-tree artifact (root + outputs glob) + two ordered steps,
    // a typst-compile followed by a shell step (order preserved).
    let archive = &lesson.targets[1];
    assert_eq!(archive.name, "archive");
    assert_eq!(
        archive.artifact,
        Artifact::FileTree {
            root: PathBuf::from("build/archive"),
            outputs: "**/*.{html,js,json}".to_string(),
        }
    );
    assert_eq!(
        archive.steps,
        vec![
            Step::TypstCompile {
                template: PathBuf::from("exports/archive.typ"),
            },
            Step::Shell {
                run: "npm run build".to_string(),
            },
        ]
    );

    // teacher: empty body → all defaults.
    let teacher = &lesson.targets[2];
    assert_eq!(teacher.name, "teacher");
    assert_eq!(
        teacher.artifact,
        Artifact::SingleFile {
            filepath: PathBuf::from("build/teacher.pdf"),
        }
    );
    assert_eq!(
        teacher.steps,
        vec![Step::TypstCompile {
            template: PathBuf::from("exports/teacher.typ"),
        }]
    );
}

#[test]
fn malformed_target_config_is_non_fatal_with_schema_violations() {
    use cph_model::{Artifact, Step};

    let (lesson, diags) = load(&fixture("bad-target-config"));
    let lesson = lesson.expect("bad-target-config must still produce a Lesson");

    // Both targets survive despite their malformed fields.
    assert_eq!(lesson.target_names(), vec!["student", "teacher"]);

    // Bad `artifact.type` → SchemaViolation, target kept with default artifact.
    let student = &lesson.targets[0];
    assert_eq!(
        student.artifact,
        Artifact::SingleFile {
            filepath: PathBuf::from("build/student.pdf"),
        }
    );

    // Bad step `type` → the step is skipped; the file-tree artifact survives and
    // the empty step list falls back to the default step.
    let teacher = &lesson.targets[1];
    assert_eq!(
        teacher.artifact,
        Artifact::FileTree {
            root: PathBuf::from("build/teacher"),
            outputs: "**/*.html".to_string(),
        }
    );
    assert_eq!(
        teacher.steps,
        vec![Step::TypstCompile {
            template: PathBuf::from("exports/teacher.typ"),
        }]
    );

    let violations: Vec<_> = diags
        .iter()
        .filter(|d| d.code == DiagCode::SchemaViolation)
        .collect();
    assert_eq!(
        violations.len(),
        2,
        "expected one SchemaViolation per malformed field, got: {diags:?}"
    );
    assert!(
        violations.iter().any(|d| d.message.contains("pdf-thing")),
        "a diagnostic should name the bad artifact type, got: {diags:?}"
    );
    assert!(
        violations
            .iter()
            .any(|d| d.message.contains("make-it-nice")),
        "a diagnostic should name the bad step type, got: {diags:?}"
    );
}