#include <iostream>
#include <unit++.h>
#include <igraph/igraph.h>
#include <string>

using namespace std;
using namespace unitpp;

// Find the maximum shortest path for inVertex
int getEccentricities(igraph_t* inGraph, igraph_vector_t* outResults, igraph_vs_t inFrom, igraph_neimode_t inMode) {
  // Check to make sure graph isnt empty
  if (igraph_vcount(inGraph)==0) throw string("Empty graph doesn't have any vertices to measure.");

  // Get shortest paths
  igraph_matrix_t lShortestPaths;
  igraph_matrix_init(&lShortestPaths, 0,0);
  igraph_shortest_paths(inGraph, &lShortestPaths, inFrom, inMode);

  // Allocate space for results
  unsigned int lItems = igraph_matrix_nrow(&lShortestPaths);
  igraph_vector_resize(outResults, lItems);

  // Extract results
  for (unsigned int i=0; i<lItems; ++i) {
    // Get row containing shortest paths for vertex i
    igraph_vector_t lRow;
    igraph_vector_init(&lRow, 0);
    igraph_matrix_get_row(&lShortestPaths, &lRow, i);

    // Find maximum shortest path (eccentricity)
    VECTOR(*outResults)[i] = igraph_vector_max(&lRow);
    
    // Clean up row storage
    igraph_vector_destroy(&lRow);
  }

  // Clean up shortest path matrix
  igraph_matrix_destroy(&lShortestPaths);

  return 0;
}

int getRadius(igraph_t* inGraph) {
  // Check we dont have an empty graph
  if (igraph_vcount(inGraph)==0) throw string("Empty graph does not have a radius");

  // Ensure graph is connected
  igraph_bool_t lConnected;
  igraph_is_connected(inGraph, &lConnected, IGRAPH_STRONG);
  if (!lConnected) throw string("The graph is not connected; radius is infinite");

  // Get eccentricities for the graph
  igraph_vector_t lEccentricities;
  igraph_vector_init(&lEccentricities, 0);
  getEccentricities(inGraph, &lEccentricities, igraph_vss_all(), IGRAPH_OUT);

  // Get minimum eccentricity
  unsigned int lRadius = igraph_vector_min(&lEccentricities);

  // Clean up
  igraph_vector_destroy(&lEccentricities);

  return lRadius;
}


namespace {
  class TestRadius : public suite {
    void testRadiusEmptyGraph() {
      igraph_t lEmptyGraph;
      igraph_empty(&lEmptyGraph, 0, true);
      try {
	getRadius(&lEmptyGraph);
 	assert_true("An exception should have been thrown", false);
      }
      catch(string& inException) {
	cout << "Exception expected and caught: " << inException << endl;
 	assert_true("An exception was thrown", true);
      }
    }

    void testRadiusOneVertex() {
      igraph_t lOneVertex;
      igraph_empty(&lOneVertex, 1, true);
      assert_true("one vertex has radius of zero", getRadius(&lOneVertex)==0);
    }

    void testRadiusTwoDisconnectedVertices() {
      igraph_t lDisconnectedGraph;
      igraph_empty(&lDisconnectedGraph, 2, true);
      try {
	getRadius(&lDisconnectedGraph);
 	assert_true("An exception should have been thrown", false);
      }
      catch(string& inException) {
	cout << "Exception expected and caught: " << inException << endl;
 	assert_true("An exception was correctly thrown", true);
      }
    }

    void testEccentricityEmpty() {
      igraph_t lEmptyGraph;
      igraph_empty(&lEmptyGraph, 0, true);
      igraph_vector_t lEccentricities;
      try {
	getEccentricities(&lEmptyGraph, &lEccentricities, igraph_vss_1(0), IGRAPH_OUT);
 	assert_true("An exception should have been thrown", false);
      }
      catch(string& inException) {
	cout << "Exception expected and caught: " << inException << endl;
 	assert_true("An exception was correctly thrown", true);
      }
    }

    void testEccentricityTwoConnectedVertices() {
      igraph_t lGraph;
      igraph_empty(&lGraph, 3, false);
      igraph_add_edge(&lGraph, 0, 1);
      igraph_add_edge(&lGraph, 0, 2);

      igraph_vector_t lEccentricities;
      igraph_vector_init(&lEccentricities, 0);
      getEccentricities(&lGraph, &lEccentricities, igraph_vss_1(0), IGRAPH_OUT);
      unsigned int lEccentricity = VECTOR(lEccentricities)[0];
      igraph_vector_destroy(&lEccentricities);
      assert_true("eccentricity - two connected vertices", lEccentricity==1);
    }

    void testRadiusTwoConnectedVertices() {
      igraph_t lGraph;
      igraph_empty(&lGraph, 2, false);
      igraph_add_edge(&lGraph, 0, 1);
      assert_true("two connected vertices", getRadius(&lGraph)==1);
    }

    void testRadiusSmallGraph() {
      igraph_t lGraph;
      igraph_empty(&lGraph, 5, false);
      igraph_add_edge(&lGraph, 0, 1);
      igraph_add_edge(&lGraph, 1, 2);
      igraph_add_edge(&lGraph, 2, 3);
      igraph_add_edge(&lGraph, 2, 4);
      igraph_add_edge(&lGraph, 3, 4);
      assert_true("small graph", getRadius(&lGraph)==2);
    }

  public:
    TestRadius () : suite("Radius Measure") {
      // add the tests in to the suite
      add("radius - empty graph", 
	  testcase(this, "Radius test", &TestRadius::testRadiusEmptyGraph));
      add("radius - one vertex", 
	  testcase(this, "Radius test", &TestRadius::testRadiusOneVertex));
      add("radius - two disconnected vertices", 
	  testcase(this, "Radius test", &TestRadius::testRadiusTwoDisconnectedVertices));
      add("eccentricity - two disconnected vertices", 
      	  testcase(this, "Radius test", &TestRadius::testEccentricityEmpty));
      add("eccentricity - two connected vertices", 
	  testcase(this, "Radius test", &TestRadius::testEccentricityTwoConnectedVertices));
      add("radius - two connected vertices", 
        testcase(this, "Radius test", &TestRadius::testRadiusTwoConnectedVertices));
      add("radius - small graph", 
        testcase(this, "Radius test", &TestRadius::testRadiusSmallGraph));

      // add this suite to the main suite
      suite::main().add("Radius", this);
    }
  };
  TestRadius* theTest = new TestRadius();
}