use grapherity::algorithms;
use grapherity::models::AppendGraph;
use grapherity::traits::GraphTopology;

#[test]
fn dijkstra_single_vertex() {
    let mut graph = AppendGraph::new();
    let v1 = graph.add_vertex();
    let result = algorithms::dijkstra(&graph, v1);
    assert_eq!(
        result.distances.len(),
        1,
        "distances count must equal vertex count"
    );
    assert_eq!(
        result.predecessors.len(),
        1,
        "predecessors count must equal vertex count"
    );
    assert_eq!(
        result.distances[0],
        Some(0),
        "unexpected distance of source vertex"
    );
    assert_eq!(
        result.predecessors[0], None,
        "unexpected predecessor of source vertex",
    );
}

#[test]
fn dijkstra_disconnected() {
    let mut graph = AppendGraph::new();
    let v1 = graph.add_vertex();
    graph.add_vertex();
    let result = algorithms::dijkstra(&graph, v1);
    assert_eq!(
        result.distances.len(),
        2,
        "distances count must equal vertex count"
    );
    assert_eq!(
        result.predecessors.len(),
        2,
        "predecessors count must equal vertex count"
    );
    assert_eq!(
        result.distances[1], None,
        "unexpected distance of disconnected vertex"
    );
    assert_eq!(
        result.predecessors[0], None,
        "unexpected predecessor of disconnected vertex",
    );
}

#[test]
fn dijkstra() {
    let (graph, vertices) = make_test_graph();
    let result = algorithms::dijkstra(&graph, vertices[0]);
    let expected_distances_from_v0 = [
        Some(0),
        Some(1),
        Some(2),
        Some(2),
        Some(2),
        Some(3),
        Some(3),
        Some(3),
        Some(3),
        Some(4),
    ];
    let expected_predecessors_from_v0 = [
        vec![None],
        vec![Some(vertices[0])],
        vec![Some(vertices[1])],
        vec![Some(vertices[1])],
        vec![Some(vertices[1])],
        vec![Some(vertices[2])],
        vec![Some(vertices[2]), Some(vertices[3])],
        vec![Some(vertices[4])],
        vec![Some(vertices[4])],
        vec![Some(vertices[5]), Some(vertices[6]), Some(vertices[7])],
    ];
    assert_eq!(
        result.distances.len(),
        graph.vertex_count(),
        "distances count must equal vertex count"
    );
    assert_eq!(
        result.predecessors.len(),
        graph.vertex_count(),
        "predecessors count must equal vertex count"
    );
    for i in 0..graph.vertex_count() {
        assert_eq!(
            result.distances[i], expected_distances_from_v0[i],
            "unexpected distance from {:?} to {:?}",
            vertices[0], vertices[i]
        );
        assert!(
            expected_predecessors_from_v0[i].contains(&result.predecessors[i]),
            "unexpected predecessor {:?} of {:?}",
            result.predecessors[i],
            vertices[i]
        );
    }
}

#[test]
fn dijkstra_distances_single_vertex() {
    let mut graph = AppendGraph::new();
    let v1 = graph.add_vertex();
    let distances = algorithms::dijkstra_distances(&graph, v1);
    assert_eq!(distances.len(), 1, "distances count must equal vertex count");
    assert_eq!(distances[0], Some(0), "unexpected distance of source vertex");
}

#[test]
fn dijkstra_distances_disconnected() {
    let mut graph = AppendGraph::new();
    let v1 = graph.add_vertex();
    graph.add_vertex();
    let distances = algorithms::dijkstra_distances(&graph, v1);
    assert_eq!(distances.len(), 2, "distances count must equal vertex count");
    assert_eq!(distances[1], None, "unexpected distance of disconnected vertex");
}

#[test]
fn dijkstra_distances() {
    let (graph, vertices) = make_test_graph();
    let distances = algorithms::dijkstra_distances(&graph, vertices[0]);
    let expected_distances_from_v0 = [
        Some(0),
        Some(1),
        Some(2),
        Some(2),
        Some(2),
        Some(3),
        Some(3),
        Some(3),
        Some(3),
        Some(4),
    ];
    assert_eq!(
        distances.len(),
        graph.vertex_count(),
        "distances count must equal vertex count"
    );
    for i in 0..graph.vertex_count() {
        assert_eq!(
            distances[i], expected_distances_from_v0[i],
            "unexpected distance from {:?} to {:?}",
            vertices[0], vertices[i]
        );
    }
}

fn make_test_graph() -> (AppendGraph, [<AppendGraph as GraphTopology>::Vertex; 10]) {
    let mut graph = AppendGraph::new();
    let vertices = core::array::from_fn::<_, 10, _>(|_| graph.add_vertex());
    graph.add_edge(vertices[0], vertices[1]);
    graph.add_edge(vertices[1], vertices[2]);
    graph.add_edge(vertices[1], vertices[3]);
    graph.add_edge(vertices[1], vertices[4]);
    graph.add_edge(vertices[2], vertices[4]);
    graph.add_edge(vertices[2], vertices[5]);
    graph.add_edge(vertices[2], vertices[6]);
    graph.add_edge(vertices[3], vertices[6]);
    graph.add_edge(vertices[4], vertices[7]);
    graph.add_edge(vertices[4], vertices[8]);
    graph.add_edge(vertices[5], vertices[9]);
    graph.add_edge(vertices[6], vertices[9]);
    graph.add_edge(vertices[7], vertices[8]);
    graph.add_edge(vertices[7], vertices[9]);
    (graph, vertices)
}