// Copyright (C) 2007-2008 The Trustees of Indiana University.

// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include <boost/graph/use_mpi.hpp>
#include <boost/config.hpp>
#include <boost/throw_exception.hpp>
#include <boost/mpl/print.hpp>
#include <boost/graph/distributed/adjacency_list.hpp>
#include <boost/graph/distributed/mpi_process_group.hpp>
#include <boost/graph/iteration_macros.hpp>
#include <boost/test/minimal.hpp>
#include <boost/graph/graphviz.hpp>
#include <boost/graph/graphml.hpp>
#include <boost/graph/erdos_renyi_generator.hpp>
#include <boost/graph/random.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/property_map/property_map.hpp>
#include <string>
#include <iostream>

#include <boost/graph/iteration_macros.hpp>
#include <boost/graph/rmat_graph_generator.hpp>
#include <boost/random/linear_congruential.hpp>

#include <boost/graph/metis.hpp>

#ifdef BOOST_NO_EXCEPTIONS
void
boost::throw_exception(std::exception const& ex)
{
    std::cout << ex.what() << std::endl;
    abort();
}
#endif

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

struct EdgeProperties {

  	EdgeProperties() {
		cash = 0;
  	}

  	EdgeProperties(double c) : cash(c) { }

public:
  	double cash;

  	friend class serialization::access;
    	template<class Archive>
    	void serialize(Archive & ar, const unsigned int version) {
		ar & cash;
    	}
};

typedef boost::adjacency_list<vecS, distributedS<mpi_process_group, vecS>, bidirectionalS, property<vertex_index_t, int>, EdgeProperties> Graph;
typedef graph_traits<Graph>::vertex_descriptor Vertex;
typedef graph_traits<Graph>::edge_descriptor Edge;

struct remote_key_e {
	remote_key_e(int p = -1, Edge l = Edge()) : processor(p){local_key = &l;  }

  	int processor;
  	Edge* local_key;

  	template<typename Archiver>
  	void serialize(Archiver& ar, const unsigned int /*version*/) {
    		ar & processor & local_key;
  	}
};

namespace boost { 
template<>
struct hash<remote_key_e> {
  	std::size_t operator()(const remote_key_e& key) const {
    		std::size_t hash = hash_value(key.processor);
    		hash_combine(hash, key.local_key);
    		return hash;
  	}
};
}

inline bool operator==(const remote_key_e& x, const remote_key_e& y) { 
	return x.processor == y.processor && (*(x.local_key)) == (*(y.local_key)); 
}

struct remote_key_to_global_e {
  	typedef readable_property_map_tag category;
  	typedef remote_key_e key_type;
  	typedef std::pair<int, Edge> value_type;
  	typedef value_type reference;
};

inline std::pair<int, Edge> 
get(remote_key_to_global_e, const remote_key_e& key) {
  	return std::make_pair(key.processor, *(key.local_key));
}


template<typename T>
struct rank_accumulate_reducer {
  	static const bool non_default_resolver = false;

  	// The default rank of an unknown node
  	template<typename K>
  	T operator()(const K&) const {return T(0); }

  	template<typename K>
  	T operator()(const K&, const T& x, const T& y) const { return x; }
};

int test_main(int argc, char** argv) {
  	boost::mpi::environment env(argc, argv);

	//Random scale-free
	typedef boost::unique_rmat_iterator<boost::minstd_rand, Graph> RMATGen;
	boost::minstd_rand gen;
  	Graph g(RMATGen(gen, 20, 100, 0.57, 0.19, 0.19, 0.05), RMATGen(), 20);

  	mpi_process_group pg = g.process_group();
  	int rank = graph::distributed::process_id(g.process_group());

  	std::ofstream myfile;
  	char numstr[21]; // enough to hold all numbers up to 64-bits
  	sprintf(numstr, "file.%d.graphml", rank);
  	myfile.open (numstr);

  	property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g);
  	property_map<Graph, double EdgeProperties::*>::type ecash = get(&EdgeProperties::cash, g);

	typedef property_map<Graph, double EdgeProperties::*>::type	ecash_map;

  	//Vertex iterator distributed property maps
  	typedef property_map<Graph, vertex_index_t>::const_type VertexIndexMap;
  	typedef iterator_property_map<std::vector<size_t>::iterator, VertexIndexMap> d_index_map;
 
  	std::vector<size_t> index_S(num_vertices(g), std::numeric_limits<size_t>::max());
  	d_index_map d_index(index_S.begin(), get(vertex_index, g));
  	d_index.set_reduce(rank_accumulate_reducer<size_t>());

	graph_traits<Graph>::out_edge_iterator ei, edge_end, einext;
  	graph_traits<Graph>::in_edge_iterator ei_i, edge_end_i;

	//Vertex initializations
	BGL_FORALL_VERTICES(v, g, Graph) {
	  	put(d_index, v, 10* rank + index_map[v]);
	}

 	//Edge iterator distributed property maps
  	typedef boost::parallel::distributed_property_map<mpi_process_group,remote_key_to_global_e,ecash_map> Dist_ecash_Map;

	Dist_ecash_Map d_ecash = boost::parallel::make_distributed_property_map(pg, remote_key_to_global_e(), ecash);
	d_ecash.set_reduce(rank_accumulate_reducer<double>());

	synchronize(g);

  	for (int t = 0; t < 2; t++) {
		myfile<<rank<<":Time "<<t<<endl;

		BGL_FORALL_VERTICES(v, g, Graph) {
	    		for (boost::tie(ei_i,edge_end_i) = in_edges(v, g); ei_i != edge_end_i; ++ei_i) {
				remote_key_e k(rank, *ei_i);
				myfile<<"value "<<d_index[source(*ei_i, g)]<<" -> "<<d_index[target(*ei_i, g)]<<" valor "<<get(d_ecash, k)<<endl;
	    		}
		}

		synchronize(d_ecash);
		BGL_FORALL_VERTICES(v, g, Graph) {
	    		for (boost::tie(ei,edge_end) = out_edges(v, g); ei != edge_end; ++ei) {
				remote_key_e k(rank, *ei);
				put(d_ecash, k, t + 1);
    			}
		}
  		synchronize(d_ecash);

	 
  	}
	synchronize(pg);

  return 0;
}