wolf-graph 0.1.0

use wolf_graph::prelude::*;
use serde::{Deserialize, Serialize};

pub fn make_test_graph(edges: &[(EdgeID, NodeID, NodeID)]) -> BlankGraph {
    let mut graph = Graph::new();
    for edge in edges {
        let (edge, source, target) = edge;
        if !graph.has_node(source) {
            graph.add_node(source).unwrap();
        }
        if !graph.has_node(target) {
            graph.add_node(target).unwrap();
        }
        graph.add_edge(edge, source, target).unwrap();
    }
    graph
}

pub fn make_graph() -> BlankGraph {
    make_test_graph(&graph_edges())
}

pub fn make_dag() -> BlankGraph {
    make_test_graph(&dag_edges())
}

pub fn make_tree() -> BlankGraph {
    make_test_graph(&tree_edges())
}

pub fn make_test_string_graph(edges: &[(EdgeID, NodeID, NodeID)]) -> Graph<String, String, String> {
    let mut graph = Graph::new_with_data("G".to_string());
    for edge in edges {
        let (edge, source, target) = edge;
        if !graph.has_node(source) {
            graph.add_node_with_data(source, source.to_string()).unwrap();
        }
        if !graph.has_node(target) {
            graph.add_node_with_data(target, target.to_string()).unwrap();
        }
        graph.add_edge_with_data(edge, source, target, edge.to_string()).unwrap();
    }
    graph
}

pub fn make_string_graph() -> Graph<String, String, String> {
    make_test_string_graph(&graph_edges())
}

pub fn make_string_dag() -> Graph<String, String, String> {
    make_test_string_graph(&dag_edges())
}

pub fn make_string_tree() -> Graph<String, String, String> {
    make_test_string_graph(&tree_edges())
}

pub fn graph_edges() -> Vec<(EdgeID, NodeID, NodeID)> {
    let v = vec![
        ("AC", "A", "C"),
        ("AD", "A", "D"),
        ("AE", "A", "E"),
        ("BA", "B", "A"),
        ("BC", "B", "C"),
        ("BG", "B", "G"),
        ("CD", "C", "D"),
        ("ED", "E", "D"),
        ("FD", "F", "D"),
        ("FE", "F", "E"),
        ("HJ", "H", "J"),
        ("IC", "I", "C"),
        ("IK", "I", "K"),
        ("JA", "J", "A"),
        ("JE", "J", "E"),
        ("JF", "J", "F"),
        ("GI", "G", "I"), // back edge
        ("IB", "I", "B"), // back edge
    ];
    v.into_iter().map(|(a, b, c)| (eid!(a), nid!(b), nid!(c))).collect()
}

// http://magjac.com/graphviz-visual-editor/
/*
 digraph G {
 A [label="A"]
 B [label="B"]
 C [label="C"]
 D [label="D"]
 E [label="E"]
 F [label="F"]
 G [label="G"]
 H [label="H"]
 I [label="I"]
 J [label="J"]
 K [label="K"]
 A -> C [label="AC"]
 A -> D [label="AD"]
 A -> E [label="AE"]
 B -> A [label="BA"]
 B -> C [label="BC"]
 B -> G [label="BG"]
 C -> D [label="CD"]
 E -> D [label="ED"]
 F -> D [label="FD"]
 F -> E [label="FE"]
 G -> I [label="GI"]
 H -> J [label="HJ"]
 I -> B [label="BI"]
 I -> C [label="IC"]
 I -> K [label="IK"]
 J -> A [label="JA"]
 J -> E [label="JE"]
 J -> F [label="JF"]
 }
 */

 pub fn dag_edges() -> Vec<(EdgeID, NodeID, NodeID)> {
    let v = vec![
        ("AC", "A", "C"),
        ("AD", "A", "D"),
        ("AE", "A", "E"),
        ("BA", "B", "A"),
        ("BC", "B", "C"),
        ("BG", "B", "G"),
        ("CD", "C", "D"),
        ("ED", "E", "D"),
        ("FD", "F", "D"),
        ("FE", "F", "E"),
        ("HJ", "H", "J"),
        ("IC", "I", "C"),
        ("IK", "I", "K"),
        ("JA", "J", "A"),
        ("JE", "J", "E"),
        ("JF", "J", "F"),
        ("IG", "I", "G"),
        ("BI", "B", "I"),
    ];
    v.into_iter().map(|(a, b, c)| (eid!(a), nid!(b), nid!(c))).collect()
}

// http://magjac.com/graphviz-visual-editor/
/*
 digraph G {
     A [label="A"]
     B [label="B"]
     C [label="C"]
     D [label="D"]
     E [label="E"]
     F [label="F"]
     G [label="G"]
     H [label="H"]
     I [label="I"]
     J [label="J"]
     K [label="K"]
     A -> C [label="AC"]
     A -> D [label="AD"]
     A -> E [label="AE"]
     B -> A [label="BA"]
     B -> C [label="BC"]
     B -> G [label="BG"]
     C -> D [label="CD"]
     E -> D [label="ED"]
     F -> D [label="FD"]
     F -> E [label="FE"]
     I -> G [label="GI"]
     H -> J [label="HJ"]
     B -> I [label="BI"]
     I -> C [label="IC"]
     I -> K [label="IK"]
     J -> A [label="JA"]
     J -> E [label="JE"]
     J -> F [label="JF"]
 }
 */

 pub fn tree_edges() -> Vec<(EdgeID, NodeID, NodeID)> {
    let v = vec![
        ("AB", "A", "B"),
        ("AC", "A", "C"),
        ("AD", "A", "D"),
        ("DE", "D", "E"),
        ("DF", "D", "F"),
        ("DG", "D", "G"),
        ("CH", "C", "H"),
        ("BI", "B", "I"),
        ("HJ", "H", "J"),
        ("HK", "H", "K"),
        ("FL", "F", "L"),
        ("EM", "E", "M"),
        ("EN", "E", "N"),
        ("EO", "E", "O"),
    ];
    v.into_iter().map(|(a, b, c)| (eid!(a), nid!(b), nid!(c))).collect()
}

// http://magjac.com/graphviz-visual-editor/
/*
 digraph G {
     A [label="A"]
     B [label="B"]
     C [label="C"]
     D [label="D"]
     E [label="E"]
     F [label="F"]
     G [label="G"]
     H [label="H"]
     I [label="I"]
     J [label="J"]
     K [label="K"]
     L [label="L"]
     M [label="M"]
     N [label="N"]
     O [label="O"]
     A -> B [label="AB"]
     A -> C [label="AC"]
     A -> D [label="AD"]
     B -> I [label="BI"]
     C -> H [label="CH"]
     D -> E [label="DE"]
     D -> F [label="DF"]
     D -> G [label="DG"]
     E -> M [label="EM"]
     E -> N [label="EN"]
     E -> O [label="EO"]
     F -> L [label="FL"]
     H -> J [label="HJ"]
     H -> K [label="HK"]
 }
 */

 #[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
pub struct TestElemData(pub i32, pub String);