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