// -*- c++ -*-

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

#include <lemon/concept_check.h>

#include <lemon/smart_graph.h>

#include <lemon/graph_reader.h>

#include <lemon/bin_heap.h>
#include <lemon/fib_heap.h>
#include <lemon/radix_heap.h>

#include "test_tools.h"

#include "heap_test.h"


using namespace lemon;

template <typename Item, typename Prio, typename ItemIntMap>
class HeapConcept {
public:  

  template <typename _Heap>
  struct Constraints {
  public:
    
    void constraints() {
      Item item;
      Prio prio;

      ignore_unused_variable_warning(item);
      ignore_unused_variable_warning(prio);

      typedef typename _Heap::state_enum state_enum;
      state_enum state;

      ignore_unused_variable_warning(state);
      
      _Heap heap1 = _Heap(map);

      ignore_unused_variable_warning(heap1);
      
      heap.push(item, prio);

      prio = heap.prio();
      item = heap.top();

      heap.pop();

      heap.set(item, prio);
      heap.decrease(item, prio);
      heap.increase(item, prio);
      prio = heap[item];

      heap.erase(item);

      state = heap.state(item);

      state = _Heap::PRE_HEAP;
      state = _Heap::IN_HEAP;
      state = _Heap::POST_HEAP;
    }
    
    _Heap& heap;
    ItemIntMap& map;

    Constraints() : heap(0), map(0) {}
  };
};

int main() {

  typedef int Item;
  typedef int Prio;
  typedef IntIntMap ItemIntMap;

  typedef ListGraph Graph;

  typedef Graph::Edge Edge;
  typedef Graph::Node Node;
  typedef Graph::EdgeIt EdgeIt;
  typedef Graph::NodeIt NodeIt;
  typedef Graph::EdgeMap<int> LengthMap;

  Graph graph;
  LengthMap length(graph);
  Node start;

  /// \todo create own test graph

  std::string f_name;
  if( getenv("srcdir") )
    f_name = std::string(getenv("srcdir"));
  else f_name = ".";
  f_name += "/dijkstra_test.lgf";
  
  std::ifstream input(f_name.c_str());
  check(input, "Input file '" << f_name << "' not found.");
  readGraph(input, graph, length, start);  
 
  {
    std::cerr << "Checking Bin Heap" << std::endl;

    typedef BinHeap<Item, Prio, ItemIntMap> IntHeap;
    checkConcept<HeapConcept<Item, Prio, ItemIntMap>, IntHeap>();
    heapSortTest<IntHeap>(100);
    heapIncreaseTest<IntHeap>(100);
    
    typedef FibHeap<Node, Prio, Graph::NodeMap<int> > NodeHeap;
    checkConcept<HeapConcept<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();
    dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);
  }
  {
    std::cerr << "Checking Fib Heap" << std::endl;

    typedef FibHeap<Item, Prio, ItemIntMap> IntHeap;
    checkConcept<HeapConcept<Item, Prio, ItemIntMap>, IntHeap>();
    heapSortTest<IntHeap>(100);
    heapIncreaseTest<IntHeap>(100);

    typedef FibHeap<Node, Prio, Graph::NodeMap<int> > NodeHeap;
    checkConcept<HeapConcept<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();
    dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);
  }
  {
    std::cerr << "Checking Radix Heap" << std::endl;

    typedef RadixHeap<Item, ItemIntMap> IntHeap;
    checkConcept<HeapConcept<Item, Prio, ItemIntMap>, IntHeap>();
    heapSortTest<IntHeap>(100);
    heapIncreaseTest<IntHeap>(100);

    typedef RadixHeap<Node, Graph::NodeMap<int> > NodeHeap;
    checkConcept<HeapConcept<Node, Prio, Graph::NodeMap<int> >, NodeHeap>();
    dijkstraHeapTest<Graph, LengthMap, NodeHeap>(graph, length, start);
  }

  std::cout << __FILE__ ": All tests passed.\n";

  return 0;
}