use std::fs;

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct BoundaryRuntimePrerequisitesDecision {
    #[serde(rename = "decisionDate")]
    decision_date: String,
    scope: String,
    #[serde(rename = "startingState")]
    starting_state: StartingState,
    #[serde(rename = "comparisonMatrix")]
    comparison_matrix: Vec<ComparisonEntry>,
    #[serde(rename = "selectedDirection")]
    selected_direction: SelectedDirection,
    #[serde(rename = "holdReasons")]
    hold_reasons: Vec<String>,
    notes: Vec<String>,
}

#[derive(Debug, Deserialize)]
struct StartingState {
    #[serde(rename = "boundaryClosed")]
    boundary_closed: Vec<String>,
    #[serde(rename = "boundaryHeld")]
    boundary_held: Vec<String>,
    #[serde(rename = "mainlineClosed")]
    mainline_closed: Vec<String>,
    #[serde(rename = "deferredOutOfScope")]
    deferred_out_of_scope: Vec<String>,
}

#[derive(Debug, Deserialize)]
struct ComparisonEntry {
    direction: String,
    #[serde(rename = "blockedCapability")]
    blocked_capability: String,
    #[serde(rename = "isolationCost")]
    isolation_cost: String,
    decision: String,
    reason: String,
}

#[derive(Debug, Deserialize)]
struct SelectedDirection {
    direction: String,
    #[serde(rename = "nextDesign")]
    next_design: String,
    #[serde(rename = "nextPlan")]
    next_plan: String,
}

#[test]
fn boundary_runtime_prerequisites_roadmap_selects_one_direction() {
    let decision: BoundaryRuntimePrerequisitesDecision = serde_json::from_str(
        &fs::read_to_string(
            "tests/fixtures/generated_scene/boundary_runtime_prerequisites_decision_2026-04-19.json",
        )
        .unwrap(),
    )
    .unwrap();

    assert_eq!(decision.decision_date, "2026-04-19");
    assert_eq!(decision.scope, "boundary-runtime-prerequisites-roadmap");
    assert_eq!(decision.starting_state.boundary_closed, vec!["G7"]);
    assert_eq!(decision.starting_state.boundary_held, vec!["G6", "G8"]);
    assert_eq!(
        decision.starting_state.mainline_closed,
        vec!["G1-E", "G2", "G3"]
    );
    assert_eq!(
        decision.starting_state.deferred_out_of_scope,
        vec!["G4", "G5"]
    );

    assert_eq!(decision.comparison_matrix.len(), 2);
    assert_eq!(
        decision
            .comparison_matrix
            .iter()
            .filter(|entry| entry.decision == "selected")
            .count(),
        1
    );
    assert!(decision
        .comparison_matrix
        .iter()
        .any(|entry| entry.direction == "G6-host-bridge-prerequisites"
            && entry.decision == "selected"
            && entry.isolation_cost == "medium"));
    assert!(decision
        .comparison_matrix
        .iter()
        .any(|entry| entry.direction == "G8-local-doc-prerequisites"
            && entry.decision == "hold"
            && entry.isolation_cost == "high"));

    assert_eq!(
        decision.selected_direction.direction,
        "G6-host-bridge-prerequisites"
    );
    assert!(decision
        .selected_direction
        .next_design
        .ends_with("2026-04-19-g6-host-bridge-prerequisites-design.md"));
    assert!(decision
        .selected_direction
        .next_plan
        .ends_with("2026-04-19-g6-host-bridge-prerequisites-plan.md"));

    assert_eq!(decision.hold_reasons.len(), 1);
    assert!(!decision.notes.is_empty());
}