// 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;

/// VertexProperties structure to be attached to each vertex
struct VertexProperties {
  VertexProperties() {
	cash = 100;
	goods = 10;
        price = 0.1;
 }

/*  VertexProperties(double cash = 100, double goods = 10, double price = 0.1)
    : cash(cash), goods(goods), price(price) { }*/
  
  template<typename Archiver>
  void serialize(Archiver& ar, const unsigned int /*version*/)
  {
    ar & cash & goods & price;
  }

  double cash;
  double goods;
  double price;

};

struct EdgeProperties {

  EdgeProperties() {
	cash = 0;
	goods = 0;
	index = 0;
  }

  EdgeProperties(size_t i, double c, double g) : index(i), cash(c), goods(g) { }

public:
  std::size_t index;
  double cash;
  double goods;

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

};


  double lambda = 0.2;
  double mu = 0.3;
  double tau = 10;
  double eps = 0.01;

typedef boost::adjacency_list<vecS, 
                       distributedS<mpi_process_group, vecS>, 
                       bidirectionalS, VertexProperties, 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 GMap, typename PMap, typename Graph>
class Remover
{
public:
	Remover(const double min, const GMap& egoods, const PMap& price, const Graph& graph)
	: m_min(min), m_egoods(egoods), m_price(price), m_graph(graph) {}
	
	template<typename ED>
	bool operator()(ED w) const {
		return m_price[target(w, m_graph)] > tau * m_min || m_egoods[w] < eps;
	}

private:
	const Graph&	m_graph;
	const GMap&	m_egoods;
	const PMap&	m_price;
	const double    m_min;
};

template<typename Graph>
class Remover_1
{
public:
	Remover_1(const Graph& graph)
	: m_graph(graph) {}
	
	template<typename ED>
	bool operator()(ED w) const {
		return target(w, m_graph) == source(w, m_graph);
	}

private:
	const Graph&	m_graph;
};

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, 100, 1000, 0.57, 0.19, 0.19, 0.05),
          RMATGen(), 100);

  mpi_process_group pg = g.process_group();


  synchronize(g);
  

  property_map<Graph, vertex_index_t>::type
    index_map = get(vertex_index, g);


	typedef property_map<Graph, double EdgeProperties::*>::type	egoods_map;
	typedef property_map<Graph, double EdgeProperties::*>::type	ecash_map;
  	typedef property_map<Graph, double VertexProperties::*>::type   price_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>());



synchronize(g);


  //Delete self-edges
  Remover_1<Graph>	r(g);
  remove_edge_if(r, g);
   
 synchronize(g);
  
  boost::graph_traits<Graph>::vertex_iterator vit, vit_end;
  boost::graph_traits<Graph>::in_edge_iterator it, it_end;
  boost::graph_traits<Graph>::out_edge_iterator oit, oit_end;

  for(boost::tie(vit,vit_end) = vertices(g); vit != vit_end; ++vit) {
    cout << index_map[*vit] << " --> ";
    for (boost::tie(oit,oit_end) = out_edges(*vit, g); oit != oit_end; ++oit)
      cout << index_map[target(*oit, g)] << "  ";
    cout << endl;
  }

  for(boost::tie(vit,vit_end) = vertices(g); vit != vit_end; ++vit) {
    cout << index_map[*vit] << " <-- ";
    for (boost::tie(it,it_end) = in_edges(*vit, g); it != it_end; ++it)
      cout << index_map[source(*it, g)] << "  ";
    cout << endl;
  }


  return 0;
}