/* -*- C++ -*-
 * src/lemon/merge_node_graph_wrapper.h - Part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Combinatorial Optimization Research Group, 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.
 *
 */

#ifndef LEMON_MERGE_NODE_GRAPH_WRAPPER_H
#define LEMON_MERGE_NODE_GRAPH_WRAPPER_H

#include <lemon/invalid.h>
#include <lemon/maps.h>
#include <lemon/map_defines.h>
#include <lemon/graph_wrapper.h>
#include <iostream>

namespace lemon {

  template <typename _Graph1, typename _Graph2, typename Enable=void>
  class MergeNodeGraphWrapperBase : 
    public GraphWrapperBase<_Graph1>, public GraphWrapperBase<_Graph2> {
  public:
    typedef _Graph1 Graph1;
    typedef _Graph2 Graph2;
    typedef GraphWrapperBase<_Graph1> Parent1;
    typedef GraphWrapperBase<_Graph2> Parent2;
    typedef typename Parent1::Node Graph1Node;
    typedef typename Parent2::Node Graph2Node;
  protected:
    MergeNodeGraphWrapperBase() { }
  public:
    template <typename _Value> class NodeMap;

    class Node : public Graph1Node, public Graph2Node {
      friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>;
      template <typename Value> friend class NodeMap;
    protected:
      bool backward; //true, iff backward
    public:
      Node() { }
      /// \todo =false is needed, or causes problems?
      /// If \c _backward is false, then we get an edge corresponding to the 
      /// original one, otherwise its oppositely directed pair is obtained.
      Node(const Graph1Node& n1, 
	   const Graph2Node& n2, bool _backward) : 
	Graph1Node(n1), Graph2Node(n2), backward(_backward) { }
      Node(Invalid i) : Graph1Node(i), Graph2Node(i), backward(true) { }
      bool operator==(const Node& v) const { 
	return (this->backward==v.backward && 
		static_cast<Graph1Node>(*this)==
		static_cast<Graph1Node>(v) && 
		static_cast<Graph2Node>(*this)==
		static_cast<Graph2Node>(v));
      } 
      bool operator!=(const Node& v) const { 
	return (this->backward!=v.backward || 
		static_cast<Graph1Node>(*this)!=
		static_cast<Graph1Node>(v) || 
		static_cast<Graph2Node>(*this)!=
		static_cast<Graph2Node>(v));
      }
    };

    //typedef void Edge;
    class Edge { };
    
    void first(Node& i) const {
      Parent1::graph->first(*static_cast<Graph1Node*>(&i));
      i.backward=false;
      if (*static_cast<Graph1Node*>(&i)==INVALID) {
	Parent2::graph->first(*static_cast<Graph2Node*>(&i));
	i.backward=true;
      }
    }
    void next(Node& i) const {
      if (!(i.backward)) {
	Parent1::graph->next(*static_cast<Graph1Node*>(&i));
	if (*static_cast<Graph1Node*>(&i)==INVALID) {
	  Parent2::graph->first(*static_cast<Graph2Node*>(&i));
	  i.backward=true;
	}
      } else {
	Parent2::graph->next(*static_cast<Graph2Node*>(&i));
      }
    }

    int id(const Node& n) const { 
      if (!n.backward) 
	return this->Parent1::graph->id(n);
      else
	return this->Parent2::graph->id(n);
    }

    template <typename _Value> 
    class NodeMap : public Parent1::template NodeMap<_Value>, 
		    public Parent2::template NodeMap<_Value> { 
      typedef typename Parent1::template NodeMap<_Value> ParentMap1;
      typedef typename Parent2::template NodeMap<_Value> ParentMap2;
    public:
      typedef _Value Value;
      typedef Node Key;
      NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : 
	ParentMap1(gw), ParentMap2(gw) { }
      NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, 
	      const _Value& value) : 
	ParentMap1(gw, value), ParentMap2(gw, value) { }
//       NodeMap(const NodeMap& copy)
// 	: ParentMap1(copy), 
// 	  ParentMap2(copy) { }
//       template <typename TT>
//       NodeMap(const NodeMap<TT>& copy)
// 	: ParentMap1(copy),
// 	  ParentMap2(copy) { }
//       NodeMap& operator=(const NodeMap& copy) {
// 	ParentMap1::operator=(copy);
// 	ParentMap2::operator=(copy);
// 	return *this;
//       }
//       template <typename TT>
//       NodeMap& operator=(const NodeMap<TT>& copy) {
// 	ParentMap1::operator=(copy);
// 	ParentMap2::operator=(copy);
// 	return *this;
//       }
      _Value operator[](const Node& n) const {
	if (!n.backward) 
	  return ParentMap1::operator[](n);
	else 
	  return ParentMap2::operator[](n);
      }
      void set(const Node& n, const _Value& value) {
	if (!n.backward) 
	  ParentMap1::set(n, value);
	else 
	  ParentMap2::set(n, value);
      }
      using ParentMap1::operator[];
      using ParentMap2::operator[];
    };

  };


  template <typename _Graph1, typename _Graph2, typename Enable=void>
  class MergeNodeGraphWrapper : public 
  IterableGraphExtender<MergeNodeGraphWrapperBase<_Graph1, _Graph2, Enable> > {
  public:
    typedef _Graph1 Graph1;
    typedef _Graph2 Graph2;
    typedef IterableGraphExtender<
      MergeNodeGraphWrapperBase<_Graph1, _Graph2, Enable> > Parent;
  protected:
    MergeNodeGraphWrapper() { }
  public:
    MergeNodeGraphWrapper(_Graph1& _graph1, _Graph2& _graph2) { 
      Parent::Parent1::setGraph(_graph1);
      Parent::Parent2::setGraph(_graph2);
    }
  };

} //namespace lemon

#endif //LEMON_MERGE_NODE_GRAPH_WRAPPER_H