#include "GraphX/Graph.hpp"
using namespace GraphX;

Graph<int, std::string, double> g;

// Add nodes
g.add_node(1, "Beijing");
g.add_node(2, "Shanghai");

// Add edges
g.add_edge(1, 2, 1064.7);  // Distance in km

// Query graph properties
std::cout << "Nodes: " << g.node_count() << "\n";
std::cout << "Node 1: " << g[1] << "\n";

// Get neighbors
for (auto neighbor : g.neighbors(1)) {
    std::cout << "Neighbor: " << neighbor << "\n";
}

#include "GraphX/GraphAlgorithms.hpp"

// BFS traversal
algorithms::bfs(g, 1, [](int node) {
    std::cout << "Visiting: " << node << "\n";
});

// Dijkstra's shortest path
auto distances = algorithms::shortest_paths::Dijkstra<decltype(g)>::compute(g, 1);

// Connected components
auto components = algorithms::connected_components(g);

// Topological sort for DAG
auto topo_order = algorithms::topological_sort(dag);

#include "GraphX/GraphFactory.hpp"

// Using Factory
auto graph = GraphFactory::create_graph<int, std::string, double>();

// Using Builder (Fluent Interface)
auto network = GraphBuilder<Graph<int, std::string, double>>()
    .add_node(1, "A")
    .add_node(2, "B")
    .add_node(3, "C")
    .add_edge(1, 2, 10.0)
    .add_edge(2, 3, 20.0)
    .build();

// Creating from edge list
std::vector<std::tuple<int, int, double>> edges = {
    {1, 2, 10.0},
    {2, 3, 20.0}
};
auto g = GraphFactory::from_edge_list(edges);

#include "GraphX/algorithms/maxflow_dinic.hpp"
#include "GraphX/algorithms/maxflow_edmonds_karp.hpp"

// Using Dinic's Algorithm (faster)
auto result = algorithms::maxflow::Dinic<DiGraph>::compute(g, source, sink);
std::cout << "Max Flow: " << result.max_flow << "\n";

// Using Edmonds-Karp Algorithm
auto ek_result = algorithms::maxflow::EdmondsKarp<DiGraph>::compute(g, source, sink);

#include "GraphX/GraphIO.hpp"

// Write edge list
io::EdgeListIO<Graph>::write("graph.txt", g);

// Write GraphML
io::GraphMLIO<Graph>::write("graph.graphml", g);

// Write DIMACS
io::DIMACS_IO<Graph>::write("graph.dimacs", g, 1, 4);

// Read edge list
auto g2 = io::EdgeListIO<Graph>::read("graph.txt");

Graph<int, std::string, double> g;

// Add nodes
g.add_node(1, "Node A");
g.add_node(2, "Node B");

// Query nodes
g.has_node(1);          // bool
g.node_count();         // size_t
g.nodes();              // vector<NodeId>

// Access/modify node data
auto data = g[1];
g[1] = "Updated Label";

// Add/remove edges
g.add_edge(1, 2, 5.0);
g.remove_edge(1, 2);

// Query edges
g.has_edge(1, 2);
g.edge(1, 2);           // Get edge weight
g.degree(1);            // Node degree
g.neighbors(1);         // Adjacent nodes
g.edges();              // All edges as vector<tuple<u,v,w>>

DiGraph<int, std::string, double> dg;

dg.add_node(1, "A");
dg.add_edge(1, 2, 1.0);

// Directed-specific queries
dg.in_degree(2);        // Number of incoming edges
dg.out_degree(1);       // Number of outgoing edges
dg.predecessors(2);     // Nodes pointing to 2
dg.successors(1);       // Nodes pointed to by 1
dg.is_directed();       // bool (true for DiGraph)

// Factory method
auto g1 = GraphFactory::create_graph<int, std::string, double>();

// Builder with fluent interface
auto g2 = GraphBuilder<Graph<int, std::string, double>>()
    .add_node(1, "A")
    .add_node(2, "B")
    .add_edge(1, 2, 10.0)
    .build();

// From edge list
std::vector<std::tuple<int, int, double>> edges = {{1,2,10}, {2,3,20}};
auto g3 = GraphFactory::from_edge_list(edges);

// From directed edge list
auto g4 = GraphFactory::from_directed_edge_list(edges);

// NodeId: type of node identifiers (int, string, etc.)
// NodeData: data stored at each node (string, struct, etc.)
// EdgeData: data stored at each edge/weight (double, struct, etc.)

Graph<NodeId, NodeData, EdgeData> g;

// Example: City network with populations and distances
Graph<int, std::string, double> cities;

// Example: Program dependency graph with names and artifact sizes
Graph<std::string, std::pair<std::string, int>, double> build_graph;