// -*- c++ -*-

#include <iostream>

#include <vector>

#include <lemon/concept_check.h>

#include <lemon/concept/matrix_maps.h>

#include <lemon/concept/maps.h>

#include <lemon/concept/graph.h>

#include <lemon/matrix_maps.h>

#include <lemon/smart_graph.h>

#include "test_tools.h"

#include "graph_test.h"

#include "map_test.h"

using namespace lemon;

using namespace lemon::concept;

int main() {

  typedef SmartGraph Graph;

  typedef Graph::Node Node;

  { // checking MatrixMap for int

    typedef DynamicMatrixMap<Graph, Node, int> IntMatrixMap;

    checkConcept<ReferenceMatrixMap<Node, Node, int, 

      IntMatrixMap::Reference, IntMatrixMap::ConstReference>,

      IntMatrixMap>();

  }

  { // checking MatrixMap for bool

    typedef DynamicMatrixMap<Graph, Node, bool> BoolMatrixMap;

    checkConcept<ReferenceMatrixMap<Node, Node, bool, 

      BoolMatrixMap::Reference, BoolMatrixMap::ConstReference>,

      BoolMatrixMap>();

  }

  {

    Graph graph;

    typedef DynamicMatrixMap<Graph, Node, int> IntMatrixMap;

    IntMatrixMap matrix(graph);

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

      graph.addNode();

    }

    for (Graph::NodeIt it(graph); it != INVALID; ++it) {

      for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

	int val = urandom(100);

	matrix.set(it, jt, val);

	check(matrix(it, jt) == val, "Wrong assign");

	check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");

	check(matrix(it, jt) == matrixColMap(matrix, jt)[it], "Wrong colMap");

      }

    }

    const IntMatrixMap& cm = matrix;

    for (Graph::NodeIt it(graph); it != INVALID; ++it) {

      for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

	check(cm(it, jt) == matrixRowMap(cm, it)[jt], "Wrong rowMap");

	check(cm(it, jt) == matrixColMap(cm, jt)[it], "Wrong colMap");

      }

    }

  }

  { // checking MatrixMap for int

    typedef DynamicSymMatrixMap<Graph, Node, int> IntMatrixMap;

    checkConcept<ReferenceMatrixMap<Node, Node, int, 

      IntMatrixMap::Reference, IntMatrixMap::ConstReference>,

      IntMatrixMap>();

  }

  { // checking MatrixMap for bool

    typedef DynamicSymMatrixMap<Graph, Node, bool> BoolMatrixMap;

    checkConcept<ReferenceMatrixMap<Node, Node, bool, 

      BoolMatrixMap::Reference, BoolMatrixMap::ConstReference>,

      BoolMatrixMap>();

  }

  {

    Graph graph;

    typedef DynamicSymMatrixMap<Graph, Node, int> IntMatrixMap;

    IntMatrixMap matrix(graph);

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

      graph.addNode();

    }

    for (Graph::NodeIt it(graph); it != INVALID; ++it) {

      for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

	int val = urandom(100);

	matrix.set(it, jt, val);

	check(matrix(it, jt) == val, "Wrong assign");

	check(matrix(jt, it) == val, "Wrong assign");

	check(matrix(it, jt) == matrixRowMap(matrix, it)[jt], "Wrong rowMap");

	check(matrix(it, jt) == matrixColMap(matrix, jt)[it], "Wrong colMap");

      }

    }

    const IntMatrixMap& cm = matrix;

    for (Graph::NodeIt it(graph); it != INVALID; ++it) {

      for (Graph::NodeIt jt(graph); jt != INVALID; ++jt) {

	check(cm(it, jt) == matrixRowMap(cm, it)[jt], "Wrong rowMap");

	check(cm(it, jt) == matrixColMap(cm, jt)[it], "Wrong colMap");

      }

    }

  }

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

  return 0;

}