<?php

/**
 * This file is part of the Propel package.
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @license    MIT License
 */

if (!isset($argc)) echo "<pre>";

error_reporting(E_ALL);

$conf_path = realpath(dirname(__FILE__) . '/fixtures/treetest/build/conf/treetest-conf.php');
if (!file_exists($conf_path)) {
	echo "Make sure that you specify properties in conf/treetest.properties and "
	."build propel before running this script.";
	exit;
}

// Add PHP_CLASSPATH, if set
if (getenv("PHP_CLASSPATH")) {
	set_include_path(getenv("PHP_CLASSPATH") . PATH_SEPARATOR . get_include_path());
}

 // Add build/classes/ and classes/ to path
set_include_path(
	realpath(dirname(__FILE__) . '/fixtures/treetest/build/classes') . PATH_SEPARATOR .
	dirname(__FILE__) . '/../runtime/classes' . PATH_SEPARATOR .
	get_include_path()
);


// Require classes.
require_once 'propel/Propel.php';
require_once 'treetest/TestNodePeer.php';

function dumpTree($node, $querydb = false, $con = null)
{
	$opts = array('querydb' => $querydb,
				  'con' => $con);

	$node->setIteratorOptions('pre', $opts);

	$indent = 0;
	$lastLevel = $node->getNodeLevel();

	foreach ($node as $n)
	{
		$nodeLevel = $n->getNodeLevel();
		$indent += $nodeLevel - $lastLevel;
		echo str_repeat('  ',  $indent);
		echo $n->getNodePath() . " -> " . $n->getLabel();
		echo "\n";
		$lastLevel = $nodeLevel;
	}
}

try {
	// Initialize Propel
	 Propel::init($conf_path);
} catch (Exception $e) {
	die("Error initializing propel: ". $e->__toString());
}

try {

	$nodeKeySep = TestNodePeer::NPATH_SEP;

	echo "\nCreating initial tree:\n";
	echo "-------------------------------------\n";

	$a = new Test();
	$a->setLabel("a");
	$a = TestNodePeer::createNewRootNode($a);
	echo "Created 'a' as new root\n";

	$b = new TestNode();
	$b->setLabel('b');
	$a->addChildNode($b);
	echo "Added 'b' as first child of 'a'\n";

	$c = new TestNode();
	$c->setLabel('c');
	$a->addChildNode($c);
	echo "Added 'c' as second child of 'a'\n";

	$f = new TestNode();
	$f->setLabel('f');
	$b->addChildNode($f);
	echo "Added 'f' as first child of 'b'\n";

	$d = new TestNode();
	$d->setLabel('d');
	$b->addChildNode($d, $f);
	echo "Added 'd' as first child of 'b' before 'f' (insert before first child test - f is now second child)\n";

	$e = new TestNode();
	$e->setLabel('e');
	$b->addChildNode($e, $f);
	echo "Added 'e' as second child of 'b' before 'f' (insert before last child test - f is now third child)\n";

	$g = new TestNode();
	$g->setLabel('g');
	$c->addChildNode($g);
	echo "Added 'g' as first child of 'c'\n";

	$h = new TestNode();
	$h->setLabel('h');
	$c->addChildNode($h);
	echo "Added 'h' as second child of 'c'\n";

	$i = new TestNode();
	$i->setLabel('i');
	$d->addChildNode($i);
	echo "Added 'i' as first child of 'd'\n";

	$j = new TestNode();
	$j->setLabel('j');
	$f->addChildNode($j);
	echo "Added 'j' as first child of 'f'\n";

	$k = new TestNode();
	$k->setLabel('k');
	$j->addChildNode($k);
	echo "Added 'k' as first child of 'j'\n";

	$l = new TestNode();
	$l->setLabel('l');
	$j->addChildNode($l);
	echo "Added 'l' as second child of 'j'\n";

	dumpTree($a);


	echo "\n\nDeleting 'd' node sub-tree:\n";
	echo "-------------------------------------\n";

	$d->delete();

	dumpTree($a);


	echo "\n\nMove node tests:\n";
	echo "-------------------------------------\n";

	echo "Move 'j' sub-tree to 'b' before 'e' (move tree/insert before first child test):\n";
	$b->addChildNode($j, $e);
	dumpTree($a);

	echo "\nMove 'j' sub-tree to 'c' (move tree after last child test):\n";
	$c->addChildNode($j);
	dumpTree($a);

	echo "\nMove 'j' sub-tree to 'g' (move tree to first child test):\n";
	$g->addChildNode($j);
	dumpTree($a);


	echo "\n\nCreating new (in-memory) sub-tree:\n";
	echo "-------------------------------------\n";

	$m = new TestNode();
	$m->setLabel('m');
	echo "Created 'm' as root of new sub-tree\n";

	$n = new TestNode();
	$n->setLabel('n');
	$m->addChildNode($n);
	echo "Added 'n' as first child of 'm'\n";

	$o = new TestNode();
	$o->setLabel('o');
	$m->addChildNode($o);
	echo "Added 'o' as second child of 'm'\n";

	$r = new TestNode();
	$r->setLabel('r');
	$n->addChildNode($r);
	echo "Added 'r' as first child of 'n'\n";

	$p = new TestNode();
	$p->setLabel('p');
	$n->addChildNode($p, $r);
	echo "Added 'p' as first child of 'n' before 'r' (insert before first child test - r is now second child)\n";

	$q = new TestNode();
	$q->setLabel('q');
	$n->addChildNode($q, $r);
	echo "Added 'q' as second child of 'n' before 'r' (insert before last child test - r is now third child)\n";

	$s = new TestNode();
	$s->setLabel('s');
	$o->addChildNode($s);
	echo "Added 's' as first child of 'o'\n";

	$t = new TestNode();
	$t->setLabel('t');
	$o->addChildNode($t);
	echo "Added 't' as second child of 'o'\n";

	$u = new TestNode();
	$u->setLabel('u');
	$p->addChildNode($u);
	echo "Added 'u' as first child of 'p'\n";

	$v = new TestNode();
	$v->setLabel('v');
	$r->addChildNode($v);
	echo "Added 'v' as first child of 'r'\n";

	$w = new TestNode();
	$w->setLabel('w');
	$v->addChildNode($w);
	echo "Added 'w' as first child of 'v'\n";

	$x = new TestNode();
	$x->setLabel('x');
	$v->addChildNode($x);
	echo "Added 'x' as second child of 'v'\n";

	dumpTree($m);


	echo "\n\nDeleting in-memory 'p' node sub-tree:\n";
	echo "-------------------------------------\n";

	$p->delete();

	dumpTree($m);


	echo "\n\nMove in-memory node tests:\n";
	echo "-------------------------------------\n";

	echo "Move 'v' sub-tree to 'n' before 'q' (move tree/insert before first child test):\n";
	$n->addChildNode($v, $q);
	dumpTree($m);

	echo "\nMove 'v' sub-tree to 'o' (move tree after last child test):\n";
	$o->addChildNode($v);
	dumpTree($m);

	echo "\nMove 'v' sub-tree to 's' (move tree to first child test):\n";
	$s->addChildNode($v);
	dumpTree($m);


	echo "\n\nAdd in-memory 'm' sub-tree to 'a':\n";
	echo "-------------------------------------\n";

	$a->addChildNode($m);

	dumpTree($a);


	echo "\n\nInsert new root node 'z' and retrieve descendants on demand (via querydb param in iterator):\n";
	echo "-------------------------------------\n";
	$z = new Test();
	$z->setLabel("z");
	$z = TestNodePeer::insertNewRootNode($z);

	dumpTree($z, true);

} catch (Exception $e) {
	die("Error creating initial tree: " . $e->__toString());
}

try {

	echo "\n\nTest retrieveRootNode() (without descendants)\n";
	echo "-------------------------------------\n";
	$root = TestNodePeer::retrieveRootNode(false);
	dumpTree($root);


	echo "\n\nTest retrieveRootNode() (with descendants)\n";
	echo "-------------------------------------\n";
	$root = TestNodePeer::retrieveRootNode(true);
	dumpTree($root);

	$m_addr = array(1,1,3);

	echo "\n\nTest retrieveNodeByNP() for 'm' (without descendants)\n";
	echo "-------------------------------------\n";
	$node = TestNodePeer::retrieveNodeByNP(implode($nodeKeySep, $m_addr), false, false);
	dumpTree($node);


	echo "\n\nTest retrieveNodeByNP() for 'm' (with descendants)\n";
	echo "-------------------------------------\n";
	$node = TestNodePeer::retrieveNodeByNP(implode($nodeKeySep, $m_addr), false, true);
	dumpTree($node);


	echo "\n\nTest getAncestors() for 'x' in one query:\n";
	echo "-------------------------------------\n";

	$criteria = new Criteria();
	$criteria->add(TestPeer::LABEL, 'x', Criteria::EQUAL);

	$nodes = TestNodePeer::retrieveNodes($criteria, true, false);
	$ancestors = $nodes[0]->getAncestors(false);

	foreach ($ancestors as $ancestor)
		echo $ancestor->getNodePath() . " -> " . $ancestor->getLabel() . "\n";


	echo "\n\nTest retrieveNodeByNP() for 'o' (with ancestors and descendants in one query):\n";
	echo "-------------------------------------\n";

	$o_addr = array(1,1,3,2);

	$node = TestNodePeer::retrieveNodeByNP(implode($nodeKeySep, $o_addr), true, true);

	echo "ancestors:\n";
	foreach ($node->getAncestors(false) as $ancestor)
		echo $ancestor->getNodePath() . " -> " . $ancestor->getLabel() . "\n";

	echo "\ndescendants:\n";
	dumpTree($node);


	echo "\n\nTest retrieveNodes() between 'b' and 'g' (without descendants)\n";
	echo "-------------------------------------\n";

	$criteria = new Criteria();
	$criteria->add(TestPeer::LABEL, 'b', Criteria::GREATER_EQUAL);
	$criteria->addAnd(TestPeer::LABEL, 'g', Criteria::LESS_EQUAL);
	$criteria->addAscendingOrderByColumn(TestPeer::LABEL);

	$nodes = TestNodePeer::retrieveNodes($criteria, false, false);

	foreach ($nodes as $node)
		echo $node->getNodePath() . " -> " . $node->getLabel() . "\n";


	echo "\n\nTest retrieveNodes() between 'b' and 'g' (with descendants)\n";
	echo "-------------------------------------\n";

	$criteria = new Criteria();
	$criteria->add(TestPeer::LABEL, 'b', Criteria::GREATER_EQUAL);
	$criteria->addAnd(TestPeer::LABEL, 'g', Criteria::LESS_EQUAL);
	$criteria->addAscendingOrderByColumn(TestPeer::LABEL);

	$nodes = TestNodePeer::retrieveNodes($criteria, false, true);

	foreach ($nodes as $node)
	{
		dumpTree($node);
		echo "\n";
	}


} catch (Exception $e) {
	die("Error retrieving nodes: " . $e->__toString());
}

try {

	echo "\nCreating new tree:\n";
	echo "-------------------------------------\n";

	$a = new Test();
	$a->setLabel("a");
	$a = TestNodePeer::createNewRootNode($a);
	echo "Created 'a' as new root\n";

	echo "\nAdding 10 child nodes:\n";
	echo "-------------------------------------\n";

	$b = new TestNode();
	$b->setLabel('b');
	$a->addChildNode($b);

	$c = new TestNode();
	$c->setLabel('c');
	$a->addChildNode($c);

	$d = new TestNode();
	$d->setLabel('d');
	$a->addChildNode($d);

	$e = new TestNode();
	$e->setLabel('e');
	$a->addChildNode($e);

	$f = new TestNode();
	$f->setLabel('f');
	$a->addChildNode($f);

	$g = new TestNode();
	$g->setLabel('g');
	$a->addChildNode($g);

	$h = new TestNode();
	$h->setLabel('h');
	$a->addChildNode($h);

	$i = new TestNode();
	$i->setLabel('i');
	$a->addChildNode($i);

	$j = new TestNode();
	$j->setLabel('j');
	$a->addChildNode($j);

	$k = new TestNode();
	$k->setLabel('k');
	$a->addChildNode($k);

	echo "\ndescendants:\n";
	dumpTree($a);

	echo "\nRetrieving last node:\n";
	echo "-------------------------------------\n";

	$last = $a->getLastChildNode(true);
	echo "Last child node is '" . $last->getLabel() . "' (" . $last->getNodePath() . ")\n";

} catch (Exception $e) {
	die("Error creating tree with > 10 nodes: " . $e->__toString());
}

if (!isset($argc)) echo "</pre>";
