//! 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.
    for target in &lesson.targets {
        assert_eq!(target.artifact, cph_model::ArtifactKind::SingleFile);
        assert_eq!(target.numbering, None);
    }

    // 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::ArtifactKind;

    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 + heading numbering override, in order.
    let student = &lesson.targets[0];
    assert_eq!(student.name, "student");
    assert_eq!(student.artifact, ArtifactKind::SingleFile);
    let numbering = student
        .numbering
        .as_ref()
        .expect("student declares a numbering override");
    assert_eq!(
        numbering.heading.as_deref(),
        Some(
            &[
                "{1:一}、".to_string(),
                "{1:1}.{2:1}".to_string(),
                "{1:1}.{2:1}.{3:1}".to_string(),
            ][..]
        )
    );

    // archive: file-tree artifact, no presentation override.
    let archive = &lesson.targets[1];
    assert_eq!(archive.name, "archive");
    assert_eq!(archive.artifact, ArtifactKind::FileTree);
    assert_eq!(archive.numbering, None);

    // teacher: empty body → all defaults, numbering absent.
    let teacher = &lesson.targets[2];
    assert_eq!(teacher.name, "teacher");
    assert_eq!(teacher.artifact, ArtifactKind::SingleFile);
    assert_eq!(teacher.numbering, None);
}

#[test]
fn malformed_target_config_is_non_fatal_with_schema_violations() {
    use cph_model::ArtifactKind;

    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` value → SchemaViolation, target kept with default artifact.
    let student = &lesson.targets[0];
    assert_eq!(student.artifact, ArtifactKind::SingleFile);

    // Bad `numbering.heading` (not an array of strings) → heading stays None,
    // but the numbering table itself is present.
    let teacher = &lesson.targets[1];
    assert_eq!(teacher.artifact, ArtifactKind::FileTree);
    let teacher_numbering = teacher
        .numbering
        .as_ref()
        .expect("teacher declares a numbering table");
    assert_eq!(teacher_numbering.heading, None);

    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 value, got: {diags:?}"
    );
    assert!(
        violations
            .iter()
            .any(|d| d.message.contains("numbering.heading")),
        "a diagnostic should name the malformed numbering.heading, got: {diags:?}"
    );
}