// -*- c++ -*- //

 #ifndef HUGO_KRUSKAL_H

 #define HUGO_KRUSKAL_H

 #include <algorithm>

 #include <hugo/unionfind.h>

 ///\file

 ///\brief Kruskal's algorithm to compute a minimum cost tree

 namespace hugo {

   /// Kruskal's algorithm to find a minimum cost tree of a graph.

   /// This function runs Kruskal's algorithm to find a minimum cost tree.

   /// \param G The graph the algorithm runs on.

   /// \param in This object is used to describe the edge costs. It must

   /// be an STL 'forward container'

   /// with value_type <tt> std::pair<Graph::Edge,X> </tt>,

   /// where X is the type of the costs. It must contain every edge in

   /// cost-ascending order.

   /// \retval out This must be a writeable EdgeMap. After running the algorithm

   /// this will contain the found minimum cost spanning tree: the value of an

   /// edge will be set to \c true if it belongs to the tree, otherwise it will

   /// be set to \c false. The value of each edge will be set exactly once.\n

   /// For the sake of simplicity, there is a helper class KruskalPairVec,

   /// which converts a

   /// simple EdgeMap to an input of this form. Alternatively, you can use

   /// the function \ref kruskalEdgeMap to compute the minimum cost tree if

   /// the edge costs are given by an EdgeMap.

   /// \return The cost of the found tree.

   template <typename Graph, typename InputEdgeOrder, typename OutBoolMap>

   typename InputEdgeOrder::value_type::second_type

   kruskal(Graph const& G, InputEdgeOrder const& in, 

 		 OutBoolMap& out)

   {

     typedef typename InputEdgeOrder::value_type::second_type EdgeCost;

     typedef typename Graph::template NodeMap<int> NodeIntMap;

     typedef typename Graph::Node Node;

     NodeIntMap comp(G, -1);

     UnionFind<Node,NodeIntMap> uf(comp); 

     EdgeCost tot_cost = 0;

     for (typename InputEdgeOrder::const_iterator p = in.begin(); 

 	 p!=in.end(); ++p ) {

       if ( uf.join(G.head((*p).first),

 		   G.tail((*p).first)) ) {

 	out.set((*p).first, true);

 	tot_cost += (*p).second;

       }

       else {

 	out.set((*p).first, false);

       }

     }

     return tot_cost;

   }

   /* A work-around for running Kruskal with const-reference bool maps... */

   template<typename Map>

   class NonConstMapWr {

     const Map &m;

   public:

     typedef typename Map::ValueType ValueType;

     NonConstMapWr(const Map &_m) : m(_m) {}

     template<typename KeyType>

     void set(KeyType const& k, ValueType const &v) const { m.set(k,v); }

   };

   template <typename Graph, typename InputEdgeOrder, typename OutBoolMap>

   inline

   typename InputEdgeOrder::ValueType

   kruskal(Graph const& G, InputEdgeOrder const& edges, 

 	  OutBoolMap const& out_map)

   {

     NonConstMapWr<OutBoolMap> map_wr(out_map);

     return kruskal(G, edges, map_wr);

   }  

   /* ** ** Output-objektumok: egyszeruen extra bool mapek ** ** */

   /// A writable bool-map that makes a sequence of "true" keys

   /// A writable bool-map that creates a sequence out of keys that receives

   /// the value "true".

   /// \warning Not a regular property map, as it doesn't know its KeyType

   template<typename Iterator>

   class SequenceOutput {

     mutable Iterator it;

   public:

     typedef bool ValueType;

     SequenceOutput(Iterator const &_it) : it(_it) {}

     template<typename KeyType>

     void set(KeyType const& k, bool v) const { if(v) {*it=k; ++it;} }

   };

   template<typename Iterator>

   inline

   SequenceOutput<Iterator>

   makeSequenceOutput(Iterator it) {

     return SequenceOutput<Iterator>(it);

   }

   /* ** ** InputSource -ok ** ** */

   /// Kruskal input source.

   /// Kruskal input source.

   ///

   template<typename Graph, typename Map>

   class KruskalPairVec

     : public std::vector< std::pair<typename Graph::Edge,

 				    typename Map::ValueType> > {

   public:

     typedef std::vector< std::pair<typename Graph::Edge,

 				   typename Map::ValueType> > Parent;

     typedef typename Parent::value_type value_type;

 //     typedef Key KeyType;

 //     typedef Val ValueType;

 //     typedef std::pair<Key,Val> PairType;

 //     typedef typename Parent::iterator iterator;

 //     typedef typename Parent::const_iterator const_iterator;

   private:

     class comparePair {

     public:

       bool operator()(const value_type& a,

 		      const value_type& b) {

 	return a.second < b.second;

       }

     };

   public:

     // FIXME: kell ez?

     // KruskalPairVec(Parent const& p) : Parent(p) {}

     void sort() {

       std::sort(this->begin(), this->end(), comparePair());

     }

     // FIXME: nem nagyon illik ez ide...

     KruskalPairVec(Graph const& G, Map const& m) {

       typedef typename Graph::EdgeIt EdgeIt;

       this->clear();

       for(EdgeIt e(G);G.valid(e);G.next(e)) {

 	// for (EdgeIt e=G.template first<EdgeIt>(); G.valid(e); G.next(e)) {

 	push_back(make_pair(e, m[e]));

       }

       sort();

     }

 //     Key const& first(const_iterator i) const { return i->first; }

 //     Key& first(iterator i) { return i->first; }

 //     Val const& second(const_iterator i) const { return i->second; }

 //     Val& second(iterator i) { return i->second; }

   };

 //   template <typename Map>

 //   class KruskalMapVec : public std::vector<typename Map::KeyType> {

 //   public:

 //     typedef typename Map::KeyType KeyType;

 //     typedef typename Map::ValueType ValueType;

 //     typedef typename std::vector<KeyType> Parent;

 //     typedef typename Parent::iterator iterator;

 //     typedef typename Parent::const_iterator const_iterator;

 //   private:

 //     const Map &m;

 //     class compareKeys {

 //       const Map &m;

 //     public:

 //       compareKeys(Map const &_m) : m(_m) {}

 //       bool operator()(KeyType const& a, KeyType const& b) {

 // 	return m[a] < m[b];

 //       }

 //     };

 //   public:

 //     KruskalMapVec(Map const& _m) : m(_m) {}

 //     void sort() {

 //       std::sort(begin(), end(), compareKeys(m));

 //     }

 //     // FIXME: nem nagyon illik ez ide...

 //     template<typename Graph>

 //     KruskalMapVec(Graph const& G, Map const& _m) : m(_m) {

 //       typedef typename Graph::EdgeIt EdgeIt;

 //       clear();

 //       for(EdgeIt e(G);G.valid(e);G.next(e)) {

 //       // for (EdgeIt e=G.template first<EdgeIt>(); G.valid(e); G.next(e)) 

 // 	push_back(e);

 //       }

 //       sort();

 //     }

 //     KeyType const& first(const_iterator i) const { return *i; }

 //     KeyType& first(iterator i) { return *i; }

 //     ValueType const& second(const_iterator i) const { return m[*i]; }

 //     ValueType& second(iterator i) { return m[*i]; }

 //   };

   /* ** ** Wrapper fuggvenyek ** ** */

   /// \brief Wrapper to Kruskal().

   /// Input is from an EdgeMap, output is a plain boolmap.

   ///\todo some more words would be nice here.

   ///

   template <typename Graph, typename EdgeCostMap, typename RetEdgeBoolMap>

   inline

   typename EdgeCostMap::ValueType

   kruskalEdgeMap(Graph const& G,

 			EdgeCostMap const& edge_costs,

 			RetEdgeBoolMap &ret_bool_map) {

     typedef KruskalPairVec<Graph,EdgeCostMap> InputVec;

     InputVec iv(G, edge_costs);

     return kruskal(G, iv, ret_bool_map);

   }

   /// \brief Wrapper to Kruskal().

   /// Input is from an EdgeMap, output is to a sequence.

   ///\todo it does not follow the naming convention.

   ///

   template <typename Graph, typename EdgeCostMap, typename RetIterator>

   inline

   typename EdgeCostMap::ValueType

   kruskalEdgeMap_IteratorOut(const Graph& G,

 			     const EdgeCostMap& edge_costs,

 			     RetIterator ret_iterator)

   {

     typedef typename EdgeCostMap::ValueType ValueType;

     typedef SequenceOutput<RetIterator> OutMap;

     OutMap out(ret_iterator);

     typedef KruskalPairVec<Graph, EdgeCostMap> InputVec;

     InputVec iv(G, edge_costs);

     return kruskal(G, iv, out);

   }

 } //namespace hugo

 #endif //HUGO_KRUSKAL_H