<?php

	define('hBEFORE',	1);
	define('hAFTER',	2);

	define('reBEFORE',	1);
	define('reAFTER',	2);

	class kEventManager extends kBase {

		/**
		* Connection to database
		*
		* @var kDBConnection
		* @access public
		*/
		var $Conn;

		/**
		 * Cache of QueryString parameters
		 * from config, that are represented
		 * in enviroment variable
		 *
		 * @var Array
		 */
		var $queryMaps = Array();

		/**
		 * Build events registred for
		 * pseudo classes. key - pseudo class
		 * value - event name
		 *
		 * @var Array
		 * @access private
		 */
		var $buildEvents=Array();


		/**
		 * Events, that should be run before parser initialization
		 *
		 * @var Array
		 */
		var $beforeRegularEvents = Array();

		/**
		 * Events, that should be run after parser initialization
		 *
		 * @var Array
		 */
		var $afterRegularEvents = Array();

		/**
		 * Holds before hooks
		 * key - prefix.event (to link to)
		 * value - hooked event info
		 *
		 * @var Array
		 * @access private
		 */
		var $beforeHooks=Array();

		/**
		 * Holds after hooks
		 * key - prefix.event (to link to)
		 * value - hooked event info
		 *
		 * @var Array
		 * @access private
		 */
		var $afterHooks = Array();

		
		var $recursionStack = Array();
		
		function kEventManager()
		{
			parent::kBase();
			$this->Conn =& $this->Application->GetADODBConnection();
		}

		/**
		 * Set's new enviroment parameter mappings
		 * between their names as application vars
		 *
		 * @param Array $new_query_maps
		 * @access public
		 */
		/*function setQueryMaps($new_query_maps)
		{
			$this->queryMaps = $new_query_maps;
		}*/

		/**
		 * Adds new query map to already parsed query maps
		 *
		 * @param string $prefix
		 */
		function setQueryMap($prefix_special)
		{
			list($prefix) = explode('.', $prefix_special);
			$query_map = $this->Application->getUnitOption($prefix, 'QueryString');
			if ($query_map) {
				$this->queryMaps[$prefix_special] = $query_map;
			}
			else {
				unset($this->queryMaps[$prefix]);
			}

			$this->Application->SetVar('passed', implode(',', array_keys($this->queryMaps)) );
			return $query_map;
		}

		/**
		 * Registers new regular event
		 *
		 * @param string $short_name name to be used to store last maintenace run info
		 * @param string $event_name
		 * @param int $run_interval run interval in seconds
		 * @param int $type before or after regular event
		 */
		function registerRegularEvent($short_name, $event_name, $run_interval, $type = reBEFORE)
		{
			if($type == reBEFORE)
			{
				$this->beforeRegularEvents[$short_name] = Array('EventName' => $event_name, 'RunInterval' => $run_interval);
			}
			else
			{
				$this->afterRegularEvents[$short_name] = Array('EventName' => $event_name, 'RunInterval' => $run_interval);
			}
		}

		function registerBuildEvent($pseudo_class,$build_event_name)
		{
			$this->buildEvents[$pseudo_class]=$build_event_name;
		}

		/**
		 * Returns build event by pseudo class
		 * name if any defined in config
		 *
		 * @param string $pseudo_class
		 * @return kEvent
		 * @access public
		 */
		function &getBuildEvent($pseudo_class)
		{
			$false = false;
			if( !isset($this->buildEvents[$pseudo_class]) ) return $false;

			$event = new kEvent();
			$event->Name=$this->buildEvents[$pseudo_class];
			$event->MasterEvent=null;
			return $event;
		}

		/**
		 * Check if event is called twice, that causes recursion
		 *
		 * @param kEvent $event
		 */
		function isRecursion(&$event)
		{
			$event_key = $event->getPrefixSpecial().':'.$event->Name;
			return in_array($event_key, $this->recursionStack) ? true : false;
		}
		
		function pushEvent(&$event)
		{
			$event_key = $event->getPrefixSpecial().':'.$event->Name;
			array_push($this->recursionStack, $event_key);
		}
		
		function popEvent()
		{
			array_pop($this->recursionStack);
		}
		
		/**
		 * Allows to process any type of event
		 *
		 * @param kEvent $event
		 * @access public
		 */
		function HandleEvent(&$event)
		{
			if ($this->isRecursion($event)) {
				return true;
			}
			
			$this->pushEvent($event);
			
			if( !$this->Application->prefixRegistred($event->Prefix) )
			{
				trigger_error('Prefix <b>'.$event->Prefix.'</b> not registred (requested event <b>'.$event->Name.'</b>)', E_USER_NOTICE);
				return false;
			}

			if (!$event->SkipBeforeHooks) {
				$this->processHooks($event, hBEFORE);
				if ($event->status == erFATAL) return true;
			}

			$event_handler =& $this->Application->recallObject($event->Prefix.'_EventHandler');
			$event_handler->processEvent($event);

			if ($event->status == erFATAL) return true;
			if (!$event->SkipAfterHooks) {
				$this->processHooks($event, hAFTER);
			}

			$this->popEvent();
			
			return true;
		}

		function ProcessRequest()
		{
			$this->processOpener();

			// 1. get events from $_POST
			$events = $this->Application->GetVar('events');
			if ($events === false) $events = Array();
			// 2. if nothing there, then try to find them in $_GET
			if ($this->queryMaps && !$events) {
				// if we got $_GET type submit (links, not javascript)
				foreach ($this->queryMaps as $prefix_special => $query_map) {
					$query_map = array_flip($query_map);
					if (isset($query_map['event'])) {
						$event_name = $this->Application->GetVar($prefix_special.'_event');
						if ($event_name) {
							$events[$prefix_special] = $event_name;
						}
					}
				}
				$actions = $this->Application->GetVar('do');
				if ($actions) {
					list($prefix, $event_name) = explode('_', $actions);
					$events[$prefix] = $event_name;
				}
			}

			$passed = explode(',', $this->Application->GetVar('passed'));
			foreach($events as $prefix_special => $event_name)
			{
				if(!$event_name) continue;
				if( is_array($event_name) )
				{
					$event_name = key($event_name);
					$events[$prefix_special] = $event_name;
					$this->Application->SetVar($prefix_special.'_event', $event_name);
				}

				$event = new kEvent();
				$event->Name=$event_name;
				$event->Prefix_Special=$prefix_special;

				$prefix_special=explode('.',$prefix_special);
				$event->Prefix=$prefix_special[0];
				array_push($passed, $prefix_special[0]);
				$event->Special=isset($prefix_special[1])?$prefix_special[1]:'';

				$event->redirect_params = Array('opener'=>'s', 'pass'=>'all');
				$event->redirect = true;
				
				$event_handler =& $this->Application->recallObject($event->Prefix.'_EventHandler');
				if ($event_handler->checkPermissions($event)) {
					$this->HandleEvent($event);
				}
				
				if($event->status==erSUCCESS && ($event->redirect === true || strlen($event->redirect) > 0) )
				{
					$this->Application->Redirect($event->redirect, $event->redirect_params, null, $event->redirect_script);
				}
			}

			$this->Application->SetVar('events', $events);
			$this->Application->SetVar('passed', implode(',', $passed));
		}

		function processOpener()
		{
			$opener_action=$this->Application->GetVar('m_opener');
			$opener_stack=$this->Application->RecallVar('opener_stack');
			$opener_stack=$opener_stack?unserialize($opener_stack):Array();
			switch($opener_action)
			{
				case 'r':	// "reset" opener stack
					$opener_stack=Array();
					break;

				case 'd':	// "down/push" new template to opener stack, deeplevel++
					if ($this->Application->GetVar('front')) {
						array_push($opener_stack, '../'.$this->Application->RecallVar('last_template') );
					}
					else {
						array_push($opener_stack, $this->Application->RecallVar('last_template') );
					}
					break;

				case 'u':	// "up/pop" last template from opener stack, deeplevel--
					array_pop($opener_stack);
					break;

				case 'p': //pop-up - do not store last template
					$this->Application->SetVar('skip_last_template', 1);
					break;

				default:	// "s/0," stay on same deep level
					break;
			}
			if ( !$this->Application->GetVar('skip_last_template') ) {
				$this->Application->SetVar('m_opener','s');
			}
			$this->Application->StoreVar('opener_stack',serialize($opener_stack));
		}

		function registerHook($hookto_prefix, $hookto_special, $hookto_event, $mode, $do_prefix, $do_special, $do_event, $conditional)
		{
			if( !$this->Application->getUnitOptions($hookto_prefix) )
			{
				if($this->Application->isDebugMode())
				{
					trigger_error('Prefix <b>'.$hookto_prefix.'</b> doesn\'t exist when trying to hook from <b>'.$do_prefix.':'.$do_event.'</b>', E_USER_WARNING);
				}
				return;
			}
			$hookto_prefix_special = rtrim($hookto_prefix.'.'.$hookto_special, '.');
			if ($mode == hBEFORE) {
				$this->beforeHooks[strtolower($hookto_prefix_special.'.'.$hookto_event)][] = Array(
						'DoPrefix' => $do_prefix,
						'DoSpecial' => $do_special,
						'DoEvent' => $do_event,
						'Conditional' => $conditional,
					);
			}
			elseif ($mode == hAFTER) {
				$this->afterHooks[strtolower($hookto_prefix_special.'.'.$hookto_event)][] = Array(
						'DoPrefix' => $do_prefix,
						'DoSpecial' => $do_special,
						'DoEvent' => $do_event,
						'Conditional' => $conditional,
					);
			}
		}

		/**
		 * Enter description here...
		 *
		 * @param kEvent $event
		 * @param int $mode hBEFORE or hAFTER
		 * @return Array
		 */
		function &getHooks(&$event, $mode, $special = null)
		{
			$event_key = !isset($special) ? $event->Prefix_Special : $event->Prefix.'.'.$special;

			if ($mode == hBEFORE) {
				$mode_hooks =& $this->beforeHooks;
			}
			else {
				$mode_hooks =& $this->afterHooks;
			}

			$hooks = getArrayValue($mode_hooks, strtolower($event_key.'.'.$event->Name));
			if (!$hooks) {
				$hooks = Array();
			}
			return $hooks;
		}

		/**
		 * Enter description here...
		 *
		 * @param kEvent $event
		 * @param int $mode hBEFORE or hAFTER
		 */
		function processHooks(&$event, $mode)
		{
			// * - get hooks that are valid with any special of given prefix
			$hooks = array_merge($this->getHooks($event, $mode, '*'), $this->getHooks($event, $mode));

			if ($hooks) {
				foreach ($hooks as $hook) {
					if ($hook['DoSpecial'] == '*') {
						// use same special as master event
						$hook['DoSpecial'] = $event->Special;
					}
					
					$prefix_special = rtrim($hook['DoPrefix'].'_'.$hook['DoSpecial'], '_');
					if ( $hook['Conditional'] && !$this->Application->GetVar($prefix_special) ) {
						continue;
					}

					$hook_event = new kEvent( Array('name'=>$hook['DoEvent'],'prefix'=>$hook['DoPrefix'],'special'=>$hook['DoSpecial']) );
					$hook_event->MasterEvent =& $event;
					$this->HandleEvent($hook_event);
				}
			}
		}

		/**
		 * Set's new event for $prefix_special
		 * passed
		 *
		 * @param string $prefix_special
		 * @param string $event_name
		 * @access public
		 */
		function setEvent($prefix_special,$event_name)
		{
			$actions =& $this->Application->recallObject('kActions');
			$actions->Set('events['.$prefix_special.']',$event_name);
		}

		/**
		 * Run registred regular events with specified event type
		 *
		 * @param int $event_type
		 */
		function RunRegularEvents($event_type = reBEFORE, $from_cron=false)
		{
			// if RegularEvents are set to run from cron
			if (!$from_cron && $this->Application->ConfigValue('UseCronForRegularEvent')) return ;
			$events_source = ($event_type == reBEFORE) ? $this->beforeRegularEvents : $this->afterRegularEvents;

			/*if(rand(0, 100) < 90)
			{
				return;
			}*/

			$sql = 'SELECT Data FROM '.TABLE_PREFIX.'Cache WHERE VarName = %s';
			$event_last_runs = $this->Conn->GetOne( sprintf($sql, $this->Conn->qstr('RegularEventRuns') ) );
			$event_last_runs = $event_last_runs ? unserialize($event_last_runs) : Array();

			foreach($events_source as $short_name => $event_data)
			{
				$event_last_run = getArrayValue($event_last_runs, $short_name);
				if($event_last_run && $event_last_run > adodb_mktime() - $event_data['RunInterval'])
				{
					continue;
				}
				else
				{
					$event = new kEvent($event_data['EventName']);
					$event->redirect = false;
					$this->Application->HandleEvent($event);
					$event_last_runs[$short_name] = adodb_mktime();
				}
			}

			$sql = 'REPLACE INTO '.TABLE_PREFIX.'Cache (VarName,Data,Cached) VALUES (%s,%s,%s)';
			$this->Conn->Query( sprintf($sql, $this->Conn->qstr('RegularEventRuns'), $this->Conn->qstr(serialize($event_last_runs)), adodb_mktime() ) );
		}
		
		/**
		 * Allows to determine, that required event is beeing processed right now
		 *
		 * @param string $event_key Event name in format prefix[.special]:event_name
		 * @return bool
		 */
		function eventRunning($event_key)
		{
			return array_search($event_key, $this->recursionStack) !== false;
		}
	}


?>