use std::fmt::Debug;
use std::hash::Hash;

use grapherity::algorithms;
use grapherity::algorithms::DijkstraResult;
use grapherity::maps::ElementMap;
use grapherity::testing::fixtures;
use grapherity::testing::fixtures::MakeTestGraph;
use grapherity::traits::{GraphTopology, Incidence};

macro_rules! dijkstra_tests {
    ($T:ty) => {
        dijkstra_tests!(@wrap $T,
            dijkstra_single_vertex,
            dijkstra_disconnected,
            dijkstra_zero_weight_loop,
            dijkstra,
            dijkstra_distances,
            dijkstra_unweighted_single_vertex,
            dijkstra_unweighted_disconnected,
            dijkstra_unweighted,
            dijkstra_distances_unweighted_single_vertex,
            dijkstra_distances_unweighted_disconnected,
            dijkstra_distances_unweighted,
        );
    };

    (@wrap $T:ty, $($name:ident),* $(,)?) => {
        $(
            #[test]
            fn $name() {
                super::$name::<$T>();
            }
        )*
    };
}

mod append_graph {
    use grapherity::models::AppendGraph;

    dijkstra_tests!(AppendGraph);
}

mod graph {
    use grapherity::models::Graph;

    dijkstra_tests!(Graph);
}

fn dijkstra_single_vertex<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, v) = G::single_vertex();
    let result = algorithms::dijkstra(&graph, v, |_| panic!("unexpected call of weight functor"));
    assert_single_vertex::<G>(&result, v);
}

fn dijkstra_disconnected<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices) = G::disconnected();
    let result = algorithms::dijkstra(&graph, vertices[0], |_| {
        panic!("unexpected call of weight functor")
    });
    assert_single_vertex::<G>(&result, vertices[0]);
    assert_disconnected::<G>(&result, &vertices[1..3]);
}

fn dijkstra_zero_weight_loop<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices, _, weights) = make_two_edge_path_with_zero_weight_loops::<G>();
    let result = algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
    assert_single_vertex::<G>(&result, vertices[0]);
    for i in 1..3 {
        assert_eq!(
            result.predecessors[vertices[i]],
            Some(vertices[i - 1]),
            "unexpected predecessor of vertex {:?}",
            vertices[i]
        );
        assert_eq!(
            result.distances[vertices[i]],
            Some(i.try_into().unwrap()),
            "unexpected distance of vertex {:?}",
            vertices[i]
        );
    }
}

fn dijkstra<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices, _, _, weights) = make_standard_weighted::<G>();
    let result = algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
    assert_standard_weighted_distances_v0::<G>(&result.distances, &vertices);
    assert_standard_weighted_predecessors_v0::<G>(&result.predecessors, &vertices);
}

fn dijkstra_distances<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices, _, _, weights) = make_standard_weighted::<G>();
    let distances = algorithms::dijkstra_distances(&graph, vertices[0], |e| weights[e]);
    assert_standard_weighted_distances_v0::<G>(&distances, &vertices);
}

fn dijkstra_unweighted_single_vertex<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, v) = G::single_vertex();
    let result = algorithms::dijkstra_unweighted(&graph, v);
    assert_single_vertex::<G>(&result, v)
}

fn dijkstra_unweighted_disconnected<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices) = G::disconnected();
    let result = algorithms::dijkstra_unweighted(&graph, vertices[0]);
    assert_single_vertex::<G>(&result, vertices[0]);
    assert_disconnected::<G>(&result, &vertices[1..3]);
}

fn dijkstra_unweighted<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices, _, _) = G::standard();
    let result = algorithms::dijkstra_unweighted(&graph, vertices[0]);
    fixtures::assert_standard_unweighted_distances_v0(|v| result.distances[v], &vertices);
    fixtures::assert_standard_unweighted_predecessors_v0(&result.predecessors, &vertices);
}

fn dijkstra_distances_unweighted_single_vertex<G: MakeTestGraph>()
where
    G::Vertex: Hash,
{
    let (graph, v) = G::single_vertex();
    let distances = algorithms::dijkstra_distances_unweighted(&graph, v);
    assert_distances_single_vertex::<G>(&distances, v);
}

fn dijkstra_distances_unweighted_disconnected<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices) = G::disconnected();
    let distances = algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
    assert_distances_single_vertex::<G>(&distances, vertices[0]);
    assert_distances_disconnected::<G>(&distances, &vertices[1..3]);
}

fn dijkstra_distances_unweighted<G: MakeTestGraph>()
where
    G::Vertex: Debug + Hash,
{
    let (graph, vertices, _, _) = G::standard();
    let distances = algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
    fixtures::assert_standard_unweighted_distances_v0(|v| distances[v], &vertices);
}

fn assert_single_vertex<G: GraphTopology>(result: &DijkstraResult<G::Vertex>, v: G::Vertex)
where
    G::Vertex: Debug,
{
    assert_distances_single_vertex::<G>(&result.distances, v);
    assert_eq!(
        result.predecessors[v], None,
        "unexpected predecessor of source vertex",
    );
}

fn assert_distances_single_vertex<G: GraphTopology>(
    distances: &ElementMap<G::Vertex, Option<u32>>,
    v: G::Vertex,
) {
    assert_eq!(
        distances[v],
        Some(0),
        "unexpected distance of source vertex"
    );
}

fn assert_disconnected<G: GraphTopology>(result: &DijkstraResult<G::Vertex>, vertices: &[G::Vertex])
where
    G::Vertex: Debug,
{
    assert_distances_disconnected::<G>(&result.distances, &vertices);
    for &v in vertices {
        assert_eq!(
            result.predecessors[v], None,
            "unexpected predecessor of disconnected vertex {v:?}",
        );
    }
}

fn assert_distances_disconnected<G: GraphTopology>(
    distances: &ElementMap<G::Vertex, Option<u32>>,
    vertices: &[G::Vertex],
) where
    G::Vertex: Debug,
{
    for &v in vertices {
        assert_eq!(
            distances[v], None,
            "unexpected distance of disconnected vertex {v:?}",
        );
    }
}

fn assert_standard_weighted_predecessors_v0<G: GraphTopology>(
    actual: &ElementMap<G::Vertex, Option<G::Vertex>>,
    vertices: &[G::Vertex],
) where
    G::Vertex: Debug,
{
    let expected = [
        vec![None],
        vec![Some(vertices[0])],
        vec![Some(vertices[4])],
        vec![Some(vertices[1])],
        vec![Some(vertices[7])],
        vec![Some(vertices[9])],
        vec![Some(vertices[3])],
        vec![Some(vertices[9])],
        vec![Some(vertices[7])],
        vec![Some(vertices[6])],
    ];
    for i in 0..10 {
        assert!(
            expected[i].contains(&actual[vertices[i]]),
            "unexpected predecessor {:?} of {:?}",
            actual[vertices[i]],
            vertices[i]
        );
    }
}

fn assert_standard_weighted_distances_v0<G: GraphTopology>(
    actual: &ElementMap<G::Vertex, Option<u32>>,
    vertices: &[G::Vertex],
) where
    G::Vertex: Debug,
{
    let expected = [
        Some(0),
        Some(1),
        Some(65),
        Some(4),
        Some(58),
        Some(43),
        Some(14),
        Some(46),
        Some(145),
        Some(29),
    ];
    for i in 0..10 {
        assert_eq!(
            actual[vertices[i]], expected[i],
            "unexpected distance from {:?} to {:?}",
            vertices[0], vertices[i]
        );
    }
}

fn make_standard_weighted<G: MakeTestGraph>() -> (
    G,
    [G::Vertex; 10],
    [(G::Edge, G::Vertex, G::Vertex); 18],
    [Vec<Incidence<G::Vertex, G::Edge>>; 10],
    ElementMap<G::Edge, u32>,
) {
    let (graph, vertices, edges, incidences) = G::standard();
    let mut weights = graph.edge_map(99);
    for i in [1, 3, 7, 10, 12, 14, 15, 17] {
        weights[edges[i].0] = i.try_into().unwrap();
    }
    (graph, vertices, edges, incidences, weights)
}

fn make_two_edge_path_with_zero_weight_loops<G: MakeTestGraph>()
-> (G, [G::Vertex; 3], [G::Edge; 4], ElementMap<G::Edge, u32>) {
    let (graph, vertices, edges) = G::two_edge_path_with_loops();
    let mut weights = graph.edge_map(1);
    weights[edges[2]] = 0;
    weights[edges[3]] = 0;
    (graph, vertices, edges, weights)
}