/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2007

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

///\ingroup paths

///\file

///\brief Classes for representing paths in graphs.

///

#ifndef LEMON_PATH_UTILS_H

#define LEMON_PATH_UTILS_H

#include <lemon/concepts/path.h>

#include <lemon/lemon_reader.h>

#include <lemon/lemon_writer.h>

namespace lemon {

  namespace _path_bits {

    template <typename Path, typename Enable = void>

    struct RevTagIndicator {

      static const bool value = false;

    };

    template <typename Graph>

    struct RevTagIndicator<

      Graph, 

      typename enable_if<typename Graph::RevTag, void>::type

    > {

      static const bool value = true;

    };

    template <typename Target, typename Source,

              typename BuildEnable = void, typename RevEnable = void>

    struct PathCopySelector {

      static void copy(Target& target, const Source& source) {

        target.clear();

        for (typename Source::EdgeIt it(source); it != INVALID; ++it) {

          target.addBack(it);

        }

      }

    };

    template <typename Target, typename Source, typename BuildEnable>

    struct PathCopySelector<

      Target, Source, BuildEnable, 

      typename enable_if<typename Source::RevPathTag, void>::type> {

      static void copy(Target& target, const Source& source) {

        target.clear();

        for (typename Source::RevEdgeIt it(source); it != INVALID; ++it) {

          target.addFront(it);

        }

      }

    };

    template <typename Target, typename Source, typename RevEnable>

    struct PathCopySelector<

      Target, Source, 

      typename enable_if<typename Target::BuildTag, void>::type, RevEnable> {

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.build(source);

      }

    };

    template <typename Target, typename Source>

    struct PathCopySelector<

      Target, Source, 

      typename enable_if<typename Target::BuildTag, void>::type,

      typename enable_if<typename Source::RevPathTag, void>::type> {

      static void copy(Target& target, const Source& source) {

        target.clear();

        target.buildRev(source);

      }

    };

  }

  /// \brief Make of copy of a path.

  ///

  ///  Make of copy of a path.

  template <typename Target, typename Source>

  void copyPath(Target& target, const Source& source) {

    checkConcept<concepts::PathDumper<typename Source::Graph>, Source>();

    _path_bits::PathCopySelector<Target, Source>::copy(target, source);

  }

  /// \brief Checks the path's consistency.

  ///

  /// Checks that each edge's target is the next's source. 

  /// 

  template <typename Graph, typename Path>

  bool checkPath(const Graph& graph, const Path& path) {

    typename Path::EdgeIt it(path);

    if (it == INVALID) return true;

    typename Graph::Node node = graph.target(it);

    ++it;

    while (it != INVALID) {

      if (graph.source(it) != node) return false;

      node = graph.target(it);

      ++it;

    }

    return true;

  }

  /// \brief Gives back the source of the path

  ///

  /// Gives back the source of the path.

  template <typename Graph, typename Path>

  typename Graph::Node pathSource(const Graph& graph, const Path& path) {

    return graph.source(path.front());

  }

  /// \brief Gives back the target of the path

  ///

  /// Gives back the target of the path.

  template <typename Graph, typename Path>

  typename Graph::Node pathTarget(const Graph& graph, const Path& path) {

    return graph.target(path.back());

  }

  /// \brief Class which helps to iterate the nodes of a path

  ///

  /// In a sense, the path can be treated as a list of edges. The

  /// lemon path type stores just this list. As a consequence it

  /// cannot enumerate the nodes in the path and the zero length paths

  /// cannot store the node.

  ///

  /// This class implements the node iterator of a path structure. To

  /// provide this feature, the underlying graph should be given to

  /// the constructor of the iterator.

  template <typename Path>

  class PathNodeIt {

  private:

    const typename Path::Graph *_graph;

    typename Path::EdgeIt _it;

    typename Path::Graph::Node _nd;

  public:

    typedef typename Path::Graph Graph;

    typedef typename Graph::Node Node;

    /// Default constructor

    PathNodeIt() {}

    /// Invalid constructor

    PathNodeIt(Invalid) 

      : _graph(0), _it(INVALID), _nd(INVALID) {}

    /// Constructor

    PathNodeIt(const Graph& graph, const Path& path) 

      : _graph(&graph), _it(path) {

      _nd = (_it != INVALID ? _graph->source(_it) : INVALID);

    }

    /// Constructor

    PathNodeIt(const Graph& graph, const Path& path, const Node& src) 

      : _graph(&graph), _it(path), _nd(src) {}

    ///Conversion to Graph::Node

    operator Node() const {

      return _nd;

    }

    /// Next node

    PathNodeIt& operator++() {

      if (_it == INVALID) _nd = INVALID;

      else {

	_nd = _graph->target(_it);

	++_it;

      }

      return *this;

    }

    /// Comparison operator

    bool operator==(const PathNodeIt& n) const { 

      return _it == n._it && _nd == n._nd; 

    }

    /// Comparison operator

    bool operator!=(const PathNodeIt& n) const { 

      return _it != n._it || _nd != n._nd; 

    }

    /// Comparison operator

    bool operator<(const PathNodeIt& n) const { 

      return (_it < n._it && _nd != INVALID);

    }

  };

  /// \brief Item writer for paths

  ///

  /// This class can write paths into files. You can store paths in

  /// distinict mapset or in attributes section.

  ///

  ///\code

  /// GraphWriter<SmartGraph> gw(std::cout, g);

  /// NodeMapWriter<SmartGraph> nmw(gw, g, gw);

  ///

  /// SmartGraph::NodeMap<Path<SmartGraph> > pnm(g);

  /// for (SmartGraph::NodeIt n(g); n != INVALID; ++n) {

  ///   pnm[n] = bfs.path(n);

  /// }

  /// nmw.writeNodeMap("pnm", pnm, PathWriter<Path<SmartGraph> >(gw));

  ///

  /// gw.run();

  ///\endcode

  ///

  /// \warning Do not use this class to write node or edge map values

  /// into usual nodesets or edgesets. You will not be able to read

  /// back your paths. Rather use NodeMapWriter, EdgeSetWriter or

  /// UEdgeSetWriter to dump paths from maps to lemon file.

  template <typename Path>

  class PathWriter {

  private:

    typedef typename Path::Edge Edge;

    std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > edgeLabelWriter;

  public:

    typedef Path Value;

    PathWriter(const PathWriter& pw) {

      edgeLabelWriter.reset(pw.edgeLabelWriter->clone());

    }

    /// \brief Constructor

    ///

    /// The paramter shold be an edge label writer which could

    /// be a GraphWriter or an EdgeSetWriter. 

    template <typename EdgeLabelWriter>

    explicit PathWriter(const EdgeLabelWriter& _edgeLabelWriter) {

      edgeLabelWriter.reset(new _writer_bits::

	LabelWriter<Edge, EdgeLabelWriter>(_edgeLabelWriter));

    }

    /// \brief Writer function

    ///

    /// Writes the path to the current stream. The representation

    /// is the edge labels beetween parentheses.

    void write(std::ostream& os, const Value& value) const {

      if (!edgeLabelWriter->isLabelWriter()) {

	throw DataFormatError("Cannot find edgeset or label map");

      }

      os << '(' << ' ';

      for (typename Path::EdgeIt e(value); e != INVALID; ++e) {

	edgeLabelWriter->write(os, e);

	os << ' ';

      }

      os << ')';

    }

  };

  namespace _path_bits {

    template <typename _Graph>

    class PathProxy {

    public:

      typedef False RevPathTag;

      typedef _Graph Graph;

      typedef typename Graph::Edge Edge;

      PathProxy(const std::vector<Edge>& edges)

	: _edges(edges) {}

      int length() const {

	return _edges.size();

      }

      bool empty() const {

	return _edges.size() == 0;

      }

      class EdgeIt {

      public:

	EdgeIt() {}

	EdgeIt(const PathProxy& path) 

	  : _path(&path), _index(0) {}

	operator const Edge() const {

	  return _path->_edges[_index];

	}

	EdgeIt& operator++() {

	  ++_index;

	  return *this;

	}

	bool operator==(Invalid) const { 

	  return int(_path->_edges.size()) == _index; 

	}

	bool operator!=(Invalid) const { 

	  return int(_path->_edges.size()) != _index; 

	}

      private:

	const PathProxy* _path;

	int _index;

      };

    private:

      const std::vector<Edge>& _edges;

    };

  }

  /// \brief Item reader for paths 

  ///

  /// This class can read paths from files. You can store paths in

  /// distinict mapset or in attributes section.

  ///

  ///\code

  /// GraphReader<SmartGraph> gr(std::cout, g);

  /// NodeMapReader<SmartGraph> nmr(gr, g, gr);

  ///

  /// SmartGraph::NodeMap<Path<SmartGraph> > pnm(g);

  /// nmr.readNodeMap("pnm", pnm, PathReader<Path<SmartGraph> >(gr));

  ///

  /// gr.run();

  ///\endcode

  ///

  /// \warning Do not use this class to read node or edge map values

  /// from nodesets or edgesets. The edges are not surely constructed

  /// when the edge list should be read. Rather use NodeMapReader,

  /// EdgeSetReader or UEdgeSetReader to read distinict map sets from file.

  template <typename Path>

  class PathReader {

  private:

    typedef typename Path::Edge Edge;

    std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > edgeLabelReader;

  public:

    typedef Path Value;

    PathReader(const PathReader& pw) {

      edgeLabelReader.reset(pw.edgeLabelReader->clone());

    }

    /// \brief Constructor

    ///

    /// The paramter shold be an edge label reader which could

    /// be a GraphReader or an EdgeSetReader. 

    template <typename EdgeLabelReader>

    explicit PathReader(const EdgeLabelReader& _edgeLabelReader) {

      edgeLabelReader.reset(new _reader_bits::

	LabelReader<Edge, EdgeLabelReader>(_edgeLabelReader));

    }

    /// \brief Reader function

    ///

    /// Reads the path from the current stream. The representation

    /// is the edge labels beetween parentheses.

    void read(std::istream& is, Value& value) const {

      if (!edgeLabelReader->isLabelReader()) {

	throw DataFormatError("Cannot find edgeset or label map");

      }

      char c;

      if (!(is >> c) || c != '(') 

	throw DataFormatError("PathReader format error");

      std::vector<typename Path::Edge> v;

      while (is >> c && c != ')') {

	is.putback(c);

	Edge edge = edgeLabelReader->read(is);

	v.push_back(edge);

      }

      if (!is) throw DataFormatError("PathReader format error");

      copyPath(value, _path_bits::PathProxy<typename Path::Edge>(v));

    }

  };

}

#endif