#include <iostream>

#include <fstream>

#include <list_graph.hh>

#include <dimacs.hh>

#include <edmonds_karp.hh>

#include <time_measure.h>

#include <graph_wrapper.h>

using namespace hugo;

// Use a DIMACS max flow file as stdin.

// read_dimacs_demo < dimacs_max_flow_file

/*

  struct Ize {

  };

  struct Mize {

    Ize bumm;

  };

  template <typename B>

    class Huha {

    public:

      int u;

      B brr;

    };

*/

int main(int, char **) {

  typedef ListGraph::NodeIt NodeIt;

  typedef ListGraph::EachEdgeIt EachEdgeIt;

/*

  Mize mize[10];

  Mize bize[0];

  Mize zize;

  typedef Mize Tize[0];

  std::cout << &zize << " " << sizeof(mize) << sizeof(Tize) << std::endl;

  std::cout << sizeof(bize) << std::endl;

  Huha<Tize> k;

  std::cout << sizeof(k) << std::endl;

  struct Bumm {

    //int a;

    bool b;

  };

  std::cout << sizeof(Bumm) << std::endl;

*/

  ListGraph G;

  NodeIt s, t;

  ListGraph::EdgeMap<int> cap(G);

  readDimacsMaxFlow(std::cin, G, s, t, cap);

/*

  typedef TrivGraphWrapper<ListGraph> TGW;

  TGW gw(G);

  TGW::EachNodeIt sw;

  gw.getFirst(sw);

  std::cout << "p1:" << gw.nodeNum() << std::endl;

  gw.erase(sw);

  std::cout << "p2:" << gw.nodeNum() << std::endl;

  typedef const ListGraph cLG;

  typedef TrivGraphWrapper<const cLG> CTGW;

  CTGW cgw(G);

  CTGW::EachNodeIt csw;

  cgw.getFirst(csw);

  std::cout << "p1:" << cgw.nodeNum() << std::endl;

  //cgw.erase(csw);

  std::cout << "p2:" << cgw.nodeNum() << std::endl;

*/

  {

  std::cout << "edmonds karp demo (blocking flow augmentation)..." << std::endl;

  ListGraph::EdgeMap<int> flow(G); //0 flow

  Timer ts;

  ts.reset();

  //double pre_time=currTime();

  MaxFlow<ListGraph, int, ListGraph::EdgeMap<int>, ListGraph::EdgeMap<int> > max_flow_test(G, s, t, flow, cap);

  //max_flow_test.augmentWithBlockingFlow<ListGraph>();

  int i=0;

  while (max_flow_test.augmentOnBlockingFlow<ListGraph>()) { 

//     for(EachEdgeIt e=G.template first<EachEdgeIt>(); e.valid(); ++e) { 

//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";

//     }

//     std::cout<<std::endl;

    ++i; 

  }

  //double post_time=currTime();

  //std::cout << "maximum flow: "<< std::endl;

  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) { 

  //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";

  //}

  //std::cout<<std::endl;

  std::cout << "elapsed time: " << ts << std::endl;

  std::cout << "number of augmentation phases: " << i << std::endl; 

  std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;

  }

  {

  std::cout << "edmonds karp demo (blocking flow augmentation)..." << std::endl;

  ListGraph::EdgeMap<int> flow(G); //0 flow

  Timer ts;

  ts.reset();

  //double pre_time=currTime();

  MaxFlow<ListGraph, int, ListGraph::EdgeMap<int>, ListGraph::EdgeMap<int> > max_flow_test(G, s, t, flow, cap);

  //max_flow_test.augmentWithBlockingFlow<ListGraph>();

  int i=0;

  while (max_flow_test.augmentOnBlockingFlow2()) { 

//     for(EachEdgeIt e=G.template first<EachEdgeIt>(); e.valid(); ++e) { 

//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";

//     }

//     std::cout<<std::endl;

    ++i; 

  }

  //double post_time=currTime();

  //std::cout << "maximum flow: "<< std::endl;

  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) { 

  //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";

  //}

  //std::cout<<std::endl;

  std::cout << "elapsed time: " << ts << std::endl;

  std::cout << "number of augmentation phases: " << i << std::endl; 

  std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;

  }

  {

  std::cout << "edmonds karp demo (shortest path augmentation)..." << std::endl;

  ListGraph::EdgeMap<int> flow(G); //0 flow

  Timer ts;

  ts.reset();

  //double pre_time=currTime();

  MaxFlow<ListGraph, int, ListGraph::EdgeMap<int>, ListGraph::EdgeMap<int> > max_flow_test(G, s, t, flow, cap);

  //max_flow_test.augmentWithBlockingFlow<ListGraph>();

  int i=0;

  while (max_flow_test.augmentOnShortestPath()) { 

//     for(EachEdgeIt e=G.template first<EachEdgeIt>(); e.valid(); ++e) { 

//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";

//     }

//     std::cout<<std::endl;

    ++i; 

  }

  //double post_time=currTime();

  //std::cout << "maximum flow: "<< std::endl;

  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) { 

  //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";

  //}

  //std::cout<<std::endl;

  std::cout << "elapsed time: " << ts << std::endl;

  std::cout << "number of augmentation phases: " << i << std::endl; 

  std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;

  }

  return 0;

}