// -*- mode:C++ -*-

#include<math.h>

#include<hugo/list_graph.h>

#include<hugo/smart_graph.h>

#include<hugo/dijkstra.h>

#include<hugo/max_flow.h>

#include"bench_tools.h"

using namespace std;

using namespace hugo;

inline int numOfOnes(int n,int dim)

{

  int s=0;

  for(int i=0;i<dim;i++) {

    s+=n%2;

    n>>=1;

  }

  return s;

}

inline int numOfZeros(int n,int dim)

{

  int s=dim;

  for(int i=0;i<dim;i++) {

    s-=n&1;

    n>>=1;

  }

  return s;

}

template<class Graph>

void bfsStlQueue(Graph &G,typename Graph::Node source)

{

  GRAPH_TYPEDEF_FACTORY(Graph);

  using namespace std;

  typename Graph::template NodeMap<bool> visited(G,false);

  queue<typename Graph::Node> Q;

  Q.push(source);

  visited[source]=true;

  do {

    Node n(Q.front());

    Node m;

    Q.pop();

    for(OutEdgeIt e(G,n);G.valid(e);G.next(e))

      if(!visited[m=G.head(e)]) {

	Q.push(m);

	visited.set(m,true);

      }

  } while(!Q.empty());

}

template<class Graph>

void bfsOwnQueue(Graph &G,typename Graph::Node source)

{

  GRAPH_TYPEDEF_FACTORY(Graph);

  using namespace std;

  typename Graph::template NodeMap<bool> visited(G,false);

  int N=G.nodeNum();

  vector<typename Graph::Node> Q(N);

  int Qh=0;

  int Qt=0;

  Q[Qh++]=source;

  visited.set(source,true);

  do {

    Node m;

    Node n=Q[Qt++];

    for(OutEdgeIt e(G,n);G.valid(e);G.next(e))

      if(!visited[m=G.head(e)]) {

	Q[Qh++]=m;

	visited.set(m,true);

      }

  } while(Qt!=Qh);

}

template<class Graph>

void iteratorBench(Graph &G)

{

  GRAPH_TYPEDEF_FACTORY(Graph);

  int i=0;

  for(NodeIt n(G);G.valid(n);G.next(n))

    for(OutEdgeIt e(G,n);G.valid(e);G.next(e))

      i++;

}

int main(int argc, char *argv[])

{

  //  typedef ListGraph Graph;

  typedef SmartGraph Graph;

  ///\bug GRAPH_TYPEDEF_FACTORY(Graph);

  GRAPH_TYPEDEF_FACTORY_NOTYPENAME(Graph);

  Graph G;

  Timer T;

  if(argc!=3) {

    cout << "Usage: " << argv[0] << " dim mul\n";

    return 1;

  }

  int dim=atoi(argv[1]);

  int mul=atoi(argv[2]);

//   cout << "Creating Hipercube ("<< (1<<dim) << " nodes, "

//        << dim*(1<<dim) << " edges):";

  T.reset();

  vector<Node> nodes;

  addBiDirHiperCube(G,dim,nodes);

  PrintTime("GENGRAPH",T);

  T.reset();

  {

    for(int i=0;i<mul;i++)

      bfsStlQueue(G,nodes[0]);

  }

  PrintTime("BFS-STL",T);

  T.reset();

  {

    for(int i=0;i<mul;i++)

      bfsOwnQueue(G,nodes[0]);

  }

  PrintTime("BFS-OWN",T);

  T.reset();

  {

    for(int i=0;i<mul;i++)

      iteratorBench(G);

  }

  PrintTime("ITERATE",T);

}