#include <iostream>

 #include <fstream>

 #include <lemon/list_graph.h>

 #include <lemon/smart_graph.h>

 #include <lemon/dimacs.h>

 #include <lemon/preflow.h>

 #include <lemon/full_graph.h>

 #include <merge_node_graph_wrapper.h>

 #include<lemon/concept_check.h>

 #include<lemon/concept/graph.h>

 using std::cout;

 using std::endl;

 using namespace lemon;

 using namespace lemon::concept;

 class Graph3 : ListGraph {

 public:

   class Node : public ListGraph::Node { };

   class Edge { };

 };

 template <typename Graph>

 void printGraph(const Graph& g) {

   cout << " nodes:" << endl;

   for (typename Graph::NodeIt n(g); n!=INVALID; ++n) { 

     cout << "  " << g.id(n) << ": out edges:" << endl;

     for (typename Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) 

       cout << "   " << g.id(g.source(e)) << "->" << g.id(g.target(e)) << endl;

   }

   cout << " edges:" << endl;

   for (typename Graph::EdgeIt e(g); e!=INVALID; ++e) { 

     cout << "   " << g.id(e) << ": " 

 	 << g.id(g.source(e)) << "->" << g.id(g.target(e)) << endl;

   }  

 }

 int main() {

   {

     cout << "FIRST TEST" << endl;

     //typedef SmartGraph Graph1;

     typedef ListGraph Graph1;

     typedef ListGraph Graph2;

     typedef SmartGraph Graph3;

 //     {

 //       checkConcept<StaticGraph, MergeEdgeGraphWrapper<Graph1, Graph2> >();   

 //       MergeEdgeGraphWrapper<Graph1, Graph2>::printNode(); 

 //       MergeEdgeGraphWrapper<Graph1, Graph2>::printEdge(); 

 //       checkConcept<StaticGraph, MergeEdgeGraphWrapper<Graph1, Graph1> >();   

 //       MergeEdgeGraphWrapper<Graph1, Graph1>::printNode(); 

 //       MergeEdgeGraphWrapper<Graph1, Graph1>::printEdge(); 

 //       typedef ResGraphWrapper<Graph1, int, 

 // 	ConstMap<Graph1, int>, ConstMap<Graph1, int> > Graph4;

 //       checkConcept<StaticGraph, MergeEdgeGraphWrapper<Graph1, Graph4> >();   

 //       MergeEdgeGraphWrapper<Graph1, Graph4>::printNode(); 

 //       MergeEdgeGraphWrapper<Graph1, Graph4>::printEdge();

 //       checkConcept<StaticGraph, MergeEdgeGraphWrapper<Graph4, Graph1> >();   

 //       MergeEdgeGraphWrapper<Graph4, Graph1>::printNode(); 

 //       MergeEdgeGraphWrapper<Graph4, Graph1>::printEdge();  

 //     }

     Graph1 g1;

     Graph2 g2;

     typedef MergeEdgeGraphWrapper<Graph1, Graph2> GW;

     GW gw(g1, g2);

     Graph1::Node s1, t1;

     Graph2::Node s2, t2;

     Graph1::EdgeMap<int> cap1(g1);

     Graph2::EdgeMap<int> cap2(g2);

     std::ifstream f1("graph1.dim");

     std::ifstream f2("graph2.dim");

     readDimacs(f1, g1);

     readDimacs(f2, g2);

 //     GW::NodeMap<int> ize(gw, 8);

 //     for (GW::NodeIt n(gw); n!=INVALID; ++n) ize.set(n, 9);

 //     GW::EdgeMap<int> mize(gw, 8);

 //     for (GW::EdgeIt n(gw); n!=INVALID; ++n) mize.set(n, 7);

 //     std::ifstream f1("flow-1.dim");

 //     std::ifstream f2("flow2.dim");

 //     readDimacs(f1, g1, cap1, s1, t1);

 //     readDimacs(f2, g2, cap2, s2, t2);

 //     GW::EdgeMap<int> cap(gw);

 //     for (GW::EdgeIt e(gw); e!=INVALID; ++e) {

 //       if (gw.forward(e)) cap.set(e, cap1[e]);

 //       if (gw.backward(e)) cap.set(e, cap2[e]);

 //     }

 //     {

 //       GW::EdgeMap<int> flow(gw, 0);

 //       Preflow<GW, int> preflow(gw, GW::Node(s1, INVALID, false), 

 // 			       GW::Node(t1, INVALID, false), cap, flow);

 //       preflow.run();

 //       std::cout << "s1->t1: " << preflow.flowValue() << std::endl; 

 //     }

 //     {

 //       GW::EdgeMap<int> flow(gw, 0);

 //       Preflow<GW, int> preflow(gw, GW::Node(INVALID, s2, true), 

 // 			       GW::Node(INVALID, t2, true), cap, flow);

 //       preflow.run();

 //       std::cout << "s2->t2: " << preflow.flowValue() << std::endl; 

 //     }

 //     {

 //       GW::EdgeMap<int> flow(gw, 0);

 //       Preflow<GW, int> preflow(gw, GW::Node(s1, INVALID, false), 

 // 			       GW::Node(INVALID, t2, true), cap, flow);

 //       preflow.run();

 //       std::cout << "s1->t2: " << preflow.flowValue() << std::endl; 

 //     }

 //     {

 //       GW::EdgeMap<int> flow(gw, 0);

 //       Preflow<GW, int> preflow(gw, GW::Node(INVALID, s2, true), 

 // 			       GW::Node(s1, INVALID, false), cap, flow);

 //       preflow.run();

 //       std::cout << "s2->t1: " << preflow.flowValue() << std::endl; 

 //     }

      cout << "1st graph" << endl;

      printGraph(g1);

      cout << "2nd graph" << endl;

      printGraph(g2);

      cout << "merged graph" << endl;

      printGraph(gw);

 //      for (GW::NodeIt n(gw); n!=INVALID; ++n) 

 //        std::cout << ize[n] << std::endl;

 //      for (GW::EdgeIt n(gw); n!=INVALID; ++n) 

 //        std::cout << mize[n] << std::endl;

      typedef NewEdgeSetGraphWrapper2<GW, Graph3> GWW;

 //     {

 //       checkConcept<StaticGraph, GWW>();   

 //     }

      GWW gww(gw);

      cout << "new edges graph" << endl;

      printGraph(gww);

      GWW::NodeIt n(gww);

      GWW::Node n1=n; 

      ++n;

      GWW::Node n2=n; 

      gww.addEdge(n1, n2);

      //     gww.addNode();

      //     gww.addNode();

      cout << "new edges graph" << endl;

      printGraph(gww);

      typedef AugmentingGraphWrapper<GW, GWW> GWWW;

      //     {

      //       checkConcept<StaticGraph, GWWW>();   

      //     }

      GWWW gwww(gw, gww);

      cout << "fully merged graph" << endl;

      printGraph(gwww);

   }

   {

     cout << "SECOND TEST" << endl;

     typedef SmartGraph Graph1;

 //     {

 //       checkConcept<StaticGraph, Graph1>();

 //     }

     Graph1 g1;

     FullGraph pre_g2(2);

     ConstMap<FullGraph::Edge, bool> const_false_map(false);

     typedef EdgeSubGraphWrapper<FullGraph, ConstMap<FullGraph::Edge, bool> >

       Graph2;

 //     {

 //       checkConcept<StaticGraph, Graph2>();

 //     }

     Graph2 g2(pre_g2, const_false_map);

     typedef MergeEdgeGraphWrapper<Graph1, Graph2> GW;

 //     {

 //       checkConcept<StaticGraph, GW>();   

 //     }

     GW gw(g1, g2);

     GW::Node sw;

     GW::Node tw;

     {

       Graph2::NodeIt k(g2);

       sw=GW::Node(INVALID, k, true);

       ++k;

       tw=GW::Node(INVALID, k, true);

     }

     std::ifstream f1("graph2.dim");

     readDimacs(f1, g1);

     cout << "1st graph" << endl;

     printGraph(g1);

     cout << "2nd graph" << endl;

     printGraph(g2);

     cout << "merged graph" << endl;

     printGraph(gw);

     typedef ListGraph Graph3;

     //typedef SmartGraph Graph3;

     Graph3 g3;

     GW::NodeMap<Graph3::Node> gwn(gw);

     Graph3::NodeMap<GW::Node> g3n(g3);

     for (GW::NodeIt n(gw); n!=INVALID; ++n) {

       Graph3::Node m=g3.addNode();

       gwn.set(n, m);

       g3n.set(m, n);

     }

     typedef NewEdgeSetGraphWrapper<GW, Graph3> GWW;

 //     {

 //       checkConcept<StaticGraph, GWW>();   

 //     }

     GWW gww(gw, g3, gwn, g3n);

     for (Graph1::NodeIt n(g1); n!=INVALID; ++n) {

       g3.addEdge(gwn[sw], gwn[GW::Node(n,INVALID,false)]);

     }

 //     for (Graph1::NodeIt n(g1); n!=INVALID; ++n) {

 //       gww.addEdge(sw, GW::Node(n,INVALID,false));

 //     }

     cout << "new edges" << endl;

     printGraph(g3);

     cout << "new edges in the new graph" << endl;

     printGraph(gww);

     typedef AugmentingGraphWrapper<GW, GWW> GWWW;

 //     {

 //       checkConcept<StaticGraph, GWWW>();   

 //     }

     GWWW gwww(gw, gww);

     cout << "new edges merged into the original graph" << endl;

     printGraph(gwww);

   }

 }