#include <string>

#include <iostream>

#include <path.h>

#include <list_graph.h>

using namespace std;

using namespace hugo;

bool passed = true;

void check(bool rc) {

  passed = passed && rc;

  if(!rc) {

    cout << "Test failed!" << endl;

  }

}

#ifdef DEBUG

const bool debug = true;

#else

const bool debug = false;

#endif

int main() {

  try {

    typedef ListGraph::Node Node;

    typedef ListGraph::Edge Edge;

    ListGraph G;

    Node s=G.addNode();

    Node v1=G.addNode();

    Node v2=G.addNode();

    Node v3=G.addNode();

    Node v4=G.addNode();

    Node t=G.addNode();

    Edge e1 = G.addEdge(s, v1);

    Edge e2 = G.addEdge(s, v2);

    Edge e3 = G.addEdge(v1, v2);

    Edge e4 = G.addEdge(v2, v1);

    Edge e5 = G.addEdge(v1, v3);

    Edge e6 = G.addEdge(v3, v2);

    Edge e7 = G.addEdge(v2, v4);

    Edge e8 = G.addEdge(v4, v3);

    Edge e9 = G.addEdge(v3, t);

    Edge e10 = G.addEdge(v4, t);

    bool rc;

    {

      cout << "\n\n\nDirPath tesztelese...\n";

      cout << "Ures path letrehozasa" << endl;

      typedef DirPath<ListGraph> DPath;

      DPath P(G);

      cout << "P.length() == " << P.length() << endl;

      check(P.length() == 0);

      cout << "P.from() valid? " << G.valid(P.from()) << endl;

      check(! G.valid(P.from()));

      {

	cout << "Builder objektum letrehozasa" << endl;

	DPath::Builder B(P);

	cout << "Hozzaadunk az elejehez ket elet..." << endl;

	B.pushFront(e6);

	B.pushFront(e5);

	cout << "P.length() == " << P.length() << endl;

	check(P.length() == 0);

	cout << "Commitolunk..." << endl;

	B.commit();

	cout << "P.length() == " << P.length() << endl;

	check(P.length() == 2);

	cout << "P.from() valid? " << G.valid(P.from()) << endl;

	check(G.valid(P.from()));

	cout << "P.from()==v1 ? " << (P.from()==v1) << endl;

	check(P.from() == v1);

	// Na ja, ez igy nem igazi, mindket esetet le kene tesztelni,

	// de legalabb valami:

#ifdef DEBUG

	cout << "Hozzaadunk az elejehez egy nem illeszkedo elet..." << endl;

	rc = false;

	try {

	  B.pushFront(e3);

	}

	catch(const Exception &e) {

	  cout << "E: " << e.what() << endl;

	  rc = true;

	}

	check(rc);

#endif

	cout << "Hozzaadunk a vegehez ket elet..." << endl;

	B.pushBack(e7);

	B.pushBack(e8);

	cout << "P.length() == " << P.length() << endl;

	check(P.length() == 2);

	cout << "Es commitolunk...\n";

	B.commit();

      }

      cout << "P.length() == " << P.length() << endl;

      check(P.length() == 4);

      cout << "P.to()==v3 ? " << (P.to()==v3) << endl;

      check(P.to() == v3);

      cout << "Vegigiteralunk az eleken." << endl;

      typedef DPath::NodeIt NodeIt;

      typedef DPath::EdgeIt EdgeIt;

      EdgeIt e;

      int i=1;

      for(P.first(e); P.valid(e); P.next(e), ++i) {

	cout << i << ". el: " << e << endl;

      }

      // Na ja, ez igy nem igazi, mindket esetet le kene tesztelni,

      // de legalabb valami:

      rc = false;

      try {

	cout << "Setting an edgeiter to a nonexistant edge." << endl;

	P.nth(e,134);

	rc = !debug;

      }

      catch(const Exception &e) {

	cout << "E: " << e.what() << endl;

	rc = debug;

      }

      check(rc);

    }

  }

  catch(const std::exception &e) {

    cout << "Uncaught exception: " << e.what() << endl;

    return 1;

  }

  catch(...) {

    cout << "Something horrible happened: an exception which isn't "

	 << "std::exception" << endl;

    return 2;

  }

  cout << (passed ? "All tests passed." : "Some of the tests failed!!!")

       << endl;

  return passed ? 0 : 1;

}