#ifndef HUGO_PREFLOW_PUSH_HH

 #define HUGO_PREFLOW_PUSH_HH

 //#include <algorithm>

 #include <list>

 #include <vector>

 #include <queue>

 //#include "pf_hiba.hh"

 //#include <marci_list_graph.hh>

 //#include <marci_graph_traits.hh>

 #include <invalid.h>

 #include <graph_wrapper.h>

 //#include <reverse_bfs.hh>

 using namespace std;

 namespace hugo {

   template <typename Graph, typename T>

   class preflow_push {

     //Useful typedefs

     typedef typename Graph::Node Node;

     typedef typename Graph::NodeIt NodeIt;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::OutEdgeIt OutEdgeIt;

     typedef typename Graph::InEdgeIt InEdgeIt;

     typedef typename Graph::EdgeMap<T> CapacityType;

     typedef ResGraphWrapper<const Graph,int,CapacityType,CapacityType> ResGraphType;

     //---------------------------------------------

     //Parameters of the algorithm

     //---------------------------------------------

     //Fully examine an active node until excess becomes 0

     enum node_examination_t {examine_full, examine_to_relabel};

     //No more implemented yet:, examine_only_one_edge};

     node_examination_t node_examination;

     //Which implementation to be used

     enum implementation_t {impl_fifo, impl_highest_label};

     //No more implemented yet:};

     implementation_t implementation;

     //---------------------------------------------

     //Parameters of the algorithm

     //---------------------------------------------

   private:

     //input

     Graph& G;

     Node s;

     Node t;

     CapacityType &capacity;

     //output

     CapacityType preflow;

     T maxflow_value;

     //auxiliary variables for computation

     //The number of the nodes

     int number_of_nodes;

     //A nodemap for the level

     typename Graph::NodeMap<int> level;

     //A nodemap for the excess

     typename Graph::NodeMap<T> excess;

     //Number of nodes on each level

     vector<int> num_of_nodes_on_level;

     //For the FIFO implementation

     list<Node> fifo_nodes;

     //For 'highest label' implementation

     int highest_active;

     //int second_highest_active;

     vector< list<Node> > active_nodes;

   public:

     //Constructing the object using the graph, source, sink and capacity vector

     preflow_push(

 		      Graph& _G, 

 		      Node _s, 

 		      Node _t, 

 		      typename Graph::EdgeMap<T> & _capacity)

       : G(_G), s(_s), t(_t), 

 	capacity(_capacity), 

 	preflow(_G),

 	//Counting the number of nodes

 	//number_of_nodes(count(G.first<EachNodeIt>())),

 	number_of_nodes(G.nodeNum()),

 	level(_G),

 	excess(_G)//,

         // Default constructor: active_nodes()

     { 

       //Simplest parameter settings

       node_examination = examine_full;//examine_to_relabel;//

       //Which implementation to be usedexamine_full

       implementation = impl_highest_label;//impl_fifo;

       //

       num_of_nodes_on_level.resize(2*number_of_nodes-1);

       num_of_nodes_on_level.clear();

       switch(implementation){

       case impl_highest_label :{

 	active_nodes.clear();

 	active_nodes.resize(2*number_of_nodes-1);

 	break;

       }

       default:

 	break;

       }

     }

     //Returns the value of a maximal flow 

     T run();

     typename Graph::EdgeMap<T>  getmaxflow(){

       return preflow;

     }

   private:

     //For testing purposes only

     //Lists the node_properties

     void write_property_vector(typename Graph::NodeMap<T> a,

 			       //node_property_vector<Graph, T> a, 

 			       char* prop_name="property"){

       for(NodeIt i=G.template first<NodeIt>(); G.valid(i); G.next(i)) {

 	cout<<"Node id.: "<<G.id(i)<<", "<<prop_name<<" value: "<<a[i]<<endl;

       }

       cout<<endl;

     }

     /*

     //Modifies the excess of the node and makes sufficient changes

     void modify_excess(const Node& a ,T v){

       //T old_value=excess[a];

       excess[a] += v;

     }

     //This private procedure is supposed to modify the preflow on edge j

     //by value v (which can be positive or negative as well) 

     //and maintain the excess on the head and tail

     //Here we do not check whether this is possible or not

     void modify_preflow(Edge j, const T& v){

       //Modifiyng the edge

       preflow[j] += v;

       //Modifiyng the head

       modify_excess(G.head(j),v);

       //Modifiyng the tail

       modify_excess(G.tail(j),-v);

     }

     */

     //Gives the active node to work with 

     //(depending on the implementation to be used)

     Node get_active_node(){

       switch(implementation) {

       case impl_highest_label : {

 	//First need to find the highest label for which there's an active node

 	while( highest_active>=0 && active_nodes[highest_active].empty() ){ 

 	  --highest_active;

 	}

 	if( highest_active>=0) {

 	  Node a=active_nodes[highest_active].front();

 	  active_nodes[highest_active].pop_front();

 	  return a;

 	}

 	else {

 	  return INVALID;

 	}

 	break;

       }

       case impl_fifo : {

 	if( ! fifo_nodes.empty() ) {

 	  Node a=fifo_nodes.front();

 	  fifo_nodes.pop_front();

 	  return a;

 	}

 	else {

 	  return INVALID;

 	}

 	break;

       }

       }

       //

       return INVALID;

     }

     //Puts node 'a' among the active nodes

     void make_active(const Node& a){

       //s and t never become active

       if (a!=s && a!= t){

 	switch(implementation){

 	case impl_highest_label :

 	  active_nodes[level[a]].push_back(a);

 	  break;

 	case impl_fifo :

 	  fifo_nodes.push_back(a);

 	  break;

 	}

       }

       //Update highest_active label

       if (highest_active<level[a]){

 	highest_active=level[a];

       }

     }

     //Changes the level of node a and make sufficent changes

     void change_level_to(Node a, int new_value){

       int seged = level[a];

       level.set(a,new_value);

       --num_of_nodes_on_level[seged];

       ++num_of_nodes_on_level[new_value];

     }

     //Collection of things useful (or necessary) to do before running

     void preprocess(){

       //---------------------------------------

       //Initialize parameters

       //---------------------------------------

       //Setting starting preflow, level and excess values to zero

       //This can be important, if the algorithm is run more then once

       for(NodeIt i=G.template first<NodeIt>(); G.valid(i); G.next(i)) {

         level.set(i,0);

         excess.set(i,0);

 	for(OutEdgeIt j=G.template first<OutEdgeIt>(i); G.valid(j); G.next(j)) 

 	  preflow.set(j, 0);

       }

       num_of_nodes_on_level[0]=number_of_nodes;

       highest_active=0;

       //---------------------------------------

       //Initialize parameters

       //---------------------------------------

       //------------------------------------

       //This is the only part that uses BFS

       //------------------------------------

       /*Reverse_bfs from t, to find the starting level.*/

       //Copyright: Jacint

       change_level_to(t,0);

       std::queue<Node> bfs_queue;

       bfs_queue.push(t);

       while (!bfs_queue.empty()) {

 	Node v=bfs_queue.front();	

 	bfs_queue.pop();

 	int l=level[v]+1;

 	InEdgeIt e;

 	for(G.first(e,v); G.valid(e); G.next(e)) {

 	  Node w=G.tail(e);

 	  if ( level[w] == number_of_nodes && w != s ) {

 	    bfs_queue.push(w);

 	    //Node first=level_list[l];

 	    //if ( G.valid(first) ) left.set(first,w);

 	    //right.set(w,first);

 	    //level_list[l]=w;

 	    change_level_to(w, l);

 	    //level.set(w, l);

 	  }

 	}

       }

       change_level_to(s,number_of_nodes);

       //level.set(s,number_of_nodes);

       /*

       //Setting starting level values using reverse bfs

       reverse_bfs<Graph> rev_bfs(G,t);

       rev_bfs.run();

       //write_property_vector(rev_bfs.dist,"rev_bfs");

       for(NodeIt i=G.template first<NodeIt>(); G.valid(i); G.next(i)) {

         change_level_to(i,rev_bfs.dist(i));

 	//level.put(i,rev_bfs.dist.get(i));

       }

       */

       //------------------------------------

       //This is the only part that uses BFS

       //------------------------------------

       //Starting level of s

       change_level_to(s,number_of_nodes);

       //level.put(s,number_of_nodes);

       //we push as much preflow from s as possible to start with

       for(OutEdgeIt j=G.template first<OutEdgeIt>(s); G.valid(j); G.next(j)){ 

 	modify_preflow(j,capacity[j] );

 	make_active(G.head(j));

 	int lev=level[G.head(j)];

 	if(highest_active<lev){

 	  highest_active=lev;

 	}

       }

       //cout<<highest_active<<endl;

     } 

     //If the preflow is less than the capacity on the given edge

     //then it is an edge in the residual graph

     bool is_admissible_forward_edge(Edge j, int& new_level){

       if (capacity[j]>preflow[j]){

 	if(level[G.tail(j)]==level[G.head(j)]+1){

 	  return true;

 	}

 	else{

 	  if (level[G.head(j)] < new_level)

 	    new_level=level[G.head(j)];

 	}

       }

       return false;

     }

     //If the preflow is greater than 0 on the given edge

     //then the edge reversd is an edge in the residual graph

     bool is_admissible_backward_edge(Edge j, int& new_level){

       if (0<preflow[j]){

 	if(level[G.tail(j)]==level[G.head(j)]-1){

 	  return true;

 	}

 	else{

 	  if (level[G.tail(j)] < new_level)

 	    new_level=level[G.tail(j)];

 	}

       }

       return false;

     }

   };  //class preflow_push  

   template<typename Graph, typename T>

     T preflow_push<Graph, T>::run() {

     //We need a residual graph

     ResGraphType res_graph(G, preflow, capacity);

     preprocess();

     //write_property_vector(level,"level");

     T e,v;

     Node a;

     while (a=get_active_node(), G.valid(a)){

       bool go_to_next_node=false;

       e = excess[a];

       while (!go_to_next_node){

 	//Initial value for the new level for the active node we are dealing with

 	int new_level=2*number_of_nodes;

 	//Out edges from node a

 	{

 	  ResGraphType::OutEdgeIt j=res_graph.first(j,a);

 	  while (res_graph.valid(j) && e){

 	    if (is_admissible_forward_edge(j,new_level)){

 	      v=min(e,res_graph.resCap(j));

 	      e -= v;

 	      //New node might become active

 	      if (excess[res_graph.head(j)]==0){

 		make_active(res_graph.head(j));

 	      }

 	      res_graph.augment(j,v);

 	      excess[res_graph.tail(j)] -= v;

 	      excess[res_graph.head(j)] += v;

 	    }

 	    res_graph.next(j);

 	  }

 	}

 	/*

 	//Out edges from node a

 	{

 	  OutEdgeIt j=G.template first<OutEdgeIt>(a);

 	  while (G.valid(j) && e){

 	    if (is_admissible_forward_edge(j,new_level)){

 	      v=min(e,capacity[j] - preflow[j]);

 	      e -= v;

 	      //New node might become active

 	      if (excess[G.head(j)]==0){

 		make_active(G.head(j));

 	      }

 	      modify_preflow(j,v);

 	    }

 	    G.next(j);

 	  }

 	}

 	//In edges to node a

 	{

 	  InEdgeIt j=G.template first<InEdgeIt>(a);

 	  while (G.valid(j) && e){

 	    if (is_admissible_backward_edge(j,new_level)){

 	      v=min(e,preflow[j]);

 	      e -= v;

 	      //New node might become active

 	      if (excess[G.tail(j)]==0){

 		make_active(G.tail(j));

 	      }

 	      modify_preflow(j,-v);

 	    }

 	    G.next(j);

 	  }

 	}

 	*/

 	//if (G.id(a)==999)

 	//cout<<new_level<<" e: "<<e<<endl;

 	//cout<<G.id(a)<<" "<<new_level<<endl;

 	if (0==e){

 	  //Saturating push

 	  go_to_next_node=true;

 	}

 	else{//If there is still excess in node a

 	  //change_level_to(a,new_level+1);

 	  //Level remains empty

 	  if (num_of_nodes_on_level[level[a]]==1){

 	    change_level_to(a,number_of_nodes);

 	    //go_to_next_node=True;

 	  }

 	  else{

 	    change_level_to(a,new_level+1);

 	    //increase_level(a);

 	  }

 	  switch(node_examination){

 	  case examine_to_relabel:

 	    make_active(a);

 	    go_to_next_node = true;

 	    break;

 	  default:

 	    break;

 	  }

 	}//if (0==e)

       }

     }

     maxflow_value = excess[t];

     return maxflow_value;

   }//run

 }//namespace hugo

 #endif //PREFLOW_PUSH_HH