#include <boost/graph/use_mpi.hpp>
#include <boost/graph/distributed/mpi_process_group.hpp>
#include <boost/graph/distributed/adjacency_list.hpp>
#include <boost/graph/dijkstra_shortest_paths.hpp>

#include <iostream>
#include <string>
#include <utility>

using namespace boost;
using boost::graph::distributed::mpi_process_group;

// graph definition
typedef boost::property<boost::vertex_distance_t, long> vertex_prop;
typedef boost::property<boost::edge_weight_t, long>  edge_prop;
typedef adjacency_list<vecS, distributedS<mpi_process_group, vecS>, directedS,
                        vertex_prop, edge_prop > Graph;
typedef boost::graph_traits<Graph>::edge_descriptor EdgeDescriptor;

// raw edge
struct MyEdge
{
    MyEdge( long s, long t, long w ) : source(s), target(t), weight(w) {}
    long source, target, weight;
};

int main(int argc, char* argv[])
{
    boost::mpi::environment env(argc,argv);

    // graph's elements
    long num_vertices = 10;
    enum V { A, B, C, D, E, F, G, H, I, L };
    const std::string VertexName[] = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "L" };
    MyEdge edgeList[] = { MyEdge(A, B, 1),  MyEdge(A, C, 10), MyEdge(A, D, 11), 
                          MyEdge(B, D, 13), MyEdge(C, D, 12), MyEdge(B, E, 1), 
                          MyEdge(C, F, 14), MyEdge(E, D, 1),  MyEdge(D, G, 15), 
                          MyEdge(D, F, 1),  MyEdge(E, G, 16), MyEdge(F, G, 1), 
                          MyEdge(E, H, 17), MyEdge(F, I, 19), MyEdge(G, H, 18),
                          MyEdge(G, I, 1),  MyEdge(I, H, 1),  MyEdge(H, L, 1),  MyEdge(I, L, 20) };
    long num_edges = sizeof(edgeList) / sizeof(MyEdge);
    Graph g( num_vertices );
    
    // access to graph's property
    typedef boost::property_map<Graph, boost::edge_weight_t>::type EdgeWeightMap;
    typedef boost::property_map<Graph, boost::vertex_index_t>::type VertexIndexMap;
    EdgeWeightMap edgeWeightMap = boost::get( boost::edge_weight, g );
    VertexIndexMap vertexIndexMap = boost::get( boost::vertex_index, g );

    if (boost::graph::distributed::process_id(g.process_group()) == 0) {
        std::cout << "num_vertices: " << num_vertices << std::endl;
        std::cout << "num_edges: " << num_edges << std::endl;
        EdgeDescriptor ed;
        bool exists;
        for ( long i = 0; i < num_edges; ++i )
        {
            boost::add_edge( boost::vertex( edgeList[i].source , g ), boost::vertex( edgeList[i].target, g ), g );
            boost::tie( ed, exists ) = boost::edge( boost::vertex( edgeList[i].source, g ), boost::vertex( edgeList[i].target, g ), g );        
            boost::put( boost::edge_weight, g, ed, edgeList[i].weight );           

            std::cout << VertexName[ boost::get( boost::vertex_index, g, boost::source( ed, g ) ) ] << "-->" 
                      << VertexName[ boost::get( boost::vertex_index, g, boost::target( ed, g ) ) ] << " : " 
                      << boost::get( boost::edge_weight, g, ed ) << std::endl;
        }
        std::cout << "Graph loaded" << std::endl;
    }

    return 0;
}