// -*-mode: c++; -*-

#ifndef GRAPH_WRAPPER_H

#define GRAPH_WRAPPER_H

namespace hugo {

  template<typename Graph>

  class TrivGraphWrapper {

    Graph* graph;

  public:

    typedef Graph BaseGraph;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::EachNodeIt EachNodeIt;

    typedef typename Graph::OutEdgeIt OutEdgeIt;

    typedef typename Graph::InEdgeIt InEdgeIt;

    typedef typename Graph::SymEdgeIt SymEdgeIt;

    typedef typename Graph::EachEdgeIt EachEdgeIt;

    int nodeNum() const { return graph->nodeNum(); }

    int edgeNum() const { return graph->edgeNum(); }

    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }

    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 

      return graph->getFirst(i, p); }

    //template<typename I> I next(const I i); { return graph->goNext(i); }

    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }

    template< typename It > It first() const { 

      It e; getFirst(e); return e; }

    template< typename It > It first(NodeIt v) const { 

      It e; getFirst(e, v); return e; }

    NodeIt head(const EdgeIt& e) const { return graph->head(e); }

    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

    template<typename I> NodeIt aNode(const I& e) const { 

      return graph->aNode(e); }

    template<typename I> NodeIt bNode(const I& e) const { 

      return graph->bNode(e); }

    //template<typename I> bool valid(const I& i) 

    //{ return graph->valid(i); }

    //template<typename I> void setInvalid(const I &i);

    //{ return graph->setInvalid(i); }

    NodeIt addNode() const { return graph->addNode(); }

    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const { 

      return graph->addEdge(tail, head); }

    template<typename I> void erase(const I& i) const { graph->erase(i); }

    void clear() const { graph->clear(); }

    template<typename T> class NodeMap : public Graph::NodeMap<T> { 

    public:

      NodeMap(const Graph& _G) : Graph::NodeMap<T>(_G) { }

      NodeMap(const Graph& _G, T a) : Graph::NodeMap<T>(_G, a) { }

    };

    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };

    void setGraph(Graph& _graph) { graph = &_graph; }

    Graph& getGraph() { return (*graph); }

    //TrivGraphWrapper() : graph(0) { }

    TrivGraphWrapper(Graph& _graph) : graph(&_graph) { }

  };

  template<typename Graph>

  class ConstTrivGraphWrapper {

    const Graph* graph;

  public:

    typedef Graph BaseGraph;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::EachNodeIt EachNodeIt;

    typedef typename Graph::OutEdgeIt OutEdgeIt;

    typedef typename Graph::InEdgeIt InEdgeIt;

    typedef typename Graph::SymEdgeIt SymEdgeIt;

    typedef typename Graph::EachEdgeIt EachEdgeIt;

    int nodeNum() const { return graph->nodeNum(); }

    int edgeNum() const { return graph->edgeNum(); }

    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }

    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 

      return graph->getFirst(i, p); }

    //template<typename I> I next(const I i); { return graph->goNext(i); }

    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }

    template< typename It > It first() const { 

      It e; getFirst(e); return e; }

    template< typename It > It first(NodeIt v) const { 

      It e; getFirst(e, v); return e; }

    NodeIt head(const EdgeIt& e) const { return graph->head(e); }

    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

    template<typename I> NodeIt aNode(const I& e) const { 

      return graph->aNode(e); }

    template<typename I> NodeIt bNode(const I& e) const { 

      return graph->bNode(e); }

    //template<typename I> bool valid(const I& i) 

    //{ return graph->valid(i); }

    //template<typename I> void setInvalid(const I &i);

    //{ return graph->setInvalid(i); }

    NodeIt addNode() const { return graph->addNode(); }

    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) const { 

      return graph->addEdge(tail, head); }

    template<typename I> void erase(const I& i) const { graph->erase(i); }

    void clear() const { graph->clear(); }

    template<typename T> class NodeMap : public Graph::NodeMap<T> { 

    public:

      NodeMap(const Graph& _G) : Graph::NodeMap<T>(_G) { }

      NodeMap(const Graph& _G, T a) : Graph::NodeMap<T>(_G, a) { }

    };

    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };

    void setGraph(const Graph& _graph) { graph = &_graph; }

    const Graph& getGraph() { return (*graph); }

    //ConstTrivGraphWrapper() : graph(0) { }

    ConstTrivGraphWrapper(const Graph& _graph) : graph(&_graph) { }

  };

  template<typename Graph>

  class RevGraphWrapper

  {

    Graph* graph;

  public:

    typedef Graph BaseGraph;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::EachNodeIt EachNodeIt;

    typedef typename Graph::OutEdgeIt InEdgeIt;

    typedef typename Graph::InEdgeIt OutEdgeIt;

    typedef typename Graph::SymEdgeIt SymEdgeIt;

    typedef typename Graph::EachEdgeIt EachEdgeIt;

    int nodeNum() const { return graph->nodeNum(); }

    int edgeNum() const { return graph->edgeNum(); }

    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }

    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 

      return graph->getFirst(i, p); }

    //template<typename I> I next(const I i); { return graph->goNext(i); }

    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }

    template< typename It > It first() const { 

      It e; getFirst(e); return e; }

    template< typename It > It first(NodeIt v) const { 

      It e; getFirst(e, v); return e; }

    NodeIt head(const EdgeIt& e) const { return graph->tail(e); }

    NodeIt tail(const EdgeIt& e) const { return graph->head(e); }

    template<typename I> NodeIt aNode(const I& e) const { 

      return graph->aNode(e); }

    template<typename I> NodeIt bNode(const I& e) const { 

      return graph->bNode(e); }

    //template<typename I> bool valid(const I i);

    //{ return graph->valid(i); }

    //template<typename I> void setInvalid(const I &i);

    //{ return graph->setInvalid(i); }

    NodeIt addNode() { return graph->addNode(); }

    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 

      return graph->addEdge(tail, head); }

    template<typename I> void erase(const I& i) { graph->erase(i); }

    void clear() { graph->clear(); }

    template<typename T> class NodeMap : public Graph::NodeMap<T> { };

    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };

    void setGraph(Graph& _graph) { graph = &_graph; }

    Graph& getGraph() { return (*graph); }

    //RevGraphWrapper() : graph(0) { }

    RevGraphWrapper(Graph& _graph) : graph(&_graph) { }

  };

  template<typename Graph>

  class SymGraphWrapper

  {

    Graph* graph;

  public:

    typedef Graph BaseGraph;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::EachNodeIt EachNodeIt;

    //FIXME tag-ekkel megcsinalni, hogy abbol csinaljon

    //iranyitatlant, ami van

    //mert csak 1 dolgot lehet be typedef-elni

    typedef typename Graph::OutEdgeIt SymEdgeIt;

    //typedef typename Graph::InEdgeIt SymEdgeIt;

    //typedef typename Graph::SymEdgeIt SymEdgeIt;

    typedef typename Graph::EachEdgeIt EachEdgeIt;

    int nodeNum() const { return graph->nodeNum(); }

    int edgeNum() const { return graph->edgeNum(); }

    template<typename I> I& getFirst(I& i) const { return graph->getFirst(i); }

    template<typename I, typename P> I& getFirst(I& i, const P& p) const { 

      return graph->getFirst(i, p); }

    //template<typename I> I next(const I i); { return graph->goNext(i); }

    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }

    template< typename It > It first() const { 

      It e; getFirst(e); return e; }

    template< typename It > It first(NodeIt v) const { 

      It e; getFirst(e, v); return e; }

    NodeIt head(const EdgeIt& e) const { return graph->head(e); }

    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

    template<typename I> NodeIt aNode(const I& e) const { 

      return graph->aNode(e); }

    template<typename I> NodeIt bNode(const I& e) const { 

      return graph->bNode(e); }

    //template<typename I> bool valid(const I i);

    //{ return graph->valid(i); }

    //template<typename I> void setInvalid(const I &i);

    //{ return graph->setInvalid(i); }

    NodeIt addNode() { return graph->addNode(); }

    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 

      return graph->addEdge(tail, head); }

    template<typename I> void erase(const I& i) { graph->erase(i); }

    void clear() { graph->clear(); }

    template<typename T> class NodeMap : public Graph::NodeMap<T> { };

    template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };

    void setGraph(Graph& _graph) { graph = &_graph; }

    Graph& getGraph() { return (*graph); }

    //SymGraphWrapper() : graph(0) { }

    SymGraphWrapper(Graph& _graph) : graph(&_graph) { }

  };

// FIXME: comparison should be made better!!!

  template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>

  class ResGraphWrapper

  {

    Graph* graph;

  public:

    typedef Graph BaseGraph;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::EachNodeIt EachNodeIt;

    class OutEdgeIt {

    public:

      //Graph::NodeIt n;

      bool out_or_in;

      typename Graph::OutEdgeIt o;

      typename Graph::InEdgeIt i;   

    };

    class InEdgeIt {

    public:

      //Graph::NodeIt n;

      bool out_or_in;

      typename Graph::OutEdgeIt o;

      typename Graph::InEdgeIt i;   

    };

    typedef typename Graph::SymEdgeIt SymEdgeIt;

    typedef typename Graph::EachEdgeIt EachEdgeIt;

    int nodeNum() const { return graph->nodeNum(); }

    int edgeNum() const { return graph->edgeNum(); }

    NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }

    // EachEdge and SymEdge  is missing!!!!

    // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!

    //FIXME

    OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const 

      {

	e.n=n;

	graph->getFirst(e.o,n);

	while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))

	  graph->goNext(e.o);

	if(!graph->valid(e.o)) {

	  graph->getFirst(e.i,n);

	  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))

	    graph->goNext(e.i);

	}

	return e;

      }

/*

  OutEdgeIt &goNext(OutEdgeIt &e)

  {

  if(graph->valid(e.o)) {

  while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))

  graph->goNext(e.o);

  if(graph->valid(e.o)) return e;

  else graph->getFirst(e.i,e.n);

  }

  else {

  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))

  graph->goNext(e.i);

  return e;

  }

  }

  OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}

*/

    //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}

    //FIXME

    InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const 

      {

	e.n=n;

	graph->getFirst(e.i,n);

	while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))

	  graph->goNext(e.i);

	if(!graph->valid(e.i)) {

	  graph->getFirst(e.o,n);

	  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))

	    graph->goNext(e.o);

	}

	return e;

      }

/*

  InEdgeIt &goNext(InEdgeIt &e)

  {

  if(graph->valid(e.i)) {

  while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))

  graph->goNext(e.i);

  if(graph->valid(e.i)) return e;

  else graph->getFirst(e.o,e.n);

  }

  else {

  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))

  graph->goNext(e.o);

  return e;

  }

  }

  InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}

*/

    //bool valid(const InEdgeIt e) { return graph->valid(e.i)||graph->valid(e.o);}

    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }

    //template<typename I> I next(const I i); { return graph->goNext(i); }

    template< typename It > It first() const { 

      It e; getFirst(e); return e; }

    template< typename It > It first(NodeIt v) const { 

      It e; getFirst(e, v); return e; }

    NodeIt head(const EdgeIt& e) const { return graph->head(e); }

    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

    template<typename I> NodeIt aNode(const I& e) const { 

      return graph->aNode(e); }

    template<typename I> NodeIt bNode(const I& e) const { 

      return graph->bNode(e); }

    //template<typename I> bool valid(const I i);

    //{ return graph->valid(i); }

    //template<typename I> void setInvalid(const I &i);

    //{ return graph->setInvalid(i); }

    NodeIt addNode() { return graph->addNode(); }

    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 

      return graph->addEdge(tail, head); }

    template<typename I> void erase(const I& i) { graph->erase(i); }

    void clear() { graph->clear(); }

    template<typename S> class NodeMap : public Graph::NodeMap<S> { };

    template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };

    void setGraph(Graph& _graph) { graph = &_graph; }

    Graph& getGraph() { return (*graph); }

    //ResGraphWrapper() : graph(0) { }

    ResGraphWrapper(Graph& _graph) : graph(&_graph) { }

  };

// FIXME: comparison should be made better!!!

  template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>

  class ConstResGraphWrapper

  {

    const Graph* graph;

    const LowerMap* low;

    FlowMap* flow;

    const UpperMap* up;

  public:

    typedef Graph BaseGraph;

    typedef typename Graph::NodeIt NodeIt;

    typedef typename Graph::EdgeIt EdgeIt;

    typedef typename Graph::EachNodeIt EachNodeIt;

    class OutEdgeIt {

    public:

      //Graph::NodeIt n;

      bool out_or_in;

      typename Graph::SymEdgeIt sym;

    };

    class InEdgeIt {

    public:

      //Graph::NodeIt n;

      bool out_or_in;

      typename Graph::OutEdgeIt sym;

    };

    //typedef typename Graph::SymEdgeIt SymEdgeIt;

    //typedef typename Graph::EachEdgeIt EachEdgeIt;

    int nodeNum() const { return graph->nodeNum(); }

    //int edgeNum() const { return graph->edgeNum(); }

    NodeIt& getFirst(NodeIt& n) const { return graph->getFirst(n); }

    // EachEdge and SymEdge  is missing!!!!

    // EdgeIt <-> In/OutEdgeIt conversion is missing!!!!

    //FIXME

    OutEdgeIt& getFirst(OutEdgeIt& e, const NodeIt& n) const 

      {

	e.n=n;

	graph->getFirst(e.o,n);

	while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))

	  graph->goNext(e.o);

	if(!graph->valid(e.o)) {

	  graph->getFirst(e.i,n);

	  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))

	    graph->goNext(e.i);

	}

	return e;

      }

/*

  OutEdgeIt &goNext(OutEdgeIt &e)

  {

  if(graph->valid(e.o)) {

  while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))

  graph->goNext(e.o);

  if(graph->valid(e.o)) return e;

  else graph->getFirst(e.i,e.n);

  }

  else {

  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))

  graph->goNext(e.i);

  return e;

  }

  }

  OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}

*/

    //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}

    //FIXME

    InEdgeIt& getFirst(InEdgeIt& e, const NodeIt& n) const 

      {

	e.n=n;

	graph->getFirst(e.i,n);

	while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))

	  graph->goNext(e.i);

	if(!graph->valid(e.i)) {

	  graph->getFirst(e.o,n);

	  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))

	    graph->goNext(e.o);

	}

	return e;

      }

/*

  InEdgeIt &goNext(InEdgeIt &e)

  {

  if(graph->valid(e.i)) {

  while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))

  graph->goNext(e.i);

  if(graph->valid(e.i)) return e;

  else graph->getFirst(e.o,e.n);

  }

  else {

  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))

  graph->goNext(e.o);

  return e;

  }

  }

  InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}

*/

    //bool valid(const InEdgeIt e) { return graph->valid(e.i)||graph->valid(e.o);}

    //template<typename I> I &goNext(I &i); { return graph->goNext(i); }

    //template<typename I> I next(const I i); { return graph->goNext(i); }

    template< typename It > It first() const { 

      It e; getFirst(e); return e; }

    template< typename It > It first(NodeIt v) const { 

      It e; getFirst(e, v); return e; }

    NodeIt head(const EdgeIt& e) const { return graph->head(e); }

    NodeIt tail(const EdgeIt& e) const { return graph->tail(e); }

    template<typename I> NodeIt aNode(const I& e) const { 

      return graph->aNode(e); }

    template<typename I> NodeIt bNode(const I& e) const { 

      return graph->bNode(e); }

    //template<typename I> bool valid(const I i);

    //{ return graph->valid(i); }

    //template<typename I> void setInvalid(const I &i);

    //{ return graph->setInvalid(i); }

    NodeIt addNode() { return graph->addNode(); }

    EdgeIt addEdge(const NodeIt& tail, const NodeIt& head) { 

      return graph->addEdge(tail, head); }

    template<typename I> void erase(const I& i) { graph->erase(i); }

    void clear() { graph->clear(); }

    template<typename S> class NodeMap : public Graph::NodeMap<S> { };

    template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };

    void setGraph(const Graph& _graph) { graph = &_graph; }

    const Graph& getGraph() { return (*graph); }

    //ConstResGraphWrapper() : graph(0) { }

    ConstResGraphWrapper(const Graph& _graph) : graph(&_graph) { }

  };

} //namespace hugo

#endif //GRAPH_WRAPPER_H

//   NodeIt &getFirst(NodeIt &n) { return graph->getFirst(n); }

//   InEdgeIt &getFirst(InEdgeIt &e,const NodeIt &n);

//   { return graph->getFirst(e,n); }

//   OutEdgeIt &getFirst(OutEdgeIt &e,const NodeIt &n);

//   { return graph->getFirst(e,n); }

//   SymEdgeIt &getFirst(SymEdgeIt &e,const NodeIt &n);

//   { return graph->getFirst(e,n); }

//   EachEdgeIt &getFirst(EachEdgeIt &e);

//   { return graph->getFirst(e); }

//   NodeIt next(const NodeIt &n);

//   { return graph->next(n); }

//   InEdgeIt next(const InEdgeIt &e);

//   { return graph->next(e); }

//   OutEdgeIt next(const OutEdgeIt &e);

//   { return graph->next(e); }

//   SymEdgeIt next(const SymEdgeIt &e);

//   { return graph->next(e); }

//   EachEdgeIt next(const EachEdgeIt &e);

//   { return graph->next(e); }

//   NodeIt &goNext(NodeIt &n);

//   { return graph->goNext(n); }

//   InEdgeIt &goNext(InEdgeIt &e);

//   { return graph->goNext(e); }

//   OutEdgeIt &goNext(OutEdgeIt &e);

//   { return graph->goNext(e); }

//   SymEdgeIt &goNext(SymEdgeIt &e);

//   { return graph->goNext(e); }

//   EachEdgeIt &goNext(EachEdgeIt &e);

//   { return graph->goNext(e); }