<?php

interface PhpizeInterface {
	
	public function __toPhp( $compact = false );
	
}

function html ($a, $encoding = 'UTF-8', $flag = null ) {
	
	if ( is_null($flag) )
		$flag = ENT_COMPAT;
	
	return htmlentities($a, $flag, $encoding);
	
}

function phpize( $data, $file = null, $compact = false ) {
	
	if ( is_array($data) ) {
		
		$str = $compact ? '' : "\n";
		$php = "array(";
		
		foreach ( $data as $k => $v ) {
			
			if ( !is_numeric($k) )
				$k = "'" . addslashes($k) . "'";
			
			$php .= $str . $k . " => " . phpize($v, false, $compact) . ",";
			
		}
		
		if ( !$compact )
			$php = preg_replace("!\n!", "\n\t", $php);
		
		$php .= $str . ")";
		
	} elseif ( is_numeric($data) )
		$php = addslashes($data);
	
	elseif ( is_bool($data) )
		$php = $data ? 'true' : 'false';
	
	elseif ( is_null($data) )
		$php = "null";
	
	elseif ( is_string($data) )
		$php = "'" . implode('\' . "\n" . \'', explode("\n", preg_replace(
			array('!\\\\!', '!\'!'),
			array('\\\\\\', '\\\''),
			$data
		))) . "'";
	
	elseif ( $data instanceof  PhpizeInterface )
		$php = $data->__toPhp($compact);

	else throw new Exception('Object does not implements PhpizeInterface : ' . get_class($data));
	
	if ( $file )
		file_put_contents($file, "<?php\n\nreturn " . $php . "\n\n?>");
	
	return $php;
	
}

function sprinto( $str, $obj, $default = '') {
	
	$a = function ($matches) use ($obj, $default, &$set) {
		
		$data = (array) $obj;
		$path = preg_split('!\.!', $matches[1]);
		foreach ( $path as $step )
			if ( array_key_exists($step, $data) )
				$data = $data[$step];
			else $data = '';
		
		return $data;
		return !empty($data) ? $data : ( $default === null ? $matches[0] : $default );
	};
	
	return preg_replace_callback("!\{([a-zA-Z0-9_:\-\.]*)\}!", $a, $str);
	
}

function joinstr ( $array, $glue = ' ', $start = '', $end = '' ) {
	
	if ( $str = implode($glue, $array) )
		return $start . $str . $end;
	
	return '';
	
}

/*
interface dataItem {
	
	function __construct($item);
	function lister($deepscan);
	
	
}
*/

class DSDirectory {
	
	//var $root = $_SERVER['DOCUMENT_ROOT'];
	var $dir = '.';
	var $targetDir = '';
	
	var $listing = array();
	
	
	function __construct($item, $target = '.') {
		
		$this->dir = $item . '/';
		$tg = $this->makeAR(realpath($item), realpath($target));
		if (empty($tg)) $tg = './';
		$this->targetDir = $tg;
	}
	
	function chroot ($root) {
		$this->root = realpath($root);
		return $this->root;
	}
	
	function lister($deepscan, $deep = 1) {
		
		$dir = $this->targetDir;
		$this->listing = $this->recursiveList($dir, $deepscan, $deep++);
		return $this->listing;
	}
	
	function read($item) {
		
		/*if (!is_array($item)) return $this->readOne($item);
		$items = array();
		foreach($item as $oneitem) {
			
			$items[] = $this->readOne($oneitem);
			
		}
		return $items;
		*/
		return $this->vector('readOne', array($item));
	}
	
	function write($item, $data) {
		
		if (!is_array($item) && !is_array($data)) return $this->writeOne($item, $data);
		if (sizeof($item) != sizeof($data)) {
			echo "DSDirectory::write error $item and $data have a different length.";
			return false;
		}
		$items = array();
		foreach($item as $key => $oneitem) {
			
			$items[] = $this->writeOne($oneitem, $data[$key]);
			
		}
		return array_combine($item, $data);
		
		//return $this->vector('writeOne', array($item, $data));
	}
	
	function writeH($items) {
		$itemi = array();
		foreach($items as $item) {
			$itemi[] = $this->writeOne($item['path'], $item['data']);
		}
		return $itemi;
	}
	
	
	private function makeAR($base, $target) { 	// both absolute
		
		$rel = '';
		$sep = "![\\|/]!";
		$bases = preg_split($sep, $base);
		$tg = preg_split($sep, $target);
		$b = min(sizeof($bases), sizeof($tg));
		$i = 0;
		
		while ($i < $b && $bases[$i] == $tg[$i]) {
			$i++;
		}
		$z = $i;
		
		while (!empty($bases[$i])) {
			$rel .= "../";
			$i++;
		}
		
		while (!empty($tg[$z])) {
			$rel .= $tg[$z] . "/";
			$z++;
		}
		
		return $rel;			// relative to base
	}
	
	
	private function vector($func, $arglist) {
		
		$cplx = false;
		$str = '';
		$i = 0;
		foreach($arglist as $key => $item) {
			$cplx = $cplx || is_array($item);
			$str .= "\$arglist[$key], ";
		}
		$str = ereg_replace(", $", "", $str);
		if (!$cplx) return $this->$func($item);
		
		$items = array();
		
		foreach (current($arglist) as $unitem) {
			
			$items[] = eval('$this->$func(' . $str . ');');
		}
		
		
		return eval('array_combine(' . $str . ');');
	}
	
	private function deleteOne($item) {
		
		if ( !is_dir($item) ) unlink($item);
		return true;
	}
	
	private function readOne($item) {
		
		$content = '';
		$file = $this->dir . $item;		
		$fd = fopen($file, "r");
		while (!feof($fd)) {
			$content .= fgets($fd, 256);
		}
		fclose($fd);
		return $content;	
	}
	
	private function writeOne($item, $data) {
		
		
		$path = pathinfo($item);
		echo $path['dirname'] . "\n";
		if (!file_exists($path['dirname'])) {
			mkdir($path['dirname'], 077, 1);
		}
		$file = $item;		
		$fd = fopen($file, "w");
		fwrite($fd, $data);
		fclose($fd);
		return $data;
	}
	
	private function appendOne($item, $data) {
		
		$file = $this->dir . $item;		
		$fd = fopen($file, "a");
		fwrite($fd, $data);
		fclose($fd);
		return $data;
	}
	
	private function readOneHex($item) {
		
		$c = '';
		$file = $this->dir . $item;
		$fid = fopen($file, 'r');
		while (!feof($fid)) {
			$c .= bin2hex(fgets($fid, 2));
		}
		fclose($fid);
		return $c;
	}
	
	function sizeFile($size) {
		
		if ($size < 1024) $size = $size . ' o';
		else if ($size < 1024 * 1024) $size = (int)($size / 1024) . ' Ko';
		else if ($size < 1024 * 1024 * 1024) $size = (int)($size / 1024 / 1024) . ' Ko';
		else $size = (int)($size / 1024 / 1024 / 1024) . ' Mo';
		return $size;
	}
	
	function synchronise() {
		
	}
		
	private function recursiveList($curr, $deepscan, $deep) {
		$deep--;
		$result = array();
		$list = scandir($curr);
		if (!$list) return null;
		$isempty = true;
		$z = sizeof($list);
		foreach($list as $key => $elem) {
			if (!in_array($elem, array('..', '.'))) {if (is_dir($curr . $elem) and $elem != '.' and $elem != '..') {
				
				if ($deepscan) {
					if ( $deep < 1 ) $res = null;
					else $res = $this->recursiveList($curr . $elem . '/', 1, $deep);
					$tot = 0;
					if ($res){
						 foreach($res as $k => $it) {
							$tot += $it['size'];
							$it['size'] = $this->sizeFile($it['size']);
						}
					}
					$result[] = array( 'type' => 'dir', 'curr' => $curr, 'name' => $elem, 'size' => $tot, 'subC' => $res);
				} else {
					$result[] = array( 'type' => 'dir', 'curr' => $curr, 'name' => $elem, 'size' => 0 );
				}
				$isempty = false;
			} elseif (!$deepscan || ($elem != '.' and $elem != '..')) {
				$a = preg_split('!\.!', $elem);
				$type = $a[sizeof($a) - 1];
				if ($elem == '.' || $elem == '..') $type = 'dir';
				$size = filesize($curr . $elem );
				//$size = $this->sizeFile($size);
				$result[] = array( 'type' => $type, 'curr' => $curr, 'name' => $elem, 'size' => $size );
				$isempty = false;
			} elseif ($elem == '.' || $elem == '..') {
				
				$result[] = array( 'type' => 'dir', 'curr' => $curr, 'name' => $elem, 'size' => 0 );
			}
			}
		}
		if ($isempty) return null;
		return $result;
	}
	
}


function recursiveTpl($list) {
	$template = new Template('.');
	$template->set_filenames(array('explorer' => 'dev2.html'));
	if (!$list) return false;
	foreach ($list as $row) {
		if ($row['type'] == 'dir') {
			if (isset($row['subC'])) $row['sub'] = recursiveTpl($row['subC']);
			$template->assign_block_vars("dir", $row);
		} else {
			$template->assign_block_vars("file", $row);
		}
	}
	$template->pparse('explorer');
	return $template->xml;
}


// Immutable

class Path implements IteratorAggregate {
	
	public static function get ( $path ) {
		
		return new self($path);
		
	}
	
	public static function conv ( $path ) {
		
		if ( is_string($path) ) {
			
			if ( !$path )
				return array();
			
			$abs = $path[0] === DIRECTORY_SEPARATOR ? array(null) : array();
			$elements = array_filter(explode(DIRECTORY_SEPARATOR, $path));
			return array_merge($abs, $elements);
			
		} elseif ( is_array($path) )
			return $path;
		
		elseif ( $path instanceof self )
			return $path->elements;
		
		else throw new InvalidArgumentException();
		
	}
	
	private static function compute ( $elements, $target ) {
		
		foreach ( $target as $elem )
			if ( $elem === '.' );
			elseif ( $elem === '..' ) {
				if ( count($elements) && end($elements) && end($elements) !== '..' )
					array_pop($elements);
				elseif (!count($elements) || end($elements) === '..' ) $elements[] = $elem;
			} elseif ( $elem || !$elements )
				$elements[] = $elem;
		
		return $elements;
		
	}
	
	private $elements;
	
	public function __construct ( $path ) {
		
		$this->elements = self::compute(array(), self::conv($path));
		
	}
	
	public function getIterator () {
		
		return new ArrayIterator($this->elements);
		
	}
	
	public function isAbsolute () {
		
		return count($this->elements) && !$this->elements;
		
	}
	
	public function append ( $path ) {
		
		$source = $this->elements;
		foreach ( func_get_args() as $path )
			$source = self::compute($source, self::conv($path));
		
		return new self($source);
		
	}
	
	public function pop ( $path ) {
		
		$source = $this->elements;
		$target = self::compute(array(), self::conv($path));
		
		foreach ( func_get_args() as $path ) {
			
			while ( count($source) && count($target) && last($source) === last($target) ) {
				
				array_pop($source);
				array_pop($target);
				
			}
			
			if ( count($target) )
				return false;
			
		}
		
		return new self($source);
		
	}
	
	public function prepend ( $path ) {
		
		$source = $this->elements;
		foreach ( func_get_args() as $path )
			$source = self::compute(self::conv($path), $source);
		
		return new self($source);
		
	}
	
	public function shift ( $path ) {
		
		$source = $this->elements;
		$target = self::compute(array(), self::conv($path));
		
		foreach ( func_get_args() as $path ) {
			
			while ( count($source) && count($target) && reset($source) === reset($target) ) {
				
				array_shift($source);
				array_shift($target);
				
			}
			
			if ( count($target) )
				return false;
			
		}
		
		return new self($source);
		
	}
	
	public function absolute () {
		
		return array_key_exists(0, $this->elements) && !$this->elements[0];
		
	}
	
	public function __toString () {
		
		$abs = count($this->elements) === 1 && array_key_exists(0, $this->elements) && !$this->elements[0] ? DIRECTORY_SEPARATOR : '';
		
		return $abs . implode(DIRECTORY_SEPARATOR, $this->elements);
		
	}
	
}


class Url {
	
	static private $properties = array(
		'scheme' => '',
		'host' => '',
		'port' => '',
		'path' => '',
		'dirname' => '',
		'basename' => '',
		'filename' => '',
		'extension' => '',
		'fragment' => '',
		'query' => '',
	);
	
	static public function get ( $url = '' ) {
		
		return new self($url);
		
	}
	
	static public function parse ( $url ) {
		
		$urlData = parse_url($url);
		$urlData = array_merge(self::$properties, $urlData, pathinfo($urlData['path']));
		
		if ( isset($urlData['query']) )
			parse_str($urlData['query'], $urlData['query']);
		
		return $urlData;
		
	}
	
	static public function build ( $urlData ) {
		
		if ( isset($urlData['query']) )
			$urlData['query'] = http_build_str($urlData['query']);
		
		return http_build_url($urlData);
		
	}
	
	static public function override ( $urlData, $part, $value ) {
		
		$urlData[$part] = $value;
		$update = 0;
		
		switch ( $part ) {
			
			case 'path':
				$update = 1;
			break;
			
			case 'dirname':
				$urlData['path'] = preg_replace('!//++!', '/', $urlData['dirname'] . '/' . $urlData['basename']);
			break;
			
			case 'basename':
				$urlData['path'] = preg_replace('!//++!', '/', $urlData['dirname'] . '/' . $urlData['basename']);
				$update = 1;
			break;
			
			case 'filename':
				$urlData['path'] = preg_replace('!//++!', '/', $urlData['dirname'] . '/' . $urlData['filename'] . '.' . $urlData['extension']);
				$urlData['basename'] = $urlData['filename'] . ( $urlData['extension'] ? '.' . $urlData['extension'] : '' );
			break;
			
			case 'extension':
				$urlData['path'] = preg_replace('!//++!', '/', $urlData['dirname'] . '/' . $urlData['filename'] . '.' . $urlData['extension']);
				$urlData['basename'] = $urlData['filename'] . ( $urlData['extension'] ? '.' . $urlData['extension'] : '' );
			break;
			
		}
		
		if ( $update ) {
			
			$urlData['dirname'] = '';
			$urlData['basename'] = '';
			$urlData['filename'] = '';
			$urlData['extension'] = '';
			
			$urlData = array_merge($urlData, pathinfo($urlData['path']));
			
		}
		
		return $urlData;
		
	}
	
	private $data = array();
	
	public function __construct ( $urlData = array() ) {
		
		if ( $urlData instanceof self )
			$urlData = $urlData->data;
		
		elseif ( is_string($urlData) )
			$urlData = self::parse($urlData);
		
		elseif ( is_array($urlData) ) foreach ( $urlData as $p => $v )
			$urlData = self::override($urlData, $p, $v);
		
		else throw SenseException::sprintf(
			'Argument of type "%1$s" is invalid ! Type "string","array" or "Url" expected !',
			gettype($urlData)
		);
		
		$this->data = $urlData;
		
	}
	
	public function __invoke ( $parts ) {
		
		$urlData = $this->data;
		
		foreach ( $parts as $part => $value ) {
			
			if ( !array_key_exists($part, self::$properties) )
				throw new SenseException(sprintf(
					'Property "%1$s" does not exist in Url instance !', 
					$part
				));
			
			$urlData = self::override($urlData, $part, $value);
			
		}
		
		return new self($urlData);
		
	}
	
	public function __call ( $name, $args ) {
		
		if ( !array_key_exists($name, self::$properties) )
			throw new SenseException(sprintf(
				'Property "%1$s" does not exist in Url instance !', 
				$name
			));
		
		return new self(self::override($this->data, $name, $args[0]));
		
	}
	
	public function &__get ( $offset ) {
		
		if ( !array_key_exists($offset, self::$properties) )
			throw new SenseException(sprintf(
				'Property "%1$s" does not exist in Url instance !', 
				$offset
			));
		
		return $this->data[$offset];
		
	}
	
	public function __set ( $offset, $value ) {
		
		if ( !array_key_exists($offset, self::$properties) )
			throw new SenseException(sprintf(
				'Property "%1$s" does not exist in Url instance !', 
				$offset
			));
		
		$this->data = self::override($this->data, $offset, $value);
		
		return $value;
		
	}
	
	public function __unset ( $offset ) {
		
		if ( !array_key_exists($offset, self::$properties) )
			throw new SenseException(sprintf(
				'Property "%1$s" does not exist in Url instance !', 
				$offset
			));
		
		$this->$offset = '';
		
	}
	
	public function __toString ( ) {
		
		return self::build($this->data);
		
	}
	
}


abstract class Controller {
	
	protected function __construct () {
		
		if ( empty($_SESSION[get_called_class()]) )
			$_SESSION[get_called_class()] = array();
		
	}
	
	protected function store ( $key, $value ) {
		
		$_SESSION[get_called_class()][$key] = $value;
		
		return $this;
		
	}
	
	protected function restore ( $key ) {
		
		return !empty($_SESSION[get_called_class()][$key]) ? $_SESSION[get_called_class()][$key] : null;
		
	}
	
}


// singleton
class Auth extends Controller {
	
	private static $instance;
	
	private $service, $user;
	
	static public function get ( Service $service = null ) {
		
		if ( self::$instance )
			return self::$instance;
		
		return self::$instance = new self($service);
		
	}
	
	protected function __construct ( Service $service ) {
		
		parent::__construct();
		
		$this->service = $service;
		
		$this->user = $this->restore('user');
		
	}
	
	public function getUser () {
		
		return $this->user;
		
	}
	
	// Action Interface
	public function login ( $user ) {
		
		// query for ( login, pass )
		$users = $this->service;
		
		// no match ( login, pass )
		if ( empty($users[$user['login']]) )
			throw new Exception('Wrong user !');
		
		if ( $users[$user['login']]['password'] !== $user['password'] )
			throw new Exception('Wrong password !');
		
		$this->user = $users[$user['login']];
		
		$this->store('user', $this->user);
		
	}
	
	public function logout () {
		
		$this->user = null;
		$this->store('user', null);
		
		$_SESSION = array();
		
	}
	
}


class EngineSystem {
	
	protected static $instances = array();
	
	public static function get ( $name ) {
		
		if ( !empty(static::$instances[$name]) )
			return static::$instances[$name];
		
		throw new Exception(sprintf(
			'EngineSystem "%1$s" not registered !',
			$name
		));
		
	}
	
	public static function set ( $name, $engineClass, $root = '', $cache = '', $mkCache = false ) {
		
		if ( $mkCache && !file_exists($cache) )		
			mkdir($cache, 0777, 1);
		
		return static::$instances[$name] = new static($engineClass, $root, $cache);
		
	}
	
	protected
		$root = '',
		$cache = '',
		$engineClass = '';
	
	protected function __construct ( $engineClass, $root, $cache ) {
		
		if ( !class_exists($engineClass) || !method_exists($engineClass, 'fromFile') )
			throw new Exception(sprintf('Engine class %1$s does not exists or does not have a static "fromFile" method !', $engineClass));
		
		if ( !file_exists($root) )
			throw new Exception(sprintf('Root folder "%1$s" does not exists !', $root));
		
		if ( $cache && !file_exists($cache) )
			throw new Exception(sprintf('Cache folder "%1$s" does not exists !', $cache));
		
		$this->root = realpath($root);
		$this->cache = realpath($cache);
		$this->engineClass = $engineClass;
		
	}
	
	public function load ( $file, $content = null ) {
		
		$engineClass = $this->engineClass;
		
		return $engineClass::fromFile($file, $this->root, $this->cache, $content);
		
	}
	
	public function exists ( $file ) {
		
		$root = Path::get($this->root);
		$file = $root->append($file);
		
		return $file->shift($root) && file_exists($file) && is_file($file);
		
	}
	
	public function getClass () {
		
		return $this->engineClass;
		
	}
	
	public function getRoot () {
		
		return $this->root;
		
	}
	
	public function getCache () {
		
		return $this->cache;
		
	}
	
}


abstract class Engine {
	
	abstract function run ( $data = array() );
	
	protected static $instances = array();
	
	public static function fromFile ( $file, $root = '', $cache = '', $content = '' ) {
		
		if ( !$file )
			throw new Exception('No file provided !');
		
		// if specified, $root must be an actual directory
		if ( $root && !( $root = realpath($root[0] === DIRECTORY_SEPARATOR ? $root : realpath('.') . DIRECTORY_SEPARATOR . $root) ) )
			throw new Exception(sprintf('Directory "%1$s" for root not found !', $root));
		
		// if specified, $cache must be an actual directory
		if ( $cache && !( $cache = realpath($cache[0] === DIRECTORY_SEPARATOR ? $cache : realpath('.') . DIRECTORY_SEPARATOR . $cache) ) )
			throw new Exception(sprintf('Directory "%1$s" for cache not found !', $cache));
		
		// if $cache is set, then $root too !!
		if ( $cache && !$root )
			throw new Exception(sprintf('Directory cache "%1$" set but empty root directory provided !', $cache));
		
		$file = Path::get($file);
		$filepath = $file->prepend('/', $root);
		$filemirror = $file->prepend($cache);
		$cachepath = Path::get($file . '.php')->prepend($cache);
		$basename = basename($file);
		$dirname = dirname($file);
		
		// Process Level cache : not instantiate the same file twice
		if ( !empty(static::$instances[get_called_class()][$filepath->__toString()]) )
			return static::$instances[get_called_class()][$filepath->__toString()];
		
		// prepare cache dirctories
		if ( $cache ) {
			$cacheDir = dirname($cachepath);
			if ( !file_exists($cacheDir) )
				mkdir($cacheDir, 0777, 1);
		}
		
/*#BEGIN debug#*/
		if ( file_exists($filepath) )
			$m = filemtime($filepath);
		elseif ( $content && ( !file_exists($filemirror) || $content === file_get_contents($filemirror) ) )
			$m = -1;
		else $m = time();
		if ( $cache && !file_exists($cachepath . $m) ) {
			
			if ( file_exists($filemirror) )
				unlink($filemirror);
			if ( file_exists($cachepath) )
				unlink($cachepath);
			
		}
		if ( $cache ) file_put_contents($cachepath . $m, $m);
/*#END debug#*/
		
		if ( $cache && file_exists($cachepath) ) {
			
			$instance = new static($dirname, $root, $cache, $basename);
			$instance->file = $filemirror;
			$instance->include = $cachepath;
			
		} else {
			
			if ( file_exists($filepath) )
				$content = file_get_contents($filepath);
			
			elseif ( !$content )
				throw new Exception(sprintf('File "%1$s" not found and no content provided !', $filepath));
			
			if ( $cache )
				file_put_contents($filemirror, $content);
			
			try {
				
				$instance = static::fromString($content, $dirname, $root, $cache, $basename);
				
			} catch ( Exception $e ) {
				
				throw new Exception(sprintf(
					'Error during compilation of file "%1$s" !',
					$filepath
				), 0, $e);
				
			}
			
			if ( $cache ) {
				
				file_put_contents($cachepath, "<?php\n" . $instance->code . "\n?>");
				
				$instance->include = $cachepath;
				$instance->code = '';
				$instance->file = $filemirror;
				$instance->source = '';
				
			}
			
		}
		
		return static::$instances[get_called_class()][$filepath->__toString()] = $instance;
		
	}
	
	protected
	// Source code
		$source = '',
		$file = '',
	// Compiled code
		$code = '',
		$include = '',
	// Env
		$dir = '',
		$root = '',
		$cache = '',
		$basename = '';
	
	protected function __construct ( $dir, $root = '', $cache = '', $basename = '') {
		
		$this->dir = $dir;
		$this->root = $root;
		$this->cache = $cache;
		$this->basename = $basename;
		
	}
	
	public function getSource () {
		
		if ( $this->file )
			return file_get_contents($this->file);
		
		return $this->source;
		
	}
	
	/*** Runtime API ***/
	
	public function getDir () {
		
		return $this->dir;
		
	}
	
	public function getRoot () {
		
		return $this->root;
		
	}
	
	public function getCache () {
		
		return $this->cache;
		
	}
	
	public function getFile () {
		
		return $this->dir . '/' . $this->basename;
		
	}
	
	public function getBasename () {
		
		return $this->basename;
		
	}
	
}


class Grammar {
	
	static public function fromFile ( $file, $path = null ) {
		
		if ( !file_exists($file) || is_dir($file) )
			throw new Exception('File not found : ' . $file);
		
		try {
			
			return self::fromString(file_get_contents($file), $path ? $path : dirname($file) );
			
		} catch ( Exception $e ) {
			
			throw new Exception(sprintf(
				'Error in file "%1$s" : "%2$s"', $file, $e->getMessage()),
				0,
				$e
			);
			
		}
		
	}
	
	static public function fromString ( $string, $path = '.' ) {
		
		return new self($string, $path);
		
	}
	
	private
		$path = '',
		$dummyString = '',
		$dummies = array(),
		$terminals = array(),
		$rules = array(),
		$firsts = array(),
		$follows = array();
	
	private function __construct ( $string, $path = '.' ) {
		
		$this->path = realpath($path);
		
		$this->parseGrammar($string);
		
	}
	
	private function parseGrammar ( $string ) {
		
		$lines = preg_split('!\n!', $string);
		$seen = array();
		$current = 0;
		$section = 0;
		
		while ( count($lines) ) {
			
			$line = array_shift($lines);
			$current++;
			
			if ( $line === '%%' ) { // section separator
				
				$section++;
				
			} elseif ( preg_match('!^(//.*)?$!', $line) ) { // one line comments and empty lines
				
			} elseif ( $section < 1 ) { // terminal
				
				if ( $dummy = $this->parseTerminal($line, $current) )
					$this->dummies[$dummy] = $dummy;
				
			} elseif ( $section < 2 ) { // production
				
				if ( preg_match('!\#include\(\s*(.+)\s*\)\s*$!', $line, $m) ) {
					
					$seen = $this->mergeGrammar($m[1], $seen);
					
				} else $seen = array_merge($this->parseProduction($line, $current), $seen);
				
			} else break; // eof comments
			
		}
		
		if ( $this->dummies )
			$this->dummyString = '(?:' . implode('|', $this->dummies) . ')++';
		
		if ( $undefined = array_diff_key($seen, $this->terminals, $this->rules) )
			throw new Exception(sprintf(
				'Malformed Grammar : undefiner symbol "%1$s" on line "%2$s".',
				key($undefined),
				current($undefined)
			));
		
		$this->findRecursions();
		$this->firstSet();
		$this->followSet();
		
	}
	
	private function mergeGrammar ( $file, $seen ) {
		
		$g = self::fromFile($this->path . '/' . $file);
		
		foreach ( $g->dummies as $k => $v )
			if ( empty($this->dummies[$k]) )
				$this->dummies[$k] = $v;
		
		foreach ( $g->terminals as $k => $v )
			if ( empty($this->terminals[$k]) )
				$this->terminals[$k] = $v;
		
		foreach ( $g->rules as $k => $v ) {
			
			$seen[$k] = 1;
			
			if ( empty($this->rules[$k]) )
				$this->rules[$k] = $v;
			else {
				
				$this->rules[$k]['seed'] |= $v['seed'];
				$this->rules[$k]['productions'] = array_merge($this->rules[$k]['productions'], $v['productions']);
				array_walk($this->rules[$k]['productions'], function ( &$value, $key ) {
					$value['idx'] = $key;
				});
				
			}
			
		}
		
		return $seen;
		
	}
	
	private function parseTerminal ( $line, $current ) {
		
		if ( preg_match('!^((?:\!|\.)?)([^\s]++)\s+->\s+!', $line, $m)) {
			
			$terminal = preg_split('!\s+->\s+!', $line);
			$this->terminals[$m[2]] = array(
				'type' => $m[2],
				'regex' => $terminal[1],
				'ignore' => $m[1] === '!',
				'line' => $current,
			);
		
			if ( $m[1] === '!' )
				return $terminal[1];
			
		} else throw new Exception(sprintf(
			'Malformed input in grammar at line "%1$s" !',
			$current
		));
		
	}
	
	private function parseProduction ( $line, $current ) {
		
		if ( preg_match('!^(\!?)([^\s]++)\s+(\*?->|<-)\s+!', $line, $m)) {
			
			$terminals = &$this->terminals;
			$seen = array();
			$rule = preg_split('!\s*(\*?->|<-)\s*!', $line, 2, PREG_SPLIT_DELIM_CAPTURE);
			
			if ( empty($this->rules[$rule[0]]) )
				$this->rules[$rule[0]] = array(
					'type' => $rule[0],
					'left' => 0,
					'right' => 0,
					'seed' => 0,
					'productions' => array(),
				);
			
			$this->rules[$rule[0]]['seed'] = $this->rules[$rule[0]]['seed'] || $rule[1] !== '->';
			
			$i = 0;
			$this->rules[$rule[0]]['productions'][] = array(
				
				'idx' => count($this->rules[$rule[0]]),
				'type' => $rule[0],
				'line' => $current,
				'rule' => $rule[2],
				'left' => 0,
				'right' => 0,
				'seed' => $rule[1] === '->' ? false : true,
				'production' => $line,
				'tokens' => array_map(function ($token) use ( &$seen, $current, &$i, &$terminals ) {
					
					$precedence = 0;
					$associative = 0;
					
					if ( preg_match('!^((?:[0-9]++)?)(<|>).++$!', $token, $m) ) {
						
						$token = preg_replace('!^([0-9]++)(<|>)!', '', $token);
						$precedence = (int) $m[1];
						$associative = ( $m[2] === '<' ? 'left' : 'right' );
						
					}
					
					if ( strlen($token) === 1 || !in_array($token[strlen($token) - 1], array('+', '*', '?', '.', '&', '!')) )
						$token .= '.';
					
					$seen[$type = substr($token, 0, strlen($token) - 1)] = $current;
					
					return array(
						'idx' => $i++,
						'type' => $type,
						'repeat' => $token[strlen($token) - 1],
						'precedence' => $precedence,
						'associative' => $associative,
					);
					
				}, array_filter(preg_split('!\s+!', $rule[2])))
				
			);
			
			return $seen;
			
		} else throw new Exception(sprintf(
			'Malformed input in grammar at line "%1$s" !',
			$current
		));
		
	}
	
	private function findRecursions () {
		
		foreach ( $this->rules as $name => $rule )
			foreach ( $rule['productions'] as $idx => $production ) {
				
				if ( $this->recurse($name, $production) ) {
					$production['left'] = 1;
					$this->rules[$name]['left'] = 1;
				}
				
				if ( $this->recurse($name, $production, true) ) {
					$production['right'] = 1;
					$this->rules[$name]['right'] = 1;
				}
				
				$this->rules[$name]['productions'][$idx] = $production;
				
			}
	}
	
	private function recurse ( $rul, $prod, $right = false, $visited = array() ) {
		
		// to support filters
		if ( !empty($visited[$prod['type']]) )
			return ( $prod['type'] === $rul );
		$visited[$prod['type']] = 1;
		
		$tokens = $prod['tokens'];
		if ( $right )
			$tokens = array_reverse($tokens);
		
		foreach ( $tokens as $token ) {
			
			if ( !empty($this->rules[$token['type']]) )
				foreach ( $this->rules[$token['type']]['productions'] as $production )
						if ( $this->recurse($rul, $production, $right, $visited) )
							return true;
			
			if ( in_array($token['repeat'], array('.', '+')) )
				return false;
			
		}
		
		return false;
		
	}
	
	private function firstSet () {
		
		foreach ( $this->rules as $name => $rule )
			foreach ( $rule['productions'] as $idx => $production )
				$this->firsts[$name] = array_merge(
					!empty($this->firsts[$name]) ? $this->firsts[$name] : array(),
					$this->first($production)
				);
				
		
	}
	
	private function first ( $production, $visited = array() ) {
		
		if ( !empty($visited[$production['type']]) )
			return array();
		$visited[$production['type']] = 1;
		
		$firsts = array();
		
		foreach ( $production['tokens'] as $token ) {
			
			if ( !empty($this->terminals[$token['type']]) )
				$firsts[$token['type']] = $token;
			
			else foreach ( $this->rules[$token['type']]['productions'] as $production )
				$firsts = array_merge($firsts, $this->first($production, $visited));
			
			if ( in_array($token['repeat'], array('.', '+')) )
				break;
			
		}
		
		return $firsts;
		
	}
	
	private function followSet () {
		
		foreach ( $this->rules as $name => $rule )
			foreach ( $rule['productions'] as $idx => $production ) {
				
				if ( $production['left'] && !empty($this->rules[$production['tokens'][0]['type']]['left']) && !empty($production['tokens'][1]) ) {
					
					if ( empty($this->follows[$production['tokens'][0]['type']]) )
						$this->follows[$production['tokens'][0]['type']] = array();
					
					//~ $this->follows[$production['tokens'][0]['type']][$production['tokens'][1]['type']] = $production['tokens'][1];
					$this->follows[$production['tokens'][0]['type']][] = $production['tokens'][1];
					
				}
				
			}
		
	}
	
	public function getDummyString () {
		
		return $this->dummyString;
		
	}
	
	public function getTerminals () {
		
		return $this->terminals;
		
	}
	
	public function getRules () {
		
		return $this->rules;
		
	}
	
	public function getFirsts () {
		
		return $this->firsts;
		
	}
	
	public function getFollows () {
		
		return $this->follows;
		
	}
	
	public function __toString() {
		
		return print_r($this, 1);
		
	}
	
}


class ParserException extends Exception {}

class SGParser {
	
	static public function fromFile ( $file, $translator = null ) {
		
		return new static(Grammar::fromFile($file), $translator);
		
	}
	
	static public function fromString ( $string, $translator = null ) {
		
		return new static(Grammar::fromString($string), $translator);
		
	}
	
	protected
		$debug = 0,
		$translator = null,
		$grammar = null,
		$dummies = null,
		$terminals = null,
		$rules = null,
		$firsts = null,
		$follows = null;
	
	protected function __construct ( Grammar $grammar, $translator = null ) {
		
		$this->grammar = $grammar;
		$this->dummies = $grammar->getDummyString();
		$this->terminals = $grammar->getTerminals();
		$this->rules = $grammar->getRules();
		$this->firsts = $grammar->getFirsts();
		$this->follows = $grammar->getFollows();
		
		$this->translator = $translator;
		
	}
	
	public function setDebug ( $debug ) {
		
		$this->debug = $debug;
		
		return $this;
		
	}
	
	public function parseFile ( $file, $litteral = false ) {
		
		if ( !file_exists($file) )
			throw new ParserException(sprintf('File "%1$s" does not exist !', $file));
		
		try {
			
			return $this->parseString(file_get_contents($file), $litteral);
			
		} catch ( ParserException $e ) {
			
			throw new ParserException(sprintf(
				'Error parsing file "%1$s" : "%2$s"', $file, $e->getMessage()),
				0,
				$e
			);
			
		}
		
	}
	
	public function parseString ( $string, $litteral = false, $symbol = 'S', $repeat = '.' ) {
		
		$parseState = $this->getState($string, $litteral);
		
		$tree = $this->parse($parseState, $symbol, $repeat);
		
		if ( !preg_match(
			sprintf('/^(%1$s)*$/', $this->dummies), 
			$string = substr($string, $parseState['state']['position'])
		) ) throw new ParserException("Unexpected end of input :" . $string);
		
		foreach ( $parseState as $k => $v )
			unset($parseState[$k]);
		
		return $tree['nodes'];
		
	}
	
	public function parse ( &$parseState, $symbol = 'S', $repeat = '.' ) {
		
		try {
			
			$tree = $this->work($parseState, array(
				'type' => $symbol,
				'repeat' => $repeat,
			));
			
		} catch ( ParserException $e ) {
			
			preg_match('![^\n]++$!', substr($parseState['string'], 0, $parseState['error']['position']), $m);
			
			throw new ParserException(sprintf(
				'Error on line %1$u at position %2$u.',
					$parseState['error']['line'],
					!empty($m[0]) ? strlen($m[0]) : 0),
				0,
				$parseState['error']['ParserException']
			);
			
		}
		
		return $tree;
		
	}
	
	protected function getState ( $string, $litteral ) {
		
		return array(
			'parser' => $this,
			'string' => $string,
			'litteral' => $litteral,
			'matches' => array(),
			'error' => array(
				'position' => 0,
				'line' => 0,
				'ParserException' => null,
			),
			'state' => array(
				'line' => 1,
				'position' => 0,
				'deepness' => 0,
				'operators' => array(),
				'ntoken' => null,
				'production' => null,
			),
			'memo' => array(),
		);
		
	}
	
	protected function setState ( &$parseState, $oldState, $no = array() ) {
		
		foreach ( array_diff_key($oldState['state'], $no) as $k => $v )
			if ( empty($no[$k]) )
				$parseState['state'][$k] = $v;
		
		return $parseState;
		
	}
	
	protected function saveState ( &$parseState ) {
		
		$state = array();
		foreach ( $parseState['state'] as $k => $v )
			$state[$k] = $v;
		
		return array('state' => $state);
		
	}
	
	protected function getId ( $parseState, $token ) {
		
		return $token['type'] . ':' . $parseState['state']['position'];
		
	}
	
	protected function reportError ( &$parseState, $token, ParserException $e ) {
		
		if ( !$parseState['error']['ParserException'] || $parseState['state']['position'] > $parseState['error']['position'] ) {
			
			$parseState['error']['position'] = $parseState['state']['position'];
			$parseState['error']['line'] = $parseState['state']['line'];
			$parseState['error']['ParserException'] = $e;
			
		}
		
	}
	
	protected function match ( &$parseState, $token ) {
		
		$id = $this->getId($parseState, $token);
		if ( !empty($parseState['matches'][$id]) )
			return $parseState['matches'][$id]['value'];
		
		if ( !empty($this->terminals[$token['type']]) )
			return $parseState['matches'][$id]['value'] = preg_match(sprintf(
				'/^((?:%2$s)?)(%1$s)/S',
				$this->terminals[$token['type']]['regex'],
				$this->dummies), 
				substr($parseState['string'], $parseState['state']['position'])
			);
		
		foreach ( $this->firsts[$token['type']] as $k => $terminal )
			if ( preg_match(sprintf(
				'/^((?:%2$s)?)(%1$s)/S',
				$this->terminals[$k]['regex'],
				$this->dummies), 
				substr($parseState['string'], $parseState['state']['position'])
			)) return $parseState['matches'][$id]['value'] = true;
		
		return $parseState['matches'][$id]['value'] = false;
		
	}
	
	protected function consume ( &$parseState, $token ) {
		
if ( $this->debug ) $indent = str_repeat("\t", $parseState['state']['deepness']);
		
		$id = $this->getId($parseState, $token);
		if ( !empty($parseState['memo'][$id]) ) {
			
if ( $this->debug ) echo "\n\t\t$indent memo {$token['type']} : {$parseState['state']['position']} => {$parseState['memo'][$id]['position']}";
			
			if ( $parseState['memo'][$id]['value'] )
				$parseState['state']['position'] = $parseState['memo'][$id]['position'];
			
			return $parseState['memo'][$id]['value'];
			
		}
		
		$parseState['memo'][$id] = array(
			'value' => null,
			'position' => null,
		);
		
		if ( !empty($this->terminals[$token['type']]) ) {
			
			$nodes = $this->eat($parseState, $token);
			
		} elseif ( $this->match($parseState, $token) ) {
			
			$nodes = $this->test($parseState, $token);
			
		} else $nodes = null;
		
		if ( $nodes && $this->translator )
			$nodes = call_user_func($this->translator, $parseState, $token, $nodes);
		
		if ( empty($this->rules[$token['type']]['left']) )
			$parseState['memo'][$id] = array(
				'value' => $nodes,
				'position' => $parseState['state']['position'],
			);
		
		else unset($parseState['memo'][$id]);
		
		return $nodes;
		
	}
	
	protected function test ( &$parseState, $token, $growing = false ) {
		
		$parseState['state']['deepness']++;
		
		$state = $this->saveState($parseState);
		
		$id = $this->getId($parseState, $token);
		
if ( $this->debug ) $indent = str_repeat("\t", $parseState['state']['deepness']);
		
		$nodes = array();
		$error = false;
		//~ $match = array('pos' => 0, 'val' => null);
		foreach ( $this->rules[$token['type']]['productions'] as $i => $production )
		if ( $growing || !$this->rules[$token['type']]['seed'] || $production['seed'] )
		if ( !$growing || $growing && !$production['seed'] )
		try {
			
if ( $this->debug ) echo "\n\t$indent [ $id : {$production['production']}";
			
			$error = false;
			
			$nodes = $this->production($parseState, $token, $production);
			
if ( $this->debug ) echo "\nOOO\t$indent ]O $id : {$parseState['state']['position']}";
			
			$parseState['state']['deepness']--;
			
			break;
			
			//~ if ( $parseState['state']['position'] > $match['pos'] ) {
				
				//~ $match['pos'] = $parseState['state']['position'];
				//~ $match['state'] = $this->saveState($parseState);
				//~ $match['val'] = $nodes;
				
			//~ }
			
			//~ $this->setState($parseState, $state);
			
		} catch ( ParserException $e ) {
			
if ( $this->debug ) echo "\n###\t$indent ]# $id : {$parseState['state']['position']}";
			
			$this->reportError($parseState, $token, $e);
			
			$error = true;
			$nodes = null;
			$this->setState($parseState, $state);
			
		}
		
		if ( !$error && $nodes && !$growing && !empty($this->rules[$token['type']]['seed']) ) {
		
if ( $this->debug ) echo "\n###\t$indent try to grow : {$parseState['state']['position']}";
			$nodes = $this->grow($parseState, $token, $state, $nodes);
			
		}
elseif ( $this->debug ) echo "\n###\t$indent dont try to grow : {$parseState['state']['position']}";
		
		return $nodes;
		
	}
	
	protected function doesGrow ( $parseState, $token, $follow, $precedence ) {
		
		if (
			$this->match($parseState, $follow) && 
			(
				!empty($parseState['state']['ntoken']) &&
				$this->match($parseState, $parseState['state']['ntoken']) && $follow['precedence'] < $parseState['state']['ntoken']['precedence']
			)
		)
			return false;
		
		return
			$this->match($parseState, $follow) && 
			( 
				empty($parseState['state']['production']['right']) || 
				!empty($parseState['state']['production']['tokens'][$token['idx'] + 1]) || 
				$follow['precedence'] > $precedence || 
				$follow['precedence'] === $precedence && $follow['associative'] === 'right' 
			);
		
	}
	
	protected function grow ( &$parseState, $token, $oldState, $nodes ) {
		
		$precedence = 0;
		if ( $c = count($parseState['state']['operators']) )
			$precedence  = $parseState['state']['operators'][$c - 1]['precedence'];
		
if ( $this->debug ) $indent = str_repeat("\t", $parseState['state']['deepness']);
		
		$oid = $this->getId($oldState, $token);
		$id = $this->getId($parseState, $token);
if ( $this->debug ) echo "\n\t$indent { grow : $oid => $id";	
		
		$match = false;
		if ( !empty($this->follows[$token['type']]) )
			foreach ( $this->follows[$token['type']] as $type => $follow ) {
				
				if ( $this->doesGrow($parseState, $token, $follow, $precedence) ) {
					
					$match = true;
					break;
					
				}
				
			}
		
		if ( !$match ) {
			
if ( $this->debug ) echo "\n\t$indent } # grow : $id cause not in followset ";	
			return $nodes;
			
		}
		
		$oldNodes = $nodes;
		
		if ( $this->translator )
			$nodes = call_user_func($this->translator, $parseState, $token, $nodes);
		
		$parseState['memo'][$this->getId($oldState, $token)] = array(
			'value' => $nodes,
			'position' => $parseState['state']['position'],
		);
		
		$position = $parseState['state']['position'];
		$state = $this->saveState($parseState);
		$this->setState($parseState, $oldState);
		
if ( $this->debug ) echo "\nGGG\t$indent grow procedure : $id";	
		
		$newNodes = $this->test($parseState, $token, true);
		if ( !$newNodes ) {
			
			if ( $position >= $parseState['state']['position'] )
				$this->setState($parseState, $state);
			
			return $oldNodes;
			
		}
		
		$nodes = $newNodes;
		
		if ( $position < $parseState['state']['position'] )
			$nodes = $this->grow($parseState, $token, $oldState, $nodes);
		
if ( $this->debug ) echo "\nGGG\t$indent grow procedure successful : {$this->getId($parseState, $token)}";
		
		return $nodes;
		
	}
	
	protected function production ( &$parseState, $token, $production ) {
		
if ( $this->debug ) $indent = str_repeat("\t", $parseState['state']['deepness']);
		
		try {
			
			$prod = $parseState['state']['production'];
			$ntoken = $parseState['state']['ntoken'];
			$parseState['state']['production'] = $production;
			$nodes = array();
			$op = 0;
			foreach ( $production['tokens'] as $j => $nextToken ) {
				
	if ( $this->debug ) echo "\n\t\t$indent { {$nextToken['type']}{$nextToken['repeat']} : {$parseState['state']['position']}";
				
				if ( $nextToken['precedence'] ) {
					
					$op++;
					$parseState['state']['operators'][] = $nextToken;
					
				}
				
				$parseState['state']['ntoken'] = 
					!empty($production['tokens'][$j+1]) ?
						$production['tokens'][$j+1] :
						$ntoken;
				
				$nodes[] = $this->work($parseState, $nextToken);
				
	if ( $this->debug ) echo "\nO\t\t$indent }O {$nextToken['type']}{$nextToken['repeat']} : {$parseState['state']['position']}";
				
			}
			
			while ( $op-- ) {
				array_pop($parseState['state']['operators']);
			}
			
			$parseState['state']['production'] = $prod;
			$parseState['state']['ntoken'] = $ntoken;
			
			return $nodes;
		
		} catch ( ParserException $e ) {
			
if ( $this->debug ) echo "\n#\t\t$indent }# {$nextToken['type']}{$nextToken['repeat']} : {$parseState['state']['position']}";
			
			throw $e;
			
		}
		
	}
	
	protected function eat ( &$parseState, $token ) {
		
if ( $this->debug ) $indent = str_repeat("\t", $parseState['state']['deepness']);
		
		$string = substr($parseState['string'], $parseState['state']['position']);
		$exp = sprintf(
			'/^((?:%2$s)?)(%1$s)/S',
			$this->terminals[$token['type']]['regex'],
			$this->dummies
		);
		
		if ( preg_match($exp, $string, $m) ) {
			
if ( $this->debug ) {
	$c = strlen($m[0]);
	echo "\n\t\t$indent consume {$token['type']} : {$parseState['state']['position']} : {$c}";
}
			
			$parseState['state']['position'] += strlen($m[0]);
			$parseState['state']['line'] += substr_count($m[0], "\n");
			
if ( $this->debug ) echo "\n\t\t$indent match {$token['type']} : {$parseState['state']['position']}";
			
			$all = array_shift($m);
			$dummy = array_shift($m);
			$len = strlen($m[0]);
			
			return array(
				'type' => $token['type'],
				'line' => ( $parseState['state']['position'] - $len ) ? substr_count($parseState['string'], "\n", 0, $parseState['state']['position'] - $len) + 1 : 1,
				'position' => $parseState['state']['position'] - $len,
				'length' => $len,
				'match' => !empty($m[1]) ? $m[1] : $m[0],
				'litteral' => $parseState['litteral'] ? $all : '',
				'matches' => $m,
			);
			
		} else return null;
		
	}
	
	protected function work ( &$parseState, $token ) {
		
		$parseState['state']['deepness']++;
		
		$position = $parseState['state']['position'];
		
		switch ( $token['repeat'] ) {
			
			case '.' : $sub = $this->one($parseState, $token); break;
			
			case '?' : $sub = $this->oneAtMost($parseState, $token); break;
			
			case '+' : $sub = $this->oneAtLeast($parseState, $token); break;
			
			case '*' : $sub = $this->zeroAtLeast($parseState, $token); break;
			
			case '&' : $sub = $this->oneMore($parseState, $token); break;
			
			case '!' : $sub = $this->noMore($parseState, $token); break;
			
		}
		
		$parseState['state']['deepness']--;
		
		return array(
			'type' => $token['type'],
			'repeat' => $token['repeat'],
			'line' => ( $position ? substr_count($parseState['string'], "\n", 0, $position) : 0 ) + 1,
			'position' => $position,
			'length' => $parseState['state']['position'] - $position,
			'litteral' => $parseState['litteral'] ? substr($parseState['string'], $position, $parseState['state']['position'] - $position) : '',
			'nodes' => $sub,
		);
		
	}
	
	protected function one ( &$parseState, $token ) { // id
		
		if ( !$elem = $this->consume($parseState, $token) )
			throw self::except($parseState, $token);
		
		return $elem;
		
	}
	
	protected function oneAtMost ( &$parseState, $token ) { // id?
		
		return $this->consume($parseState, $token);
		
	}
	
	protected function oneAtLeast ( &$parseState, $token ) { // id+
		
		$nodes = array($this->one($parseState, $token));
		
		while ( $elem = $this->consume($parseState, $token) )
			$nodes[] = $elem;
		
		return $nodes;
		
	}
	
	protected function zeroAtLeast ( &$parseState, $token ) { // id*
		
		$nodes = array();
		
		while ( $elem = $this->consume($parseState, $token) )
			$nodes[] = $elem;
		
		return $nodes;
		
	}
	
	protected function oneMore ( &$parseState, $token ) { // id&
		
		$state = $this->saveState($parseState);
		
		if ( !$elem = $this->consume($parseState, $token) )
			throw self::except($parseState, $token);
		
		$this->setState($parseState, $state);
		
		return $elem;
		
	}
	
	protected function noMore ( &$parseState, $token ) { // id!
		
		if ( $this->consume($parseState, $token, 1) )
			throw self::except($parseState, $token);
		
		return true;
		
	}
	
	static protected function except ( &$parseState, $token, $notExpected = false ) {
		
		return new ParserException(sprintf(
			'%5$sxpected token : "%1$s" at position %2$s on line "%3$s" and col "%4$s" !',
			$token['type'],
			$parseState['state']['position'],
			0, //substr_count($sub, "\n"),
			0, //$parseState['state']['position'] - strrpos($sub, "\n") + 1,
			$notExpected ? 'Une' : 'E'
		));
		
	}
	
}


class FileSystem {
	
	
	public static function chmod ( $file, $mode = 0 ) {
		
		if ( !file_exists($file) )
			return false;
		
		$chmod = chmod($file, $mode);
		
		if ( !is_dir($file) )
			return $chmod;
		
		$files = new RecursiveIteratorIterator(
			new RecursiveDirectoryIterator(
				$file,
				RecursiveDirectoryIterator::SKIP_DOTS
			),
			RecursiveIteratorIterator::CHILD_FIRST
		);
		
		foreach ($files as $fileinfo) {
			
			$path = $fileinfo->getRealPath();
			$chmod &= chmod($path, $mode);
			
		}
		
		return $chmod;
		
	}
	
	public static function rm ( $file ) {
		
		$rm = 1;
		if ( file_exists($file) ) {
			
			if ( is_dir($file) ) {
				
				$files = new RecursiveIteratorIterator(
					new RecursiveDirectoryIterator(
						$file,
						RecursiveDirectoryIterator::SKIP_DOTS
					),
					RecursiveIteratorIterator::CHILD_FIRST
				);
				
				foreach ($files as $fileinfo) {
					
					$path = $fileinfo->getRealPath();
					
					if ( $fileinfo->isDir() )
						$rm &= rmdir($path);
					
					else $rm &= unlink($path);
					
				}
				
				$rm &= rmdir($file);
				
			} else $rm &= unlink($file);
			
		} else return false;
		
		return $rm;
		
	}
	
	public static function zip ( $archive, $file, $exclude = null ) {
		
		if ( file_exists($file) ) {
			
			$zip = new ZipArchive();
			$zip->open($archive, ZIPARCHIVE::CREATE);
			
			if ( $exclude )
				$exclude = Path::get(realpath($exclude));
			
			if ( is_dir($file) ) {
				
				$files = new RecursiveIteratorIterator(
					new RecursiveCallbackFilterIterator(
						new RecursiveDirectoryIterator(
							$file,
							RecursiveDirectoryIterator::SKIP_DOTS
						),
						$exclude ?
							function ( $current, $key, $iterator) use ( $exclude ) {
								return !Path::get($current->getRealPath())->shift($exclude);
							} :
							function ( $current, $key, $iterator) { return true; }
					),
					RecursiveIteratorIterator::SELF_FIRST
				);
				
				$root = Path::get(realpath($file));
				foreach ($files as $fileinfo) {
					
					$path = Path::get($fileinfo->getRealPath())->shift($root);
					
					if ( $fileinfo->isDir() )
						$zip->addEmptyDir($path);
					
					else $zip->addFile($fileinfo->getRealPath(), $path);
					
				}
				
			} else $zip->addFile($file);
			
			$zip->close();
			
		} else throw new Exception(sprintf('File "%1$s" does not exists !', $file));
		
	}
	
}


class Preprocessor {
	
	private
		$noComment = false,
		$files = array();
	
	public function __construct ( $noComment = false ) {
		
		$this->noComment = $noComment;
		
	}
	
	public function clear () {
		
		$this->files = array();
		
		return $this;
		
	}
	
	public function addFile ( $file, $mode = '', $mirror = null ) {
		
		if ( !file_exists($file) )
			throw new Exception(sprintf('"%1$s" is not a file or does not exist !', $file));
		
		$content = $this->filter($file, array_filter(preg_split('!\s++!', $mode)), $this->noComment);
		
		$this->files[] = array(
			'file' => $file,
			'content' => $content,
		);
		
		if ( $mirror )
			$this->writeFile($mirror, $content);
		
		return $this;
		
	}
	
	public function addFiles ( $files ) {
		
		foreach ( $files as $file => $mode )
			$this->addFile($file, $mode);
		
		return $this;
		
	}
	
	public function process ( $noComment = false ) {
		
		$str = '';
		
		foreach ( $this->files as $file => $mode )
			$str .= "\n" . self::filter($file, $mode, $noComment);
		
		return $this;
		
	}
	
	public function writeFile ( $file, $content ) {
		
		if ( !file_exists(dirname($file)) )
			throw new Exception(sprintf('The directory for file "%1$s" does not exist !', $file));
		
		file_put_contents($file, "<?php\n" . $content . "\n?>");
		
		return $this;
		
	}
	
	public function toFile ( $file ) {
		
		if ( !file_exists(dirname($file)) )
			throw new Exception(sprintf('The directory for file "%1$s" does not exist !', $file));
		
		$content = '';
		foreach ( $this->files as $fileContent )
			$content .= $fileContent['content'];
		
		file_put_contents($file, "<?php\n" . $content . "\n?>");
		
		return $this;
		
	}
	

	static private function filter ( $file, $mode, $noComment = false ) {
		
		$commentTokens = array(T_OPEN_TAG, T_CLOSE_TAG);
		if ( $noComment ) {
			
			$commentTokens[] = T_COMMENT;
			$commentTokens[] = T_DOC_COMMENT;
			
		}
		
		$m = array();
		$state = '';
		$str  = '';
		
		foreach ( token_get_all(file_get_contents($file)) as $token ) {
			
			if ( !empty($token[0]) && $token[0] === T_DIR )
				$token = sprintf('"%1$s"', realpath(dirname($file)));
			
			if ( !$state ) {
				
				if ( 	$token[0] === T_COMMENT && 
					preg_match('!^/\*\#BEGIN\s++((\!?)([a-zA-Z0-9]++))\s*\#\*/$!', $token[1], $m) && 
					( ( !in_array($m[3], $mode) && !$m[2] ) || ( in_array($m[3], $mode) && $m[2] ) )
				) {
					
					$state = $m[1];
					if ( !$noComment )
						$str .= $token[1];
					
				} elseif ( !is_array($token) )
					$str .= $token;
				
				elseif ( !in_array($token[0], $commentTokens) )
					$str .= $token[1];
				
			} elseif ( $token[0] === T_COMMENT ) {
				
				if ( preg_match('!^/\*\#END\s++((\!?)([a-zA-Z0-9]++))\s*\#\*/$!', $token[1], $m) )
					if ( $m[1] == $state ) {
						
						if ( !$noComment )
							$str .= $token[1];
						$state = '';
						
					}
				
			} elseif ( !$noComment )
				$str .= str_repeat("\n", count(preg_split("!\n!", is_array($token) ? $token[1] : $token)) - 1);
			
		}
		
		return $str;
		
	}
	
}


class Process {
	
	public static function fork ( $func = null ) {
		
		if ( ( $pid = pcntl_fork() ) === -1 )
			throw new Exception('Unable to fork !');
			
		else return $func ? $func($pid) : $pid;
		
	}
	
}


class ArrayTimer extends ArrayObject {
	
	public static function get ( $period ) {
		
		$a = new static();
		
		return $a->setPeriod($period);
		
	}
	
	private $period = 60, $min = 0;
	
	public function setPeriod ( $period, $min = 0 ) {
		
		$this->period = $period;
		$this->min = $min;
		
		return $this;
		
	}
	
	public function update ( $id, $delta = 0 ) {
		
		$this[$id] = time() + $delta;
		
		return $this;
		
	}
	
	public function offsetGet ( $id ) {
		
		if ( !$this->offsetExists($id) )
			$this[$id] = time() - $this->period;
		
		return parent::offsetGet($id);
		
	}
	
	public function sleepTime ( $id ) {
		
		return max(0, $this->period + $this[$id] - time());
		
	}
	
	public function sleepSkip ( $id ) {
		
		$skip = !$this->sleepTime($id);
		
		if ( $skip )
			$this->update($id);
		
		return $skip;
		
	}
	
	public function sleep ( $id ) {
		
		$sleep = $this->sleepTime($id);
		
		if ( $sleep || $this->min )
			sleep(max($sleep, $this->min));
		
		return $this->update($id);
		
	}
	
	public function select () {
		
		$timer = $this;
		return new CallbackFilterIterator($this, function ( $value, $key, $it ) use ( $timer ) {
			
			return !$timer->sleepTime($key);
			
		});
		
	}
	
}


class MemcachedTimer extends ArrayTimer {
	
	private $prefix = '', $cache = null, $period = 60, $min = 0;
	
	public function setPrefix ( $prefix ) {
		
		$this->cache = new Memcached();
		$this->prefix = $prefix;
		
		return $this;
		
	}
	
	public function sleepSkip ( $id ) {
		
		$skip = !$this->sleepTime($id);
		
		if ( $skip )
			$this->update($id);
		
		return $skip;
		
	}
	
	public function offsetGet ( $id ) {
		
		$value = $this->memcached->get($this->prefix . $id);
		
		if ( $value === false && $this->memcached->getResultCode() === Memcached::RES_NOTFOUND )
			$value = $this[$id] = time() - $this->period;
		
		parent::offsetSet($value);
		
		return $value;
		
	}
	
	public function offsetSet ( $id, $value ) {
		
		if ( $this->memcached->set($this->prefix . $id, $value) ) {
			
			parent::offsetSet($id, $value);
			
			return $value;
			
		}
		
		throw new Exception('Memcached error ! Cannot set value !');
		
	}
	
	public function offsetUnset ( $id ) {
		
		parent::offsetUnset($id);
		
		$this->memcached->delete($this->prefix . $id);
		
	}
	
	public function offsetExists ( $id ) {
		
		$value = $this->memcached->get($this->prefix . $id);
		
		if ( $value === false && $this->memcached->getResultCode() === Memcached::RES_NOTFOUND )
			return false;
		
		return true;
		
	}
	
}


abstract class Expression {
	
	static protected $types = array();
	
	public static function getParserExtension () {
		
		$context = get_called_class();
		
		return function ( &$parseState, $token, $nodes ) use ( $context ) {
			
			return $context::parse($parseState, $token, $nodes);
			
		};
		
	}
	
	public static function dispatch ( $type, $action ) {
		
		//~ echo get_called_class(), "\n";
		
		if ( !empty(static::$types[$type][$action]) )
			return static::$types[$type][$action]['value'];
		
		$class = get_called_class() . 'Type' . ucfirst($type);
		$delegate = get_called_class() . ucfirst($action);
		
		$method = $action . ucfirst($type);
		
		if ( class_exists($class) )
			$caller = array(
				$class,
				$action
			);
			
		elseif ( class_exists($delegate) && method_exists($delegate, $method) )
			$caller = array(
				$delegate,
				$method
			);
			
		elseif ( get_called_class() !== __CLASS__ )
			$caller = call_user_func(
				array(get_parent_class(get_called_class()), 'dispatch'),
				$type,
				$action
			);
		
		else $caller = null;
		
		return static::$types[$type][$action]['value'] = $caller;
		
	}
	
	public static function build ( $type ) {
		
		$args = func_get_args();
		array_shift($args);
		
		if ( $func = static::dispatch($type, __FUNCTION__) )
			return call_user_func_array(
				$func,
				$args
			);
		
		else throw static::buildException($type, __FUNCTION__);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		if ( $func = static::dispatch($token['type'], __FUNCTION__) )
			return call_user_func(
				$func,
				$parseState,
				$token,
				$nodes
			);
		
		else return $nodes;
		
	}
	
	public static function serialize ( $ast ) {
		
		if ( $func = static::dispatch($ast['type'], __FUNCTION__) )
			return call_user_func(
				$func,
				get_called_class(),
				$ast
			);
		
		else throw static::buildException($type, __FUNCTION__);
		
	}
	
	public static function compile ( $ast ) {
		
		if ( $func = static::dispatch($ast['type'], __FUNCTION__) )
			return call_user_func(
				$func,
				get_called_class(),
				$ast
			);
		
		else throw static::buildException($ast['type'], __FUNCTION__);
		
	}
	
	public static function run ( $ast ) {
		
		if ( $func = static::dispatch($ast['type'], __FUNCTION__) )
			return call_user_func(
				$func,
				get_called_class(),
				$ast
			);
		
		else throw static::buildException($type, __FUNCTION__);
		
	}
	
	public static function fromData ( $data ) {
		
		if ( is_array($data) ) {
			
			$elements = array();
			foreach ( $data as $k => $v )
				$elements[] = array(
					static::fromData($k),
					static::fromData($v)
				);
			
			return static::build($elements);
			
		} elseif ( is_float($data) )
			return static::buildFloat($data);
		
		elseif ( is_numeric($data) )
			return static::buildInteger($data);
		
		elseif ( is_bool($data) )
			return $data ? static::buildTrue() : static::buildFalse();
		
		elseif ( is_null($data) )
			return static::buildNull();
		
		elseif ( is_string($data) )
			$code = "'" . implode('\' +. "\n" +. \'', explode("\n", addslashes($data))) . "'";
		
		else throw new Exception('Object cannot be build from data : ' . get_class($data));
		
	}
	
	public static function buildException ( $type, $action ) {
		
		return new Exception(sprintf(
			'%1$s error : type "%2$s" has no action "%3$s" !',
			get_called_class(),
			$type,
			$action
		));
		
	}
	
}


class ExpressionAction {
	
}


abstract class ExpressionType {
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		throw static::buildException(__METHOD__);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		throw static::buildException(__METHOD__);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		throw static::buildException(__METHOD__);
		
	}
	
	public static function run ( $context, $ast ) {
		
		throw static::buildException(__METHOD__);
		
	}
	
	private static function buildException ( $method ) {
		
		return new Exception(sprintf(
			'Method "%3$s" of "%1$s" must be reimplemented in child class "%2$s" !',
			__CLASS__,
			get_called_class(),
			$method
		));
		
	}
	
}


abstract class ExpressionBuild extends ExpressionAction {
	
	static protected $type = array();
	
	public static function build ( $type ) {
		
		$args = func_get_args();
		array_shift($args);
		
		return call_user_func_array(
			static::dispatch($type, __METHOD__),
			$args
		);
		
	}
	
}


abstract class ExpressionCompile extends ExpressionAction {
	
	static protected $type = array();
	
	public static function compile ( $ast ) {
		
		return call_user_func_array(
			static::dispatch($ast['type'], __METHOD__),
			get_called_class(),
			$ast
		);
		
	}
	
	
}


abstract class ExpressionParse extends ExpressionAction {
	
	static protected $type = array();
	
	public static function parse ( $cst, $token, $parseState ) {
		
		return call_user_func(
			static::dispatch($token['type'], __METHOD__),
			$cst,
			$token,
			$parseState
		);
		
	}
	
	public static function parsePair ( &$parseState, $token, $nodes ) {
		
		return array(
			$nodes[0]['nodes'],
			$nodes[2]['nodes'],
		);
		
	}
	
	public static function parsePairList ( &$parseState, $token, $nodes ) {
		
		return array_merge(
			array($nodes[0]['nodes']),
			$nodes[1]['nodes'] ?: array()
		);
		
	}
	
	public static function parsePairQueue ( &$parseState, $token, $nodes ) {
		
		return $nodes[1]['nodes'];
		
	}
	
	public static function parseExprList ( &$parseState, $token, $nodes ) {
		
		return array_merge(
			array($nodes[0]),
			$nodes[1]['nodes'] ?: array()
		);
		
	}
	
	public static function parseExprQueue ( &$parseState, $token, $nodes ) {
		
		return $nodes[1];
		
	}
	
	public static function parseExprs ( &$parseState, $token, $nodes ) {
		
		return $nodes[1];
		
	}
	
	public static function parseExpr ( &$parseState, $token, $nodes ) {
		
		return $nodes[0]['nodes'];
		
	}
	
	public static function parseIsolation ( &$parseState, $token, $nodes ) {
		
		return $nodes[1]['nodes'];
		
	}
	
	public static function parseScalar ( &$parseState, $token, $nodes ) {
		
		return $nodes[0]['nodes'];
		
	}
	
	public static function parseIndex ( &$parseState, $token, $nodes ) {
		
		if ( $nodes[0]['type'] !== 'identifier' )
			return $nodes[0]['nodes'];
		
		return call_user_func(
			array($parseState['parser'], 'parseString'),
			"'" . $nodes[0]['nodes']['value'] . "'",
			1,
			'splquotes',
			'.'
		);
		
	}
	
	public static function parseFilter( &$parseState, $token, $nodes ) {
		
		$args = array($nodes[0]['nodes']);
		
		return array(
			'type' => 'function',
			'line' => $nodes[3]['line'],
			'namespace' => $nodes[2]['nodes'],
			'name' => $nodes[3]['nodes']['value'],
			'method' => $nodes[4]['nodes'] ? $nodes[4]['nodes'][1]['nodes']['value'] : '',
			'args' => empty($nodes[5]['nodes']['nodes']) ? $args : array_merge(
				$args,
				array_map(
					function ( $elem ) { return $elem['nodes']; },
					$nodes[5]['nodes']['nodes']
				)
			),
		);
		
	}
	
	public static function parseSubspace ( &$parseState, $token, $nodes ) {
		
		return $nodes[0];
		
	}
	
	public static function parseNamespace ( &$parseState, $token, $nodes ) {
		
		return ( $nodes[0]['nodes'] ? '\\' : '' ) . implode('\\', array_map(
			function ( $elem ) { return $elem['nodes']['value']; },
			$nodes[1]['nodes']
		));
		
	}
	
}


abstract class ExpressionRun extends ExpressionAction {
	
	static protected $type = array();
	
	public static function run ( $ast ) {
		
		return call_user_func_array(
			static::dispatch($ast['type'], __METHOD__),
			get_called_class(),
			$ast
		);
		
	}
	
	
}


abstract class ExpressionSerialize extends ExpressionAction {
	
	static protected $type = array();
	
	public static function serialize ( $ast ) {
		
		return call_user_func_array(
			static::dispatch($ast['type'], __METHOD__),
			get_called_class(),
			$ast
		);
		
	}
	
	
}


class ExpressionTypeArrayAccess extends ExpressionType {
	
	public static function build ( $ast1, $ast2, $line = -1 ) {
		
		return array(
			'type' => 'arrayAccess',
			'line' => $line,
			'operands' => array(
				$ast1,
				$ast2
			)
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[0]['nodes'],
			$nodes[2]['nodes'],
			$nodes[1]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'%1$s[%2$s]',
			$context::serialize($ast['operands'][0]),
			$context::serialize($ast['operands'][1])
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			'ExpressionTypeArrayAccess::runtime(%1$s, %2$s)',
			$context::compile($ast['operands'][0]),
			$context::compile($ast['operands'][1])
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		return static::runtime(
			$context::run($ast['operands'][0]),
			$context::run($ast['operands'][1])
		);
		
	}
	
	public static function runtime ( $elem, $index ) {
		
		if ( !$elem )
			return null;
		
		if ( is_array($elem) && array_key_exists($index, $elem) )
			return $elem[$index];
		
		return null;
		
	}
	
}


class ExpressionTypeBinaryOp extends ExpressionType {
	
	public static function build ( $operator, $ast1, $ast2, $line = -1 ) {
		
		return array(
			'type' => 'binaryOp',
			'line' => $line,
			'operator' => $operator,
			'operands' => array(
				$ast1,
				$ast2,
			)
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[1]['nodes']['match'],
			$nodes[0]['nodes'],
			$nodes[2]['nodes'],
			$nodes[1]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'( %2$s %1$s %3$s )',
			$ast['operator'],
			$context::serialize($ast['operands'][0]),
			$context::serialize($ast['operands'][1])
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		switch ( $ast['operator'] ) {
			
			case '^':
				$str = 'pow(%2$s, %3$s)';
			break;
			case '??':
				$str = '( %2$s ? %3$s : "" )';
			break;
			
			case '::':
				$str = '( %2$s ?: %3$s )';
			break;
			
			default:
				$str = '( %2$s %1$s %3$s )';
			break;
			
		}
		
		return sprintf(
			$str,
			( $ast['operator'] !== '+.' ) ? $ast['operator'] : '.',
			$context::compile($ast['operands'][0]),
			$context::compile($ast['operands'][1])
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		switch ( $ast['operator'] ) {
			
			case '^':
				return pow(
					$context::run($ast['operands'][0]),
					$context::run($ast['operands'][1])
				);
			break;
			
			case '??':
				if ( $context::run($ast['operands'][0]) )
					return $context::run($ast['operands'][1]);
				return null;
			break;
			
			case '::':
				if ( !$context::run($ast['operands'][0]) )
					return $context::run($ast['operands'][1]);
				return null;
			break;
			
			default:
				//~ $op1 = $context::compile($ast['operands'][0]);
				//~ $op2 = $context::compile($ast['operands'][1]);
				//~ return eval(sprintf('return %2$s %1$s %3$s;', $op1, $op2));
			break;
			
		}
		
	}
	
}


class ExpressionTypeClosure extends ExpressionType {
	
	public static function build ( $headAst, $bodyAst, $line = -1 ) {
		
		return array(
			'type' => 'closure',
			'line' => $line,
			'head' => $headAst,
			'body' => $bodyAst,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[2]['nodes'] ? array_map(function ( $elem ) { return $elem['value']; }, $nodes[2]['nodes']) : array(),
			$nodes[5]['nodes'] ? array_map(
				function ( $elem ) {
					return array(
						'return' => $elem[0]['nodes'] ? 1 : 0,
						'expression' => $elem[1]['nodes'],
					);
				},
				$nodes[5]['nodes']
			) : array(),
			$nodes[0]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		die('closure serialize');
		return sprintf(
			'( %1$s %2$s )',
			$ast['operator'],
			$context::serialize($ast['operand'])
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			'function (%1$s) use ($data, $tmp, $runtime) {' . "\n\t" . '%3$s' . "\n\t" . '%2$s' . "\n}",
			implode(', ', array_map(function ( $elem ) { return '$' . $elem; }, $ast['head'])),
			implode("\n\t", array_map(
				function ( $elem ) use ( $context ) {
					return sprintf(
						( $elem['return'] ? 'return ' : '' ) . '%1$s;',
						$context::compile($elem['expression'])
					);
				},
				$ast['body']
			)),
			implode("\n\t", array_map(function ( $elem ) { return sprintf('$data["%1$s"] = $%1$s;', $elem); }, $ast['head']))
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
	}
	
}


class ExpressionTypeDblquotes extends ExpressionType {
	
	public static function build ( $value, $line = -1 ) {
		
		return array(
			'type' => 'dblquotes',
			'line' => $line,
			'value' => $value,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			eval('return "' . str_replace('$', '\$', $nodes['matches'][1]) . '";'),
			$nodes['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return "'" . implode('\' +. "\n" +. \'', explode("\n", preg_replace(
			array('!\\\\!', '!\'!'),
			array('\\\\\\', '\\\''),
			$ast['value']
		))) . "'";
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return "'" . implode('\' . "\n" . \'', explode("\n", preg_replace(
			array('!\\\\!', '!\'!'),
			array('\\\\\\', '\\\''),
			$ast['value']
		))) . "'";
		
	}
	
	public static function run ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
}


class ExpressionTypeFalse extends ExpressionType {
	
	public static function build ( $line = -1 ) {
		
		return array(
			'type' => 'false',
			'line' => $line,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build($nodes['line']);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return '$false';
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return 'false';
		
	}
	
	public static function run ( $context, $ast ) {
		
		return false;
		
	}
	
}


class ExpressionTypeFloat extends ExpressionType {
	
	public static function build ( $value, $line = -1 ) {
		
		return array(
			'type' => 'float',
			'line' => $line,
			'value' => $value
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes['matches'][0],
			$nodes['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
	public static function run ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
}


class ExpressionTypeFunction extends ExpressionType {
	
	public static function build ( $namespace, $name, $methodName, $argsAst, $line = -1 ) {
		
		return array(
			'type' => 'function',
			'line' => $line,
			'namespace' => $namespace,
			'name' => $name,
			'method' => $methodName,
			'args' => $argsAst ?: array(),
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[0]['nodes'],
			$nodes[1]['nodes']['value'],
			$nodes[2]['nodes'] ? $nodes[2]['nodes'][1]['nodes']['value'] : '',
			array_map(
				function ( $elem ) { return $elem['nodes']; },
				$nodes[3]['nodes']['nodes'] ?: array()
			),
			$nodes[2]['nodes'][0]['nodes']['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			$ast['method'] ? '%4$s%1$s->%2$s(%3$s)' : '%4$s%1$s(%3$s)',
			$ast['name'],
			$ast['method'],
			empty($ast['args']) ? '' : 
				implode(', ', array_map(
					function ($elem) use ( $context ) { return $context::serialize($elem); },
					$ast['args']
				)),
			$ast['namespace'] ? $ast['namespace'] . '\\' : ''
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		if ( !$ast['namespace'] && !$ast['method'] && function_exists('sense_' . $ast['name']) )
			$ast['name'] = 'sense_' . $ast['name'];
		
		$str = !$ast['method'] ?
			'%4$s%1$s(%3$s)' :
			( $ast['method'] !== 'new' ?
				'%4$s%1$s::%2$s(%3$s)' :
				'new %4$s%1$s (%3$s)'
			);
		
		return sprintf(
			$str,
			$ast['name'],
			$ast['method'],
			empty($ast['args']) ? '' : 
				implode(', ', array_map(
					function ($elem) use ( $context ) { return $context::compile($elem); },
					$ast['args']
				)),
			$ast['namespace'] ? $ast['namespace'] . '\\' : ''
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		return eval('return ' . static::compile($ast) . ';');
		
		/*
		$name = ( $ast['namespace'] ? $ast['namespace'] . '\\' : '' ) . $ast['name'];
		
		if ( $ast['method'] ) {
			
			if ( $ast['method'] === 'new' )
				return eval('return ' . static::compile($ast) . ';');
			
			$name = array($name, $ast['method']);
			
		}
		
		return call_user_func_array(
			$name,
			array_map(
				function ($elem) use ( $context ) { return $context::run($elem); },
				$ast['args']
			)
		);
		*/
	}
	
}


class ExpressionTypeIdentifier extends ExpressionType {
	
	public static function build ( $name, $line = -1 ) {
		
		return array(
			'type' => 'identifier',
			'line' => $line,
			'value' => $name
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes['match'],
			$nodes['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
	public static function compile ( $context, $ast ) {
		
		if ( $ast['value'] === '_' )
			return '$data';
		
		return 'ExpressionTypeArrayAccess::runtime($data, \'' . $ast['value'] . '\')';
		
	}
	
	public static function run ( $context, $ast ) {
		
		
	}
	
}


class ExpressionTypeInteger extends ExpressionType {
	
	public static function build ( $value, $line = -1 ) {
		
		return array(
			'type' => 'integer',
			'line' => $line,
			'value' => (int) $value
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[0]['nodes']['matches'][0],
			$nodes[0]['nodes']['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
	public static function run ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
}


class ExpressionTypeList extends ExpressionType {
	
	public static function build ( $elementsAst, $line = -1 ) {
		
		return array(
			'type' => 'list',
			'line' => $line,
			'elements' => $elementsAst
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			array_map(function ( $elem ) { return $elem['nodes']; }, $nodes[1]['nodes']),
			$nodes[0]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'[%1$s]',
			implode(', ', array_map(
				function( $elem ) use ( $context ) { return $context::serialize($elem); },
				$ast['elements']
			))
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			"array(\n\t%1\$s\n)",
			implode(",\n\t", array_map(
				function( $elem ) use ( $context ) { return implode("\n\t", explode("\n", $context::compile($elem))); },
				$ast['elements']
			))
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		return array_map(
			function ( $elem ) use ( $context ) { return $context::run($elem); },
			$ast['elements']
		);
		
	}
	
}


class ExpressionTypeMap extends ExpressionType {
	
	public static function build ( $elementsAst, $line = -1 ) {
		
		return array(
			'type' => 'map',
			'line' => $line,
			'elements' => $elementsAst ?: array()
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[1]['nodes'],
			$nodes[0]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'[%1$s]',
			implode(', ', array_map(
				function( $elem ) use ( $context ) {
					return sprintf(
						'%1$s : %2$s',
						implode("\n\t", explode("\n", $context::serialize($elem[0]))),
						implode("\n\t", explode("\n", $context::serialize($elem[1])))
					);
				},
				$ast['elements']
			))
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			"array(\n\t%1\$s\n)",
			$ast['elements'] ? implode(",\n\t", array_map(
				function( $elem ) use ( $context ) {
					return sprintf(
						'%1$s => %2$s',
						implode("\n\t", explode("\n", $context::compile($elem[0]))),
						implode("\n\t", explode("\n", $context::compile($elem[1])))
					);
				},
				$ast['elements']
			)) : ''
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		return array_map(
			function ( $elem ) use ( $context ) { return $context::run($elem); },
			$ast['elements']
		);
		
	}
	
}


class ExpressionTypeMethod extends ExpressionType {
	
	public static function build ( $objectAst, $methodName, $argsAst, $line = -1 ) {
		
		return array(
			'type' => 'method',
			'line' => $line,
			'object' => $objectAst,
			'method' => $methodName,
			'args' => $argsAst,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[0]['nodes'],
			$nodes[2]['nodes']['value'],
			$nodes[3]['nodes']['nodes'] ? array_map(
				function ( $elem ) { return $elem['nodes']; },
				$nodes[3]['nodes']['nodes']
			) : array(),
			$nodes[2]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'%1$s.%2$s(%3$s)',
			$context::serialize($ast['object']),
			$ast['method'],
			empty($ast['args']) ? '' : 
				implode(', ', array_map(
					function ($elem) use ( $context ) {
						return $context::serialize($elem);
					},
					$ast['args']
				))
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			'call_user_func_array(array(%1$s, \'%2$s\'), array(%3$s) )',
			$context::compile($ast['object']),
			$ast['method'],
			empty($ast['args']) ? '' : 
				implode(', ', array_map(
					function ($elem) use ( $context ) {
						return $context::compile($elem);
					},
					$ast['args']
				))
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		return call_user_func_array(
			array($context::run($ast['object']), $ast['method']),
			empty($ast['args']) ? array() : 
				implode(', ', array_map(
					function ($elem) use ( $context ) {
						return $context::run($elem);
					},
					$ast['args']
				))
		);
		
	}
	
}


class ExpressionTypeNull extends ExpressionType {
	
	public static function build ( $line = -1 ) {
		
		return array(
			'type' => 'null',
			'line' => $line,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build($nodes['line']);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return '$null';
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return 'null';
		
	}
	
	public static function run ( $context, $ast ) {
		
		return null;
		
	}
	
}


class ExpressionTypeSplquotes extends ExpressionType {
	
	public static function build ( $value, $line = -1 ) {
		
		return array(
			'type' => 'splquotes',
			'line' => $line,
			'value' => $value,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			preg_replace(
				array('!\\\\\\\!', '!\\\\\'!'),
				array('\\', "'"),
				$nodes['matches'][1]
			),
			$nodes['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return "'" . implode('\' +. "\n" +. \'', explode("\n", preg_replace(
			array('!\\\\!', '!\'!'),
			array('\\\\\\', '\\\''),
			$ast['value']
		))) . "'";
		
	}
	
	public static function compile ( $context, $ast ) {
		
		//~ return "'" . preg_replace(
			//~ array('!\\\\!', '!\'!'),
			//~ array('\\\\\\', '\\\''),
			//~ $ast['value']
		//~ ) . "'";
		
		return "'" . implode('\' . "\n" . \'', explode("\n", preg_replace(
			array('!\\\\!', '!\'!'),
			array('\\\\\\', '\\\''),
			$ast['value']
		))) . "'";
		
	}
	
	public static function run ( $context, $ast ) {
		
		return $ast['value'];
		
	}
	
}


class ExpressionTypeTernaryOp extends ExpressionType {
	
	public static function build ( $ast1, $ast2, $ast3, $line = -1 ) {
		
		return array(
			'type' => 'ternaryOp',
			'line' => $line,
			'operands' => array(
				$ast1,
				$ast2,
				$ast3,
			)
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[0]['nodes'],
			$nodes[2]['nodes'],
			$nodes[4]['nodes'],
			$nodes[1]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'( %1$s ? %2$s : %3$s )',
			$context::serialize($ast['operands'][0]),
			$context::serialize($ast['operands'][1]),
			$context::serialize($ast['operands'][2])
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			'( %1$s ? %2$s : %3$s )',
			$context::compile($ast['operands'][0]),
			$context::compile($ast['operands'][1]),
			$context::compile($ast['operands'][2])
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		if ( $context::run($ast['operands'][0]) )
			return $context::run($ast['operands'][1]);
		
		else return $context::run($ast['operands'][2]);
		
	}
	
}


class ExpressionTypeTrue extends ExpressionType {
	
	public static function build ( $line = -1 ) {
		
		return array(
			'type' => 'true',
			'line' => $line,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build($nodes['line']);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return '$true';
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return 'true';
		
	}
	
	public static function run ( $context, $ast ) {
		
		return true;
		
	}
	
}


class ExpressionTypeUnaryOp extends ExpressionType {
	
	public static function build ( $operator, $ast, $line = -1 ) {
		
		return array(
			'type' => 'unaryOp',
			'line' => $line,
			'operator' => $operator,
			'operand' => $ast,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build(
			$nodes[0]['nodes']['match'],
			$nodes[1]['nodes'],
			$nodes[0]['line']
		);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return sprintf(
			'( %1$s %2$s )',
			$ast['operator'],
			$context::serialize($ast['operand'])
		);
		
	}
	
	public static function compile ( $context, $ast ) {
		
		return sprintf(
			'( %1$s %2$s )',
			$ast['operator'],
			$context::compile($ast['operand'])
		);
		
	}
	
	public static function run ( $context, $ast ) {
		
		switch ( $ast['operator'] ) {
			
			case '!':
				return !$context::run($ast['operand']);
			break;
			
			case '-':
				return -$context::run($ast['operand']);
			break;
			
			case '~':
				return ~$context::run($ast['operand']);
			break;
			
		}
		
	}
	
}


class Template extends Engine {
	
	public static function fromString ( $string, $dir = '', $root = '', $cache = '', $basename = '' ) {
		
		$instance = new static($dir, $root, $cache, $basename);
			
		$instance->code = SeTMLInterface::compileString($string);
		$instance->source = $string;
		
		return $instance;
		
	}
	
	/**
	 *	Rendering
	 */
	
	public function run ( $data = array() ) {
		
		if ( !( $data instanceOf SeTMLRuntime ) )
			$data = new SeTMLRuntime($data);
		
		try {
			
			return $data->run(
				$this->include ?
					$this->include :
					$this->code,
				$this,
				$this->include ? 1 : 0
			);
			
		} catch ( Exception $e ) {
			
			throw new Exception('Error during program execution !', 0, $e);
			
		}
		
		throw new Exception('File has not been compiled ! Moreover, it should not be possible to be here !');
		
	}
	
}


class SeTMLRuntime {
	
	public static function initState ($data) {
		
		return array(
			'data' => $data,
			'alloc' => array(
				'' => null,
			),
		);
		
	}
	
	/* execution environnement */
	public
		$engine = null,
		
		$flow = null,
		$alloc = null,
		$frame = null,
		$blocks = array(),
		
		$stack = array();
	
	public function __construct ( $data ) {
		
		$this->frame = self::initState($data);
		
		$this->flow = &$this->frame['alloc'][''];
		$this->alloc = &$this->frame['alloc'];
		
	}
	
	public function run ( $code, Engine $engine = null, $file = false ) {
		
		$en = $this->engine;
		$this->engine = $engine;
		
		$this->exec($this, $code, $file);
		
		$this->engine = $en;
		
		return $this;
		
	}
	
	private function exec ($runtime, $code, $file = false) {
		
		if ( $file )
			include($code);
		
		else eval($code);
		
	}
	
	public function getData( $idx = false ) {
		
		if ( $idx !== false )
			return $this->frame['alloc'][$idx];
		
		return $this->frame['alloc'];
		
	}
	
	public function appendContent ( $data ) {
		
		if ( is_array($this->flow) ) {
			
			if ( empty($this->flow['']) )
				$this->flow[''] = $data;
			else $this->flow[''] .= $data;
			
		} else $this->flow .= $data;
		
		return $this;
		
	}
	
	public function cpush ( &$pointer, $map = false ) {
		
		$this->stack[] = array(
			&$this->flow,
			&$this->alloc,
		);
		
		$this->alloc = &$pointer;
		
		if ( is_array($map) ) {
			
			foreach ( $map as $k => $v )
				$this->alloc[$k] = $v;
			
			$this->flow = &$pointer[''];
			
		} else $this->flow = &$pointer;
		
		return $this;
		
	}
	
	public function cpop () {
		
		$data = $this->frame['alloc'];
		
		$alloc = array_pop($this->stack);
		
		$this->flow = &$alloc[0];
		$this->alloc = &$alloc[1];
		
		return $data;
		
	}
	
	public function lpush ( $data = array() ) {
		
		$this->stack[] = array(
			&$this->flow,
			&$this->alloc,
			$this->frame['alloc']
		);
		
		$this->frame['alloc'] = $data;
		
		$this->flow = &$this->frame['alloc'][''];
		$this->alloc = &$this->frame['alloc'];
		
	}
	
	public function lpop () {
		
		$data = $this->frame['alloc'];
		
		$alloc = array_pop($this->stack);
		
		$this->flow = &$alloc[0];
		$this->alloc = &$alloc[1];
		$this->frame['alloc'] = $alloc[2];
		
		return $data;
		
	}
	
	public function mpush ( $data = array() ) {
		
		$this->stack[] = array(
			&$this->flow,
			&$this->alloc,
			$this->frame,
			$this->blocks
		);
		
		$this->frame = self::initState($data);
		
	}
	
	public function mpop () {
		
		$data = $this->frame;
		
		$frame = array_pop($this->stack);
		
		$this->flow = &$frame[0];
		$this->alloc = &$frame[1];
		$this->frame = $frame[2];
		$this->blocks = array_merge($frame[3], array_diff_key($this->blocks, $frame[3]));
		
		return $data;
		
	}
	
	public function mergeFrame ( $frame ) {
		
		foreach ( $frame['alloc'] as $k => $v )
			if ( $k !== '' )
				$this->frame['alloc'][$k] = $v;
		
		$this->appendContent($frame['alloc']['']);
		
	}
	
	
	public function setBlock ( &$pointer, $block, $scope = array() ) {
		
		$pointer = array(
			$block,
			$scope
		);
		
	}
	
	public function callBlock ( $pointer, $data = array() ) {
		
		if ( empty($pointer) )
			throw new Exception(sprintf('RuntimeError block does not exists !'));
		
		$block = $pointer[0];
		
		$this->mpush(array_merge($pointer[1], $data));
		
		$block($this);
		
		$this->mergeFrame($this->mpop());
		
	}
	
	public function includeTemplate ( $file, $data, $asis = false ) {
		
		$engine = $this->engine;
		
		$file = Path::get(preg_replace('!//+!', '/', preg_match('!^/!', $file) ? $file : $this->engine->getDir() . '/' . $file));
		
		try {
			
			$tpl = Template::fromFile(
				$file,
				$this->engine->getRoot(),
				$this->engine->getCache()
			);
			
			if ( $asis )
				$this->appendContent($tpl->getSource());
				
			else {
				
				$this->mpush($data);
				$tpl->run($this);
				$this->mergeFrame($this->mpop());
				
			}
			
		} catch ( Exception $e ) {
			
			throw new Exception(sprintf(
				'RuntimeError during inclusion of file "%1$s" in root directory' . "\n" . '"%2$s"' . "\n" . 'specified in file "%3$s"!',
				$file,
				$engine->getRoot(),
				$engine->getBasename()
			), 0, $e);
			
		}
		
	}
	
	public function metaTemplate ( Closure $template, $cache = null ) {
		
		$engine = $this->engine;
		
		try {
			
			$data = $template($this);
			$this->mpush($data);
			
			if ( !$cache ) {
				
				Template::fromString(
					$data[''],
					$this->engine->getDir(),
					$this->engine->getRoot(),
					$this->engine->getCache()
				)->run($this);
				
			} else {
				
				Template::fromFile(
					Path::get($cache[0] === DIRECTORY_SEPARATOR ? $cache : $this->engine->getDir() . DIRECTORY_SEPARATOR . $cache),
					$this->engine->getRoot(),
					$this->engine->getCache(),
					$data['']
				)->run($this);
				
			}
			
			$this->mergeFrame($this->mpop());
			
		} catch ( Exception $e ) {
			
			throw new Exception(sprintf(
				'RuntimeError during meta processing of file "%1$s" in root directory' . "\n" . '"%2$s"%3$s !',
				$engine->getBasename(),
				$engine->getRoot(),
				$cache ? ".\nMeta template available in mirror file " . $cache : '.'
			), 0, $e);
			
		}
		
	}
	
}


abstract class SeTML extends Expression {
	
	static protected $types = array();
	
}


/* #dirty Some things are dirty like usage of __DIR__ and a relative filepath setml.cnf */

class SeTMLInterface {
	
	static protected $parser = null;
	
	static public function parseString ( $string ) {
		
		if ( !static::$parser )
			static::$parser = SGParser::fromFile(
				"/var/www/html/admin/app/libs/sense/Sensible/SeTML/Compiler" . '/setml.peg',
				SeTML::getParserExtension()
			);
		
		return static::$parser->parseString($string, 1);
		
	}
	
	static public function compileString ( $string, SeTMLRuntime $runtime = null ) {
		
		return SeTML::compile(
			static::parseString(
				$string
			)
		);
		
	}
	
}


class SeTMLType extends ExpressionType {
}


abstract class SeTMLBuild extends ExpressionBuild {
	
	public static function buildText () {
		
		return array(
			'type' => 'text',
			'content' => func_get_args()
		);
		
	}
}


abstract class SeTMLCompile extends ExpressionCompile {
	
	static public function compileText ( $context, $ast ) {
		
		return SeTMLTypeTag::compileText($context, $ast);
		
	}
	
}


// static reference to SeTML in parseText to rewrite

abstract class SeTMLParse extends ExpressionParse {
	
	public static function parseNode ( &$parseState, $token, $nodes ) {
		
		return $nodes[0]['nodes'];
		
	}
	
	public static function parseVartag ( &$parseState, $token, $nodes ) {
		
		return array(
			'type' => 'var',
			'line' => $nodes[0]['line'],
			'meta' => (int) $nodes[1]['nodes'][1]['nodes']['value'] * ( $nodes[1]['nodes'][0]['nodes'] ? -1 : 1 ),
			'value' => $nodes[2]['nodes'],
		);
		
	}
	
	public static function parseTextual ( &$parseState, $token, $nodes ) {
		
		return array(
			'type' => 'text',
			'line' => $nodes['line'],
			'text' => $nodes['litteral'],
		);
		
	}
	
	public static function parseSpace ( &$parseState, $token, $nodes ) {
		
		return array(
			'type' => 'text',
			'line' => $nodes['line'],
			'text' => $nodes['litteral'],
		);
		
	}
	
	public static function parseAuto(&$parseState, $token, $nodes) {
		
		return static::parseOpen(
			$parseState,
			$token,
			$nodes,
			'auto'
		);
		
	}
	
	public static function parseOpen( &$parseState, $token, $nodes, $type = 'open' ) {
		
		if ( !SeTMLTypeTag::tagExists($nodes[0]['nodes']['match']) )
			return null;
		
		return SeTMLSpec::check(array_merge(
			array(
				'type' => 'tag',
				'name' => $nodes[0]['nodes']['match'],
				'tag' => $type,
				'line' => $nodes[0]['line'],
			),
			is_array($nodes[1]['nodes']) ? $nodes[1]['nodes'] : array()
		));
		
	}
	
	public static function parseClose(&$parseState, $token, $nodes) {
		
		if ( !SeTMLTypeTag::tagExists($nodes[0]['nodes']['match']) )
			return false;
		
		return array(
			'type' => 'tag',
			'name' => $nodes[0]['nodes']['match'],
			'tag' => 'close',
			'line' => $nodes[0]['line'],
		);
		
	}
	
	public static function parseParam ( &$parseState, $token, $nodes ) {
		
		if ( $nodes[0]['type'] === 'attribute' ) {
			
			$attributes = array();
			foreach ( $nodes[0]['nodes'] as $attribute )
				$attributes[$attribute['name']] = $attribute['value'];
			
			return array('attributes' => $attributes);
			
		} elseif ($nodes[0]['type'] === '(' )
			return array('expression' => $nodes[1]['nodes']);
		
		return array('form' => $nodes[0]['nodes']);
		
	}
	
	public static function parseForm ( &$parseState, $token, $nodes ) {
		
		$form = array(
			'type' => 'form',
			'line' => $nodes[0]['line'],
			'nodes' => array(
				$nodes[0]['nodes'],
				$nodes[2]['nodes']
			),
		);
		
		if ( !empty($nodes[4]['nodes']) )
			$form['nodes'][] = $nodes[4]['nodes'];
		
		if ( !empty($nodes[6]['nodes']) )
			$form['nodes'][] = $nodes[6]['nodes'];
		
		return $form;
		
	}
	
	public static function parseAttribute ( &$parseState, $token, $nodes ) {
		
		return array(
			'type' => 'attribute',
			'line' => $nodes[0]['line'],
			'name' => $nodes[0]['nodes']['value'],
			'value' => !empty($nodes[1]) ? $nodes[2]['nodes'] : 1,
		);
		
	}
	
}


abstract class SeTMLRun extends ExpressionRun {}


abstract class SeTMLSerialize extends ExpressionSerialize {}


class SeTMLTypeMagic extends SeTMLType {
	
	public static function build ( $magic, $line = -1 ) {
		
		return array(
			'type' => 'magic',
			'value' => $magic,
			'line' => $line,
		);
		
	}
	
	public static function parse ( &$parseState, $token, $nodes ) {
		
		return static::build($nodes['match'], $nodes['line']);
		
	}
	
	public static function serialize ( $context, $ast ) {
		
		return '$' . $ast['value'];
		
	}
	
	public static function compile ( $context, $ast ) {
		
		switch ( $ast['value'] ) {
			
			case 'root':
				return '$runtime->engine->getRoot()';
			break;
			
			case 'dir':
				return '$runtime->engine->getDir()';
			break;
			
			case 'file':
				return '$runtime->engine->getBasename()';
			break;
			
			case 'path':
				return '$runtime->engine->getFile()';
			break;
			
			case 'line':
				return $ast['line'];
			break;
			
			case 'session':
				return '$_SESSION';
			break;
			
			case 'server':
				return '$_SERVER';
			break;
			
			case 'get':
				return '$_GET';
			break;
			
			case 'post':
				return '$_POST';
			break;
			
			case 'request':
				return '$_REQUEST';
			break;
			
			case 'cookie':
				return '$_COOKIE';
			break;
			
			case 'files':
				return '$_FILES';
			break;
			
			default:
				throw new Exception('Magic constant not available : ' . $ast['value']);
			break;
			
		}
		
	}
	
	public static function run ( $context, $ast ) {
		
		return null;
		
	}
	
}


abstract class SeTMLTypeS extends SeTMLType {
	
	static public function build ( $ast, $line = -1 ) {
		
		return array(
			'type' => 'S',
			'line' => -1,
			'nodes' => $ast,
		);
		
	}
	
	static public function parse ( &$parseState, $token, $nodes ) {
		
		$ast = array('nodes' => array());
		$here = array(&$ast);
		foreach ( $nodes[0]['nodes'] as $token )
			
			if ( in_array($token['type'], array('text', 'var')) ) {
				
				static::addText ( $here[count($here) - 1], $token );
				
			} else switch ( $token['tag'] ) {
				
				case 'auto':
					$here[count($here) - 1]['nodes'][] = $token;
				break;
				
				case 'open':
					$now = count($here) - 1;
					$count = count($here[$now]['nodes']);
					$token['nodes'] = array();
					$here[$now]['nodes'][] = $token;
					$here[] = &$here[$now]['nodes'][$count];
				break;
				
				case 'close':
					if ( count($here) < 2 )
						throw new Exception(sprintf(
							'Close tag "%1$s" found on line %2$s but no open tag was found !',
							$token['name'], $token['line']
						));
					
					$oldToken = array_pop($here);
					if ( $oldToken['name'] !== $token['name'] )
						throw new Exception(sprintf(
							'Close tag "%1$s" found on line %3$s instead of "%2$s" expected opened on line %4$s !',
							$token['name'], $oldToken['name'], $token['line'], $oldToken['line']
						));
				break;
				
			}
		
		if ( count($here) > 1 )
			throw new Exception(sprintf(
				'Tag "%1$s" opened on line "%2$s" has not been closed !', 
				$here[count($here) - 1]['name'],
				$here[count($here) - 1]['line']
			));
		
		//~ print_r($ast['nodes']);
		//~ die();
		return static::build($ast['nodes']);
		
	}
	
	static public function addText ( &$ast, $node ) {
		
		if ( !( $c = count($ast['nodes']) ) || $ast['nodes'][$c - 1]['type'] !== 'text' )
			return $ast['nodes'][] = array(
				'type' => 'text',
				'content' => array($node)
			);
		
		$cc = count($ast['nodes'][$c - 1]['content']) - 1;
		if ( $ast['nodes'][$c - 1]['content'][$cc]['type'] === 'text' && $node['type'] === 'text' )
			$ast['nodes'][$c - 1]['content'][$cc]['text'] .= $node['text'];
		
		else $ast['nodes'][$c - 1]['content'][] = $node;
		
	}
	
	static public function serialize ( $context, $ast ) {
		
		
	}
	
	static public function compile ( $context, $ast ) {
		
		$code = array(static::open($ast));
		foreach ( $ast['nodes'] as $node )
			$code[] = $context::compile($node);
		
		$code[] = static::close($ast);
		
		return implode("\n", array_filter($code));
		
	}
	
	static public function run ( $context, $ast ) {
		
		
	}
	
	static public function open ( $ast ) {
		
		return
			'if ( !isset($tmp) ) $tmp = array();' . "\n" .
			'if ( !isset($data) ) $data = &$runtime->frame["data"];';
		
	}
	
	static public function close ( $ast ) {
		
		return '';
		
	}
	
}


abstract class SeTMLTypeTag extends SeTMLType {
	
	static public function build ( $name, $type, $attributes = array(), $content = array(), $text = '', $line = -1 ) {
		
		return array(
			'type' => 'tag',
			'name' => $name,
			'tag' => $type,
			'line' => -1,
			'text' => $text,
			'attributes' => $attributes,
			'expression' => $expression,
			'form' => $form,
			'content' => $content,
		);
		
	}
	
	static public function parse ( &$parseState, $token, $nodes ) {
		
		return $nodes;
		$ast = array();
		$here = array(&$ast);
		foreach ( $nodes[0]['nodes'] as $token ) {
			
			switch ( $token['type'] ) {
				
				case 'auto':
					$here[count($here) - 1][] = array(
						'type' => 'auto',
						'name' => $token['name'],
						'token' => $token,
					);
				break;
				
				case 'open':
					$now = count($here) - 1;
					$count = count($here[$now]);
					$here[$now][] = array(
						'type' => 'tag',
						'name' => $token['name'],
						'token' => $token,
						'nodes' => array(),
					);
					$here[] = &$here[$now][$count]['nodes'];
				break;
				
				case 'close':
					array_pop($here);
				break;
				
				case 'text':
					$here[count($here) - 1][] = array(
						'type' => 'text',
						'token' => $token,
					);
				break;
				
			}
			
		}
		
		return $ast;
		
	}
	
	static public function serialize ( $context, $ast ) {
		
		$attributes = array();
		if ( !empty($ast['attributes']) ) foreach ( $ast['attributes'] as $n => $v )
			$attributes[] = sprintf(
				'%1$s%2$s',
				$n,
				is_scalar($v) ? '' : '=' . $context::serialize($v)
			);
		
		$code = sprintf(
			'<[%3$s%1$s%4$s%2$s]>',
			$ast['name'],
			$ast['tag'] === 'auto' ? '/' : '',
			$ast['tag'] === 'close' ? '/' : '',
			$ast['tag'] === 'close' ? '' : ' ' . implode(' ', $attributes)
		);
		
		return $code;
		
	}
	
	static public function compile ( $context, $ast ) {
		
		$class = 'SeTMLTypeTag' . ucfirst($ast['name']);
		$type = $ast['tag'];
		
		return $class::$type($context, $ast);
		
	}
	
	static public function run ( $context, $ast ) {
		
		$class = 'SeTMLTypeTag' . ucfirst($ast['name']);
		
		return $class::run($context, $ast);
		
	}
	
	static public function auto ( $context, $ast ) {
		throw new Exception(sprintf(
			'SeTMLTypeTag method "%2$s" not supported for tag "%1$s" !',
			$ast['name'],
			__METHOD__
		));
	}
	
	static public function open ( $context, $ast ) {
		throw new Exception(sprintf(
			'SeTMLTypeTag method "%2$s" not supported for tag "%1$s" !',
			$ast['name'],
			__METHOD__
		));
	}
	
	static public function tagExists ( $tagName ) {
		
		$className = 'SeTMLTypeTag' . ucfirst($tagName);
		if ( class_exists($className) )
			return $className;
		
	}
	
	static public function compileValue ( $value ) {
		
		return sprintf(
			'$runtime->appendContent(' . "\n\t" . '%1$s' . "\n" . ');',
			preg_replace("!\n!", "\n\t", $value)
		);
		
	}
	
	static public function getShareAttribute ( $context, $tag, $attribute = 'share' ) {
		
		return empty($tag['attributes'][$attribute]) ?
			'array()' :
			( $tag['attributes'][$attribute] === 1 ?
				$context::compile($context::build('identifier', '_')) :
				$context::compile($tag['attributes'][$attribute]) );
		
	}
	
	static public function getAsisAttribute ( $context, $tag, $attribute = 'asis' ) {
		
		return empty($tag['attributes'][$attribute]) ?
			0 :
			( $tag['attributes'][$attribute] === 1 ?
				1 :
				$context::run($tag['attributes'][$attribute]) );
		
	}
	
	static public function getMetaAttribute ( $context, $tag, $attribute = 'meta' ) {
		
		return empty($tag['attributes'][$attribute]) ?
			0 :
			( $tag['attributes'][$attribute] === 1 ?
				1 :
				$context::run($tag['attributes'][$attribute]) );
		
	}
	
	static public function compileText ( $context, $ast ) {
		
		return static::compileValue(implode(" . \n", array_map(function ( $elem ) use ( $context ) {
			
			if ( $elem['type'] === 'text' )
				$code = $context::compile($context::build('splquotes', $elem['text']));
			
			elseif ( !$elem['meta'] )
				$code = $context::compile($elem['value']);
			
			else $code = $context::compile($context::build('splquotes', sprintf(
				!$elem['meta'] ? '{%2$s}' : '{%1$s, %2$s}',
				$elem['meta'] > 0 ? $elem['meta'] - 1 : $elem['meta'],
				$context::serialize($elem['value'])
			)));
			
			return $code;
			
		}, $ast['content'])));
		
	}
	
	static public function compileTextAsText ( $context, $ast ) {
		
		return static::compileValue(implode(" . \n", array_map(function ( $elem ) use ( $context ) {
			
			if ( $elem['type'] === 'text' )
				$code = $context::compile($context::build('splquotes', $elem['text']));
			
			else $code = $context::compile($context::build('splquotes', sprintf(
				!$elem['meta'] ? '{%2$s}' : '{%1$s, %2$s}',
				$elem['meta'],
				$context::serialize($elem['value'])
			)));
			
			return $code;
			
		}, $ast['content'])));
		
	}
	
	static public function compileTagAsText ( $context, $ast ) {
		
		if ( $ast['type'] === 'text' )
				return static::compileTextAsText($context, $ast);
		
		$code = array();
		foreach ( $ast['nodes'] as $node ) {
			
			if ( $node['type'] === 'text' )
				$code[] = static::compileTextAsText($context, $node);
			
			elseif ( $node['tag'] === 'auto' ) {
				
				$code[] = $context::serialize($node);
				
			} elseif ( $node['tag'] === 'open' ) {
				
				$code[] = static::compileValue($context::compile($context::build('splquotes', $context::serialize($node)))) . "\n";
				$code[] = static::compileTagAsText($context, $node);
				$node['tag'] = 'close';
				$code[] = static::compileValue($context::compile($context::build('splquotes', $context::serialize($node)))) . "\n";
				
			} else throw new Exception(sprintf('Error in file "%1$s" on line %2$s', __FILE__, __LINE__));
			
		}
		
		return implode("\n", $code);
		
	}
	
	static public function compileTextAsMacro ( $context, $ast ) {
		
		return static::compileValue(implode(" . \n", array_map(function ( $elem ) use ( $context ) {
			
			if ( $elem['type'] === 'text' )
				$code = $context::compile($context::build('splquotes', $elem['text']));
			
			elseif ( $elem['meta'] === -1 )
				$code = $context::compile($elem['value']);
			
			else $code = $context::compile($context::build('splquotes', sprintf(
				!$elem['meta'] ? '{%2$s}' : '{%1$s, %2$s}',
				$elem['meta'] < 0 ? $elem['meta'] + 1 : $elem['meta'],
				$context::serialize($elem['value'])
			)));
			
			return $code;
			
		}, $ast['content'])));
		
	}
	
	static public function compileTagAsMacro ( $context, $ast ) {
		
		if ( $ast['type'] === 'text' )
				return static::compileTextAsMacro($context, $ast);
		
		$code = array();
		foreach ( $ast['nodes'] as $node ) {
			
			if ( $node['type'] === 'text' )
				$code[] = static::compileTextAsMacro($context, $node);
			
			elseif ( $node['tag'] === 'auto' ) {
				
				$code[] = static::compileValue($context::compile($context::build('splquotes', $context::serialize($node))));
				
			} elseif ( $node['tag'] === 'open' ) {
				
				$code[] = static::compileValue($context::compile($context::build('splquotes', $context::serialize($node))));
				$code[] = static::compileTagAsMacro($context, $node);
				$node['tag'] = 'close';
				$code[] = static::compileValue($context::compile($context::build('splquotes', $context::serialize($node))));
				
			} else throw new Exception(sprintf('Error in file "%1$s" on line %2$s', __FILE__, __LINE__));
			
		}
		
		return implode("\n", $code);
		
	}
	
	public static function compileIndex( $context, $ast, $root, $noRoot = false ) {
		
		if ( $ast['type'] === 'arrayAccess' )  {
			
			return sprintf(
				'%1$s[%2$s]',
				static::compileIndex($context, $ast['operands'][0], $root, 1),
				$ast['operands'][1]['type'] === 'index' ?
					"'" . $ast['operands'][1]['nodes']['nodes']['match'] . "'" :
				$context::compile($ast['operands'][1])
			);
			
		} else {
			
			if ( !$noRoot && $ast['value'] === '_' )
				return $root;
			
			return sprintf(
				'%1$s["%2$s"]',
				$root,
				$ast['value']
			);
			
		}
		
		throw new Exception('Error : cannot convert tag param to index type !');
		
	}
	
	public static function compileSub ( $context, $tag ) {
		
		$code = array();
		foreach ( $tag['nodes'] as $node )
			$code[] = implode("\n\t", explode("\n", $context::compile($node)));
		
		return implode("\n\t", $code);
		
	}
	
}


class SeTMLSpec {
	
	static private $parser, $spec = array();
	
	static private function getParser () {
		
		if ( self::$parser )
			return self::$parser;
		
		return self::$parser = SGParser::fromFile("/var/www/html/admin/app/libs/sense/Sensible/SeTML/Compiler/Types/Spec" . '/spec.peg', function ( &$parseState, $token, $elem ) {
			
			switch ( $token['type'] ) {
				
				case 'S' :
					$tags = array();
					foreach ( $elem[0]['nodes'] as $tag )
						$tags[$tag['name']] = $tag;
					return $tags;
				break;
				
				case 'tag' :
					$attributes = $forms = $expression = array();
					foreach ( $elem[5]['nodes'] as $param )
						if ( $param[0]['nodes']['type'] === 'attribute' )
							$attributes[$param[0]['nodes']['name']] = $param[0]['nodes'];
						elseif ( $param[0]['nodes']['type'] === 'expression' )
							$expression = $param[0]['nodes'];
						else $forms[] = $param[0]['nodes'];
					
					$tag = array('expression' => $expression, 'forms' => $forms, 'attributes' => $attributes);
					$tags = array('open' => $tag, 'auto' => $tag);
					$tags['open']['type'] = 'open';
					$tags['auto']['type'] = 'auto';
					foreach ( $elem[6]['nodes'] as $tag ) {
						
						if ( !$tag['expression'] )
							$tag['expression'] = $expression;
						
						$tag['forms'] = array_merge($forms, $tag['forms']);
						$tag['attributes'] = array_merge($attributes, $tag['attributes']);
						
						$tags[$tag['type']] = $tag;
						
					}
					
					if ( $elem[0]['nodes'] === 'auto' )
						unset($tags['open']);
					
					elseif ( $elem[0]['nodes'] === 'noauto' )
						unset($tags['auto']);
					
					return array(
						'type' => $elem[0]['nodes'],
						'name' => $elem[1]['nodes'],
						'description' => $elem[4]['nodes'],
						'tags' => $tags,
					);
				break;
				
				case 'subTag' :
					$attributes = $forms = $expression = array();
					foreach ( $elem[5]['nodes'] as $param )
						if ( $param[0]['nodes']['type'] === 'attribute' )
							$attributes[$param[0]['nodes']['name']] = $param[0]['nodes'];
						elseif ( $param[0]['nodes']['type'] === 'expression' )
							$expression = $param[0]['nodes'];
						else $forms[] = $param[0]['nodes'];
					
					return array(
						'type' => $elem[1]['nodes'][0]['nodes']['match'],
						'description' => $elem[4]['nodes'],
						'expression' => $expression,
						'forms' => $forms,
						'attributes' => $attributes,
					);
				break;
				
				case 'expression' :
					return array(
						'type' => 'expression',
						'description' => $elem[4]['nodes'],
						'name' => $elem[2]['nodes'],
					);
				break;
				
				case 'form' :
					return array(
						'type' => 'form',
						'description' => $elem[4]['nodes'],
						'values' => $elem[2]['nodes'],
					);
				break;
				
				case 'attribute' :
					$value = $elem[3]['nodes'];
					return array(
						'type' => 'attribute',
						'description' => $elem[6]['nodes'],
						'name' => $elem[1]['nodes'],
						'value' => $value,
						'required' => empty($elem[4]['nodes']) && !in_array($value, array(
							'mixed', 'flag', 'integer', 'relative'
						)),
					);
				break;
				
				case 'description' :
					return $elem[2]['nodes']['match'];
				break;
				
				case 'type' :
					return $elem[0]['nodes']['match'];
				break;
				
				case 'name' :
					return $elem['match'];
				break;
				
			}
			
			return $elem;
			
		});
		
	}
	
	public static function getSpecs () {
		
		if ( empty(self::$spec) )
			self::loadSpecs();
		
		return self::$spec;
		
	}
	
	private static function loadSpecs () {
		
		$parser = self::getParser();
		$dir = sprintf('%1$s/../Tags/Spec/', "/var/www/html/admin/app/libs/sense/Sensible/SeTML/Compiler/Types/Spec");
		
		foreach ( scandir($dir) as $file )
			if ( preg_match('!\.spec$!', $file) ) try {
				self::$spec = array_merge(
					self::$spec,
					$parser->parseFile($file = sprintf('%1$s/../Tags/Spec/%2$s', "/var/www/html/admin/app/libs/sense/Sensible/SeTML/Compiler/Types/Spec", $file))
				);
			} catch ( Exception $e ) {
				
				throw new Exception(sprintf(
					'Parse Error on specification file "%1$s" with message "%2$s" !',
					$file,
					$e->getMessage()
				), 0);
				
			}
		
	}
	
	static public function check ( $tag ) {
		
		if ( empty(self::$spec) )
			self::loadSpecs();
		
		if ( !empty(self::$spec[$tag['name']]) ) {
			
			if ( self::$spec[$tag['name']]['type'] === 'noauto' && $tag['tag'] === 'auto' )
				throw new Exception(sprintf(
					'Error on line "%1$s" : tag "%2$s" must not be autoclosed !',
					$tag['line'],
					$tag['name']
				));
			elseif ( self::$spec[$tag['name']]['type'] === 'auto' && $tag['tag'] === 'open' )
				throw new Exception(sprintf(
					'Error on line "%1$s" : tag "%2$s" must be autoclosed !',
					$tag['line'],
					$tag['name']
				));
			
		}
		
		if ( !empty(self::$spec[$tag['name']]['tags'][$tag['tag']]) ) {
			
			$spec = self::$spec[$tag['name']]['tags'][$tag['tag']];
			
			if ( !empty($tag['expression']) )
				$tag = self::expressionToAttributes($tag, $spec);
			unset($tag['expression']);
			
			if ( !empty($tag['form']) )
				$tag = self::formToAttributes($tag, $spec);
			unset($tag['form']);
			
			foreach ( $spec['attributes'] as $name => $value ) {
				
				if ( !self::checkValue(
					!empty($tag['attributes'][$name]) ?
						$tag['attributes'][$name] :
						null,
					$value
				))
					throw new Exception(sprintf(
						'Error on line "%1$s" in tag "%2$s" : attribute "%3$s" must be of type "%4$s" !',
						$tag['line'],
						$tag['name'],
						$name,
						$value['value']
					));
				
			}
			
			if ( !empty($tag['attributes']) && $c = count($diff = array_diff_key($tag['attributes'], $spec['attributes'])) )
				throw new Exception(sprintf(
					'Error on line "%1$s" in tag "%2$s" : attribute%5$s "%3$s" do%4$s not exist !',
					$tag['line'],
					$tag['name'],
					implode('", "', array_keys($diff)),
					$c > 1 ? '' : 'es',
					$c > 1 ? 's' : ''
				));
			
		}
		
		if ( !empty($tag['attributes']) )
			ksort($tag['attributes']);
		
		return $tag;
		
	}
	
	public static function checkValue ( $value, $type ) {
		
		if ( !$value )
			return !$type['required'];
		
		$scalar = is_scalar($value);
		
		return !(
			$scalar && in_array($type['value'], array('index', 'value')) ||
			!$scalar && $type['value'] === 'flag' ||
			!$scalar && in_array($type['value'], array('relative', 'integer')) && !self::checkInteger($value, $type['value'] === 'relative') ||
			$type['value'] === 'index' && !self::checkIndex($value)
		);
		
	}
	
	public static function checkInteger ( $value, $subZero = false ) {
		
		if ( $subZero && $value['type'] === 'unaryOp' && $value['operator'] === '-' )
			$value = $value['operand'];
		
		return $value['type'] === 'integer';
		
	}
	
	public static function checkIndex ( $value ) {
		
		if ( $value['type'] === 'arrayAccess' )
			return self::checkIndex($value['operands'][0]);
		
		return in_array($value['type'], array('identifier', 'integer', 'splquotes', 'dblquotes'));
		
	}
	
	static public function expressionToAttributes ( $tag, $spec ) {
		
		if ( !$spec['expression'] )
			throw new Exception(sprintf(
				'Tag "%1$s" on line "%2$s" must not have expression attribute !',
				$tag['name'],
				$tag['line']
			));
		
		$tag['attributes'] = array(
			$spec['expression']['name'] => $tag['expression']
		);
		
		return $tag;
		
	}
	
	static public function formToAttributes ( $tag, $spec ) {
		
		if ( !$spec['forms'] )
			throw new Exception(sprintf(
				'Tag "%1$s" on line "%2$s" must not have formal attributes !',
				$tag['name'],
				$tag['line']
			));
		
		$c = count($tag['form']['nodes']);
		foreach ( $spec['forms'] as $v ) {
			
			if ( count($v['values']) !== $c )
				continue;
			
			foreach ( $v['values'] as $k => $value )
				$tag['attributes'][$value] = $tag['form']['nodes'][$k];
			
			break;
			
		}
		
		if ( empty($tag['attributes']) )
			throw new Exception(sprintf(
				'Tag "%1$s" on line "%2$s" has malformed formal attributes !',
				$tag['name'],
				$tag['line']
			));
		
		return $tag;
		
	}
	
}


class SeTMLTypeTagAffect extends SeTMLTypeTag {
	
	static public function auto ( $context, $tag ) {
		
		return sprintf(
			'%1$s %3$s %2$s;',
			static::compileIndex($context, $tag['attributes']['name'], '$runtime->frame["data"]'),
			$context::compile($tag['attributes']['value']),
			!empty($tag['attributes']['append']) ? '.=' : '='
		);
		
	}
	
	static public function open( $context, $tag ) {
		
		return sprintf(
			'$runtime->lpush(%1$s);' . "\n\t" . '%2$s' . "\n" . 
			'$runtime->frame["data"] = array_merge($data, $runtime->lpop());',
			static::getShareAttribute($context, $tag),
			str_replace("\n", "\n\t", static::compilesub($context, $tag))
		);
		
	}
	
}


class SeTMLTypeTagAsis extends SeTMLTypeTag {
	
	static protected $tagName = 'asis';
	
	static public function open ( $context, $tag ) {
		
		$code = $pcode = '';
		$meta = static::getMetaAttribute($context, $tag);
		
		if ( $meta < -1 || 0 < $meta ) {
			
			$tag['attributes']['meta'] = $context::build('integer', $meta + ( $meta > 0 ? -1 : 1 ));
			$code = static::compileValue($context::compile($context::build('splquotes', $context::serialize($tag)))) . "\n";
			
			$tag['tag'] = 'close';
			$pcode = "\n" . static::compileValue($context::compile($context::build('splquotes', $context::serialize($tag))));
			
		}
		
		if  ( $meta < 0 )
			return $code . static::compileTagAsMacro($context, $tag) . $pcode;
		
		return $code . static::compileTagAsText($context, $tag) . $pcode;
		
	}
	
}


class SeTMLTypeTagBlock extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		return sprintf(
			'$runtime->setBlock(%2$s, function ( $runtime ) {' . "\n\t" . '%1$s' . '%5$s' . '%3$s}, %4$s);',
			implode("\n\t", explode("\n", SeTMLTypeS::open($tag))),
			static::compileIndex($context, $tag['attributes']['name'], '$runtime->blocks', 1),
			implode("\n\t", explode("\n", SeTMLTypeS::close($tag))),
			self::getShareAttribute($context, $tag),
			static::compilesub($context, $tag)
		);
		
	}
	
}


class SeTMLTypeTagCall extends SeTMLTypeTag {
	
	static public function auto ( $context, $tag ) {
		
		return sprintf(
			'$runtime->callBlock(%1$s, %2$s);',
			self::compileIndex($context, $tag['attributes']['name'], '$runtime->blocks', 1),
			self::getShareAttribute($context, $tag)
		);
		
	}
	
	static public function open ( $context, $tag ) {
		
		return sprintf(
			'$runtime->lpush(%1$s);' . '%3$s' . '$runtime->callBlock(%2$s, $runtime->lpop());',
			self::getShareAttribute($context, $tag),
			self::compileIndex($context, $tag['attributes']['name'], '$runtime->blocks', 1),
			static::compilesub($context, $tag)
		);
		
	}
	
}


class SeTMLTypeTagComment extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		return '';
		
	}
	
}


class SeTMLTypeTagContent extends SeTMLTypeTag {
	
	static public function auto ( $context, $tag ) {
		
		return sprintf(
			'%1$s %3$s %2$s;',
			static::compileIndex($context, $tag['attributes']['name'], '$runtime->alloc'),
			$context::compile($tag['attributes']['value']),
			!empty($tag['attributes']['append']) ? '.=' : '='
		);
		
	}
	
	static public function open ( $context, $tag ) {
		
		$str = empty($tag['attributes']['replace']) ? '' : '%1$s = "";' . "\n";
		$asis = static::getMetaAttribute($context, $tag, 'asis');
		
		return sprintf(
			$str . '$runtime->cpush(%1$s);' . "\n\t" . '%2$s' . "\n" . '$runtime->cpop();',
			static::compileIndex($context, $tag['attributes']['name'], '$runtime->alloc'),
			( $asis === 0 ) ? static::compilesub($context, $tag) : ( $asis > 0 ? static::compileTagAsText($context, $tag) : static::compileTagAsMacro($context, $tag) )
		);
		
	}
	
}


class SeTMLTypeTagElseif extends SeTMLTypeTag {
	
	static public function auto ( $context, $tag ) {
		
		return sprintf(
			'} elseif ( %1$s ) {',
			$context::compile($tag['attributes']['condition'])
		);
		
	}
	
}


class SeTMLTypeTagElse extends SeTMLTypeTag {
	
	static public function auto ( $context, $tag ) {
		
		return "} else {";
		
	}
	
}


class SeTMLTypeTagForeach extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		$str = '';
		if ( !empty($tag['attributes']['key']) )
			$str = sprintf(
				"\n\t" . '%1$s = $k;',
				static::compileIndex($context, $tag['attributes']['key'], '$data')
			);
		if ( !empty($tag['attributes']['transform']) )
			$str .= sprintf(
				"\n\t" . '%1$s = %2$s;',
				static::compileIndex($context, $tag['attributes']['value'], '$data'),
				$context::compile($tag['attributes']['transform'])
			);
		
		return sprintf(
			'if ( ( $tmp[\'%2$s\'] = %1$s ) && count($tmp[\'%2$s\']) )' .
				"\n" . 'foreach ( $tmp[\'%2$s\'] as $k => $v ) {' .
				"\n\t" . '%3$s = $v;' . $str . "\n\t" . '%4$s' . "\n}",
			$context::compile($tag['attributes']['list']),
			uniqid(),
			static::compileIndex($context, $tag['attributes']['value'], '$data'),
			static::compilesub($context, $tag)
		);
		
	}
	
}


class SeTMLTypeTagFor extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		return sprintf(
			'for ( %1$s = %2$s; %1$s < %3$s; %1$s++ ) {' .
				"\n\t" . '%4$s' . "\n}",
			static::compileIndex($context, $tag['attributes']['value'], '$data'),
			$context::compile($tag['attributes']['start']),
			$context::compile($tag['attributes']['end']),
			static::compilesub($context, $tag)
		);
		
	}
	
	static public function opesn ( &$state, $tag ) {
		
		return sprintf(
			'$tmp["%5$s"] = %3$s;' . "\n" .
			'$tmp["%5$s-step"] = %4$s;' . "\n" .
			'if ( %2$s < %3$s )' ."\n\t" . 'for ( %1$s = %2$s; %1$s < $tmp["%5$s"]; %1$s += $tmp["%5$s-step"] ) {',
			SeTMLExpression::compileIndex($tag['attributes']['value']['ast'], '$data'),
			$tag['attributes']['start']['code'],
			$tag['attributes']['end']['code'],
			!empty($tag['attributes']['step']) ? $tag['attributes']['step']['code'] : 1,
			uniqid()
		);
		
	}
	
	static public function close ( &$state, $tag ) {
		
		return "}";
		
	}
	
}


class SeTMLTypeTagIf extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		$code = array();
		foreach ( $tag['nodes'] as $node )
			$code[] = $context::compile($node);
		
		return sprintf(
			'if ( %1$s ) {' . "\n\t" . '%2$s' . "\n" . '}',
			$context::compile($tag['attributes']['condition']),
			implode("\n\t", str_replace("\n", "\n\t", $code))
		);
		
	}
	
}


class SeTMLTypeTagInclude extends SeTMLTypeTag {
		
	static public function auto ( $context, $tag ) {
		
		return sprintf(
			'$runtime->includeTemplate(%1$s, %2$s, 0);',
			$context::compile($tag['attributes']['file']),
			self::getShareAttribute($context, $tag)
		);
		
	}
	
	static public function open( $context, $tag ) {
		
		return sprintf(
			'$runtime->lpush(%1$s);' . "\n\t" . '%3$s' . "\n" . '$runtime->includeTemplate(%2$s, $runtime->lpop(), 0);',
			self::getShareAttribute($context, $tag),
			$context::compile($tag['attributes']['file']),
			static::compilesub($context, $tag)
		);
		
	}
	
}


class SeTMLTypeTagMacro extends SeTMLTypeTag {
	
}


class SeTMLTypeTagMap extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		return sprintf(
			( empty($tag['attributes']['replace']) ? '' : 'unset(%1$s);' . "\n") .
			'$runtime->cpush(%1$s, %2$s);' . "\n" . '%3$s' . "\n" . '$runtime->cpop();',
			static::compileIndex($context, $tag['attributes']['name'], '$runtime->alloc'),
			static::getShareAttribute($context, $tag),
			static::compilesub($context, $tag)
		);
		
	}
	
}


class SeTMLTypeTagMeta extends SeTMLTypeTag {
	
	static public function open ( $context, $tag ) {
		
		return sprintf(
			'$runtime->metaTemplate(function ( $runtime ) {' .
			"\n\t" . '%1$s' . "\n\t" . '$runtime->lpush(%2$s);' . "\n\t" . '%3$s' .
			"\n\t" . 'return $runtime->lpop();' . "\n" . '}, %4$s);',
			implode("\n\t", explode("\n", SeTMLTypeS::open($context))),
			static::getShareAttribute($context, $tag),
			static::compilesub($context, $tag),
			empty($tag['attributes']['cache']) ? 'null' : $context::compile($tag['attributes']['cache'])
		);
	}
	
}


abstract class Entity {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType,
		$cache = array(),
		$entities = array();
	
	final public static function getType ( $root = false ) {
		
		if ( !empty(static::$type) )
			return static::$type;
		
		$class = static::getSubType();
		
		return static::$type =
			( $parent = get_parent_class($class) ) && ( __CLASS__ !== $parent ) ?
				$parent::getType() :
				$class;
		
	}
	
	final public static function getSubType () {
		
		if ( static::$subType )
			return static::$subType;
		
		$class = get_called_class();
		
		if ( $class === __CLASS__ )
			throw new Exception('Cannot call static method on Entity !');
		
		return static::$subType = $class;
		
	}
	
	final public static function getParentType ( $root = false ) {
		
		if ( !$root )
			return static::$parentType;
		
		elseif ( static::$rootType )
			return static::$rootType;
		
		return static::$rootType = 
			( $parent = static::$parentType ) ?
				$parent::getParentType($root) :
				static::getSubType();
		
	}
	
	final public static function getEntityData ( $id ) {
		
		return static::getEntity($id)->getData();
		
	}
	
	final public static function getEntity ( $id ) {
		
		if ( !empty(self::$entities[$id]) )
			return self::$entities[$id];
		
		$path = explode(':', $id);
		$type = $path[0];
		
		return $type::get($path[1]);
		
	}
	
	final public static function get ( $fullName ) {
		
		$ctype = static::getType();
		$id = $ctype . ':' . $fullName;
		
		//~ echo sprintf(
			//~ '%1$s::%2$s(%3$s)' . "\n",
			//~ get_called_class(),
			//~ __METHOD__,
			//~ $fullName
		//~ );
		
		if ( !empty(self::$entities[$id]) )
			return self::$entities[$id];
		
		if ( !( $instance = $ctype::getInstance($fullName) ) )
			return null;
		
		self::$entities[$instance->getId()] = $instance;
		self::$entities[$instance->getId(1)] = $instance;
		
		return $instance;
		
	}
	
	protected static function getInstance ( $fullName ) {
		
		//~ echo sprintf(
			//~ '%1$s::%2$s(%3$s)' . "\n",
			//~ get_called_class(),
			//~ __METHOD__,
			//~ $fullName
		//~ );
		
		$path = explode('.', $fullName);
		$name = array_pop($path);
		$type = static::getType();
		$parentType = $type::getParentType();
		$parent = $parentType::get(implode('.', $path));
		$data = $parent->getChildrenData($type, $name);
		
		if ( !$data )
			return null;
		
		$data['name'] = $name;
		
		$subType = $data['type'];
		
		if ( !$subType )
			$subType = static::getSubType();
		
		return new $subType(
			$data,
			$parent
		);
		
	}
	
	protected
		$collections = array(),
		$names = array(),
		$ids = array(),
		$parent,
		$data,
		$root;
	
	protected function __construct ( $data, $parent = null ) {
		
		$this->data = $data;
		$this->parent = $parent;
		
	}
	
	public function __destruct () {
		
		unset(self::$entities[$this->getId()]);
		unset(self::$entities[$this->getId(1)]);
		
		foreach ( $this->data as $k => $v )
			unset($this->data[$k]);
		
	}
	
	final public function __get ( $type ) {
		
		$type = $type::getType();
		
		if ( !empty($this->collections[$type]) )
			return $this->collections[$type];
		
		return $this->collections[$type] = new ChildrenTypeEntityIteratorAggregate($this, $type);
		
	}
	
	final public function __toString () {
		
		return $this->getId(1);
		
	}
	
	final public function getName ( $full = false ) {
		
		if ( !empty($this->names[$full]) )
			return $this->names[$full];
		
		if ( empty($this->data['name']))
			print_r($this);
		
		return $this->names[$full] =
			( $full && ( $parent = $this->getParent() ) ? $parent->getName(1) . '.' : '' ) . 
			$this->data['name'];
		
	}
	
	final public function getId ( $canonical = false ) {
		
		if ( !empty($this->ids[$canonical]) )
			return $this->ids[$canonical];
		
		return $this->ids[$canonical] = sprintf(
			'%1$s:%2$s',
			$canonical ?
				static::getType() :
				static::getSubType(),
			$this->getName(true)
		);
		
	}
	
	final public function getData ( $offset = null ) {
		
		if ( $offset && array_key_exists($offset, $this->data) )
			return $this->data[$offset];
		
		elseif ( $offset )
			return null;
		
		return $this->data;
		
	}
	
	final public function getParent ( $root = false ) {
		
		if ( !$root )
			return $this->parent;
		
		elseif ( $this->root )
			return $this->root;
		
		return $this->root = $this->parent ? $this->parent->getParent(1) : $this;
		
	}
	
	final public function getChild ( $type, $name ) {
		
		return $type::get($this->getName(1) . '.' . $name);
		
	}
	
	final public function getChildrenData ( $type = null, $name = null ) {
		
		//~ echo sprintf(
			//~ '%1$s::%2$s(%3$s, %4$s)' . "\n",
			//~ get_called_class(),
			//~ __METHOD__,
			//~ $type,
			//~ $name
		//~ );
		
		if ( !$type )
			return !empty($this->data['children']) ? $this->data['children'] : null;
			
		elseif ( $name && !empty($this->data['children'][$type][$name]) )
			return $this->data['children'][$type][$name];
		
		elseif ( $name )
			return null;
		
		return !empty($this->data['children'][$type]) ? $this->data['children'][$type] : array();
		
	}
	
	final protected function setCache ( $offset, $value ) {
		
		self::$cache[$this->getId(1)][$offset] = $value;
		
		return $this;
		
	}
	
	final protected function getCache ( $offset ) {
		
		return self::$cache[$this->getId(1)][$offset];
		
	}
	
	final public function getChildrenIterator () {
		
		return new ChildrenEntityIterator($this);
		
	}
	
	final public function getParentIterator () {
		
		return new ParenEntityIterator($this);
		
	}
	
}


class EntityObject implements ArrayAccess, IteratorAggregate {
	
	private $model, $data;
	
	public function __construct ( Model $model, $data = array() ) {
		
		$this->model = $model;
		$this->data = $data;
		
	}
	
	public function getModel () {
		
		return $this->model;
		
	}
	
	public function getData () {
		
		return $this->data;
		
	}
	
	public function setData ( $data = array() ) {
		
		$this->data = $data;
		
		return $this;
		
	}
	
	public function apply () {
		
		$this->data = $this->model->apply($this->data);
		
		return $this;
		
	}
	
	public function invalid () {
		
		return $this->model->invalid($this->data);
		
	}
	
	public function getState ( $service = '' ) {
		
		return $this->model->getState($this->data, $service);
		
	}
	
	public function offsetSet ( $offset, $value ) {
		
		return $this->data[$offset] = $value;
		
	}
	
	public function offsetGet ( $offset ) {
		
		return !empty($this->data[$offset]) ? $this->data[$offset] : null;
		
	}
	
	public function offsetExists ( $offset ) {
		
		return array_key_exists($offre, $this->data);
		
	}
	
	public function offsetUnset ( $offset ) {
		
		unset($this->data[$offset]);
		
	}
	
	public function getIterator () {
		
		return new ArrayIterator($this->data);
		
	}
	
}


abstract class Element {
	
	private static $systemType;
	
	final public static function getSystemType ( $root = false ) {
		
		if ( static::$systemType )
			return static::$systemType;
		
		$class = get_called_class();
		
		return static::$systemType = lcfirst(preg_replace('!$Element!', '',
			( $parent = get_parent_class($class) ) && ( __CLASS__ !== $parent ) ?
				$parent::getSystemType() :
				$class));
		
	}
	
	public static function getDefinition () {
		
		throw new Exception('Children class must reimplement Element::getSchema !');
		
	}
	
	public static function getSchema ( $params ) {
		
		throw new Exception('Children class must reimplement Element::getParams !');
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( is_null($value) && !empty($schema['null']) )
			return false;
		
		if ( is_null($value) )
			return 'Value should not be null !';
		
		return false;
		
	}
	
	public static function apply ( $schema, $value, $data = array() ) {
		
		if ( $error = static::invalid($schema, $value, $data) ) {
			
			$value = array_key_exists('default', $schema) ? $schema['default'] : null;
			
			if ( is_null($value) && empty($schema['null']) )
				throw new Exception('No default to set for missing value for type ' . $schema['type'] . "\n" . $error);
			
			return $value;
			
		}
		
		return $value;
		
	}
	
}


abstract class Provider extends Entity implements IteratorAggregate {
	
	protected static 
		$type,
		$subType,
		$rootType,
		$parentType,
		$providers = array();
	
	final public static function addProviderDir ( $dir, $cache = null ) {
		
		static::checkDirectories($dir, $cache);
		
		foreach ( scandir($dir) as $name )
			if ( file_exists($dir . '/' . $name . '/provider.php') ) {
				
				if ( $cache && !file_exists($cache . '/' . $name) )
					mkdir($cache . '/' . $name, 0777, 1);
				
				self::set($name, $dir . '/' . $name, $cache ? $cache . '/' . $name : null);
				
			}
		
	}
	
	final public static function set ( $name, $dir, $cache = '' ) {
		
		if ( !empty(self::$providers[$name]) )
			throw new Exception(sprintf(
				'Provider "%1$s" already set !',
				$name
			));
		
		static::checkDirectories($dir, $cache);
		
		self::$providers[$name] = array($dir, $cache);
		
	}
	
	final public static function checkDirectories ( $folder, $cache = null ) {
		
		if ( !( $exists = file_exists($folder) ) || !is_dir($folder) )
			throw new Exception(sprintf(
				$exists ? 
					'Directory "%1$s" doest not exists ! It is a file !' :
					'Directory "%1$s" doest not exists !',
				$folder
			));
		
		if ( $cache && ( !( $exists = file_exists($cache) ) || !is_dir($cache) ) )
			throw new Exception(sprintf(
				$exists ? 
					'Directory "%1$s" doest not exists ! It is a file !' :
					'Directory "%1$s" doest not exists !',
				$cache
			));
		
	}
	
	protected static function getInstance ( $name ) {
		
		//~ echo sprintf(
			//~ '%1$s::%2$s(%3$s)' . "\n",
			//~ get_called_class(),
			//~ __METHOD__,
			//~ $name
		//~ );
		
		if ( empty(self::$providers[$name]) )
			throw new Exception(sprintf(
				'Provider "%1$s" not registered !',
				$name
			));
		
		$data = include(self::$providers[$name][0] . '/provider.php');
		
		$data['name'] = $name;
		$class = $data['type'];
		
		return new $class($data);
		
	}
	
	abstract protected function build ();
	
	protected function __construct ( $data, $parent = null ) {
		
		parent::__construct($data, $parent);
		
		$this->load();
		
	}
	
	public function getIterator () {
		
		return $this->__get('Model');
		
	}
	
	protected function load () {
		
		// if not in cache
		if ( !$this->loadFromCache() ) {
			
			// if no model structure found
			$this->loadFromFiles();
			$this->build();
			
			$this->saveToFiles();
			
			// merge data for faster access and cache
			$this->saveToCache();
			
		}
		
		return $this;
		
	}
	
	private function loadFromFiles () {
		
		$loaded = false;
		$name = $this->getName();
		if ( $dir = self::$providers[$name][0] ) {
			
			foreach ( scandir($dir) as $file )
				if ( preg_match('!^([a-zA-Z0-9_]++)\.([a-zA-Z0-9_]++)\.php$!', $file, $m) ) {
					
					$loaded = true;
					$this->data['children'][$m[1]][$m[2]] = include($dir . '/' . $file);
					
				}
			
		}
		
/*#BEGIN debug#*/
		return false;
/*#END debug#*/
		return $loaded;
		
	}
	
	private function saveToFiles ( ) {
		
		$name = $this->getName();
		if ( $dir = self::$providers[$name][0] ) {
			
			$dir .= '/auto';
			if ( !file_exists($dir) )
				mkdir($dir, 0777, 1);
			
			$provider = $this->data;
			unset($provider['children']);
			phpize($provider, $dir . '/provider.php');
			
			foreach ( $this->data['children'] as $type => $instances )
				foreach ( $instances as $k => $instance )
					phpize($instance, sprintf(
						'%1$s/%2$s.%3$s.php',
						$dir,
						$type,
						$k
					));
			
		}
		
		//~ if ( $dir = self::$providers[$name][1] ) {
			
			//~ if ( !file_exists($dir = dirname($this->cachePath) . '/' . $this->getName()) )
				//~ mkdir($dir, 0770, 1);
			
			//~ foreach ( $props as $f )
				//~ phpize($this->$f, $dir . '/' . $f . '.php');
			
		//~ }
		
		return $this;
		
	}
	
	private function loadFromCache ( ) {
		
		if ( $cache = self::$providers[$name = $this->getName()][1] ) {
			
			$cacheFile = sprintf(
				'%1$s/provider.php',
				$cache
			);
			
/*#BEGIN debug#*/
		//~ // clear the cache if it is.
			if ( file_exists($cacheFile) )
				unlink($cacheFile);
			
/*#END debug#*/
			
			$cached = null;
			if ( file_exists($cacheFile) )
				$cached = include($cacheFile);
			
			// restore the cache
			if ( $cached ) {
				
				$this->data = $cached;
				
				$cached = null;
				
				return true;
				
			}
			
		}
		
		return false;
		
	}
	
	private function saveToCache ( ) {
		
		// Cache the merged model data
		if ( $cache = self::$providers[$name = $this->getName()][1] ) {
			
			$cacheFile = sprintf(
				'%1$s/provider.php',
				$cache
			);
			
			phpize($this->data, $cacheFile);
			
		}
		
		return $this;
		
	}
	
}


class Role extends Entity {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType = 'Provider';
	
	
	public function getSource () {
		
		return $this->getParent()->getChild('Model', $this->data['source']);
		
	}
	
	public function getTarget () {
		
		return $this->getParent()->getChild('Model', $this->data['target']);
		
	}
	
}


class Model extends Entity implements IteratorAggregate {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType = 'Provider';
	
	protected function __construct ( $data, Provider $provider ) {
		
		parent::__construct($data, $provider);
		
		// extends model
		if ( !empty($this->data['extends']) ) {
			
			if ( !$parentData = $provider->getChildrenData('Model', $this->data['extends']) )
				throw new Exception(sprintf(
					'Parent Model "%3$s" for Child Model "%2$s" in Provider "%1$s" does not exists !',
					$provider->getName(),
					$this->data['name'],
					$this->data['extends']
				));
			
			// extends services
			$this->data['children']['Service'] = array_merge(
				!empty($parentData['children']['Service']) ? $parentData['children']['Service'] : array(),
				!empty($this->data['children']['Service']) ? $this->data['children']['Service'] : array()
			);
			
			// extends views
			$this->data['children']['View'] = array_merge(
				!empty($parentData['children']['View']) ? $parentData['children']['View'] : array(),
				!empty($this->data['children']['View']) ? $this->data['children']['View'] : array()
			);
			
		}
		
	}
	
	public function getIterator () {
		
		return $this->__get('Field');
		
	}
	
	public function apply () {
		
		$errors = array();
		foreach ( $this->model->Field as $name => $field )
			if ( $field->apply($this->data) )
		
		return $this;
		
	}
	
	public function invalid () {
		
		$errors = array();
		foreach ( $this->model->Field as $name => $field )
			if ( $error = $field->invalid(
				!empty($this->data[$field->getName()]) ? $this->data[$field->getName()] : null
			) );// $errors[] = $error;
		
		return $errors;
		
	}
	
	public function getState ( $service, $data = array() ) {
		
		if ( $service )
			return $this->getModel()->Service->$service->getState($data);
		
		throw new Exception(sprintf(
			'Method "%1$s->%2$s" must be reimplemented in child class "%3$s" !',
			__CLASS__,
			__METHOD__,
			$this::getSubType()
		));
		
	}
	
	public function getEntityObject ( $data = array() ) {
		
		return new EntityObject($this, $data);
		
	}
	
}


class Field extends Entity {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType = 'Model';
	
	protected function __construct ( $data, Model $parent = null ) {
		
		parent::__construct($data, $parent);
		
	}
	
	public function invalid ( $value, $data = array() ) {
		
		$class = 'Element' . ucfirst($this->data['value']['type']);
		
		return $class::invalid($this->data['value'], $value, $data);
		
	}
	
	public function apply ( $value, $data = array() ) {
		
		$class = 'Element' . ucfirst($this->data['value']['type']);
		
		return $class::apply($this->data['value'], $value, $data);
		
	}
	
	public function unaryOperator ( $operator, $arg ) {
		
		$class = 'Element' . ucfirst($this->data['value']['type']);
		
		return $class::unaryOperator($this->data['value'], $operator, $arg);
		
	}
	
	public function binaryOperator ( $operator, $arg ) {
		
		$class = 'Element' . ucfirst($this->data['value']['type']);
		
		return $class::binaryOperator($this->data['value'], $operator, $arg1, $arg2);
		
	}
	
}


abstract class Index extends Entity implements IteratorAggregate {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType = 'Model';
	
	
	public function getIterator () {
		
		return $this->__get('Field');
		
	}
	
	final public function getField ( $name ) {
		
		if ( empty($this->data['fields'][$name]) )
			return null;
		
		return Field::get($this->getParent()->getName(1) . '.' . $name);
		
	}
	
	final public function getFieldsData ( $name = null ) {
		
		if ( $name && !empty($this->data['fields'][$name]) )
			return $this->data['fields'][$name];
		
		elseif ( $name )
			return null;
		
		return $this->data['fields'];
		
	}
	
	final public function getPositionField ( $position ) {
		
		if ( empty($this->data['fields'][$position]) )
			return null;
		
		return $this->getField($this->data['fields'][$position]);
		
	}
	
	final public function getPositionFieldsData ( $position = null ) {
		
		if ( $position && !empty($this->data['fields'][$position]) )
			return $this->data['fields'][$this->data['fields'][$position]];
		
		elseif ( $name )
			return null;
		
		return $this->data['fields'];
		
	}
	
}


class View extends Entity {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType = 'Model';
	
	protected function __construct ( $data, Model $model ) {
		
		//~ echo $model . ":\n";
		//~ print_r($data);
		//~ echo "\n";
		
		parent::__construct($data, $model);
		
		$fields = $this->getParent()->getChildrenData('Field');
		unset($fields['id']);
		
		$f = array();
		foreach ( $fields as $n => $field )
			$f[$n] = 0;
		
		$ff = array();
		foreach ( $fields as $n => $field )
			$ff[$n] = 1;
		
		if ( $this->data['list'] === '*' )
			$this->data['list'] = $f;
		
		elseif ( is_string($this->data['list']) ) {
			
			$tokens = preg_split('!\s+!', $this->data['list']);
			
			if ( $tokens && $tokens[0] === '*' ) {
				$first = array_shift($tokens);
				$this->data['list'] = $f;
			} else $this->data['list'] = array();
			
			while ( count($tokens) ) {
				
				$a = array_shift($tokens);
				$b = explode(':', array_shift($tokens));
				
				if ( $a === '-' ) {
					
					unset($this->data['list'][$b[0]]);
					
				} elseif ( $model->getChild('Field', $b[0]) ) {
					
					$this->data['list'][$b[0]] = empty($b[1]) ? null : (
						$b[1] === '1' ? 1 : 0
					);
					
				}
				
			}
			
		}
		
		if ( $this->data['edit'] === '*' )
			$this->data['edit'] = $ff;
		
		elseif ( is_string($this->data['edit']) ) {
			
			$tokens = preg_split('!\s+!', $this->data['edit']);
			
			if ( $tokens && $tokens[0] === '*' ) {
				$first = array_shift($tokens);
				$this->data['edit'] = $ff;
			} else $this->data['edit'] = array();
			
			//~ $tokens = preg_split('!\s!', $this->data['edit']);
			//~ $first = array_shift($tokens);
			
			//~ $this->data['edit'] = $ff;
			while ( count($tokens) ) {
				
				$a = array_shift($tokens);
				$b = explode(':', array_shift($tokens));
				
				if ( $a === '-' ) {
					
					unset($this->data['edit'][$b[0]]);
					
				} elseif ( array_key_exists($b[0], $ff) ) {
					$this->data['edit'][$b[0]] = ( !isset($b[1]) || $b[1] === '1' ) ? 1 : null;
				}
				
			}
			
		}
		
		//~ print_r($this->data);
		
	}
	
}


abstract class Service extends Entity {
	
	protected static
		$type,
		$subType,
		$rootType,
		$parentType = 'Model';
	
	public function getState ( EntityObject $dataObject ) {
		
		return $this->getParent()->getState($dataObject);
		
	}
	
}


define('INT_32_MAX', pow(2, 32));
define('INT_32_MIN', -INT_32_MAX - 1);

class ElementInteger extends Element {
	
	const
		_MIN = INT_32_MIN,
		_MAX = INT_32_MAX;
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'min' => self::getSchema(array('min' => self::_MIN, 'max' => self::_MAX, 'default' => self::_MIN, 'null' => true)),
			'max' => self::getSchema(array('min' => self::_MIN, 'max' => self::_MAX, 'default' => self::_MAX, 'null' => true)),
			'default' => ElementBoolean::getSchema(array('default' => null, 'null' => true)),
			'null' => ElementBoolean::getSchema(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'integer';
		return $params;
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( $error = parent::invalid($schema, $value, $data) )
			return $error;
		
		if ( is_null($value) || is_int($value) )
			return false;
		
		return 'Value is not an integer !';
		
	}
	
	public static function apply ( $schema, $value, $data = array() ) {
		
		if ( !$value )
			$value = 0;
		
		else $value = (int) $value;
		
		return (int) parent::apply($schema, $value, $data);
		
	}
	
}


class ElementBoolean extends Element {
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'default' => self::getSchema(array('default' => null, 'null' => true)),
			'null' => self::getSchema(array('default' => null, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'boolean';
		return $params;
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( $error = parent::invalid($schema, $value, $data) )
			return $error;
		
		if ( is_null($value) || is_bool($value) )
			return false;
		
		return 'Value is not a boolean !';
		
	}
	
	public static function apply ( $schema, $value, $data = array() ) {
		
		return (bool) $value;
		return (bool) parent::apply($schema, $value, $data);
		
	}
	
}


class ElementString extends Element {
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'minlength' => ElementInteger::getSchema(array('default' => false, 'null' => true)),
			'maxlength' => ElementInteger::getSchema(array('default' => false, 'null' => true)),
			'default' => ElementBoolean::getSchema(array('default' => false, 'null' => true)),
			'null' => ElementBoolean::getSchema(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'string';
		return $params;
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( $error = parent::invalid($schema, $value, $data) )
			return $error;
		
		if ( is_null($value) || is_string($value) )
			return false;
		
		return 'Value is not a string !';
		
	}
	
	
	public static function apply ( $schema, $value, $data = array() ) {
		
		return (string) parent::apply($schema, $value, $data);
		
	}
	
}


class ElementSet extends Element {
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= static::getSchema(array(
			'values' => self::getParams(array('default' => null, 'null' => true)),
			'default' => ElementBoolean::getParams(array('default' => null, 'null' => true)),
			'null' => ElementBoolean::getParams(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'set';
		return $params;
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( $error = parent::invalid($value, $data) )
			return $error;
		
		if ( is_null($value) || is_array($value) )
			return false;
		
		return 'Value is not a set !';
		
	}
	
}


class ElementEnum extends ElementSet {
	
	private static $schema;
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'enum';
		return $params;
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( $error = parent::invalid($value, $data) )
			return $error;
		
		if ( is_null($value) || is_string($value) )
			return false;
		
		return 'Value is not an enum !';
		
	}
	
}


class ElementImage extends ElementString {
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'minlength' => ElementInteger::getSchema(array('default' => false, 'null' => true)),
			'maxlength' => ElementInteger::getSchema(array('default' => false, 'null' => true)),
			'default' => ElementBoolean::getSchema(array('default' => false, 'null' => true)),
			'null' => ElementBoolean::getSchema(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'image';
		return $params;
		
	}
	
}


class ElementDate extends ElementString {
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'format' => ElementString::getSchema(array('default' => 'Y-m-d', 'null' => 'false')),
			'default' => ElementBoolean::getSchema(array('default' => false, 'null' => true)),
			'null' => ElementBoolean::getSchema(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'date';
		return $params;
		
	}
	
}


class ElementRichText extends ElementString {
	
}


class ElementText extends ElementString {
	
}


class ElementRelation extends Element {
	
	const
		_MIN = INT_32_MIN,
		_MAX = INT_32_MAX;
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'min' => self::getSchema(array('min' => self::_MIN, 'max' => self::_MAX, 'default' => self::_MIN, 'null' => true)),
			'max' => self::getSchema(array('min' => self::_MIN, 'max' => self::_MAX, 'default' => self::_MAX, 'null' => true)),
			'default' => ElementBoolean::getSchema(array('default' => null, 'null' => true)),
			'null' => ElementBoolean::getSchema(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'integer';
		return $params;
		
	}
	
	public static function invalid ( $schema, $value, $data = array() ) {
		
		if ( $error = parent::invalid($schema, $value, $data) )
			return $error;
		
		if ( is_null($value) || is_int($value) )
			return false;
		
		return 'Value is not an integer !';
		
	}
	
	public static function apply ( $schema, $value, $data = array() ) {
		
		return $value;
		if ( !$value )
			$value = 0;
		
		else $value = (int) $value;
		
		return (int) parent::apply($schema, $value, $data);
		
	}
	
}


class ElementFile extends ElementString {
	
	private static $schema;
	
	public static function getDefinition () {
		
		if ( self::$schema )
			return static::$schema;
		
		return static::$schema= self::getSchema(array(
			'minlength' => ElementInteger::getSchema(array('default' => false, 'null' => true)),
			'maxlength' => ElementInteger::getSchema(array('default' => false, 'null' => true)),
			'default' => ElementBoolean::getSchema(array('default' => false, 'null' => true)),
			'null' => ElementBoolean::getSchema(array('default' => true, 'null' => true))
		));
		
	}
	
	public static function getSchema ( $params = array() ) {
		
		$params['type'] = 'file';
		return $params;
		
	}
	
}


class ParentEntityIterator implements Iterator {
	
	private $entity, $current;
	
	public function __construct ( Entity $entity ) {
		
		$this->entity = $entity;
		$this->current = $entity;
		
	}
	
	public function rewind () {
		
		$this->current = $this->entity;
		
	}
	
	public function valid () {
		
		return $this->current ? true : false;
		
	}
	
	public function current () {
		
		return $this->current;
		
	}
	
	public function key () {
		
		return $this->current->getId(1);
		
	}
	
	public function next () {
		
		$this->current = $this->current->getParent();
		
	}
	
}


class ChildrenEntityIterator extends ArrayIterator implements RecursiveIterator {
	
	private $entity;
	
	public function __construct ( Entity $entity ) {
		
		$this->entity = $entity;
		
		$data = array();
		foreach ( $this->entity->getChildrenData() as $type => $entities )
			foreach ( $entities as $name => $entity )
				$data[] = array($type, $name);
		
		parent::__construct($data);
		
	}
	
	public function current () {
		
		$current = parent::current();
		
		return $this->entity->getChild($current[0], $current[1]);
		
	}
	
	public function key () {
		
		return $this->current()->getId(1);
		
	}
	
	public function hasChildren () {
		
		return count($this->current()->getChildrenData()) ? true : false;
		
	}
	
	public function getChildren () {
		
		return new self($this->current());
		
	}
	
}


class ChildrenTypeEntityIterator extends ArrayIterator {
	
	private $entity, $type;
	
	public function __construct ( Entity $entity, $type ) {
		
		$this->entity = $entity;
		$this->type = $type;
		
		parent::__construct(array_keys($this->entity->getChildrenData($this->type)));
		
	}
	
	public function current () {
		
		return $this->entity->getChild($this->type, parent::current());
		
	}
	
	public function key () {
		
		return $this->current()->getId(1);
		
	}
	
}


class ChildrenTypeEntityIteratorAggregate implements IteratorAggregate {
	
	private $entity, $type;
	
	public function __construct ( Entity $entity, $type ) {
		
		$this->entity = $entity;
		$this->type = $type;
		
	}
	
	public function __get ( $name ) {
		
		return $this->entity->getChild($this->type, $name);
		
	}
	
	public function getIterator () {
		
		return new ChildrenTypeEntityIterator($this->entity, $this->type);
		
	}
	
}


class PHPProvider extends Provider implements ArrayAccess, IteratorAggregate {
	
	protected static
		$subType;
	
	protected
		$database = array();
	
	protected function __construct ( $data, $parent = null ) {
		
		$file = $data['root'] . '/' . $data['file'];
		
		if ( file_exists($file) )
			$this->database = include($file);
		
		else phpize(array(), $file);
		
		parent::__construct($data);
		
	}
	
	public function __destruct () {
		
		$file = $this->data['root'] . '/' . $this->data['file'];
		
		phpize($this->database, $file);
		
		parent::__destruct();
		
	}
	
	protected function build () {
		
		return $this;
		
	}
	
	public function offsetExists ( $offset ) {
		
		return array_key_exists($offset, $this->database);
		
	}
	
	public function offsetSet ( $offset, $value ) {
		
		return $this->database[$offset] = $value;
		
	}
	
	public function &offsetGet ( $offset ) {
		
		if ( array_key_exists($offset, $this->database) )
			return $this->database[$offset];
		
		return null;
		
	}
	
	public function offsetUnset ( $offset ) {
		
		unset($this->database[$offset]);
		
	}
	
	public function getIterator () {
		
		return new ArrayIterator($this->database);
		
	}
	
}


class PHPService extends Service implements ArrayAccess, IteratorAggregate {
	
	protected static
		$subType;
	
	protected
		$provider;
	
	protected function __construct ( $data, Model $parent ) {
		
		parent::__construct($data, $parent);
		
		$this->provider = $parent->getParent();
		$this->modelName = $parent->getName();
		
	}
	
	public function offsetExists ( $offset ) {
		
		return array_key_exists($offset, $this->provider[$this->modelName]);
		
	}
	
	public function offsetSet ( $offset, $value ) {
		
		return $this->provider[$this->modelName][$offset] = $value;
		
	}
	
	public function &offsetGet ( $offset ) {
		
		if ( !array_key_exists($offset, $this->provider[$this->modelName]) )
			$this->provider[$this->modelName][$offset] = array();
		
		return $this->provider[$this->modelName][$offset];
		
	}
	
	public function offsetUnset ( $offset ) {
		
		unset($this->provider[$this->modelName][$offset]);
		
	}
	
	public function getIterator () {
		
		return new ArrayIterator($this->provider[$this->modelName]);
		
	}
	
}


class MySQLProvider extends Provider {
	
	protected static
		$subType,
		$buildQueries = array(
			'update' => 'ALTER TABLE  `%1$s` CHANGE  `%2$s`  `%2$s` %3$s %4$s COMMENT \'%5$s\'',
			'tables' => 'SHOW TABLES;',
			'fields' => 'SHOW FULL FIELDS FROM `%1$s`;',
			'indexes' => 'SHOW INDEX FROM `%1$s`;',
			'fkeys' => 'SELECT * FROM `information_schema`.`KEY_COLUMN_USAGE` AS kcu WHERE 
						kcu.`TABLE_SCHEMA` = "%1$s" AND 
						kcu.`TABLE_NAME` = "%2$s" AND 
						kcu.`REFERENCED_COLUMN_NAME` IS NOT NULL;',
		);
	
	protected
		$link = null;
	
	protected function __construct ( $data, $parent = null ) {
		
		$this->open($data);
		
		parent::__construct($data);
		
	}
	
	public function updateFields () {
		
		foreach ( $this->Model as $mid => $m ) if ( !$m->getData('virtual') ) {
			
			$fields = array();
			$sql = $this->query(sprintf('SHOW FIELDS FROM %1$s', $m->getName()));
			foreach ( $sql[0] as $sqlf )
				$fields[$sqlf['Field']] = $sqlf;
			
			foreach ( $fields as $fid => $field ) if ( $fid !== 'id' ) {
				$this->query(sprintf(
					self::$buildQueries['update'],
					$m->getName(),
					$fid,
					$field['Type'],
					$field['Null'] === 'NO' ? 'NOT NULL' : 'NULL',
					$this->link->real_escape_string(json_encode($m->Field->$fid->getData('value')))
				)) . "\n";
			}
		}
	}
	
	protected function build () {
		
		$tablesList = $this->query(self::$buildQueries['tables']);
		if ( !count($tablesList[0]) )
			throw new Exception('DB Error : DB is empty !');
		
		foreach ( $tablesList[0] as $table ) {
			
			$tableName = $table['Tables_in_' . $this->data['dbname']];
			
			// model
			$this->data['children']['Model'][$tableName] = MySQLTable::build(
				$tableName,
				!empty($this->data['children']['Model'][$tableName]) ? $this->data['children']['Model'][$tableName] : array()
			);
			
			// Schema
			$fieldsList = $this->query(sprintf(self::$buildQueries['fields'], $tableName));
			$this->data['children']['Model'][$tableName] = MySQLTable::buildSchema(
				$tableName,
				$this->data['children']['Model'][$tableName], 
				$fieldsList[0]
			);
			
			// Indexes
			$indexesList = $this->query(sprintf(self::$buildQueries['indexes'], $tableName));
			$this->data['children']['Model'][$tableName]['children']['Index'] = MySQLIndex::build(
				$tableName,
				!empty($this->data['children']['Model'][$tableName]['children']['Index']) ?
					$this->data['children']['Model'][$tableName]['children']['Index'] : array(), 
				$indexesList[0]
			);
			
			// Roles
			$rolesList = $this->query(sprintf(self::$buildQueries['fkeys'], $this->data['dbname'], $tableName));
			$this->data['children']['Role'] = MySQLRole::build(
				!empty($this->data['children']['Role']) ? $this->data['children']['Role'] : array(),
				$rolesList[0]
			);
			
		}
		
		return $this;
		
	}
	
	public function open ( $data = null ) {
		
		if ( !$data )
			$data = $this->data;
		
		if ( !$this->link ) {
			
			$link = new Mysqli(
				$data['host'],
				$data['user'],
				$data['password'],
				$data['dbname']
			);
			
			if ( $link->connect_errno )
				throw new Exception(sprintf(
					'Error connecting to database "%1$s".' . "\n" . 'MysqlErrorCode : %2$s : ' . "\n" . '%3$s',
					$data['dbname'],
					$link->connect_errno,
					$link->connect_error
				));
			
			$this->link = $link;
			
			$this->setOptions($data);
			
		}
		
		return $this;
		
	}
	
	public function close () {
		
		if ( $this->link ) {
			
			$this->link->close();
			$this->link = null;
			
		}
		
		return $this;
		
	}
	
	public function setOptions ( $options ) {
		
		if ( !empty($options['charset']) )
			$this->link->set_charset($options['charset']);
		
	}
	
	public function getLink () {
		
		return $this->link;
		
	}
	
	public function escape ( $str ) {
		
		if ( $str === null )
			return 'NULL';
		
		elseif ( $str === false )
			return 'FALSE';
		
		elseif ( $str === true )
			return 'TRUE';
		
		elseif ( $str === 0 )
			return '0';
		
		elseif ( is_int($str) || is_float($str) )
			return $str;
		
		//~ elseif ( !$str )
			//~ return '""';
		
		return '\'' . $this->link->real_escape_string($str) . '\'';
		
	}
	
	public function getEscaper () {
		
		$self = $this;
		
		return function ( $str ) use ( $self ) {
			
			return $self->escape($str);
			
		};
		
	}
	
	public function queryValue ( $sql, $context = null ) {
		
		$a = $this->queryObject($sql);
		
		return !empty($a) ? end($a) : null;
		
	}
	
	public function queryObject ( $sql, $context = null ) {
		
		$a = $this->queryList($sql);
		
		return !empty($a) ? end($a) : null;
		
	}
	
	public function queryList ( $sql, $context = null ) {
		
		$a = $this->query($sql);
		
		return end($a);
		
	}
	
	public function query ( $sql, $context = null ) {
		
		if ( !$this->link->multi_query($sql) )
			throw new Exception(sprintf(
				'Error querying the database "%1$s".' . "\n" . 'MysqlErrorCode : %2$s ' . "\nMySQL Error Message : " . '%3$s' . "\n" . 'SQL : %4$s',
				$this->data['dbname'],
				$this->link->errno,
				$this->link->error,
				$sql
			));
		
		$i = 1;
		$results = array();
		
		do {
			
			$r = $this->link->use_result();
			if ( $r instanceof Mysqli_Result) {
				
				//~ $results[] = $r->fetch_all(MYSQLI_ASSOC);
				$rows = array();
				while ( $row = $r->fetch_assoc() )
					$rows[] = $row;
				
				$results[] = $rows;
				$r->free();
				
			} else $results[] = $r;
			
		} while ( $this->link->more_results() && $this->link->next_result() );
		
		return $results;
		
	}
	
}


class MySQLRole extends Role {
	
	protected static
		$parentType = 'MySQLProvider',
		$subType;
	
	static public function build ( $roles, $sqlRoles ) {
		
		foreach ( $sqlRoles as $sqlFKey )
			$roles[$sqlFKey['CONSTRAINT_NAME']] = array(
				
				'type' => 'MySQLRole',
				'name' => $sqlFKey['CONSTRAINT_NAME'],
				'source' => $sqlFKey['TABLE_NAME'],
				'target' => $sqlFKey['REFERENCED_TABLE_NAME'],
				'links' => array(
					array(
						'source' => $sqlFKey['COLUMN_NAME'],
						'target' => $sqlFKey['REFERENCED_COLUMN_NAME'],
						'op' => '=',
					)
				),
				
			);
		
		return $roles;
		
	}
	
}


class MySQLTable extends Model {
	
	protected static
		$parentType = 'MySQLProvider',
		$subType;
	
	static public function build ( $tableName, $model ) {
		
		return array_merge(
			array(
				'type' => get_called_class(),
				'name' => $tableName,
				'extends' => '_MySQLTable',
				'desc' => array(
					'gender' => null,
					'singular' => $tableName,
					'plural' => $tableName,
				),
				'children' => array(),
			),
			$model
		);
		
	}
	
	static public function buildSchema ( $tableName, $model, $sqlFields ) {
		
		foreach ( $sqlFields as $field ) {
			
			$model['children']['Field'][$field['Field']] = MySQLField::build(
				!empty($model['children']['Field'][$field['Field']]) ? $model['children']['Field'][$field['Field']] : array(),
				$field
			);
			
		}
		
		return $model;
		
	}
	
}


class MySQLField extends Field {
	
	private static $valueTypes = array();
	
	protected static
		$parentType = 'MySQLTable',
		$subType;
	
	public static function build ( $field, $sqlField ) {
		
		$sqlField['Null'] = ( $sqlField['Null'] === 'NO' ) ? false : true;
		
		$value = self::getFieldValue($sqlField);
		
		return array_merge(
			array(
				'type' => static::getSubType(),
				'name' => $sqlField['Field'],
				'desc' => array(
					'gender' => null,
					'singular' => $sqlField['Field'],
					'plural' => '',
				),
				'value' => $value,
				//~ 'sql' => $sqlField,
			),
			$field
		);
		
	}
	
	static public function addValueType( $regex, $closure ) {
		
		return self::$valueTypes[$regex] = $closure;
		
	}
	
	static public function getFieldValue ( $field ) {
		
		if ( preg_match('!^{!', $field['Comment']) )
			return json_decode($field['Comment'], 1);
		
		$m = array();
		
		$fld = array();
		foreach ( self::$valueTypes as $k => $f )
			if ( preg_match($k, $field['Type'], $m) )
				$fld = $f($field, $m);
		
		if ( !$fld ) $fld = array(
			'default' => $field['Default'],
			'null' => $field['Null'],
		);
		
		if ( $field['Comment'] )
			$fld['type'] = $field['Comment'];
		
		return $fld;
		
	}
	
	public function toSql ( $object ) {
		
		$value = array_key_exists($this->getName(), $object) ? $object[$this->getName()] : null;
		
		$value = $this->apply($value, $object);
		
		return $this->getParent()->getParent()->escape($value);
		
	}
	
}


MySQLField::addValueType('!(BIT|BOOLEAN)!i', $bool = function ($f, $m) {
	
	return ElementBoolean::getSchema(array(
		'default' => $f['Default'],
		'null' => $f['Null']
	));
	
});

MySQLField::addValueType('!date!i', function ($f, $m) {
	
	return ElementDate::getSchema(array(
		'format' => 'Y-m-d',
		'default' => null,
	));
	
});

MySQLField::addValueType('!^(.*)INT((?:\(\d+\))?)((?: UNSIGNED)?)!i', function ($f, $m) use( $bool ) {
	
	if ( $m[1] === 'tiny' )
		return $bool($f, $m);
	
	return ElementInteger::getSchema(array(
		'min' => $m[3] ? 0 : ElementInteger::_MIN,
		'max' => ElementInteger::_MAX,
		'default' => $f['Default'],
		'null' => $f['Null']
	));
	
});

MySQLField::addValueType('!^(.*)(CHAR)\((.*)\)$!i', function ($f, $m) {
	
	return ElementString::getSchema(array(
		'minlength' => $m[1] ? 0 : $m[3],
		'maxlength' => $m[3],
		'default' => $f['Default'],
		'null' => $f['Null']
	));
	
});

MySQLField::addValueType('!(.*)TEXT!i', function ($f, $m) {
	
	return ElementString::getSchema(array(
		'minlength' => 0,
		'maxlength' => 0,
		'default' => $f['Default'],
		'null' => $f['Null']
	));
	
});

MySQLField::addValueType('!(.*)BLOB!i', function ($f, $m) {
	
	return ElementString::getSchema(array(
		'minlength' => 0,
		'maxlength' => 0,
		'default' => $f['Default'],
		'null' => $f['Null']
	));
	
});

MySQLField::addValueType('!(ENUM)\((.*)\)!i', function ($f, $m) {
	
	return ElementEnum::getSchema(array(
		'values' => array_map(function ($arg) { return preg_replace('!\'\'!', '\'', preg_replace('!^\'|\'$!', '', $arg));}, explode(',', $m[2])),
		'desc' => array_map(function ($arg) { return preg_replace('!\'\'!', '\'', preg_replace('!^\'|\'$!', '', $arg));}, explode(',', $m[2])),
		'default' => $f['Default'],
		'null' => false
	));
	
});

MySQLField::addValueType('!(SET)\((.*)\)!i', function ($f, $m) {
	
	return ElementEnum::getSchema(array(
		'values' => array_map(function ($arg) { return preg_replace('!\'\'!', '\'', preg_replace('!^\'|\'$!', '', $arg));}, explode(',', $m[2])),
		'desc' => array_map(function ($arg) { return preg_replace('!\'\'!', '\'', preg_replace('!^\'|\'$!', '', $arg));}, explode(',', $m[2])),
		'default' => explode(',', preg_replace('!\'!', '', $f['Default'])),
		'null' => true
	));
	
});

/*

/*
MySQLField::addValueType('!(DECIMAL|FLOAT|REAL|DOUBLE)!i', function ($f, $m) {
	
	return array(
		'Element' => 'float',
		'default' => $f['Default'],
	);
	
});

MySQLField::addValueType('!(ENUM|SET)\((.*)\)!i', function ($f, $m) {
	
	return array(
		'Element' => $t = strtolower($m[1]),
		'values' => array_map(function ($arg) { return preg_replace('!\'\'!', '\'', preg_replace('!^\'|\'$!', '', $arg));}, explode(',', $m[2])),
		'default' => ( $t == 'set' ) ? explode(',', preg_replace('!\'!', '', $f['Default'])) : $f['Default'],
	);
	
});
MySQLField::addValueType('!(.*BINARY\((.*)\)|(.*)BLOB)!i', function ($f, $m) {
	
	return array(
		'Element' => empty($m[2]) ? 'blob' : '',
		'size' => (int) $m[2],
		'default' => $f['Default'],
	);
	
});

MySQLField::addValueType('!datetime!i', function ($f, $m) {
	
	return array(
		'Element' => 'datetime',
		
		'format' => 'Y-m-d',
		'formatjs' => 'yy-mm-dd',
		
		'timeformat' => 'H:i:s',
		'timeformatjs' => 'hh:mm:ss',
		
		'timezone' => date_default_timezone_get(),
		'default' => null,
	);
	
});
*/


class MySQLIndex extends Index {
	
	protected static
		$parentType = 'MySQLTable',
		$subType;
	
	
	static public function build ( $tableName, $indexes, $sqlIndexes ) {
		
		foreach ( $sqlIndexes as $sqlIndex ) {
			
			if ( empty($indexes[$sqlIndex['Key_name']]) )
				$indexes[$sqlIndex['Key_name']] = array(
					'type' => 'MySQLIndex',
					'model' => $tableName,
					'name' => $sqlIndex['Key_name'],
					'unique' => !$sqlIndex['Non_unique'],
					'fields' => array(
						$sqlIndex['Seq_in_index'] => $sqlIndex['Column_name'],
						$sqlIndex['Column_name'] => array(
							'position' => $sqlIndex['Seq_in_index'],
							'op' => empty($indexes) || 
								empty($indexes[$sqlIndex['Key_name']]['fields'][$sqlIndex['Column_name']]) ? '=' : 
								$indexes[$sqlIndex['Key_name']]['fields'][$sqlIndex['Column_name']]['op'],
						),
					),
				);
			
			else {
				
				$indexes[$sqlIndex['Key_name']]['fields'][$sqlIndex['Seq_in_index']] = 
					$sqlIndex['Column_name'];
				$indexes[$sqlIndex['Key_name']]['fields'][$sqlIndex['Column_name']] = array(
					'name' => $sqlIndex['Column_name'],
					'position' => $sqlIndex['Seq_in_index'],
					'op' => empty($indexes[$sqlIndex['Key_name']]) || 
						empty($indexes[$sqlIndex['Key_name']]['fields'][$sqlIndex['Column_name']]) ? '=' : 
						$indexes[$sqlIndex['Key_name']]['fields'][$sqlIndex['Column_name']]['op'],
				);
				
			}
			
		}
		
		return $indexes;
		
	}
	
}


class ArrayService extends Service implements ArrayAccess, Countable, IteratorAggregate {
	
	private $key;
	
	public function __construct ( $data, Model $model, $filter = null ) {
		
		parent::__construct($data, $model);
		
		$this->provider = $this->getParent()->getParent();
		
		$key = $this->getParent()->Index->PRIMARY;
		
		$error = '';
		if ( !$key )
			$error = 'Index:%1$s.PRIMARY does not exists !';
		
		elseif ( count($key->getFieldsData()) !== 2 )
			$error = 'Index:%1$s.PRIMARY must have exactly 1 field !';
		
		elseif ( !$key->getData('unique') )
			$error = 'Index:%1$s.PRIMARY must be unique !';
		
		if ( $error )
			throw new Exception(sprintf($error, $model->getName(1)));
		
		if ( $this->getParent()->getName() === 'users' )
			$this->key = $model->Field->login;
		
		else $this->key = $key->getPositionField(1);
		
	}
	
	public function add ( $value ) {
		
		return $this->offsetSet(null, $value);
		
	}
	
	public function offsetSet ( $offset, $value ) {
		
		$fields = array();
		$values = array();
		$update = array();
		
		$value[$this->key->getName()] = $offset;
		
		foreach ( $this->getParent()->Field as $field ) {
			
			$name = $field->getName();
			
			if ( array_key_exists($name, $value) && ($sql = $field->toSql($value)) ) {
				
				$fields[] = $name;
				$values[] = $sql;
				
				if ( $name !== $this->key->getNAme() )
					$update[] = sprintf(
						'`%1$s` = %2$s',
						$name,
						$sql
					);
				
			}
			
		}
		
		return $this->getParent()->getParent()->queryObject($sql = sprintf(
			'INSERT INTO `%1$s` ( `%2$s` ) VALUES ( %3$s ) ON DUPLICATE KEY UPDATE %4$s;' .
			'SELECT * FROM `%1$s` WHERE %5$s = LAST_INSERT_ID() LIMIT 1;',
			$this->getParent()->getName(),
			implode('`, `', $fields),
			implode(', ', $values),
			implode(', ', $update),
			$this->key->getName()
		));
		
	}
	
	public function offsetGet ( $offset ) {
		
		return $this->getParent()->getParent()->queryObject(sprintf(
			'SELECT * FROM `%1$s` WHERE `%2$s` = %3$s LIMIT 1;',
			$this->getParent()->getName(),
			$this->key->getName(),
			$this->provider->escape($offset)
		));
		
	}
	
	public function offsetUnset ( $offset ) {
		
		return $this->getParent()->getParent()->queryObject(sprintf(
			'DELETE FROM `%1$s` WHERE `%2$s` = %3$s LIMIT 1;',
			$this->getParent()->getName(),
			$this->key->getName(),
			$this->provider->escape($offset)
		));
		
	}
	
	public function offsetExists ( $offset ) {
		
		return $this->offsetGet($offset) ? true : false;
		
	}
	
	public function count () {
		
		return $this->getParent()->getParent()->queryValue(sprintf(
			'SELECT COUNT(*) FROM `%1$s`;',
			$this->getParent()->getName()
		));
		
	}
	
	public function max () {
		
		return $this->getParent()->getParent()->queryValue(sprintf(
			'SELECT MAX(%2$s) FROM `%1$s`;',
			$this->getParent()->getName(),
			$this->key->getName()
		));
		
	}
	
	public function min () {
		
		return $this->getParent()->getParent()->queryValue(sprintf(
			'SELECT MIN(%2$s) FROM `%1$s`;',
			$this->getParent()->getName(),
			$this->key->getName()
		));
		
	}
	
	public function sum () {
		
		return $this->getParent()->getParent()->queryValue(sprintf(
			'SELECT SUM(%2$s) FROM `%1$s`;',
			$this->getParent()->getName(),
			$this->key->getName()
		));
		
	}
	
	public function avg () {
		
		return $this->getParent()->getParent()->queryValue(sprintf(
			'SELECT AVG(%2$s) FROM `%1$s`;',
			$this->getParent()->getName(),
			$this->key->getName()
		));
		
	}
	
	public function getIterator () {
		
		return new ArrayIterator($this->getParent()->getParent()->queryList(sprintf(
			'SELECT * FROM `%1$s`;',
			$this->getParent()->getName(),
			$this->key->getName()
		)));
		
	}
	
}


class MySQLServiceCrud extends Service {
	
	private $key;
	
	public function __construct ( $data, Model $model, $filter = null ) {
		
		parent::__construct($data, $model);
		
		$this->provider = $this->getParent()->getParent();
		$key = $this->getParent()->Index->PRIMARY;
		
		$error = '';
		if ( !$key )
			$error = 'Index:%1$s.PRIMARY does not exists !';
		
		elseif ( count($key->getFieldsData()) !== 2 )
			$error = 'Index:%1$s.PRIMARY must have exactly 1 field !';
		
		elseif ( !$key->getData('unique') )
			$error = 'Index:%1$s.PRIMARY must be unique !';
		
		if ( $error )
			throw new Exception(sprintf($error, $model->getName(1)));
		
		$this->key = $key->getPositionField(1);
		
	}
	
	public function getKey () {
		
		return $this->key;
		
	}
	
	public function set ( $object = array() ) {
		
		if ( !empty($object[$this->key->getName()]) )
			return $this->update($object);
		
		return $this->create($object);
		
	}
	
	public function create ( $object = array() ) {
		
		//~ print_r($object);
		$fields = array();
		$values = array();
		
		unset($object[$this->key->getName()]);
		
		foreach ( $this->getParent()->Field as $field ) {
			
			$name = $field->getName();
			
			if ( array_key_exists($name, $object) && ($sql = $field->toSql($object)) ) {
				
				$fields[] = $name;
				$values[] = $sql;
				
			}
			
		}
		
		return $this->getParent()->getParent()->queryObject(($sql = sprintf(
			'INSERT INTO `%1$s` ( `%2$s` ) VALUES ( %3$s );' .
			'SELECT * FROM `%1$s` WHERE %4$s = LAST_INSERT_ID() LIMIT 1;',
			$this->getParent()->getName(),
			implode('`, `', $fields),
			implode(', ', $values),
			$this->key->getName()
		)));
		
	}
	
	public function update ( $object = array() ) {
		
		$update = array();
		
		foreach ( $this->getParent()->Field as $field ) {
			
			$name = $field->getName();
			
			if ( array_key_exists($name, $object) && ($sql = $field->toSql($object)) ) {
				
				if ( $name !== $this->key->getName() )
					$update[] = sprintf(
						'`%1$s` = %2$s',
						$name,
						$sql
					);
				
			}
			
		}
		
		return $this->getParent()->getParent()->queryObject(($sql = sprintf(
			'UPDATE `%1$s` SET %2$s WHERE %3$s = %4$s;' .
			'SELECT * FROM `%1$s` WHERE %3$s = %4$s LIMIT 1;',
			$this->getParent()->getName(),
			implode(', ', $update),
			$this->key->getName(),
			$this->key->toSql($object)
		)));
		
	}
	
	public function delete ( $object = array() ) {
		
		$this->getParent()->getParent()->queryObject(($sql = sprintf(
			'DELETE FROM `%1$s` WHERE %2$s = %3$s; LIMIT 1',
			$this->getParent()->getName(),
			$this->key->getName(),
			$this->key->toSql($object)
		)));
		
		return null;
		
	}
	
	public function read ( $object = array(), $order = array('position' => 0, 'date' => 1), $limit = array() ) {
		
		$fields = $this->getParent()->Field;
		
		$where = array();
		foreach ( $object as $ff => $v ) {
			
			$not = $ff[0] === '!';
			$f = $not ? substr($ff, 1) : $ff;
			if ( $fields->$f )
				$where[$f] = sprintf(
					'`%1$s` %3$s %2$s',
					$f,
					$fields->$f->toSql(array_merge($object, array($f => $object[$ff]))),
					$not ? '!=' : '='
				);
		}
		
		$o = array();
		foreach ( $order as $f => $v )
			if ( $fields->$f )
				$o[$f] = sprintf(
					'`%1$s` %2$s',
					$f,
					$v ? 'DESC' : 'ASC'
				);
		
		return $this->getParent()->getParent()->queryList((sprintf(
			'SELECT * FROM %1$s WHERE ( %2$s ) ORDER BY %3$s LIMIT %4$s, %5$s;',
			$this->getParent()->getName(),
			$where ? implode(' AND ', $where) : 1,
			$o ? implode(', ', $o) : $this->key->getName() . ' ASC',
			!empty($limit['offset']) ? $limit['offset'] : 0,
			!empty($limit['length']) ? $limit['length'] : 10000
		)));
		
	}
	
	public function readObject ( $object = array(), $order = array('position' => 0, 'date' => 1), $limit = array() ) {
		
		
		$a = $this->read($object, $order, $limit);
		return $a ? $a[0] : $a;
		
	}
}


class MySQLOrderService extends Service {
	
	private $sql = array(
		'sorted' => 'SELECT ( COUNT(DISTINCT {index}) = COUNT(*) ) AND ( MIN({index}) = 0 ) FROM {table} WHERE {clause}',
		'update' => 'UPDATE {table} SET {index} = {position} WHERE {clauseId}',
		'list' => 'SELECT {id} FROM {table} WHERE {clause} ORDER BY {index}',
	);
	
	public function __construct ( $data, Model $model, $filter = null ) {
		
		if ( empty($data['fields']) )
			throw new Exception('No Fields specified for ORDER Service !');
		
		parent::__construct($data, $model);
		
		print_r($data);
		print_r($this->sql);
		
		$self = $this;
		$d = array(
			'table' => $self->getParent()->getName(),
			'index' => $data['fields'][count($data['fields']) - 1],
			'clause' => '',
		);
		
		$this->sql = array_map(function ( $e ) use ( $self, $data ) {
			
			return sprinto($e, $data);
			
		}, $this->sql);
		
	}
	
	public function move ( $source, $target ) {
		
		$this->resort($source);
		
		$source = $this->getParent()->Service->crud->readObject($source);
		$target = $this->getParent()->Service->crud->readObject($target);
		
		
	}
	
}

/**
 * Copyright 2011 Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

/**
 * Thrown when an API call returns an exception.
 *
 * @author Naitik Shah <naitik@facebook.com>
 */
class FacebookApiException extends Exception
{
  /**
   * The result from the API server that represents the exception information.
   */
  protected $result;

  /**
   * Make a new API Exception with the given result.
   *
   * @param array $result The result from the API server
   */
  public function __construct($result) {
    $this->result = $result;

    $code = isset($result['error_code']) ? $result['error_code'] : 0;

    if (isset($result['error_description'])) {
      // OAuth 2.0 Draft 10 style
      $msg = $result['error_description'];
    } else if (isset($result['error']) && is_array($result['error'])) {
      // OAuth 2.0 Draft 00 style
      $msg = $result['error']['message'];
    } else if (isset($result['error_msg'])) {
      // Rest server style
      $msg = $result['error_msg'];
    } else {
      $msg = 'Unknown Error. Check getResult()';
    }

    parent::__construct($msg, $code);
  }

  /**
   * Return the associated result object returned by the API server.
   *
   * @return array The result from the API server
   */
  public function getResult() {
    return $this->result;
  }

  /**
   * Returns the associated type for the error. This will default to
   * 'Exception' when a type is not available.
   *
   * @return string
   */
  public function getType() {
    if (isset($this->result['error'])) {
      $error = $this->result['error'];
      if (is_string($error)) {
        // OAuth 2.0 Draft 10 style
        return $error;
      } else if (is_array($error)) {
        // OAuth 2.0 Draft 00 style
        if (isset($error['type'])) {
          return $error['type'];
        }
      }
    }

    return 'Exception';
  }

  /**
   * To make debugging easier.
   *
   * @return string The string representation of the error
   */
  public function __toString() {
    $str = $this->getType() . ': ';
    if ($this->code != 0) {
      $str .= $this->code . ': ';
    }
    return $str . $this->message;
  }
}

/**
 * Provides access to the Facebook Platform.  This class provides
 * a majority of the functionality needed, but the class is abstract
 * because it is designed to be sub-classed.  The subclass must
 * implement the four abstract methods listed at the bottom of
 * the file.
 *
 * @author Naitik Shah <naitik@facebook.com>
 */
abstract class BaseFacebook
{
  /**
   * Version.
   */
  const VERSION = '3.1.1';

  /**
   * Default options for curl.
   */
  public static $CURL_OPTS = array(
    CURLOPT_CONNECTTIMEOUT => 10,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT        => 60,
    CURLOPT_USERAGENT      => 'facebook-php-3.1',
  );

  /**
   * List of query parameters that get automatically dropped when rebuilding
   * the current URL.
   */
  protected static $DROP_QUERY_PARAMS = array(
    'code',
    'state',
    'signed_request',
  );

  /**
   * Maps aliases to Facebook domains.
   */
  public static $DOMAIN_MAP = array(
    'api'       => 'https://api.facebook.com/',
    'api_video' => 'https://api-video.facebook.com/',
    'api_read'  => 'https://api-read.facebook.com/',
    'graph'     => 'https://graph.facebook.com/',
    'graph_video' => 'https://graph-video.facebook.com/',
    'www'       => 'https://www.facebook.com/',
  );

  /**
   * The Application ID.
   *
   * @var string
   */
  protected $appId;

  /**
   * The Application App Secret.
   *
   * @var string
   */
  protected $appSecret;

  /**
   * The ID of the Facebook user, or 0 if the user is logged out.
   *
   * @var integer
   */
  protected $user;

  /**
   * The data from the signed_request token.
   */
  protected $signedRequest;

  /**
   * A CSRF state variable to assist in the defense against CSRF attacks.
   */
  protected $state;

  /**
   * The OAuth access token received in exchange for a valid authorization
   * code.  null means the access token has yet to be determined.
   *
   * @var string
   */
  protected $accessToken = null;

  /**
   * Indicates if the CURL based @ syntax for file uploads is enabled.
   *
   * @var boolean
   */
  protected $fileUploadSupport = false;

  /**
   * Initialize a Facebook Application.
   *
   * The configuration:
   * - appId: the application ID
   * - secret: the application secret
   * - fileUpload: (optional) boolean indicating if file uploads are enabled
   *
   * @param array $config The application configuration
   */
  public function __construct($config) {
    $this->setAppId($config['appId']);
    $this->setAppSecret($config['secret']);
    if (isset($config['fileUpload'])) {
      $this->setFileUploadSupport($config['fileUpload']);
    }

    $state = $this->getPersistentData('state');
    if (!empty($state)) {
      $this->state = $this->getPersistentData('state');
    }
  }

  /**
   * Set the Application ID.
   *
   * @param string $appId The Application ID
   * @return BaseFacebook
   */
  public function setAppId($appId) {
    $this->appId = $appId;
    return $this;
  }

  /**
   * Get the Application ID.
   *
   * @return string the Application ID
   */
  public function getAppId() {
    return $this->appId;
  }

  /**
   * Set the App Secret.
   *
   * @param string $apiSecret The App Secret
   * @return BaseFacebook
   * @deprecated
   */
  public function setApiSecret($apiSecret) {
    $this->setAppSecret($apiSecret);
    return $this;
  }

  /**
   * Set the App Secret.
   *
   * @param string $appSecret The App Secret
   * @return BaseFacebook
   */
  public function setAppSecret($appSecret) {
    $this->appSecret = $appSecret;
    return $this;
  }

  /**
   * Get the App Secret.
   *
   * @return string the App Secret
   * @deprecated
   */
  public function getApiSecret() {
    return $this->getAppSecret();
  }

  /**
   * Get the App Secret.
   *
   * @return string the App Secret
   */
  public function getAppSecret() {
    return $this->appSecret;
  }

  /**
   * Set the file upload support status.
   *
   * @param boolean $fileUploadSupport The file upload support status.
   * @return BaseFacebook
   */
  public function setFileUploadSupport($fileUploadSupport) {
    $this->fileUploadSupport = $fileUploadSupport;
    return $this;
  }

  /**
   * Get the file upload support status.
   *
   * @return boolean true if and only if the server supports file upload.
   */
  public function getFileUploadSupport() {
    return $this->fileUploadSupport;
  }

  /**
   * DEPRECATED! Please use getFileUploadSupport instead.
   *
   * Get the file upload support status.
   *
   * @return boolean true if and only if the server supports file upload.
   */
  public function useFileUploadSupport() {
    return $this->getFileUploadSupport();
  }

  /**
   * Sets the access token for api calls.  Use this if you get
   * your access token by other means and just want the SDK
   * to use it.
   *
   * @param string $access_token an access token.
   * @return BaseFacebook
   */
  public function setAccessToken($access_token) {
    $this->accessToken = $access_token;
    return $this;
  }

  /**
   * Determines the access token that should be used for API calls.
   * The first time this is called, $this->accessToken is set equal
   * to either a valid user access token, or it's set to the application
   * access token if a valid user access token wasn't available.  Subsequent
   * calls return whatever the first call returned.
   *
   * @return string The access token
   */
  public function getAccessToken() {
    if ($this->accessToken !== null) {
      // we've done this already and cached it.  Just return.
      return $this->accessToken;
    }

    // first establish access token to be the application
    // access token, in case we navigate to the /oauth/access_token
    // endpoint, where SOME access token is required.
    $this->setAccessToken($this->getApplicationAccessToken());
    $user_access_token = $this->getUserAccessToken();
    if ($user_access_token) {
      $this->setAccessToken($user_access_token);
    }

    return $this->accessToken;
  }

  /**
   * Determines and returns the user access token, first using
   * the signed request if present, and then falling back on
   * the authorization code if present.  The intent is to
   * return a valid user access token, or false if one is determined
   * to not be available.
   *
   * @return string A valid user access token, or false if one
   *                could not be determined.
   */
  protected function getUserAccessToken() {
    // first, consider a signed request if it's supplied.
    // if there is a signed request, then it alone determines
    // the access token.
    $signed_request = $this->getSignedRequest();
    if ($signed_request) {
      // apps.facebook.com hands the access_token in the signed_request
      if (array_key_exists('oauth_token', $signed_request)) {
        $access_token = $signed_request['oauth_token'];
        $this->setPersistentData('access_token', $access_token);
        return $access_token;
      }

      // the JS SDK puts a code in with the redirect_uri of ''
      if (array_key_exists('code', $signed_request)) {
        $code = $signed_request['code'];
        $access_token = $this->getAccessTokenFromCode($code, '');
        if ($access_token) {
          $this->setPersistentData('code', $code);
          $this->setPersistentData('access_token', $access_token);
          return $access_token;
        }
      }

      // signed request states there's no access token, so anything
      // stored should be cleared.
      $this->clearAllPersistentData();
      return false; // respect the signed request's data, even
                    // if there's an authorization code or something else
    }

    $code = $this->getCode();
    if ($code && $code != $this->getPersistentData('code')) {
      $access_token = $this->getAccessTokenFromCode($code);
      if ($access_token) {
        $this->setPersistentData('code', $code);
        $this->setPersistentData('access_token', $access_token);
        return $access_token;
      }

      // code was bogus, so everything based on it should be invalidated.
      $this->clearAllPersistentData();
      return false;
    }

    // as a fallback, just return whatever is in the persistent
    // store, knowing nothing explicit (signed request, authorization
    // code, etc.) was present to shadow it (or we saw a code in $_REQUEST,
    // but it's the same as what's in the persistent store)
    return $this->getPersistentData('access_token');
  }

  /**
   * Retrieve the signed request, either from a request parameter or,
   * if not present, from a cookie.
   *
   * @return string the signed request, if available, or null otherwise.
   */
  public function getSignedRequest() {
    if (!$this->signedRequest) {
      if (isset($_REQUEST['signed_request'])) {
        $this->signedRequest = $this->parseSignedRequest(
          $_REQUEST['signed_request']);
      } else if (isset($_COOKIE[$this->getSignedRequestCookieName()])) {
        $this->signedRequest = $this->parseSignedRequest(
          $_COOKIE[$this->getSignedRequestCookieName()]);
      }
    }
    return $this->signedRequest;
  }

  /**
   * Get the UID of the connected user, or 0
   * if the Facebook user is not connected.
   *
   * @return string the UID if available.
   */
  public function getUser() {
    if ($this->user !== null) {
      // we've already determined this and cached the value.
      return $this->user;
    }

    return $this->user = $this->getUserFromAvailableData();
  }

  /**
   * Determines the connected user by first examining any signed
   * requests, then considering an authorization code, and then
   * falling back to any persistent store storing the user.
   *
   * @return integer The id of the connected Facebook user,
   *                 or 0 if no such user exists.
   */
  protected function getUserFromAvailableData() {
    // if a signed request is supplied, then it solely determines
    // who the user is.
    $signed_request = $this->getSignedRequest();
    if ($signed_request) {
      if (array_key_exists('user_id', $signed_request)) {
        $user = $signed_request['user_id'];
        $this->setPersistentData('user_id', $signed_request['user_id']);
        return $user;
      }

      // if the signed request didn't present a user id, then invalidate
      // all entries in any persistent store.
      $this->clearAllPersistentData();
      return 0;
    }

    $user = $this->getPersistentData('user_id', $default = 0);
    $persisted_access_token = $this->getPersistentData('access_token');

    // use access_token to fetch user id if we have a user access_token, or if
    // the cached access token has changed.
    $access_token = $this->getAccessToken();
    if ($access_token &&
        $access_token != $this->getApplicationAccessToken() &&
        !($user && $persisted_access_token == $access_token)) {
      $user = $this->getUserFromAccessToken();
      if ($user) {
        $this->setPersistentData('user_id', $user);
      } else {
        $this->clearAllPersistentData();
      }
    }

    return $user;
  }

  /**
   * Get a Login URL for use with redirects. By default, full page redirect is
   * assumed. If you are using the generated URL with a window.open() call in
   * JavaScript, you can pass in display=popup as part of the $params.
   *
   * The parameters:
   * - redirect_uri: the url to go to after a successful login
   * - scope: comma separated list of requested extended perms
   *
   * @param array $params Provide custom parameters
   * @return string The URL for the login flow
   */
  public function getLoginUrl($params=array()) {
    $this->establishCSRFTokenState();
    $currentUrl = $this->getCurrentUrl();

    // if 'scope' is passed as an array, convert to comma separated list
    $scopeParams = isset($params['scope']) ? $params['scope'] : null;
    if ($scopeParams && is_array($scopeParams)) {
      $params['scope'] = implode(',', $scopeParams);
    }

    return $this->getUrl(
      'www',
      'dialog/oauth',
      array_merge(array(
                    'client_id' => $this->getAppId(),
                    'redirect_uri' => $currentUrl, // possibly overwritten
                    'state' => $this->state),
                  $params));
  }

  /**
   * Get a Logout URL suitable for use with redirects.
   *
   * The parameters:
   * - next: the url to go to after a successful logout
   *
   * @param array $params Provide custom parameters
   * @return string The URL for the logout flow
   */
  public function getLogoutUrl($params=array()) {
    return $this->getUrl(
      'www',
      'logout.php',
      array_merge(array(
        'next' => $this->getCurrentUrl(),
        'access_token' => $this->getAccessToken(),
      ), $params)
    );
  }

  /**
   * Get a login status URL to fetch the status from Facebook.
   *
   * The parameters:
   * - ok_session: the URL to go to if a session is found
   * - no_session: the URL to go to if the user is not connected
   * - no_user: the URL to go to if the user is not signed into facebook
   *
   * @param array $params Provide custom parameters
   * @return string The URL for the logout flow
   */
  public function getLoginStatusUrl($params=array()) {
    return $this->getUrl(
      'www',
      'extern/login_status.php',
      array_merge(array(
        'api_key' => $this->getAppId(),
        'no_session' => $this->getCurrentUrl(),
        'no_user' => $this->getCurrentUrl(),
        'ok_session' => $this->getCurrentUrl(),
        'session_version' => 3,
      ), $params)
    );
  }

  /**
   * Make an API call.
   *
   * @return mixed The decoded response
   */
  public function api(/* polymorphic */) {
    $args = func_get_args();
    if (is_array($args[0])) {
      return $this->_restserver($args[0]);
    } else {
      return call_user_func_array(array($this, '_graph'), $args);
    }
  }

  /**
   * Constructs and returns the name of the cookie that
   * potentially houses the signed request for the app user.
   * The cookie is not set by the BaseFacebook class, but
   * it may be set by the JavaScript SDK.
   *
   * @return string the name of the cookie that would house
   *         the signed request value.
   */
  protected function getSignedRequestCookieName() {
    return 'fbsr_'.$this->getAppId();
  }

  /**
   * Constructs and returns the name of the coookie that potentially contain
   * metadata. The cookie is not set by the BaseFacebook class, but it may be
   * set by the JavaScript SDK.
   *
   * @return string the name of the cookie that would house metadata.
   */
  protected function getMetadataCookieName() {
    return 'fbm_'.$this->getAppId();
  }

  /**
   * Get the authorization code from the query parameters, if it exists,
   * and otherwise return false to signal no authorization code was
   * discoverable.
   *
   * @return mixed The authorization code, or false if the authorization
   *               code could not be determined.
   */
  protected function getCode() {
    if (isset($_REQUEST['code'])) {
      if ($this->state !== null &&
          isset($_REQUEST['state']) &&
          $this->state === $_REQUEST['state']) {

        // CSRF state has done its job, so clear it
        $this->state = null;
        $this->clearPersistentData('state');
        return $_REQUEST['code'];
      } else {
        self::errorLog('CSRF state token does not match one provided.');
        return false;
      }
    }

    return false;
  }

  /**
   * Retrieves the UID with the understanding that
   * $this->accessToken has already been set and is
   * seemingly legitimate.  It relies on Facebook's Graph API
   * to retrieve user information and then extract
   * the user ID.
   *
   * @return integer Returns the UID of the Facebook user, or 0
   *                 if the Facebook user could not be determined.
   */
  protected function getUserFromAccessToken() {
    try {
      $user_info = $this->api('/me');
      return $user_info['id'];
    } catch (FacebookApiException $e) {
      return 0;
    }
  }

  /**
   * Returns the access token that should be used for logged out
   * users when no authorization code is available.
   *
   * @return string The application access token, useful for gathering
   *                public information about users and applications.
   */
  protected function getApplicationAccessToken() {
    return $this->appId.'|'.$this->appSecret;
  }

  /**
   * Lays down a CSRF state token for this process.
   *
   * @return void
   */
  protected function establishCSRFTokenState() {
    if ($this->state === null) {
      $this->state = md5(uniqid(mt_rand(), true));
      $this->setPersistentData('state', $this->state);
    }
  }

  /**
   * Retrieves an access token for the given authorization code
   * (previously generated from www.facebook.com on behalf of
   * a specific user).  The authorization code is sent to graph.facebook.com
   * and a legitimate access token is generated provided the access token
   * and the user for which it was generated all match, and the user is
   * either logged in to Facebook or has granted an offline access permission.
   *
   * @param string $code An authorization code.
   * @return mixed An access token exchanged for the authorization code, or
   *               false if an access token could not be generated.
   */
  protected function getAccessTokenFromCode($code, $redirect_uri = null) {
    if (empty($code)) {
      return false;
    }

    if ($redirect_uri === null) {
      $redirect_uri = $this->getCurrentUrl();
    }

    try {
      // need to circumvent json_decode by calling _oauthRequest
      // directly, since response isn't JSON format.
      $access_token_response =
        $this->_oauthRequest(
          $this->getUrl('graph', '/oauth/access_token'),
          $params = array('client_id' => $this->getAppId(),
                          'client_secret' => $this->getAppSecret(),
                          'redirect_uri' => $redirect_uri,
                          'code' => $code));
    } catch (FacebookApiException $e) {
      // most likely that user very recently revoked authorization.
      // In any event, we don't have an access token, so say so.
      return false;
    }

    if (empty($access_token_response)) {
      return false;
    }

    $response_params = array();
    parse_str($access_token_response, $response_params);
    if (!isset($response_params['access_token'])) {
      return false;
    }

    return $response_params['access_token'];
  }

  /**
   * Invoke the old restserver.php endpoint.
   *
   * @param array $params Method call object
   *
   * @return mixed The decoded response object
   * @throws FacebookApiException
   */
  protected function _restserver($params) {
    // generic application level parameters
    $params['api_key'] = $this->getAppId();
    $params['format'] = 'json-strings';

    $result = json_decode($this->_oauthRequest(
      $this->getApiUrl($params['method']),
      $params
    ), true);

    // results are returned, errors are thrown
    if (is_array($result) && isset($result['error_code'])) {
      $this->throwAPIException($result);
    }

    if ($params['method'] === 'auth.expireSession' ||
        $params['method'] === 'auth.revokeAuthorization') {
      $this->destroySession();
    }

    return $result;
  }

  /**
   * Return true if this is video post.
   *
   * @param string $path The path
   * @param string $method The http method (default 'GET')
   *
   * @return boolean true if this is video post
   */
  protected function isVideoPost($path, $method = 'GET') {
    if ($method == 'POST' && preg_match("/^(\/)(.+)(\/)(videos)$/", $path)) {
      return true;
    }
    return false;
  }

  /**
   * Invoke the Graph API.
   *
   * @param string $path The path (required)
   * @param string $method The http method (default 'GET')
   * @param array $params The query/post data
   *
   * @return mixed The decoded response object
   * @throws FacebookApiException
   */
  protected function _graph($path, $method = 'GET', $params = array()) {
    if (is_array($method) && empty($params)) {
      $params = $method;
      $method = 'GET';
    }
    $params['method'] = $method; // method override as we always do a POST

    if ($this->isVideoPost($path, $method)) {
      $domainKey = 'graph_video';
    } else {
      $domainKey = 'graph';
    }

    $result = json_decode($this->_oauthRequest(
      $this->getUrl($domainKey, $path),
      $params
    ), true);

    // results are returned, errors are thrown
    if (is_array($result) && isset($result['error'])) {
      $this->throwAPIException($result);
    }

    return $result;
  }

  /**
   * Make a OAuth Request.
   *
   * @param string $url The path (required)
   * @param array $params The query/post data
   *
   * @return string The decoded response object
   * @throws FacebookApiException
   */
  protected function _oauthRequest($url, $params) {
    if (!isset($params['access_token'])) {
      $params['access_token'] = $this->getAccessToken();
    }

    // json_encode all params values that are not strings
    foreach ($params as $key => $value) {
      if (!is_string($value)) {
        $params[$key] = json_encode($value);
      }
    }

    return $this->makeRequest($url, $params);
  }

  /**
   * Makes an HTTP request. This method can be overridden by subclasses if
   * developers want to do fancier things or use something other than curl to
   * make the request.
   *
   * @param string $url The URL to make the request to
   * @param array $params The parameters to use for the POST body
   * @param CurlHandler $ch Initialized curl handle
   *
   * @return string The response text
   */
  protected function makeRequest($url, $params, $ch=null) {
    if (!$ch) {
      $ch = curl_init();
    }

    $opts = self::$CURL_OPTS;
    if ($this->getFileUploadSupport()) {
      $opts[CURLOPT_POSTFIELDS] = $params;
    } else {
      $opts[CURLOPT_POSTFIELDS] = http_build_query($params, null, '&');
    }
    $opts[CURLOPT_URL] = $url;

    // disable the 'Expect: 100-continue' behaviour. This causes CURL to wait
    // for 2 seconds if the server does not support this header.
    if (isset($opts[CURLOPT_HTTPHEADER])) {
      $existing_headers = $opts[CURLOPT_HTTPHEADER];
      $existing_headers[] = 'Expect:';
      $opts[CURLOPT_HTTPHEADER] = $existing_headers;
    } else {
      $opts[CURLOPT_HTTPHEADER] = array('Expect:');
    }

    curl_setopt_array($ch, $opts);
    $result = curl_exec($ch);

    if (curl_errno($ch) == 60) { // CURLE_SSL_CACERT
      self::errorLog('Invalid or no certificate authority found, '.
                     'using bundled information');
      curl_setopt($ch, CURLOPT_CAINFO,
                  dirname(__FILE__) . '/fb_ca_chain_bundle.crt');
      $result = curl_exec($ch);
    }

    if ($result === false) {
      $e = new FacebookApiException(array(
        'error_code' => curl_errno($ch),
        'error' => array(
        'message' => curl_error($ch),
        'type' => 'CurlException',
        ),
      ));
      curl_close($ch);
      throw $e;
    }
    curl_close($ch);
    return $result;
  }

  /**
   * Parses a signed_request and validates the signature.
   *
   * @param string $signed_request A signed token
   * @return array The payload inside it or null if the sig is wrong
   */
  protected function parseSignedRequest($signed_request) {
    list($encoded_sig, $payload) = explode('.', $signed_request, 2);

    // decode the data
    $sig = self::base64UrlDecode($encoded_sig);
    $data = json_decode(self::base64UrlDecode($payload), true);

    if (strtoupper($data['algorithm']) !== 'HMAC-SHA256') {
      self::errorLog('Unknown algorithm. Expected HMAC-SHA256');
      return null;
    }

    // check sig
    $expected_sig = hash_hmac('sha256', $payload,
                              $this->getAppSecret(), $raw = true);
    if ($sig !== $expected_sig) {
      self::errorLog('Bad Signed JSON signature!');
      return null;
    }

    return $data;
  }

  /**
   * Build the URL for api given parameters.
   *
   * @param $method String the method name.
   * @return string The URL for the given parameters
   */
  protected function getApiUrl($method) {
    static $READ_ONLY_CALLS =
      array('admin.getallocation' => 1,
            'admin.getappproperties' => 1,
            'admin.getbannedusers' => 1,
            'admin.getlivestreamvialink' => 1,
            'admin.getmetrics' => 1,
            'admin.getrestrictioninfo' => 1,
            'application.getpublicinfo' => 1,
            'auth.getapppublickey' => 1,
            'auth.getsession' => 1,
            'auth.getsignedpublicsessiondata' => 1,
            'comments.get' => 1,
            'connect.getunconnectedfriendscount' => 1,
            'dashboard.getactivity' => 1,
            'dashboard.getcount' => 1,
            'dashboard.getglobalnews' => 1,
            'dashboard.getnews' => 1,
            'dashboard.multigetcount' => 1,
            'dashboard.multigetnews' => 1,
            'data.getcookies' => 1,
            'events.get' => 1,
            'events.getmembers' => 1,
            'fbml.getcustomtags' => 1,
            'feed.getappfriendstories' => 1,
            'feed.getregisteredtemplatebundlebyid' => 1,
            'feed.getregisteredtemplatebundles' => 1,
            'fql.multiquery' => 1,
            'fql.query' => 1,
            'friends.arefriends' => 1,
            'friends.get' => 1,
            'friends.getappusers' => 1,
            'friends.getlists' => 1,
            'friends.getmutualfriends' => 1,
            'gifts.get' => 1,
            'groups.get' => 1,
            'groups.getmembers' => 1,
            'intl.gettranslations' => 1,
            'links.get' => 1,
            'notes.get' => 1,
            'notifications.get' => 1,
            'pages.getinfo' => 1,
            'pages.isadmin' => 1,
            'pages.isappadded' => 1,
            'pages.isfan' => 1,
            'permissions.checkavailableapiaccess' => 1,
            'permissions.checkgrantedapiaccess' => 1,
            'photos.get' => 1,
            'photos.getalbums' => 1,
            'photos.gettags' => 1,
            'profile.getinfo' => 1,
            'profile.getinfooptions' => 1,
            'stream.get' => 1,
            'stream.getcomments' => 1,
            'stream.getfilters' => 1,
            'users.getinfo' => 1,
            'users.getloggedinuser' => 1,
            'users.getstandardinfo' => 1,
            'users.hasapppermission' => 1,
            'users.isappuser' => 1,
            'users.isverified' => 1,
            'video.getuploadlimits' => 1);
    $name = 'api';
    if (isset($READ_ONLY_CALLS[strtolower($method)])) {
      $name = 'api_read';
    } else if (strtolower($method) == 'video.upload') {
      $name = 'api_video';
    }
    return self::getUrl($name, 'restserver.php');
  }

  /**
   * Build the URL for given domain alias, path and parameters.
   *
   * @param $name string The name of the domain
   * @param $path string Optional path (without a leading slash)
   * @param $params array Optional query parameters
   *
   * @return string The URL for the given parameters
   */
  protected function getUrl($name, $path='', $params=array()) {
    $url = self::$DOMAIN_MAP[$name];
    if ($path) {
      if ($path[0] === '/') {
        $path = substr($path, 1);
      }
      $url .= $path;
    }
    if ($params) {
      $url .= '?' . http_build_query($params, null, '&');
    }

    return $url;
  }

  /**
   * Returns the Current URL, stripping it of known FB parameters that should
   * not persist.
   *
   * @return string The current URL
   */
  protected function getCurrentUrl() {
    if (isset($_SERVER['HTTPS']) &&
        ($_SERVER['HTTPS'] == 'on' || $_SERVER['HTTPS'] == 1) ||
        isset($_SERVER['HTTP_X_FORWARDED_PROTO']) &&
        $_SERVER['HTTP_X_FORWARDED_PROTO'] == 'https') {
      $protocol = 'https://';
    }
    else {
      $protocol = 'http://';
    }
    $currentUrl = $protocol . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'];
    $parts = parse_url($currentUrl);

    $query = '';
    if (!empty($parts['query'])) {
      // drop known fb params
      $params = explode('&', $parts['query']);
      $retained_params = array();
      foreach ($params as $param) {
        if ($this->shouldRetainParam($param)) {
          $retained_params[] = $param;
        }
      }

      if (!empty($retained_params)) {
        $query = '?'.implode($retained_params, '&');
      }
    }

    // use port if non default
    $port =
      isset($parts['port']) &&
      (($protocol === 'http://' && $parts['port'] !== 80) ||
       ($protocol === 'https://' && $parts['port'] !== 443))
      ? ':' . $parts['port'] : '';

    // rebuild
    return $protocol . $parts['host'] . $port . $parts['path'] . $query;
  }

  /**
   * Returns true if and only if the key or key/value pair should
   * be retained as part of the query string.  This amounts to
   * a brute-force search of the very small list of Facebook-specific
   * params that should be stripped out.
   *
   * @param string $param A key or key/value pair within a URL's query (e.g.
   *                     'foo=a', 'foo=', or 'foo'.
   *
   * @return boolean
   */
  protected function shouldRetainParam($param) {
    foreach (self::$DROP_QUERY_PARAMS as $drop_query_param) {
      if (strpos($param, $drop_query_param.'=') === 0) {
        return false;
      }
    }

    return true;
  }

  /**
   * Analyzes the supplied result to see if it was thrown
   * because the access token is no longer valid.  If that is
   * the case, then we destroy the session.
   *
   * @param $result array A record storing the error message returned
   *                      by a failed API call.
   */
  protected function throwAPIException($result) {
    $e = new FacebookApiException($result);
    switch ($e->getType()) {
      // OAuth 2.0 Draft 00 style
      case 'OAuthException':
        // OAuth 2.0 Draft 10 style
      case 'invalid_token':
        // REST server errors are just Exceptions
      case 'Exception':
        $message = $e->getMessage();
        if ((strpos($message, 'Error validating access token') !== false) ||
            (strpos($message, 'Invalid OAuth access token') !== false) ||
            (strpos($message, 'An active access token must be used') !== false)
        ) {
          $this->destroySession();
        }
        break;
    }

    throw $e;
  }


  /**
   * Prints to the error log if you aren't in command line mode.
   *
   * @param string $msg Log message
   */
  protected static function errorLog($msg) {
    // disable error log if we are running in a CLI environment
    // @codeCoverageIgnoreStart
    if (php_sapi_name() != 'cli') {
      error_log($msg);
    }
    // uncomment this if you want to see the errors on the page
    // print 'error_log: '.$msg."\n";
    // @codeCoverageIgnoreEnd
  }

  /**
   * Base64 encoding that doesn't need to be urlencode()ed.
   * Exactly the same as base64_encode except it uses
   *   - instead of +
   *   _ instead of /
   *
   * @param string $input base64UrlEncoded string
   * @return string
   */
  protected static function base64UrlDecode($input) {
    return base64_decode(strtr($input, '-_', '+/'));
  }

  /**
   * Destroy the current session
   */
  public function destroySession() {
    $this->accessToken = null;
    $this->signedRequest = null;
    $this->user = null;
    $this->clearAllPersistentData();

    // Javascript sets a cookie that will be used in getSignedRequest that we
    // need to clear if we can
    $cookie_name = $this->getSignedRequestCookieName();
    if (array_key_exists($cookie_name, $_COOKIE)) {
      unset($_COOKIE[$cookie_name]);
      if (!headers_sent()) {
        // The base domain is stored in the metadata cookie if not we fallback
        // to the current hostname
        $base_domain = '.'. $_SERVER['HTTP_HOST'];

        $metadata = $this->getMetadataCookie();
        if (array_key_exists('base_domain', $metadata) &&
            !empty($metadata['base_domain'])) {
          $base_domain = $metadata['base_domain'];
        }

        setcookie($cookie_name, '', 0, '/', $base_domain);
      } else {
        self::errorLog(
          'There exists a cookie that we wanted to clear that we couldn\'t '.
          'clear because headers was already sent. Make sure to do the first '.
          'API call before outputing anything'
        );
      }
    }
  }

  /**
   * Parses the metadata cookie that our Javascript API set
   *
   * @return  an array mapping key to value
   */
  protected function getMetadataCookie() {
    $cookie_name = $this->getMetadataCookieName();
    if (!array_key_exists($cookie_name, $_COOKIE)) {
      return array();
    }

    // The cookie value can be wrapped in "-characters so remove them
    $cookie_value = trim($_COOKIE[$cookie_name], '"');

    if (empty($cookie_value)) {
      return array();
    }

    $parts = explode('&', $cookie_value);
    $metadata = array();
    foreach ($parts as $part) {
      $pair = explode('=', $part, 2);
      if (!empty($pair[0])) {
        $metadata[urldecode($pair[0])] =
          (count($pair) > 1) ? urldecode($pair[1]) : '';
      }
    }

    return $metadata;
  }

  /**
   * Each of the following four methods should be overridden in
   * a concrete subclass, as they are in the provided Facebook class.
   * The Facebook class uses PHP sessions to provide a primitive
   * persistent store, but another subclass--one that you implement--
   * might use a database, memcache, or an in-memory cache.
   *
   * @see Facebook
   */

  /**
   * Stores the given ($key, $value) pair, so that future calls to
   * getPersistentData($key) return $value. This call may be in another request.
   *
   * @param string $key
   * @param array $value
   *
   * @return void
   */
  abstract protected function setPersistentData($key, $value);

  /**
   * Get the data for $key, persisted by BaseFacebook::setPersistentData()
   *
   * @param string $key The key of the data to retrieve
   * @param boolean $default The default value to return if $key is not found
   *
   * @return mixed
   */
  abstract protected function getPersistentData($key, $default = false);

  /**
   * Clear the data with $key from the persistent storage
   *
   * @param string $key
   * @return void
   */
  abstract protected function clearPersistentData($key);

  /**
   * Clear all data from the persistent storage
   *
   * @return void
   */
  abstract protected function clearAllPersistentData();
}
/**
 * Copyright 2011 Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may
 * not use this file except in compliance with the License. You may obtain
 * a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

/**
 * Extends the BaseFacebook class with the intent of using
 * PHP sessions to store user ids and access tokens.
 */
class Facebook extends BaseFacebook
{
  /**
   * Identical to the parent constructor, except that
   * we start a PHP session to store the user ID and
   * access token if during the course of execution
   * we discover them.
   *
   * @param Array $config the application configuration.
   * @see BaseFacebook::__construct in facebook.php
   */
  public function __construct($config) {
    if (!session_id()) {
      session_start();
    }
    parent::__construct($config);
  }

  protected static $kSupportedKeys =
    array('state', 'code', 'access_token', 'user_id');

  /**
   * Provides the implementations of the inherited abstract
   * methods.  The implementation uses PHP sessions to maintain
   * a store for authorization codes, user ids, CSRF states, and
   * access tokens.
   */
  protected function setPersistentData($key, $value) {
    if (!in_array($key, self::$kSupportedKeys)) {
      self::errorLog('Unsupported key passed to setPersistentData.');
      return;
    }

    $session_var_name = $this->constructSessionVariableName($key);
    $_SESSION[$session_var_name] = $value;
  }

  protected function getPersistentData($key, $default = false) {
    if (!in_array($key, self::$kSupportedKeys)) {
      self::errorLog('Unsupported key passed to getPersistentData.');
      return $default;
    }

    $session_var_name = $this->constructSessionVariableName($key);
    return isset($_SESSION[$session_var_name]) ?
      $_SESSION[$session_var_name] : $default;
  }

  protected function clearPersistentData($key) {
    if (!in_array($key, self::$kSupportedKeys)) {
      self::errorLog('Unsupported key passed to clearPersistentData.');
      return;
    }

    $session_var_name = $this->constructSessionVariableName($key);
    unset($_SESSION[$session_var_name]);
  }

  protected function clearAllPersistentData() {
    foreach (self::$kSupportedKeys as $key) {
      $this->clearPersistentData($key);
    }
  }

  protected function constructSessionVariableName($key) {
    return implode('_', array('fb',
                              $this->getAppId(),
                              $key));
  }
}
// vim: foldmethod=marker

/* Generic exception class
 */
class OAuthException extends Exception {
  // pass
}

class OAuthConsumer {
  public $key;
  public $secret;

  function __construct($key, $secret, $callback_url=NULL) {
    $this->key = $key;
    $this->secret = $secret;
    $this->callback_url = $callback_url;
  }

  function __toString() {
    return "OAuthConsumer[key=$this->key,secret=$this->secret]";
  }
}

class OAuthToken {
  // access tokens and request tokens
  public $key;
  public $secret;

  /**
   * key = the token
   * secret = the token secret
   */
  function __construct($key, $secret) {
    $this->key = $key;
    $this->secret = $secret;
  }

  /**
   * generates the basic string serialization of a token that a server
   * would respond to request_token and access_token calls with
   */
  function to_string() {
    return "oauth_token=" .
           OAuthUtil::urlencode_rfc3986($this->key) .
           "&oauth_token_secret=" .
           OAuthUtil::urlencode_rfc3986($this->secret);
  }

  function __toString() {
    return $this->to_string();
  }
}

/**
 * A class for implementing a Signature Method
 * See section 9 ("Signing Requests") in the spec
 */
abstract class OAuthSignatureMethod {
  /**
   * Needs to return the name of the Signature Method (ie HMAC-SHA1)
   * @return string
   */
  abstract public function get_name();

  /**
   * Build up the signature
   * NOTE: The output of this function MUST NOT be urlencoded.
   * the encoding is handled in OAuthRequest when the final
   * request is serialized
   * @param OAuthRequest $request
   * @param OAuthConsumer $consumer
   * @param OAuthToken $token
   * @return string
   */
  abstract public function build_signature($request, $consumer, $token);

  /**
   * Verifies that a given signature is correct
   * @param OAuthRequest $request
   * @param OAuthConsumer $consumer
   * @param OAuthToken $token
   * @param string $signature
   * @return bool
   */
  public function check_signature($request, $consumer, $token, $signature) {
    $built = $this->build_signature($request, $consumer, $token);
    return $built == $signature;
  }
}

/**
 * The HMAC-SHA1 signature method uses the HMAC-SHA1 signature algorithm as defined in [RFC2104] 
 * where the Signature Base String is the text and the key is the concatenated values (each first 
 * encoded per Parameter Encoding) of the Consumer Secret and Token Secret, separated by an '&' 
 * character (ASCII code 38) even if empty.
 *   - Chapter 9.2 ("HMAC-SHA1")
 */
class OAuthSignatureMethod_HMAC_SHA1 extends OAuthSignatureMethod {
  function get_name() {
    return "HMAC-SHA1";
  }

  public function build_signature($request, $consumer, $token) {
    $base_string = $request->get_signature_base_string();
    $request->base_string = $base_string;

    $key_parts = array(
      $consumer->secret,
      ($token) ? $token->secret : ""
    );

    $key_parts = OAuthUtil::urlencode_rfc3986($key_parts);
    $key = implode('&', $key_parts);

    return base64_encode(hash_hmac('sha1', $base_string, $key, true));
  }
}

/**
 * The PLAINTEXT method does not provide any security protection and SHOULD only be used 
 * over a secure channel such as HTTPS. It does not use the Signature Base String.
 *   - Chapter 9.4 ("PLAINTEXT")
 */
class OAuthSignatureMethod_PLAINTEXT extends OAuthSignatureMethod {
  public function get_name() {
    return "PLAINTEXT";
  }

  /**
   * oauth_signature is set to the concatenated encoded values of the Consumer Secret and 
   * Token Secret, separated by a '&' character (ASCII code 38), even if either secret is 
   * empty. The result MUST be encoded again.
   *   - Chapter 9.4.1 ("Generating Signatures")
   *
   * Please note that the second encoding MUST NOT happen in the SignatureMethod, as
   * OAuthRequest handles this!
   */
  public function build_signature($request, $consumer, $token) {
    $key_parts = array(
      $consumer->secret,
      ($token) ? $token->secret : ""
    );

    $key_parts = OAuthUtil::urlencode_rfc3986($key_parts);
    $key = implode('&', $key_parts);
    $request->base_string = $key;

    return $key;
  }
}

/**
 * The RSA-SHA1 signature method uses the RSASSA-PKCS1-v1_5 signature algorithm as defined in 
 * [RFC3447] section 8.2 (more simply known as PKCS#1), using SHA-1 as the hash function for 
 * EMSA-PKCS1-v1_5. It is assumed that the Consumer has provided its RSA public key in a 
 * verified way to the Service Provider, in a manner which is beyond the scope of this 
 * specification.
 *   - Chapter 9.3 ("RSA-SHA1")
 */
abstract class OAuthSignatureMethod_RSA_SHA1 extends OAuthSignatureMethod {
  public function get_name() {
    return "RSA-SHA1";
  }

  // Up to the SP to implement this lookup of keys. Possible ideas are:
  // (1) do a lookup in a table of trusted certs keyed off of consumer
  // (2) fetch via http using a url provided by the requester
  // (3) some sort of specific discovery code based on request
  //
  // Either way should return a string representation of the certificate
  protected abstract function fetch_public_cert(&$request);

  // Up to the SP to implement this lookup of keys. Possible ideas are:
  // (1) do a lookup in a table of trusted certs keyed off of consumer
  //
  // Either way should return a string representation of the certificate
  protected abstract function fetch_private_cert(&$request);

  public function build_signature($request, $consumer, $token) {
    $base_string = $request->get_signature_base_string();
    $request->base_string = $base_string;

    // Fetch the private key cert based on the request
    $cert = $this->fetch_private_cert($request);

    // Pull the private key ID from the certificate
    $privatekeyid = openssl_get_privatekey($cert);

    // Sign using the key
    $ok = openssl_sign($base_string, $signature, $privatekeyid);

    // Release the key resource
    openssl_free_key($privatekeyid);

    return base64_encode($signature);
  }

  public function check_signature($request, $consumer, $token, $signature) {
    $decoded_sig = base64_decode($signature);

    $base_string = $request->get_signature_base_string();

    // Fetch the public key cert based on the request
    $cert = $this->fetch_public_cert($request);

    // Pull the public key ID from the certificate
    $publickeyid = openssl_get_publickey($cert);

    // Check the computed signature against the one passed in the query
    $ok = openssl_verify($base_string, $decoded_sig, $publickeyid);

    // Release the key resource
    openssl_free_key($publickeyid);

    return $ok == 1;
  }
}

class OAuthRequest {
  private $parameters;
  private $http_method;
  private $http_url;
  // for debug purposes
  public $base_string;
  public static $version = '1.0';
  public static $POST_INPUT = 'php://input';

  function __construct($http_method, $http_url, $parameters=NULL) {
    $parameters or $parameters = array();
    $parameters = array_merge( OAuthUtil::parse_parameters(parse_url($http_url, PHP_URL_QUERY)), $parameters);
    $this->parameters = $parameters;
    $this->http_method = $http_method;
    $this->http_url = $http_url;
  }


  /**
   * attempt to build up a request from what was passed to the server
   */
  public static function from_request($http_method=NULL, $http_url=NULL, $parameters=NULL) {
    $scheme = (!isset($_SERVER['HTTPS']) || $_SERVER['HTTPS'] != "on")
              ? 'http'
              : 'https';
    $http_url or $http_url = $scheme .
                              '://' . $_SERVER['HTTP_HOST'] .
                              ':' .
                              $_SERVER['SERVER_PORT'] .
                              $_SERVER['REQUEST_URI'];
    $http_method or $http_method = $_SERVER['REQUEST_METHOD'];

    // We weren't handed any parameters, so let's find the ones relevant to
    // this request.
    // If you run XML-RPC or similar you should use this to provide your own
    // parsed parameter-list
    if (!$parameters) {
      // Find request headers
      $request_headers = OAuthUtil::get_headers();

      // Parse the query-string to find GET parameters
      $parameters = OAuthUtil::parse_parameters($_SERVER['QUERY_STRING']);

      // It's a POST request of the proper content-type, so parse POST
      // parameters and add those overriding any duplicates from GET
      if ($http_method == "POST"
          && strstr($request_headers["Content-Type"],
                     "application/x-www-form-urlencoded")
          ) {
        $post_data = OAuthUtil::parse_parameters(
          file_get_contents(self::$POST_INPUT)
        );
        $parameters = array_merge($parameters, $post_data);
      }

      // We have a Authorization-header with OAuth data. Parse the header
      // and add those overriding any duplicates from GET or POST
      if (substr($request_headers['Authorization'], 0, 6) == "OAuth ") {
        $header_parameters = OAuthUtil::split_header(
          $request_headers['Authorization']
        );
        $parameters = array_merge($parameters, $header_parameters);
      }

    }

    return new OAuthRequest($http_method, $http_url, $parameters);
  }

  /**
   * pretty much a helper function to set up the request
   */
  public static function from_consumer_and_token($consumer, $token, $http_method, $http_url, $parameters=NULL) {
    $parameters or $parameters = array();
    $defaults = array("oauth_version" => OAuthRequest::$version,
                      "oauth_nonce" => OAuthRequest::generate_nonce(),
                      "oauth_timestamp" => OAuthRequest::generate_timestamp(),
                      "oauth_consumer_key" => $consumer->key);
    if ($token)
      $defaults['oauth_token'] = $token->key;

    $parameters = array_merge($defaults, $parameters);

    return new OAuthRequest($http_method, $http_url, $parameters);
  }

  public function set_parameter($name, $value, $allow_duplicates = true) {
    if ($allow_duplicates && isset($this->parameters[$name])) {
      // We have already added parameter(s) with this name, so add to the list
      if (is_scalar($this->parameters[$name])) {
        // This is the first duplicate, so transform scalar (string)
        // into an array so we can add the duplicates
        $this->parameters[$name] = array($this->parameters[$name]);
      }

      $this->parameters[$name][] = $value;
    } else {
      $this->parameters[$name] = $value;
    }
  }

  public function get_parameter($name) {
    return isset($this->parameters[$name]) ? $this->parameters[$name] : null;
  }

  public function get_parameters() {
    return $this->parameters;
  }

  public function unset_parameter($name) {
    unset($this->parameters[$name]);
  }

  /**
   * The request parameters, sorted and concatenated into a normalized string.
   * @return string
   */
  public function get_signable_parameters() {
    // Grab all parameters
    $params = $this->parameters;

    // Remove oauth_signature if present
    // Ref: Spec: 9.1.1 ("The oauth_signature parameter MUST be excluded.")
    if (isset($params['oauth_signature'])) {
      unset($params['oauth_signature']);
    }

    return OAuthUtil::build_http_query($params);
  }

  /**
   * Returns the base string of this request
   *
   * The base string defined as the method, the url
   * and the parameters (normalized), each urlencoded
   * and the concated with &.
   */
  public function get_signature_base_string() {
    $parts = array(
      $this->get_normalized_http_method(),
      $this->get_normalized_http_url(),
      $this->get_signable_parameters()
    );

    $parts = OAuthUtil::urlencode_rfc3986($parts);

    return implode('&', $parts);
  }

  /**
   * just uppercases the http method
   */
  public function get_normalized_http_method() {
    return strtoupper($this->http_method);
  }

  /**
   * parses the url and rebuilds it to be
   * scheme://host/path
   */
  public function get_normalized_http_url() {
    $parts = parse_url($this->http_url);

    $port = !empty($parts['port']) ? $parts['port'] : '';
    $scheme = $parts['scheme'];
    $host = $parts['host'];
    $path = !empty($parts['path']) ? $parts['path'] : '';

    $port or $port = ($scheme == 'https') ? '443' : '80';

    if (($scheme == 'https' && $port != '443')
        || ($scheme == 'http' && $port != '80')) {
      $host = "$host:$port";
    }
    return "$scheme://$host$path";
  }

  /**
   * builds a url usable for a GET request
   */
  public function to_url() {
    $post_data = $this->to_postdata();
    $out = $this->get_normalized_http_url();
    if ($post_data) {
      $out .= '?'.$post_data;
    }
    return $out;
  }

  /**
   * builds the data one would send in a POST request
   */
  public function to_postdata() {
    return OAuthUtil::build_http_query($this->parameters);
  }

  /**
   * builds the Authorization: header
   */
  public function to_header($realm=null) {
    $first = true;
	if($realm) {
      $out = 'Authorization: OAuth realm="' . OAuthUtil::urlencode_rfc3986($realm) . '"';
      $first = false;
    } else
      $out = 'Authorization: OAuth';

    $total = array();
    foreach ($this->parameters as $k => $v) {
      if (substr($k, 0, 5) != "oauth") continue;
      if (is_array($v)) {
        throw new OAuthException('Arrays not supported in headers');
      }
      $out .= ($first) ? ' ' : ',';
      $out .= OAuthUtil::urlencode_rfc3986($k) .
              '="' .
              OAuthUtil::urlencode_rfc3986($v) .
              '"';
      $first = false;
    }
    return $out;
  }

  public function __toString() {
    return $this->to_url();
  }


  public function sign_request($signature_method, $consumer, $token) {
    $this->set_parameter(
      "oauth_signature_method",
      $signature_method->get_name(),
      false
    );
    $signature = $this->build_signature($signature_method, $consumer, $token);
    $this->set_parameter("oauth_signature", $signature, false);
  }

  public function build_signature($signature_method, $consumer, $token) {
    $signature = $signature_method->build_signature($this, $consumer, $token);
    return $signature;
  }

  /**
   * util function: current timestamp
   */
  private static function generate_timestamp() {
    return time();
  }

  /**
   * util function: current nonce
   */
  private static function generate_nonce() {
    $mt = microtime();
    $rand = mt_rand();

    return md5($mt . $rand); // md5s look nicer than numbers
  }
}

class OAuthServer {
  protected $timestamp_threshold = 300; // in seconds, five minutes
  protected $version = '1.0';             // hi blaine
  protected $signature_methods = array();

  protected $data_store;

  function __construct($data_store) {
    $this->data_store = $data_store;
  }

  public function add_signature_method($signature_method) {
    $this->signature_methods[$signature_method->get_name()] =
      $signature_method;
  }

  // high level functions

  /**
   * process a request_token request
   * returns the request token on success
   */
  public function fetch_request_token(&$request) {
    $this->get_version($request);

    $consumer = $this->get_consumer($request);

    // no token required for the initial token request
    $token = NULL;

    $this->check_signature($request, $consumer, $token);

    // Rev A change
    $callback = $request->get_parameter('oauth_callback');
    $new_token = $this->data_store->new_request_token($consumer, $callback);

    return $new_token;
  }

  /**
   * process an access_token request
   * returns the access token on success
   */
  public function fetch_access_token(&$request) {
    $this->get_version($request);

    $consumer = $this->get_consumer($request);

    // requires authorized request token
    $token = $this->get_token($request, $consumer, "request");

    $this->check_signature($request, $consumer, $token);

    // Rev A change
    $verifier = $request->get_parameter('oauth_verifier');
    $new_token = $this->data_store->new_access_token($token, $consumer, $verifier);

    return $new_token;
  }

  /**
   * verify an api call, checks all the parameters
   */
  public function verify_request(&$request) {
    $this->get_version($request);
    $consumer = $this->get_consumer($request);
    $token = $this->get_token($request, $consumer, "access");
    $this->check_signature($request, $consumer, $token);
    return array($consumer, $token);
  }

  // Internals from here
  /**
   * version 1
   */
  private function get_version(&$request) {
    $version = $request->get_parameter("oauth_version");
    if (!$version) {
      // Service Providers MUST assume the protocol version to be 1.0 if this parameter is not present. 
      // Chapter 7.0 ("Accessing Protected Ressources")
      $version = '1.0';
    }
    if ($version !== $this->version) {
      throw new OAuthException("OAuth version '$version' not supported");
    }
    return $version;
  }

  /**
   * figure out the signature with some defaults
   */
  private function get_signature_method(&$request) {
    $signature_method =
        $request->get_parameter("oauth_signature_method");

    if (!$signature_method) {
      // According to chapter 7 ("Accessing Protected Ressources") the signature-method
      // parameter is required, and we can't just fallback to PLAINTEXT
      throw new OAuthException('No signature method parameter. This parameter is required');
    }

    if (!in_array($signature_method,
                  array_keys($this->signature_methods))) {
      throw new OAuthException(
        "Signature method '$signature_method' not supported " .
        "try one of the following: " .
        implode(", ", array_keys($this->signature_methods))
      );
    }
    return $this->signature_methods[$signature_method];
  }

  /**
   * try to find the consumer for the provided request's consumer key
   */
  private function get_consumer(&$request) {
    $consumer_key = $request->get_parameter("oauth_consumer_key");
    if (!$consumer_key) {
      throw new OAuthException("Invalid consumer key");
    }

    $consumer = $this->data_store->lookup_consumer($consumer_key);
    if (!$consumer) {
      throw new OAuthException("Invalid consumer");
    }

    return $consumer;
  }

  /**
   * try to find the token for the provided request's token key
   */
  private function get_token(&$request, $consumer, $token_type="access") {
    $token_field = $request->get_parameter('oauth_token');
    $token = $this->data_store->lookup_token(
      $consumer, $token_type, $token_field
    );
    if (!$token) {
      throw new OAuthException("Invalid $token_type token: $token_field");
    }
    return $token;
  }

  /**
   * all-in-one function to check the signature on a request
   * should guess the signature method appropriately
   */
  private function check_signature(&$request, $consumer, $token) {
    // this should probably be in a different method
    $timestamp = $request->get_parameter('oauth_timestamp');
    $nonce = $request->get_parameter('oauth_nonce');

    $this->check_timestamp($timestamp);
    $this->check_nonce($consumer, $token, $nonce, $timestamp);

    $signature_method = $this->get_signature_method($request);

    $signature = $request->get_parameter('oauth_signature');
    $valid_sig = $signature_method->check_signature(
      $request,
      $consumer,
      $token,
      $signature
    );

    if (!$valid_sig) {
      throw new OAuthException("Invalid signature");
    }
  }

  /**
   * check that the timestamp is new enough
   */
  private function check_timestamp($timestamp) {
    if( ! $timestamp )
      throw new OAuthException(
        'Missing timestamp parameter. The parameter is required'
      );
    
    // verify that timestamp is recentish
    $now = time();
    if (abs($now - $timestamp) > $this->timestamp_threshold) {
      throw new OAuthException(
        "Expired timestamp, yours $timestamp, ours $now"
      );
    }
  }

  /**
   * check that the nonce is not repeated
   */
  private function check_nonce($consumer, $token, $nonce, $timestamp) {
    if( ! $nonce )
      throw new OAuthException(
        'Missing nonce parameter. The parameter is required'
      );

    // verify that the nonce is uniqueish
    $found = $this->data_store->lookup_nonce(
      $consumer,
      $token,
      $nonce,
      $timestamp
    );
    if ($found) {
      throw new OAuthException("Nonce already used: $nonce");
    }
  }

}

class OAuthDataStore {
  function lookup_consumer($consumer_key) {
    // implement me
  }

  function lookup_token($consumer, $token_type, $token) {
    // implement me
  }

  function lookup_nonce($consumer, $token, $nonce, $timestamp) {
    // implement me
  }

  function new_request_token($consumer, $callback = null) {
    // return a new token attached to this consumer
  }

  function new_access_token($token, $consumer, $verifier = null) {
    // return a new access token attached to this consumer
    // for the user associated with this token if the request token
    // is authorized
    // should also invalidate the request token
  }

}

class OAuthUtil {
  public static function urlencode_rfc3986($input) {
  if (is_array($input)) {
    return array_map(array('OAuthUtil', 'urlencode_rfc3986'), $input);
  } else if (is_scalar($input)) {
    return str_replace(
      '+',
      ' ',
      str_replace('%7E', '~', rawurlencode($input))
    );
  } else {
    return '';
  }
}


  // This decode function isn't taking into consideration the above
  // modifications to the encoding process. However, this method doesn't
  // seem to be used anywhere so leaving it as is.
  public static function urldecode_rfc3986($string) {
    return urldecode($string);
  }

  // Utility function for turning the Authorization: header into
  // parameters, has to do some unescaping
  // Can filter out any non-oauth parameters if needed (default behaviour)
  public static function split_header($header, $only_allow_oauth_parameters = true) {
    $pattern = '/(([-_a-z]*)=("([^"]*)"|([^,]*)),?)/';
    $offset = 0;
    $params = array();
    while (preg_match($pattern, $header, $matches, PREG_OFFSET_CAPTURE, $offset) > 0) {
      $match = $matches[0];
      $header_name = $matches[2][0];
      $header_content = (isset($matches[5])) ? $matches[5][0] : $matches[4][0];
      if (preg_match('/^oauth_/', $header_name) || !$only_allow_oauth_parameters) {
        $params[$header_name] = OAuthUtil::urldecode_rfc3986($header_content);
      }
      $offset = $match[1] + strlen($match[0]);
    }

    if (isset($params['realm'])) {
      unset($params['realm']);
    }

    return $params;
  }

  // helper to try to sort out headers for people who aren't running apache
  public static function get_headers() {
    if (function_exists('apache_request_headers')) {
      // we need this to get the actual Authorization: header
      // because apache tends to tell us it doesn't exist
      $headers = apache_request_headers();

      // sanitize the output of apache_request_headers because
      // we always want the keys to be Cased-Like-This and arh()
      // returns the headers in the same case as they are in the
      // request
      $out = array();
      foreach( $headers AS $key => $value ) {
        $key = str_replace(
            " ",
            "-",
            ucwords(strtolower(str_replace("-", " ", $key)))
          );
        $out[$key] = $value;
      }
    } else {
      // otherwise we don't have apache and are just going to have to hope
      // that $_SERVER actually contains what we need
      $out = array();
      if( isset($_SERVER['CONTENT_TYPE']) )
        $out['Content-Type'] = $_SERVER['CONTENT_TYPE'];
      if( isset($_ENV['CONTENT_TYPE']) )
        $out['Content-Type'] = $_ENV['CONTENT_TYPE'];

      foreach ($_SERVER as $key => $value) {
        if (substr($key, 0, 5) == "HTTP_") {
          // this is chaos, basically it is just there to capitalize the first
          // letter of every word that is not an initial HTTP and strip HTTP
          // code from przemek
          $key = str_replace(
            " ",
            "-",
            ucwords(strtolower(str_replace("_", " ", substr($key, 5))))
          );
          $out[$key] = $value;
        }
      }
    }
    return $out;
  }

  // This function takes a input like a=b&a=c&d=e and returns the parsed
  // parameters like this
  // array('a' => array('b','c'), 'd' => 'e')
  public static function parse_parameters( $input ) {
    if (!isset($input) || !$input) return array();

    $pairs = explode('&', $input);

    $parsed_parameters = array();
    foreach ($pairs as $pair) {
      $split = explode('=', $pair, 2);
      $parameter = OAuthUtil::urldecode_rfc3986($split[0]);
      $value = isset($split[1]) ? OAuthUtil::urldecode_rfc3986($split[1]) : '';

      if (isset($parsed_parameters[$parameter])) {
        // We have already recieved parameter(s) with this name, so add to the list
        // of parameters with this name

        if (is_scalar($parsed_parameters[$parameter])) {
          // This is the first duplicate, so transform scalar (string) into an array
          // so we can add the duplicates
          $parsed_parameters[$parameter] = array($parsed_parameters[$parameter]);
        }

        $parsed_parameters[$parameter][] = $value;
      } else {
        $parsed_parameters[$parameter] = $value;
      }
    }
    return $parsed_parameters;
  }

  public static function build_http_query($params) {
    if (!$params) return '';

    // Urlencode both keys and values
    $keys = OAuthUtil::urlencode_rfc3986(array_keys($params));
    $values = OAuthUtil::urlencode_rfc3986(array_values($params));
    $params = array_combine($keys, $values);

    // Parameters are sorted by name, using lexicographical byte value ordering.
    // Ref: Spec: 9.1.1 (1)
    uksort($params, 'strcmp');

    $pairs = array();
    foreach ($params as $parameter => $value) {
      if (is_array($value)) {
        // If two or more parameters share the same name, they are sorted by their value
        // Ref: Spec: 9.1.1 (1)
        natsort($value);
        foreach ($value as $duplicate_value) {
          $pairs[] = $parameter . '=' . $duplicate_value;
        }
      } else {
        $pairs[] = $parameter . '=' . $value;
      }
    }
    // For each parameter, the name is separated from the corresponding value by an '=' character (ASCII code 61)
    // Each name-value pair is separated by an '&' character (ASCII code 38)
    return implode('&', $pairs);
  }
}


/*
 * Abraham Williams (abraham@abrah.am) http://abrah.am
 *
 * The first PHP Library to support OAuth for Twitter's REST API.
 */

/**
 * Twitter OAuth class
 */
class TwitterOAuth {
  /* Contains the last HTTP status code returned. */
  public $http_code;
  /* Contains the last API call. */
  public $url;
  /* Set up the API root URL. */
  public $host = "https://api.twitter.com/1.1/";
  /* Set timeout default. */
  public $timeout = 30;
  /* Set connect timeout. */
  public $connecttimeout = 30; 
  /* Verify SSL Cert. */
  public $ssl_verifypeer = FALSE;
  /* Respons format. */
  public $format = 'json';
  /* Decode returned json data. */
  public $decode_json = TRUE;
  /* Contains the last HTTP headers returned. */
  public $http_info;
  /* Set the useragnet. */
  public $useragent = 'TwitterOAuth v0.2.0-beta2';
  /* Immediately retry the API call if the response was not successful. */
  //public $retry = TRUE;


  /**
   * Set API URLS
   */
  function accessTokenURL()  { return 'https://api.twitter.com/oauth/access_token'; }
  function authenticateURL() { return 'https://api.twitter.com/oauth/authenticate'; }
  function authorizeURL()    { return 'https://api.twitter.com/oauth/authorize'; }
  function requestTokenURL() { return 'https://api.twitter.com/oauth/request_token'; }

  /**
   * Debug helpers
   */
  function lastStatusCode() { return $this->http_status; }
  function lastAPICall() { return $this->last_api_call; }

  /**
   * construct TwitterOAuth object
   */
  function __construct($consumer_key, $consumer_secret, $oauth_token = NULL, $oauth_token_secret = NULL) {
    $this->sha1_method = new OAuthSignatureMethod_HMAC_SHA1();
    $this->consumer = new OAuthConsumer($consumer_key, $consumer_secret);
    if (!empty($oauth_token) && !empty($oauth_token_secret)) {
      $this->token = new OAuthConsumer($oauth_token, $oauth_token_secret);
    } else {
      $this->token = NULL;
    }
  }


  /**
   * Get a request_token from Twitter
   *
   * @returns a key/value array containing oauth_token and oauth_token_secret
   */
  function getRequestToken($oauth_callback = NULL) {
    $parameters = array();
    if (!empty($oauth_callback)) {
      $parameters['oauth_callback'] = $oauth_callback;
    } 
    $request = $this->oAuthRequest($this->requestTokenURL(), 'GET', $parameters);
    $token = OAuthUtil::parse_parameters($request);
    $this->token = new OAuthConsumer($token['oauth_token'], $token['oauth_token_secret']);
    return $token;
  }

  /**
   * Get the authorize URL
   *
   * @returns a string
   */
  function getAuthorizeURL($token, $sign_in_with_twitter = TRUE) {
    if (is_array($token)) {
      $token = $token['oauth_token'];
    }
    if (empty($sign_in_with_twitter)) {
      return $this->authorizeURL() . "?oauth_token={$token}";
    } else {
       return $this->authenticateURL() . "?oauth_token={$token}";
    }
  }

  /**
   * Exchange request token and secret for an access token and
   * secret, to sign API calls.
   *
   * @returns array("oauth_token" => "the-access-token",
   *                "oauth_token_secret" => "the-access-secret",
   *                "user_id" => "9436992",
   *                "screen_name" => "abraham")
   */
  function getAccessToken($oauth_verifier = FALSE) {
    $parameters = array();
    if (!empty($oauth_verifier)) {
      $parameters['oauth_verifier'] = $oauth_verifier;
    }
    $request = $this->oAuthRequest($this->accessTokenURL(), 'GET', $parameters);
    $token = OAuthUtil::parse_parameters($request);
    $this->token = new OAuthConsumer($token['oauth_token'], $token['oauth_token_secret']);
    return $token;
  }

  /**
   * One time exchange of username and password for access token and secret.
   *
   * @returns array("oauth_token" => "the-access-token",
   *                "oauth_token_secret" => "the-access-secret",
   *                "user_id" => "9436992",
   *                "screen_name" => "abraham",
   *                "x_auth_expires" => "0")
   */  
  function getXAuthToken($username, $password) {
    $parameters = array();
    $parameters['x_auth_username'] = $username;
    $parameters['x_auth_password'] = $password;
    $parameters['x_auth_mode'] = 'client_auth';
    $request = $this->oAuthRequest($this->accessTokenURL(), 'POST', $parameters);
    $token = OAuthUtil::parse_parameters($request);
    $this->token = new OAuthConsumer($token['oauth_token'], $token['oauth_token_secret']);
    return $token;
  }

  /**
   * GET wrapper for oAuthRequest.
   */
  function get($url, $parameters = array()) {
    $response = $this->oAuthRequest($url, 'GET', $parameters);
    if ($this->format === 'json' && $this->decode_json) {
      return json_decode($response);
    }
    return $response;
  }
  
  /**
   * POST wrapper for oAuthRequest.
   */
  function post($url, $parameters = array()) {
    $response = $this->oAuthRequest($url, 'POST', $parameters);
    if ($this->format === 'json' && $this->decode_json) {
      return json_decode($response);
    }
    return $response;
  }

  /**
   * DELETE wrapper for oAuthReqeust.
   */
  function delete($url, $parameters = array()) {
    $response = $this->oAuthRequest($url, 'DELETE', $parameters);
    if ($this->format === 'json' && $this->decode_json) {
      return json_decode($response);
    }
    return $response;
  }

  /**
   * Format and sign an OAuth / API request
   */
  function oAuthRequest($url, $method, $parameters) {
    if (strrpos($url, 'https://') !== 0 && strrpos($url, 'http://') !== 0) {
      $url = "{$this->host}{$url}.{$this->format}";
    }
    $request = OAuthRequest::from_consumer_and_token($this->consumer, $this->token, $method, $url, $parameters);
    $request->sign_request($this->sha1_method, $this->consumer, $this->token);
    switch ($method) {
    case 'GET':
      return $this->http($request->to_url(), 'GET');
    default:
      return $this->http($request->get_normalized_http_url(), $method, $request->to_postdata());
    }
  }

  /**
   * Make an HTTP request
   *
   * @return API results
   */
  function http($url, $method, $postfields = NULL) {
    $this->http_info = array();
    $ci = curl_init();
    /* Curl settings */
    curl_setopt($ci, CURLOPT_USERAGENT, $this->useragent);
    curl_setopt($ci, CURLOPT_CONNECTTIMEOUT, $this->connecttimeout);
    curl_setopt($ci, CURLOPT_TIMEOUT, $this->timeout);
    curl_setopt($ci, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($ci, CURLOPT_HTTPHEADER, array('Expect:'));
    curl_setopt($ci, CURLOPT_SSL_VERIFYPEER, $this->ssl_verifypeer);
    curl_setopt($ci, CURLOPT_HEADERFUNCTION, array($this, 'getHeader'));
    curl_setopt($ci, CURLOPT_HEADER, FALSE);

    switch ($method) {
      case 'POST':
        curl_setopt($ci, CURLOPT_POST, TRUE);
        if (!empty($postfields)) {
          curl_setopt($ci, CURLOPT_POSTFIELDS, $postfields);
        }
        break;
      case 'DELETE':
        curl_setopt($ci, CURLOPT_CUSTOMREQUEST, 'DELETE');
        if (!empty($postfields)) {
          $url = "{$url}?{$postfields}";
        }
    }

    curl_setopt($ci, CURLOPT_URL, $url);
    $response = curl_exec($ci);
    $this->http_code = curl_getinfo($ci, CURLINFO_HTTP_CODE);
    $this->http_info = array_merge($this->http_info, curl_getinfo($ci));
    $this->url = $url;
    curl_close ($ci);
    return $response;
  }

  /**
   * Get the header info to store.
   */
  function getHeader($ch, $header) {
    $i = strpos($header, ':');
    if (!empty($i)) {
      $key = str_replace('-', '_', strtolower(substr($header, 0, $i)));
      $value = trim(substr($header, $i + 2));
      $this->http_header[$key] = $value;
    }
    return strlen($header);
  }
}

?>