/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, 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.
 *
 */

#include <iostream>
#include <vector>

#include <cmath>
#include <cstdlib>

#include <lemon/smart_graph.h>
#include <lemon/dijkstra.h>
#include <lemon/floyd_warshall.h>
#include <lemon/johnson.h>

#include <lemon/fib_heap.h>

#include <lemon/path.h>

#include <lemon/time_measure.h>
#include "test_tools.h"

using namespace lemon;
using namespace std;

int main(int argc, const char *argv[]) {
  typedef SmartGraph Graph;
  typedef Graph::Node Node;
  typedef Graph::Edge Edge;
  typedef Graph::NodeIt NodeIt;
  typedef Graph::EdgeIt EdgeIt;

  typedef Graph::EdgeMap<int> LengthMap;
  typedef Graph::NodeMap<int> DistMap;

  const int n = argc > 1 ? atoi(argv[1]) : 20;
  const int e = argc > 2 ? atoi(argv[2]) : int(n * log(double(n)));
  const int m = argc > 3 ? atoi(argv[3]) : 100;

  Graph graph;
  LengthMap length(graph);
  vector<Node> nodes;
  
  DistMap shift(graph);
  for (int i = 0; i < n; ++i) {
    Node node = graph.addNode();
    nodes.push_back(node);
    shift[node] = rnd[m];
  }

  for (int i = 0; i < e; ++i) {
    int s = rnd[n];
    int t = rnd[n];
    Edge edge = graph.addEdge(nodes[s], nodes[t]);
    length[edge] = rnd[m] - shift[nodes[s]] + shift[nodes[t]];
  }

  Johnson<Graph, LengthMap> johnson(graph, length);
  {
    Timer timer;
    johnson.run();
    cout << "Johnson: " << timer << endl;
  }

  typedef FibHeap<int, Graph::NodeMap<int> > IntFibHeap;
  Johnson<Graph, LengthMap>::DefStandardHeap<IntFibHeap>
    ::Create fibJohnson(graph, length);
  {
    Timer timer;
    fibJohnson.run();
    cout << "Johnson with fibonacci heap: " << timer << endl;
  }

  FloydWarshall<Graph, LengthMap> floyd(graph, length);
  {
    Timer timer;
    floyd.run();
    cout << "FloydWarshall: " << timer << endl;
  }    

  bool checked_path = false;

  for (NodeIt it(graph); it != INVALID; ++it) {
    for (NodeIt jt(graph); jt != INVALID; ++jt) {
      check(johnson.connected(it, jt) == floyd.connected(it, jt),
	    "Wrong connection in all pairs shortest path");
      check(johnson.connected(it, jt) == fibJohnson.connected(it, jt),
	    "Wrong connection in all pairs shortest path");
      if (johnson.connected(it, jt)) {
        if (it != jt && !checked_path) {
          {
            Path<Graph> path = johnson.path(it, jt);
            check(checkPath(graph, path), "Wrong path.");
            check(pathSource(graph, path) == it, "Wrong path.");
            check(pathTarget(graph, path) == jt, "Wrong path.");
          }
          {
            Path<Graph> path = floyd.path(it, jt);
            check(checkPath(graph, path), "Wrong path.");
            check(pathSource(graph, path) == it, "Wrong path.");
            check(pathTarget(graph, path) == jt, "Wrong path.");
          }
          checked_path = true;
          std::cout << "Path checked" << std::endl;
        }
	check(johnson.dist(it, jt) == floyd.dist(it, jt),
	      "Wrong distance in all pairs shortest path");
	check(johnson.dist(it, jt) == fibJohnson.dist(it, jt),
	      "Wrong distance in all pairs shortest path");
	if (it != jt) {
 	  check(johnson.dist(it, jt) == 
		johnson.dist(it, johnson.predNode(it, jt)) +
		length[johnson.predEdge(it, jt)],
		"Wrong edge in all pairs shortest path");
 	  check(fibJohnson.dist(it, jt) == 
		fibJohnson.dist(it, fibJohnson.predNode(it, jt)) +
		length[fibJohnson.predEdge(it, jt)],
		"Wrong edge in all pairs shortest path");
	  check(floyd.dist(it, jt) == 
		floyd.dist(it, floyd.predNode(it, jt)) +
		length[floyd.predEdge(it, jt)],
		"Wrong edge in all pairs shortest path");
	}
      }
    }
  }

  return 0;
}