<?php
class ImageEventHandler extends kDBEventHandler {

	function mapEvents()
	{
		parent::mapEvents();	// ensure auto-adding of approve/decine and so on events
		$image_events = Array(
			'OnAfterCopyToTemp'=>'ImageAction',
			'OnBeforeDeleteFromLive'=>'ImageAction',
			'OnBeforeCopyToLive'=>'ImageAction',
			'OnBeforeItemDelete'=>'ImageAction',
			'OnAfterClone'=>'ImageAction',
		);

		$this->eventMethods = array_merge($this->eventMethods, $image_events);
	}

	/**
	 * Get's special of main item for linking with subitem
	 *
	 * @param kEvent $event
	 * @return string
	 */
	function getMainSpecial(&$event)
	{
		if ($event->Special == 'list' && !$this->Application->IsAdmin()) {
			// ListImages aggregated tag uses this special
			return '';
		}
		
		return parent::getMainSpecial($event);
	}
		
	function customProcessing(&$event, $type)
	{
		$object =& $event->GetObject();
		switch ($type)
		{
			case 'before' :
				if ($object->GetDBField('LocalImage'))
				{
					$object->SetDBField('Url', '');
				}
				else
				{
					$object->SetDBField('LocalPath', '');
				}

				if ($object->GetDBField('LocalThumb'))
				{
					$object->SetDBField('ThumbUrl', '');
				}
				else
				{
					$object->SetDBField('ThumbPath', '');
				}

				if ($object->GetDBField('SameImages'))
				{
					$object->SetDBField('LocalImage', 1);
					$object->SetDBField('LocalPath', '');
					$object->SetDBField('Url', '');
				}
				break;
			case 'after' :
				if ($object->GetDBField('DefaultImg') )
				{
					$sql = 'UPDATE '.$object->TableName.' SET DefaultImg=0 WHERE ResourceId='.
							$object->GetDBField('ResourceId').' AND ImageId<>'.
							$object->GetId();
					$res = $this->Conn->Query($sql);
				}
				break;
			default:
		}
	}

	function ImageAction(&$event)
	{
		$id = $event->getEventParam('id');
		$object =& $this->Application->recallObject($event->Prefix.'.-item', $event->Prefix);
		if (in_array($event->Name, Array('OnBeforeDeleteFromLive','OnAfterClone')) ) {
			$object->SwitchToLive();
		}
		elseif ($event->Name == 'OnBeforeItemDelete') {
			// keep current table
		}
		else {
			$object->SwitchToTemp();
		}

		$object->Load($id);

		$fields = Array('LocalPath' => 'LocalImage', 'ThumbPath' => 'LocalThumb');
		foreach ($fields as $a_field => $mode_field) {
			$file = $object->GetField($a_field);
			if (!$file) continue;
			$source_file = FULL_PATH.$file;

			switch ($event->Name) {
				// Copy image files to pending dir and update corresponding fields in temp record
				// Checking for existing files and renaming if nessessary - two users may upload same pending files at the same time!
				case 'OnAfterCopyToTemp':
					$new_file = IMAGES_PENDING_PATH . $this->ValidateFileName(FULL_PATH.IMAGES_PENDING_PATH, basename($file));
					$dest_file = FULL_PATH.$new_file;
					copy($source_file, $dest_file);
					$object->Fields[$a_field]['skip_empty'] = false;
					$object->SetDBField($a_field, $new_file);
					break;

				// Copy image files to live dir (checking if fileexists and renameing if nessessary)
				// and update corresponding fields in temp record (which gets copied to live automatically)
				case 'OnBeforeCopyToLive':
					if ( $object->GetDBField($mode_field) )  { // if image is local
						// rename file if it exists in live folder
						$new_file = IMAGES_PATH . $this->ValidateFileName(FULL_PATH.IMAGES_PATH, basename($file));
						$dest_file = FULL_PATH.$new_file;
						rename($source_file, $dest_file);
					}
					else { // if image is remote url - remove local file (if any), update local file field with empty value
						if (file_exists($source_file)) @unlink($source_file);
						$new_file = '';
					}
					$object->Fields[$a_field]['skip_empty'] = false;
					$object->SetDBField($a_field, $new_file);
					break;

				case 'OnBeforeDeleteFromLive': // Delete image files from live folder before copying over from temp
				case 'OnBeforeItemDelete': // Delete image files when deleteing Image object
					@unlink(FULL_PATH.$file);
					break;

				case 'OnAfterClone': // Copy files when cloning objects, renaming it on the fly
					$path_info = pathinfo($file);
					$new_file = $path_info['dirname'].'/'.$this->ValidateFileName(FULL_PATH.$path_info['dirname'], $path_info['basename']);
					$dest_file = FULL_PATH . $new_file;
					copy($source_file, $dest_file);
					$object->Fields[$a_field]['skip_empty'] = false;
					$object->SetDBField($a_field, $new_file);
					break;
			}
		}
		if ( in_array($event->Name, Array('OnAfterClone', 'OnBeforeCopyToLive', 'OnAfterCopyToTemp')) ) {
			$object->Update(null, true);
		}
	}

	function ValidateFileName($path, $name)
	{
		$parts = pathinfo($name);
		$ext = '.'.$parts['extension'];
		$filename = substr($parts['basename'], 0, -strlen($ext));
		$new_name = $filename.$ext;
		while ( file_exists($path.'/'.$new_name) )
		{
	   		if ( preg_match("/({$filename}_)([0-9]*)($ext)/", $new_name, $regs) ) {
				$new_name = $regs[1].($regs[2]+1).$regs[3];
			}
			else {
				$new_name = $filename.'_1'.$ext;
			}
		}
		return $new_name;
	}

		/**
	 * Enter description here...
	 *
	 * @param kEvent $event
	 */
	function OnSetPrimary(&$event)
	{
		$object =& $event->getObject();
		$object->SetDBField('DefaultImg', 1);
		$object->Update();
	}

	/**
	 * Enter description here...
	 *
	 * @param kEvent $event
	 */
	function OnBeforeItemUpdate(&$event)
	{
		$object =& $event->getObject();
//		$parent_info = $object->getLinkedInfo();
		$id = $object->GetDBField('ResourceId');
//		$id = $parent_info['ParentId'] ? $parent_info['ParentId'] : $this->Application->GetVar('p_id');
		$sql = 'SELECT ImageId FROM '.$object->TableName.' WHERE ResourceId='.$id.' AND DefaultImg=1';
		if(!$this->Conn->GetOne($sql))
		{
			$object->SetDBField('DefaultImg', 1);
		}
		if($object->GetDBField('DefaultImg') && $object->Validate())
		{

			$sql = 'UPDATE '.$object->TableName.'
					SET DefaultImg = 0
					WHERE ResourceId = '.$id.' AND ImageId <> '.$object->GetDBField('ImageId');
			$this->Conn->Query($sql);
			$object->SetDBField('Enabled', 1);
		}
	}

	function OnAfterItemCreate(&$event)
	{
		$event->CallSubEvent('OnBeforeItemUpdate');
		$object =& $event->getObject();
		$object->Update();
	}

	/**
	 * Deletes all selected items.
	 * Automatically recurse into sub-items using temp handler, and deletes sub-items
	 * by calling its Delete method if sub-item has AutoDelete set to true in its config file
	 *
	 * @param kEvent $event
	 */
	function OnMassDelete(&$event)
	{
		$event->status=erSUCCESS;

		$temp =& $this->Application->recallObject($event->getPrefixSpecial().'_TempHandler', 'kTempTablesHandler');

		$event->setEventParam('ids', $this->StoreSelectedIDs($event) );
		$this->customProcessing($event, 'before');
		$ids = $event->getEventParam('ids');

		$object =& $event->getObject();
		$sql = 'SELECT ImageId FROM '.$object->TableName.' WHERE DefaultImg=1';
		$primary = $this->Conn->GetOne($sql);
		if( $primary && ($key = array_search($primary, $ids)) )
		{
			$sql = 'SELECT ImageId FROM '.$object->TableName.' WHERE DefaultImg=0';
			$res = $this->Conn->Query($sql);
			if($res)
			{
				unset($ids[$key]);
			}
		}

		if($ids)
		{
			$temp->DeleteItems($event->Prefix, $event->Special, $ids);
		}
		$this->clearSelectedIDs($event);
	}

	/*function OnAfterItemLoad(&$event)
	{
		$object =& $event->getObject();

		if ( $object->GetDBField('ThumbPath') || $object->GetDBField('SameImages') )
		{
			// return local image or url
			$path = $object->GetDBField('LocalThumb') ? PROTOCOL.SERVER_NAME.BASE_PATH.$object->GetDBField('ThumbPath') : $object->GetDBField('ThumbUrl');
			if ( $object->GetDBField('LocalThumb') && !file_exists(FULL_PATH.$object->GetDBField('ThumbPath')) ) $path = '';
		}
		else { // if we need full which is not the same as thumb
			$path = $object->GetDBField('LocalImage') ? PROTOCOL.SERVER_NAME.BASE_PATH.$object->GetDBField('LocalPath') : $object->GetDBField('Url');
			if ( $object->GetDBField('LocalImage') && !file_exists(FULL_PATH.$object->GetDBField('LocalPath')) ) $path = '';
		}

		$object->SetDBField('ImageUrl', $path);
	}*/

	function SetCustomQuery(&$event)
	{
		parent::SetCustomQuery($event);

		$types=$event->getEventParam('types');
		$except_types=$event->getEventParam('except');
		$object =& $event->getObject();
		$type_clauses = Array();

		if( !$this->Application->IsAdmin() )
		{
			$object->addFilter('active', '%1$s.Enabled = 1');
		}

		if($product_id = $event->getEventParam('product_id'))
		{
			$object->removeFilter('parent_filter');
			$sql = 'SELECT ResourceId FROM '.$this->Application->getUnitOption('p', 'TableName').'
					WHERE ProductId = '.$product_id;
			$resource_id = (int) $this->Conn->GetOne($sql);
			$object->addFilter('product_images', '%1$s.ResourceId = '.$resource_id);
		}

		$type_clauses['additional']['include'] = '%1$s.DefaultImg != 1';
		$type_clauses['additional']['except'] = '%1$s.DefaultImg = 1';
		$type_clauses['additional']['having_filter'] = false;

		/********************************************/

		$includes_or_filter =& $this->Application->makeClass('kMultipleFilter');
		$includes_or_filter->setType(FLT_TYPE_OR);

		$excepts_and_filter =& $this->Application->makeClass('kMultipleFilter');
		$excepts_and_filter->setType(FLT_TYPE_AND);

		$includes_or_filter_h =& $this->Application->makeClass('kMultipleFilter');
		$includes_or_filter_h->setType(FLT_TYPE_OR);

		$excepts_and_filter_h =& $this->Application->makeClass('kMultipleFilter');
		$excepts_and_filter_h->setType(FLT_TYPE_AND);

		$except_types_array=explode(',', $types);

		if ($types){
			$types_array=explode(',', $types);
			for ($i=0; $i<sizeof($types_array); $i++){
				$type=trim($types_array[$i]);
				if (isset($type_clauses[$type])){
					if ($type_clauses[$type]['having_filter']){
						$includes_or_filter_h->removeFilter('filter_'.$type);
						$includes_or_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['include']);
					}else{
						$includes_or_filter->removeFilter('filter_'.$type);
						$includes_or_filter->addFilter('filter_'.$type, $type_clauses[$type]['include']);
					}
				}
			}
		}

		if ($except_types){
			$except_types_array=explode(',', $except_types);
			for ($i=0; $i<sizeof($except_types_array); $i++){
				$type=trim($except_types_array[$i]);
				if (isset($type_clauses[$type])){
					if ($type_clauses[$type]['having_filter']){
						$excepts_and_filter_h->removeFilter('filter_'.$type);
						$excepts_and_filter_h->addFilter('filter_'.$type, $type_clauses[$type]['except']);
					}else{
						$excepts_and_filter->removeFilter('filter_'.$type);
						$excepts_and_filter->addFilter('filter_'.$type, $type_clauses[$type]['except']);
					}
				}
			}
		}

		$object->addFilter('includes_filter', $includes_or_filter);
		$object->addFilter('excepts_filter', $excepts_and_filter);

		$object->addFilter('includes_filter_h', $includes_or_filter_h, HAVING_FILTER);
		$object->addFilter('excepts_filter_h', $excepts_and_filter_h, HAVING_FILTER);
	}
}

?>