use nalgebra::DMatrix;
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use uuid::Uuid;

/// Helper for serializing maps with consistent ordering.
fn sort_alphabetically<T: Serialize, S: serde::Serializer>(
    value: &T,
    serializer: S,
) -> Result<S::Ok, S::Error> {
    let value = serde_json::to_value(value).map_err(serde::ser::Error::custom)?;
    value.serialize(serializer)
}

/// Metadata struct that contains common metadata for any instance.
#[derive(Serialize, Deserialize, Debug)]
pub struct Meta {
    /// Unique instance ID.
    pub id: Uuid,
    /// Instance name.
    pub name: String,
    /// Main category of this instance.
    pub kind: String,
    /// Instance labels.
    pub labels: Vec<String>,
    /// Numeric instance weights.
    #[serde(serialize_with = "sort_alphabetically")]
    pub weights: HashMap<String, f64>,
    /// Miscellaneous data fields for this instance.
    #[serde(serialize_with = "sort_alphabetically")]
    pub annotations: HashMap<String, String>,
}

impl Meta {
    /// Create a new Meta struct with arguments.
    pub fn new(
        id: Option<Uuid>,
        name: Option<String>,
        kind: Option<String>,
        labels: Option<Vec<String>>,
        weights: Option<HashMap<String, f64>>,
        annotations: Option<HashMap<String, String>>,
    ) -> Self {
        let this_id: Uuid = match id {
            None => Uuid::new_v4(),
            Some(x) => x,
        };
        Meta {
            id: this_id,
            name: match name {
                None => this_id.to_string(),
                Some(x) => x,
            },
            kind: match kind {
                None => String::from("default"),
                Some(x) => x,
            },
            labels: match labels {
                None => vec![],
                Some(x) => x,
            },
            weights: match weights {
                None => HashMap::<String, f64>::new(),
                Some(x) => x,
            },
            annotations: match annotations {
                None => HashMap::<String, String>::new(),
                Some(x) => x,
            },
        }
    }

    /// Create a new Meta struct with default arguments.
    pub fn default() -> Self {
        Meta::new(None, None, None, None, None, None)
    }
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Node {
    /// Unique instance ID.
    pub id: Uuid,
    /// Instance name.
    pub name: String,
    /// Main category of this instance.
    pub kind: String,
    /// Instance labels.
    pub labels: Vec<String>,
    /// Numeric instance weights.
    #[serde(serialize_with = "sort_alphabetically")]
    pub weights: HashMap<String, f64>,
    /// Miscellaneous data fields for this instance.
    #[serde(serialize_with = "sort_alphabetically")]
    pub annotations: HashMap<String, String>,
    /// ID of the parent of this node, if any.
    pub parent: Option<Uuid>,
    /// IDs of this node's children,
    pub children: Vec<Uuid>,
    /// Whether this node is a bus node for its parent.
    pub is_bus: bool,
}

impl Node {
    /// Create a new node struct with arguments.
    pub fn new(
        id: Option<Uuid>,
        name: Option<String>,
        kind: Option<String>,
        labels: Option<Vec<String>>,
        weights: Option<HashMap<String, f64>>,
        annotations: Option<HashMap<String, String>>,
        parent: Option<Uuid>,
        children: Option<Vec<Uuid>>,
        is_bus: Option<bool>,
    ) -> Self {
        let Meta {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
        } = Meta::new(id, name, kind, labels, weights, annotations);

        Node {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
            parent,
            children: match children {
                None => vec![],
                Some(x) => x,
            },
            is_bus: match is_bus {
                None => false,
                Some(x) => x,
            },
        }
    }

    /// Create a new Node struct with default arguments.
    pub fn default() -> Self {
        Node::new(None, None, None, None, None, None, None, None, None)
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Edge {
    /// Unique instance ID.
    pub id: Uuid,
    /// Instance name.
    pub name: String,
    /// Main category of this instance.
    pub kind: String,
    /// Instance labels.
    pub labels: Vec<String>,
    /// Numeric instance weights.
    #[serde(serialize_with = "sort_alphabetically")]
    pub weights: HashMap<String, f64>,
    /// Miscellaneous data fields for this instance.
    #[serde(serialize_with = "sort_alphabetically")]
    pub annotations: HashMap<String, String>,
    /// Source node ID.
    pub source: Uuid,
    /// Target node ID.
    pub target: Uuid,
}

impl Edge {
    /// Create a new edge struct with arguments.
    pub fn new(
        id: Option<Uuid>,
        name: Option<String>,
        kind: Option<String>,
        labels: Option<Vec<String>>,
        weights: Option<HashMap<String, f64>>,
        annotations: Option<HashMap<String, String>>,
        source: Uuid,
        target: Uuid,
    ) -> Self {
        let Meta {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
        } = Meta::new(id, name, kind, labels, weights, annotations);
        Edge {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
            source,
            target,
        }
    }

    pub fn default() -> (Self, Node, Node) {
        let source = Node::default();
        let target = Node::default();
        (
            Edge::new(
                None,
                None,
                None,
                None,
                None,
                None,
                source.id.clone(),
                target.id.clone(),
            ),
            source,
            target,
        )
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Graph {
    /// Unique instance ID.
    pub id: Uuid,
    /// Instance name.
    pub name: String,
    /// Main category of this instance.
    pub kind: String,
    /// Instance labels.
    pub labels: Vec<String>,
    /// Numeric instance weights.
    #[serde(serialize_with = "sort_alphabetically")]
    pub weights: HashMap<String, f64>,
    /// Miscellaneous data fields for this instance.
    #[serde(serialize_with = "sort_alphabetically")]
    pub annotations: HashMap<String, String>,
    /// Nodes by their IDs.
    #[serde(serialize_with = "sort_alphabetically")]
    pub nodes: HashMap<Uuid, Node>,
    /// Edges by their IDs.
    #[serde(serialize_with = "sort_alphabetically")]
    pub edges: HashMap<Uuid, Edge>,
    /// Edges mapped from source ID, to target ID, to a Vec of edge IDs.
    #[serde(serialize_with = "sort_alphabetically")]
    _edges_forward: HashMap<Uuid, HashMap<Uuid, Vec<Uuid>>>,
    /// Edges mapped from target ID, to source ID, to a Vec of edge IDs.
    #[serde(serialize_with = "sort_alphabetically")]
    _edges_reverse: HashMap<Uuid, HashMap<Uuid, Vec<Uuid>>>,
}

impl Graph {
    /// Create a new graph instance with arguments.
    pub fn new(
        id: Option<Uuid>,
        name: Option<String>,
        kind: Option<String>,
        labels: Option<Vec<String>>,
        weights: Option<HashMap<String, f64>>,
        annotations: Option<HashMap<String, String>>,
        nodes: Option<Vec<Node>>,
        edges: Option<Vec<Edge>>,
    ) -> Self {
        let Meta {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
        } = Meta::new(id, name, kind, labels, weights, annotations);
        let mut graph = Graph {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
            nodes: HashMap::<Uuid, Node>::new(),
            edges: HashMap::<Uuid, Edge>::new(),
            _edges_forward: HashMap::<Uuid, HashMap<Uuid, Vec<Uuid>>>::new(),
            _edges_reverse: HashMap::<Uuid, HashMap<Uuid, Vec<Uuid>>>::new(),
        };
        if let Some(ns) = nodes {
            graph.add_nodes(ns, true)
        }
        if let Some(es) = edges {
            graph.add_edges(es, true);
        }
        graph
    }

    /// Create a new graph instance with default arguments.
    pub fn default() -> Self {
        Graph::new(None, None, None, None, None, None, None, None)
    }

    /// Update the forward edge map..
    pub fn update_edges_forward(&mut self) {
        self._edges_forward = {
            let mut map = HashMap::<Uuid, HashMap<Uuid, Vec<Uuid>>>::new();
            for edge in self.edges.values() {
                let id = edge.id.to_owned();
                let source = edge.source.to_owned();
                let target = edge.target.to_owned();
                map.entry(source.to_owned())
                    .or_insert(HashMap::<Uuid, Vec<Uuid>>::new())
                    .entry(target.to_owned())
                    .or_insert(vec![])
                    .push(id.to_owned());
            }
            map
        }
    }

    /// Update the reverse edge map..
    pub fn update_edges_reverse(&mut self) {
        self._edges_reverse = {
            let mut map = HashMap::<Uuid, HashMap<Uuid, Vec<Uuid>>>::new();
            for edge in self.edges.values() {
                let id = edge.id.to_owned();
                let source = edge.source.to_owned();
                let target = edge.target.to_owned();
                map.entry(target.to_owned())
                    .or_insert(HashMap::<Uuid, Vec<Uuid>>::new())
                    .entry(source.to_owned())
                    .or_insert(vec![])
                    .push(id.to_owned());
            }
            map
        }
    }

    /// Update edge maps.
    pub fn update_edge_maps(&mut self) {
        self.update_edges_forward();
        self.update_edges_reverse();
    }

    /// Whether a node ID exists in the graph.
    pub fn has_node(&self, id: &Uuid) -> bool {
        self.nodes.contains_key(&id)
    }

    /// Whether an edge ID exists in the graph.
    pub fn has_edge(&self, id: &Uuid) -> bool {
        self.edges.contains_key(&id)
    }

    /// Add a single node.
    pub fn add_node(&mut self, node: Node, safe: bool) {
        let id = node.id.to_owned();
        self.nodes.insert(id.to_owned(), node);
        if safe {
            self.check_node(&id);
        }
    }

    /// Add multiple nodes.
    pub fn add_nodes(&mut self, nodes: Vec<Node>, safe: bool) {
        let mut ids = vec![];
        for n in nodes {
            ids.push(n.id.to_owned());
            self.add_node(n, false);
        }
        if safe {
            for id in ids {
                self.check_node(&id);
            }
        }
    }

    /// Check whether a node's references exist.
    pub fn check_node(&self, id: &Uuid) {
        if let Some(node) = self.nodes.get(&id) {
            if let Some(parent_id) = node.parent {
                if !self.has_node(&parent_id) {
                    panic!("Parent node doesn't exist in this graph.");
                }
            }
            for child_id in node.children.iter() {
                if !self.has_node(&child_id) {
                    panic!("Child node doesn't exist in this graph.");
                }
            }
            if node.is_bus {
                match node.parent {
                    None => panic!("Node is a bus without a parent."),
                    Some(_) => (),
                };
            }
        } else {
            panic!("Node should exist!");
        }
    }

    /// Set parent value for a node.
    pub fn set_parent(&mut self, child_id: &Uuid, parent_id: Option<&Uuid>) {
        if !self.has_node(&child_id) {
            return;
        }
        // Remove child from current parent
        if let Some(child) = self.nodes.get(child_id) {
            if let Some(current_parent_id) = child.parent {
                if let Some(current_parent) = self.nodes.get_mut(&current_parent_id) {
                    current_parent.children.retain(|x| x != child_id);
                }
            }
        }

        // Unset current parent.
        if let Some(child) = self.nodes.get_mut(child_id) {
            child.parent = None;
        }

        // Set new parent.
        if let Some(p_id) = parent_id {
            if self.has_node(p_id) {
                if let Some(child) = self.nodes.get_mut(child_id) {
                    child.parent = Some(p_id.to_owned());
                }
                if let Some(parent) = self.nodes.get_mut(p_id) {
                    parent.children.push(child_id.to_owned());
                }
            } else {
                if let Some(child) = self.nodes.get_mut(child_id) {
                    child.is_bus = false;
                }
            }
        }
    }

    /**
    Set the is_bus value of a node. Will only ever be set to `true` is it has a parent
    node to be a bus for.
    */
    pub fn set_bus(&mut self, child_id: &Uuid, is_bus: bool) {
        if let Some(child) = self.nodes.get_mut(child_id) {
            match child.parent {
                None => child.is_bus = false,
                Some(_) => child.is_bus = is_bus,
            };
        }
    }

    /// Add a single edge.
    pub fn add_edge(&mut self, edge: Edge, safe: bool) {
        let id = edge.id.to_owned();
        let source = edge.source.to_owned();
        let target = edge.target.to_owned();
        self._edges_forward
            .entry(source.to_owned())
            .or_insert(HashMap::<Uuid, Vec<Uuid>>::new())
            .entry(target.to_owned())
            .or_insert(vec![])
            .push(id.to_owned());
        self._edges_reverse
            .entry(source)
            .or_insert(HashMap::<Uuid, Vec<Uuid>>::new())
            .entry(target)
            .or_insert(vec![])
            .push(id.to_owned());
        self.edges.insert(id.to_owned(), edge);
        if safe {
            self.check_edge(&id);
        }
    }

    /// Add multiple edges.
    pub fn add_edges(&mut self, edges: Vec<Edge>, safe: bool) {
        for e in edges {
            self.add_edge(e, safe);
        }
    }

    /// Check whether an edge's references exist.
    pub fn check_edge(&self, id: &Uuid) {
        if let Some(edge) = self.edges.get(id) {
            if !self.has_node(&edge.source) {
                panic!("Source node should exist in the graph.");
            }
            if !self.has_node(&edge.target) {
                panic!("Target node should exist in the graph.");
            }
        } else {
            panic!("Edge should exist!");
        }
    }

    /// Get the adjacency matrix for this graph.
    pub fn get_adjacency_matrix(
        &self,
        sources: Option<Vec<Uuid>>,
        targets: Option<Vec<Uuid>>,
        aggregator: &Aggregator,
        fields: Option<&HashSet<String>>,
    ) -> DMatrix<f64> {
        let _sources: Vec<Uuid> = match sources {
            None => {
                let mut vec: Vec<Uuid> = self.nodes.keys().map(|x| x.to_owned()).collect();
                vec.sort();
                vec
            }
            Some(srcs) => srcs,
        };
        let _targets = match targets {
            None => _sources.clone(),
            Some(tgts) => tgts,
        };

        let mut adj = DMatrix::<f64>::zeros(_sources.len(), _targets.len());

        for (col, source) in _sources.iter().enumerate() {
            if !self._edges_forward.contains_key(source) {
                continue;
            }
            let tgt_map = self._edges_forward.get(source).unwrap();
            for (row, target) in _targets.iter().enumerate() {
                if !tgt_map.contains_key(target) {
                    continue;
                }
                let edges: Vec<&Edge> = tgt_map
                    .get(target)
                    .unwrap()
                    .iter()
                    .map(|x| self.edges.get(x).unwrap())
                    .collect();
                adj[(row, col)] = get_aggregate(&edges, &aggregator, &fields);
            }
        }

        adj
    }
}

pub enum Aggregator {
    Kinds,
    Labels,
    Weights,
    Annotations,
}

pub trait Metadata {
    fn get_meta(&self) -> Meta;
}

impl Metadata for Meta {
    fn get_meta(&self) -> Meta {
        Meta {
            id: self.id.to_owned(),
            name: self.name.clone(),
            kind: self.kind.clone(),
            labels: self.labels.clone(),
            weights: self.weights.clone(),
            annotations: self.annotations.clone(),
        }
    }
}

impl Metadata for Node {
    fn get_meta(&self) -> Meta {
        Meta {
            id: self.id.to_owned(),
            name: self.name.clone(),
            kind: self.kind.clone(),
            labels: self.labels.clone(),
            weights: self.weights.clone(),
            annotations: self.annotations.clone(),
        }
    }
}
impl Metadata for Edge {
    fn get_meta(&self) -> Meta {
        Meta {
            id: self.id.to_owned(),
            name: self.name.clone(),
            kind: self.kind.clone(),
            labels: self.labels.clone(),
            weights: self.weights.clone(),
            annotations: self.annotations.clone(),
        }
    }
}

impl Metadata for Graph {
    fn get_meta(&self) -> Meta {
        Meta {
            id: self.id.to_owned(),
            name: self.name.clone(),
            kind: self.kind.clone(),
            labels: self.labels.clone(),
            weights: self.weights.clone(),
            annotations: self.annotations.clone(),
        }
    }
}

pub fn get_aggregate(
    objects: &Vec<&impl Metadata>,
    aggregator: &Aggregator,
    fields: &Option<&HashSet<String>>,
) -> f64 {
    get_aggregates(objects, aggregator, fields).values().sum()
}

pub fn get_aggregates(
    objects: &Vec<&impl Metadata>,
    aggregator: &Aggregator,
    fields: &Option<&HashSet<String>>,
) -> HashMap<String, f64> {
    let mut map = HashMap::<String, f64>::new();

    match aggregator {
        Aggregator::Kinds => {
            for obj in objects.iter() {
                let meta = obj.get_meta();
                if let Some(fs) = fields {
                    if !fs.contains(&meta.kind) {
                        continue;
                    }
                }
                *map.entry(meta.kind.clone()).or_insert(0.0) += 1.0;
            }
        }
        Aggregator::Labels => {
            for obj in objects.iter() {
                let meta = obj.get_meta();
                if let Some(fs) = fields {
                    for label in meta.labels.iter() {
                        if !fs.contains(label) {
                            continue;
                        }
                        *map.entry(label.clone()).or_insert(0.0) += 1.0;
                    }
                } else {
                    for label in meta.labels.iter() {
                        *map.entry(label.clone()).or_insert(0.0) += 1.0;
                    }
                }
            }
        }
        Aggregator::Annotations => {
            for obj in objects.iter() {
                let meta = obj.get_meta();
                if let Some(fs) = fields {
                    for key in meta.annotations.keys() {
                        if !fs.contains(key) {
                            continue;
                        }
                        *map.entry(key.clone()).or_insert(0.0) += 1.0;
                    }
                } else {
                    for key in meta.annotations.keys() {
                        *map.entry(key.clone()).or_insert(0.0) += 1.0;
                    }
                }
            }
        }
        Aggregator::Weights => {
            for obj in objects.iter() {
                let meta = obj.get_meta();
                if let Some(fs) = fields {
                    for (key, value) in meta.weights.iter() {
                        if !fs.contains(key) {
                            continue;
                        }
                        *map.entry(key.clone()).or_insert(0.0) += value;
                    }
                } else {
                    for (key, value) in meta.weights.iter() {
                        *map.entry(key.clone()).or_insert(0.0) += value;
                    }
                }
            }
        }
    };

    map
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;
    use serde_json::to_string;
    use uuid::uuid;
    #[test]
    fn test_meta() {
        let name = String::from("Hello meta");
        let id = Uuid::new_v4();
        let kind = String::from("default");
        let labels = vec![String::from("default")];
        let weights = HashMap::<String, f64>::new();
        let annotations = HashMap::<String, String>::new();
        let m1 = Meta {
            id,
            name,
            kind,
            labels,
            weights,
            annotations,
        };
        let m2 = Meta::new(
            Some(m1.id.to_owned()),
            Some(m1.name.to_owned()),
            Some(m1.kind.to_owned()),
            Some(m1.labels.to_owned()),
            None,
            None,
        );
        let s1 = to_string(&m1).unwrap();
        let s2 = to_string(&m2).unwrap();
        assert_eq!(s1, s2);
    }

    #[test]
    fn test_node() {
        let mut node = Node::default();
        node.id = uuid!("00000000-0000-0000-0000-000000000000");
        node.name = "test".to_string();
        let ser = to_string(&node).unwrap();
        assert_eq!(
            ser,
            r#"{"id":"00000000-0000-0000-0000-000000000000","name":"test","kind":"default","labels":[],"weights":{},"annotations":{},"parent":null,"children":[],"isBus":false}"#
        );
    }

    #[test]
    fn test_edge() {
        let (mut edge, _, _) = Edge::default();
        edge.id = uuid!("00000000-0000-0000-0000-000000000000");
        edge.source = uuid!("00000000-0000-0000-0000-000000000001");
        edge.target = uuid!("00000000-0000-0000-0000-000000000002");
        edge.name = "test".to_string();
        let ser = to_string(&edge).unwrap();
        assert_eq!(
            ser,
            r#"{"id":"00000000-0000-0000-0000-000000000000","name":"test","kind":"default","labels":[],"weights":{},"annotations":{},"source":"00000000-0000-0000-0000-000000000001","target":"00000000-0000-0000-0000-000000000002"}"#
        );
    }

    #[test]
    fn test_graph() {
        let mut graph = Graph::default();
        graph.id = uuid!("00000000-0000-0000-0000-000000000000");
        graph.name = "test".to_string();
        let ser = to_string(&graph).unwrap();
        assert_eq!(
            ser,
            r#"{"id":"00000000-0000-0000-0000-000000000000","name":"test","kind":"default","labels":[],"weights":{},"annotations":{},"nodes":{},"edges":{},"_edges_forward":{},"_edges_reverse":{}}"#
        );
        let source = Node {
            id: uuid!("a0000000-0000-0000-0000-000000000001"),
            name: "source".to_string(),
            ..Node::default()
        };
        let target = Node {
            id: uuid!("a0000000-0000-0000-0000-000000000002"),
            name: "target".to_string(),
            ..Node::default()
        };
        let edge1 = Edge {
            source: source.id.to_owned(),
            target: target.id.to_owned(),
            id: uuid!("e0000000-0000-0000-0000-000000000001"),
            name: "edge1".to_string(),
            weights: HashMap::from([
                ("adjacency".to_string(), 1.0),
                ("energy".to_string(), 0.5),
                ("spatial".to_string(), 0.5),
            ]),
            ..Edge::default().0
        };
        let edge2 = Edge {
            source: target.id.to_owned(),
            target: source.id.to_owned(),
            id: uuid!("e0000000-0000-0000-0000-000000000002"),
            name: "edge2".to_string(),
            kind: "reverse".to_string(),
            weights: HashMap::from([
                ("adjacency".to_string(), 2.0),
                ("energy".to_string(), 1.5),
                ("spatial".to_string(), 0.5),
            ]),
            ..Edge::default().0
        };
        let edge3 = Edge {
            source: source.id.to_owned(),
            target: target.id.to_owned(),
            id: uuid!("e0000000-0000-0000-0000-000000000003"),
            name: "edge3".to_string(),
            weights: HashMap::from([
                ("adjacency".to_string(), 3.0),
                ("energy".to_string(), 2.0),
                ("spatial".to_string(), 1.0),
            ]),
            ..Edge::default().0
        };
        graph.add_nodes(vec![source, target], true);
        graph.add_edges(vec![edge1, edge2, edge3], true);
        assert_eq!(
            to_string(&graph).unwrap(),
            r#"{"id":"00000000-0000-0000-0000-000000000000","name":"test","kind":"default","labels":[],"weights":{},"annotations":{},"nodes":{"a0000000-0000-0000-0000-000000000001":{"annotations":{},"children":[],"id":"a0000000-0000-0000-0000-000000000001","isBus":false,"kind":"default","labels":[],"name":"source","parent":null,"weights":{}},"a0000000-0000-0000-0000-000000000002":{"annotations":{},"children":[],"id":"a0000000-0000-0000-0000-000000000002","isBus":false,"kind":"default","labels":[],"name":"target","parent":null,"weights":{}}},"edges":{"e0000000-0000-0000-0000-000000000001":{"annotations":{},"id":"e0000000-0000-0000-0000-000000000001","kind":"default","labels":[],"name":"edge1","source":"a0000000-0000-0000-0000-000000000001","target":"a0000000-0000-0000-0000-000000000002","weights":{"adjacency":1.0,"energy":0.5,"spatial":0.5}},"e0000000-0000-0000-0000-000000000002":{"annotations":{},"id":"e0000000-0000-0000-0000-000000000002","kind":"reverse","labels":[],"name":"edge2","source":"a0000000-0000-0000-0000-000000000002","target":"a0000000-0000-0000-0000-000000000001","weights":{"adjacency":2.0,"energy":1.5,"spatial":0.5}},"e0000000-0000-0000-0000-000000000003":{"annotations":{},"id":"e0000000-0000-0000-0000-000000000003","kind":"default","labels":[],"name":"edge3","source":"a0000000-0000-0000-0000-000000000001","target":"a0000000-0000-0000-0000-000000000002","weights":{"adjacency":3.0,"energy":2.0,"spatial":1.0}}},"_edges_forward":{"a0000000-0000-0000-0000-000000000001":{"a0000000-0000-0000-0000-000000000002":["e0000000-0000-0000-0000-000000000001","e0000000-0000-0000-0000-000000000003"]},"a0000000-0000-0000-0000-000000000002":{"a0000000-0000-0000-0000-000000000001":["e0000000-0000-0000-0000-000000000002"]}},"_edges_reverse":{"a0000000-0000-0000-0000-000000000001":{"a0000000-0000-0000-0000-000000000002":["e0000000-0000-0000-0000-000000000001","e0000000-0000-0000-0000-000000000003"]},"a0000000-0000-0000-0000-000000000002":{"a0000000-0000-0000-0000-000000000001":["e0000000-0000-0000-0000-000000000002"]}}}"#
        );

        let mat = graph.get_adjacency_matrix(None, None, &Aggregator::Weights, None);
        assert_eq!(
            mat,
            DMatrix::<f64>::from_vec(2, 2, vec![0.0, 8.0, 4.0, 0.0])
        );
        let mat2 = graph.get_adjacency_matrix(
            None,
            None,
            &Aggregator::Weights,
            Some(&HashSet::from(["spatial".to_string()])),
        );
        assert_eq!(
            mat2,
            DMatrix::<f64>::from_vec(2, 2, vec![0.0, 1.5, 0.5, 0.0])
        );
    }
}