// 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/config.hpp>
#include <boost/throw_exception.hpp>
#include <boost/mpl/print.hpp>
#include <boost/graph/adjacency_list.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;

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


  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;

 

};


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

typedef boost::adjacency_list<vecS, 
                       vecS,
                       bidirectionalS, VertexProperties, EdgeProperties> Graph;


typedef graph_traits<Graph>::vertex_descriptor Vertex;
typedef graph_traits<Graph>::edge_descriptor Edge;



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


int test_main(int argc, char** 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);


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



  //Delete self-edges
  Remover_1<Graph>	r(g);
  remove_edge_if(r, 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;
}