<?php
/**
 * Nested sets table tree implementation
 * 
 * Tree struct and data fields are kept in a single table
 * 
 * This class is for internal use only, not a part of public API.
 * It can be changed at any time without notification.
 * 
 * @access private
 */
namespace Bitrix\Sale\Location;

use Bitrix\Main;
use Bitrix\Main\DB;
use Bitrix\Main\Entity;
use Bitrix\Main\Localization\Loc;

use Bitrix\Sale\Location\Util\Assert;
use Bitrix\Sale\Location\DB\BlockInserter;
use Bitrix\Sale\Location\DB\Helper;

Loc::loadMessages(__FILE__);

abstract class Tree extends Entity\DataManager
{
	const SORT_FREE_BEFORE = 		1;
	const SORT_FREE_AFTER = 		2;
	const SORT_HOLE_SIZE = 			10;
	const SORT_HOLE_SIZE_HALF = 	5;

	const BLOCK_INSERT_MTU =	 	9999;

	const SPACE_ADD = 				1;
	const SPACE_REMOVE = 			2;

	public static function add(array $data)
	{
		return self::addExtended($data);
	}

	/**
	 * Available keys in $additional
	 * REBALANCE - if set to true, method will rebalance tree after insertion
	*/
	public static function addExtended(array $data, array $additional = array())
	{
		$rebalance = !isset($additional['REBALANCE']) || $additional['REBALANCE'] !== false;

		// determine LEFT_MARGIN, RIGHT_MARGIN and DEPTH_LEVEL
		if($data['PARENT_ID'] = intval($data['PARENT_ID']))
		{
			// if we have PARENT_ID set, just use it`s info
			$node = self::getNodeInfo($data['PARENT_ID']);

			$needResort = true;

			$data['LEFT_MARGIN'] = $node['RIGHT_MARGIN'];
			$data['RIGHT_MARGIN'] = $node['RIGHT_MARGIN'] + 1;
			$data['DEPTH_LEVEL'] = $node['DEPTH_LEVEL'] + 1;
			$data['PARENT_ID'] = $node['ID'];
		}
		else
		{
			// otherwise, we assume we have "virtual root node", that has LEFT_MARGIN == 0 and RIGHT_MARGIN == +INFINITY
			// it allows us to have actually a forest, not a tree

			$rm = self::getMaxMargin();
			$needResort = false;

			$data['LEFT_MARGIN'] = $rm > 1 ? $rm + 1 : 1;
			$data['RIGHT_MARGIN'] = $rm > 1 ? $rm + 2 : 2;

			$data['DEPTH_LEVEL'] = 1;
			$data['PARENT_ID'] = 0;
		}

		// process insert options: INSERT_AFTER and INSERT_BEFORE
		//self::processInsertInstruction($data);

		$addResult = parent::add($data);

		if($addResult->isSuccess() && $needResort && $rebalance)
			self::rebalance($node, $addResult->getId());

		return $addResult;
	}

	protected static function rebalance($node, $id)
	{
		self::manageFreeSpace($node['RIGHT_MARGIN'], 2, self::SPACE_ADD, $id);
	}

	// we must guarantee tree integrity in any situation, so make low-level checking to prevent walking around
	public static function checkFields(Entity\Result $result, $primary, array $data)
	{
		parent::checkFields($result, $primary, $data);

		if(!($result instanceof Entity\UpdateResult)) // work out only when update()
			return;

		foreach (static::getEntity()->getFields() as $field)
		{
			if($field->getName() == 'PARENT_ID' && strlen($data['PARENT_ID']))
			{
				//it cant be parent for itself
				if(intval($primary['ID']) == intval($data['PARENT_ID']))
				{
					$result->addError(new Entity\FieldError(
						$field,
						Loc::getMessage('SALE_LOCATION_TREE_ENTITY_CANNOT_MOVE_STRAIGHT_TO_ITSELF_EXCEPTION'),
						Entity\FieldError::INVALID_VALUE
					));
				}
				else
				{
					try
					{
						$node = self::getNodeInfo($primary['ID']);
						$nodeDst = self::getNodeInfo($data['PARENT_ID']);

						// new parent cannot belong to node subtree
						if($node['PARENT_ID'] != $nodeDst['ID'])
						{
							if($nodeDst['LEFT_MARGIN'] >= $node['LEFT_MARGIN'] && $nodeDst['RIGHT_MARGIN'] <= $node['RIGHT_MARGIN'])
							{
								$result->addError(new Entity\FieldError(
									$field,
									Loc::getMessage('SALE_LOCATION_TREE_ENTITY_CANNOT_MOVE_TO_ITSELF_EXCEPTION'),
									Entity\FieldError::INVALID_VALUE
								));
							}
						}

					}
					catch(Main\SystemException $e)
					{
					}
				}
			}
		}
	}

	public static function update($primary, array $data)
	{
		return self::update($primary, $data);
	}

	/**
	 * Available keys in $additional
	 * REBALANCE - if set to true, method will rebalance tree after insertion
	*/
	public static function updateExtended($primary, array $data, array $additional = array())
	{
		$rebalance = !isset($additional['REBALANCE']) || $additional['REBALANCE'] !== false;
		$node = self::getNodeInfo($primary);

		if(isset($data['PARENT_ID']) && !strlen($data['PARENT_ID']))
			$data['PARENT_ID'] = 0;

		$updResult = parent::update($primary, $data);

		// if we have 'PARENT_ID' key in $data, and it was changed, we should relocate subtree
		if($updResult->isSuccess() && isset($data['PARENT_ID']) && (intval($node['PARENT_ID']) != intval($data['PARENT_ID'])) && $rebalance)
			self::moveSubtree($primary, $data['PARENT_ID']);

		return $updResult;
	}

	public static function delete($primary)
	{
		static::deleteExtended($primary);
	}

	/**
	 * Available keys in $additional
	 * REBALANCE - if set to true, method will rebalance tree after insertion
	 * DELETE_SUBTREE - if set to true, only node will be deleted, and it`s subtree left unattached
	 * @param $primary
	 * @param array $additional
	 * @return Entity\DeleteResult
	 * @throws Main\SystemException
	 * @throws Tree\NodeIncorrectException
	 * @throws Tree\NodeNotFoundException
	 * @throws \Exception
	 */
	public static function deleteExtended($primary, array $additional = array()) // here also could be an implementation of CHILDREN_REATTACH
	{
		$rebalance = !isset($additional['REBALANCE']) || $additional['REBALANCE'] !== false;
		$deleteSubtree = !isset($additional['DELETE_SUBTREE']) || $additional['DELETE_SUBTREE'] !== false;

		if($deleteSubtree)
		{
			// it means we want to delete not only the following node, but the whole subtree that belongs to it
			// note that with this option set to Y tree structure integrity will be compromised
			
			$node = self::getNodeInfo($primary);
			if(intval($node['ID']))
			{
				static::checkNodeThrowException($node);
				// low-level
				Main\HttpApplication::getConnection()->query('delete from '.static::getTableName().' where LEFT_MARGIN > '.$node['LEFT_MARGIN'].' and RIGHT_MARGIN < '.$node['RIGHT_MARGIN']);

				// and also remove free spece, if needed
				if($rebalance)
				{
					self::manageFreeSpace(
						$node['RIGHT_MARGIN'], 
						($node['RIGHT_MARGIN'] - $node['LEFT_MARGIN']) + 1,
						self::SPACE_REMOVE
					);
				}
			}
			else
			{
				throw new Tree\NodeNotFoundException(false, array('INFO' => array('ID' => $primary)));
			}
		}

		return parent::delete($primary);
	}

	/**
	 * This method is for internal use only. It may be changed without any notification further, or even mystically disappear.
	 * 
	 * @access private
	 */
	public static function getSubtreeRangeSqlForNode($primary, $node = array())
	{
		$primary = Assert::expectIntegerPositive($primary, '$primary');

		if(empty($node))
		{
			$node = self::getNodeInfo($primary);
			if(!intval($node['ID']))
			{
				throw new Tree\NodeNotFoundException(false, array('INFO' => array('ID' => $primary)));
			}
		}

		static::checkNodeThrowException($node);

		$query = new Main\Entity\Query(static::getEntity());
		$query->setSelect(array('ID'));
		$query->setFilter(array(
			'>LEFT_MARGIN' => $node['LEFT_MARGIN'],
			'<RIGHT_MARGIN' => $node['RIGHT_MARGIN']
		));

		return $query->getQuery();
	}

	public static function checkNodeIsParentOfNodeById($primary, $childPrimary, $behaviour = array('CHECK_DIRECT' => false))
	{
		$primary = Assert::expectIntegerPositive($primary, '$primary');
		$childPrimary = Assert::expectIntegerPositive($childPrimary, '$childPrimary');

		return static::checkNodeIsParentOfNodeByCondition(array('=ID' => $primary), array('=ID' => $childPrimary), $behaviour);
	}

	protected static function checkNodeIsParentOfNodeByCondition($parentNodeFilter, $nodeFilter, $behaviour = array('CHECK_DIRECT' => false))
	{
		$parent = static::getList(array('filter' => $parentNodeFilter, 'limit' => 1))->fetch();
		$child = static::getList(array('filter' => $nodeFilter, 'limit' => 1))->fetch();

		if(!intval($parent['ID']))
				throw new Main\SystemException('Node being checked not found');
		if(!intval($child['ID']))
				throw new Main\SystemException('Child node not found');

		if($behaviour['CHECK_DIRECT'])
			return $parent['ID'] == $child['PARENT_ID'];

		return $parent['LEFT_MARGIN'] < $child['LEFT_MARGIN'] && $parent['RIGHT_MARGIN'] > $child['RIGHT_MARGIN'];
	}

	// recalc left_margin & right_margin in the whole tree
	// strongly recommened to invoke only inside a transaction
	public static function resort($dontCareEvents = false)
	{
		$edges = array();
		$nodes = array();

		$res = parent::getList(array('select' => array('ID', 'PARENT_ID', 'LEFT_MARGIN', 'RIGHT_MARGIN')));
		while($item = $res->Fetch())
		{
			$nodes[$item['ID']] = array(
				'LEFT_MARGIN' => $item['LEFT_MARGIN'],
				'RIGHT_MARGIN' => $item['RIGHT_MARGIN']
			);

			if(!intval($item['PARENT_ID']))
				$edges['ROOT'][] = $item['ID'];
			else
				$edges[$item['PARENT_ID']][] = $item['ID'];
		}

		// walk tree in-deep to obtain correct margins
		self::walkTreeInDeep('ROOT', $edges, $nodes, 0, 0, $dontCareEvents);

		// now massively insert new values into the database, using a temporal table
		$tabName = 'b_sale_location_temp_'.rand(99, 9999);
		$entityTableName = static::getTableName();

		$dbConnection = Main\HttpApplication::getConnection();
 		
		$dbConnection->query("create table ".$tabName." (
			ID ".Helper::getSqlForDataType('int').",
			LEFT_MARGIN ".Helper::getSqlForDataType('int').",
			RIGHT_MARGIN ".Helper::getSqlForDataType('int').",
			DEPTH_LEVEL ".Helper::getSqlForDataType('int')."
		)");
		
		$handle = new BlockInserter(array(
			'tableName' => $tabName,
			'exactFields' => array(
				'ID' => array('data_type' => 'integer'),
				'LEFT_MARGIN' => array('data_type' => 'integer'),
				'RIGHT_MARGIN' => array('data_type' => 'integer'),
				'DEPTH_LEVEL' => array('data_type' => 'integer'),
			),
			'parameters' => array(
				'mtu' => self::BLOCK_INSERT_MTU
			)
		));
		foreach($nodes as $id => $node)
		{
			$node['ID'] = $id;
			$handle->insert($node);
		}
		$handle->flush();

		// merge temp table with location table
		Helper::mergeTables($entityTableName, $tabName, array(
			'LEFT_MARGIN' => 'LEFT_MARGIN',
			'RIGHT_MARGIN' => 'RIGHT_MARGIN',
			'DEPTH_LEVEL' => 'DEPTH_LEVEL'
		), array('ID' => 'ID'));

		$dbConnection->query("drop table {$tabName}");
	}

	public static function getPathToNode($primary, $parameters, $behaviour = array('SHOW_LEAF' => true))
	{
		$primary = Assert::expectIntegerPositive($primary, '$primary');
		if(!is_array($behaviour))
			$behaviour = array();
		if(!isset($behaviour['SHOW_LEAF']))
			$behaviour['SHOW_LEAF'] = true;

		return self::getPathToNodeByCondition(array('ID' => $primary), $parameters, $behaviour);
	}

	/**
	 * Fetches a parent chain of a specified node
	 * 
	 * Available keys in $behaviour
	 * SHOW_LEAF : if set to true, return node itself in the result
	 * 
	 * @access private
	 */
	public static function getPathToNodeByCondition($filter, $parameters = array(), $behaviour = array('SHOW_LEAF' => true))
	{
		$filter = Assert::expectNotEmptyArray($filter, '$filter');

		if(!is_array($behaviour))
			$behaviour = array();
		if(!isset($behaviour['SHOW_LEAF']))
			$behaviour['SHOW_LEAF'] = true;

		if(empty($parameters))
			$parameters = array();

		// todo: try to do this job in a single query with join. Speed profit?

		$node = self::getList(array('filter' => $filter, 'limit' => 1))->fetch();
		if(!isset($node['ID']))
			throw new Main\SystemException(Loc::getMessage('SALE_LOCATION_TREE_ENTITY_NODE_NOT_FOUND_EXCEPTION'));

		$parameters['filter']['<=LEFT_MARGIN'] = intval($node['LEFT_MARGIN']);
		$parameters['filter']['>=RIGHT_MARGIN'] = intval($node['RIGHT_MARGIN']);

		if(!$behaviour['SHOW_LEAF'])
			$parameters['filter']['!=ID'] = $node['ID'];

		$parameters['order'] = array(
			'LEFT_MARGIN' => 'asc'
		);

		return self::getList($parameters);
	}

	public static function getPathToMultipleNodes($nodeInfo = array(), $parameters = array(), $behaviour = array('SHOW_LEAF' => true))
	{
		Assert::expectNotEmptyArray($nodeInfo, '$nodeInfo');

		if(!is_array($behaviour))
			$behaviour = array();
		if(!isset($behaviour['SHOW_LEAF']))
			$behaviour['SHOW_LEAF'] = true;

		if(empty($parameters))
			$parameters = array();

		if(is_array($parameters['select']))
			$originSelect = $parameters['select'];
		else
			$originSelect = array();

		if(is_array($parameters['order']))
			throw new Main\NotSupportedException('"Order" clause is not supported here');

		$parameters['order'] = array(
			'LEFT_MARGIN' => 'asc'
		);
		$parameters['select'][] = 'ID';
		$parameters['select'][] = 'PARENT_ID';

		$filter = array();
		foreach($nodeInfo as $node)
		{
			Assert::expectNotEmptyArray($node, '$nodeInfo[]');
			$node['ID'] = Assert::expectIntegerPositive($node['ID'], '$nodeInfo[][ID]');
			$node['LEFT_MARGIN'] = Assert::expectIntegerNonNegative($node['LEFT_MARGIN'], '$nodeInfo[][LEFT_MARGIN]');
			$node['RIGHT_MARGIN'] = Assert::expectIntegerPositive($node['RIGHT_MARGIN'], '$nodeInfo[][RIGHT_MARGIN]');

			$filter[] = array(
				'<=LEFT_MARGIN' => intval($node['LEFT_MARGIN']),
				'>=RIGHT_MARGIN' => intval($node['RIGHT_MARGIN'])
			);

			if(!$behaviour['SHOW_LEAF'])
				$filter['!=ID'] = $node['ID'];
		}
		$filter['LOGIC'] = 'OR';

		$parameters['filter'][] = $filter;

		$res = self::getList($parameters);

		$index = array();

		while($item = $res->Fetch())
		{
			$index[$item['ID']] = array(
				'NODE' => $item,
				'PARENT_ID' => $item['PARENT_ID']
			);
		}

		$depthLimit = count($index);

		$pathes = array();
		foreach($nodeInfo as $node)
		{
			$path = array();
			$id = $node['ID'];

			$i = 0;
			while($id)
			{
				if($i >= $depthLimit) // there is a cycle or smth like, anyway this is abnormal situation
					break;

				if(!isset($index[$id])) // non-existing element in the chain. strange, abort
					break;

				$resultNode = $index[$id]['NODE'];
				if(!in_array('PARENT_ID', $originSelect))
					unset($resultNode['PARENT_ID']);
				if(!in_array('ID', $originSelect))
					unset($resultNode['ID']);
				$path[$id] = $resultNode;

				$id = intval($index[$id]['PARENT_ID']);

				$i++;
			}

			$pathes[$node['ID']] = array(
				'ID' => $node['ID'],
				'PATH' =>  $path
			);
		}

		return new DB\ArrayResult($pathes);
	}

	public static function getDeepestCommonParent($nodeInfo = array(), $parameters = array())
	{
		Assert::expectNotEmptyArray($nodeInfo, '$nodeInfo');

		$filter = array();

		$min = false;
		$max = false; 
		foreach($nodeInfo as $node)
		{
			Assert::expectNotEmptyArray($node, '$nodeInfo[]');
			$node['LEFT_MARGIN'] = Assert::expectIntegerNonNegative($node['LEFT_MARGIN'], '$nodeInfo[][LEFT_MARGIN]');
			$node['RIGHT_MARGIN'] = Assert::expectIntegerPositive($node['RIGHT_MARGIN'], '$nodeInfo[][RIGHT_MARGIN]');

			if($min === false || $node['LEFT_MARGIN'] < $min)
				$min = $node['LEFT_MARGIN'];

			if($max === false || $node['RIGHT_MARGIN'] > $max)
				$max = $node['RIGHT_MARGIN'];
		}

		if(empty($parameters))
			$parameters = array();

		if(!is_array($parameters['order']))
			$parameters['order'] = array();

		$parameters['filter']['<LEFT_MARGIN'] = $min;
		$parameters['filter']['>RIGHT_MARGIN'] = $max;

		$parameters['order'] = array_merge(array(
			'LEFT_MARGIN' => 'desc',
			'RIGHT_MARGIN' => 'asc'
		), $parameters['order']);

		$parameters['limit'] = 1;

		return static::getList($parameters);
	}

	public static function getChildren($primary, $parameters = array())
	{
		if(empty($parameters))
			$parameters = array();

		if($primary = intval($primary)) // here $primary might be unset: in this case we take the first level of a tree
		{
			$node = self::getNodeInfo($primary);

			$parameters['filter']['>=LEFT_MARGIN'] = intval($node['LEFT_MARGIN']);
			$parameters['filter']['<=RIGHT_MARGIN'] = intval($node['RIGHT_MARGIN']);
			$parameters['filter']['!=ID'] = $primary;
			$parameters['filter']['DEPTH_LEVEL'] = intval($node['DEPTH_LEVEL']) + 1;
		}
		else
			$parameters['filter']['DEPTH_LEVEL'] = 1;

		return self::getList($parameters);
	}

	/**
	* Fetches a set of items which form sub-tree of a given node
	*/
	public static function getSubTree($primary, $parameters = array())
	{
		if(empty($parameters))
			$parameters = array();

		if($primary = intval($primary)) // here $primary might be unset: if so, get the whole tree
		{
			$node = self::getNodeInfo($primary);

			$parameters['filter']['>=LEFT_MARGIN'] = intval($node['LEFT_MARGIN']);
			$parameters['filter']['<=RIGHT_MARGIN'] = intval($node['RIGHT_MARGIN']);
		}

		if(!is_array($parameters['order']) || empty($parameters['order']))
			$parameters['order'] = array('LEFT_MARGIN' => 'asc');

		return self::getList($parameters);
	}

	/**
	* Fetches a chain of parents with their subtrees expanded
	* 
	* Available keys in $behaviour
	* SHOW_CHILDREN : if set to true, do return direct ancestors of $primary in the result
	* START_FROM
	*/
	public static function getParentTree($primary, $parameters = array(), $behaviour = array('SHOW_CHILDREN' => true, 'START_FROM' => false))
	{
		$primary = Assert::expectIntegerPositive($primary, '$primary');

		if(!is_array($behaviour))
			$behaviour = array();
		if(!isset($behaviour['SHOW_CHILDREN']))
			$behaviour['SHOW_CHILDREN'] = true;
		if(!isset($behaviour['START_FROM']))
			$behaviour['START_FROM'] = false;

		if(empty($parameters))
			$parameters = array();

		$startFrom = intval($behaviour['START_FROM']);
		$showChildren = $behaviour['SHOW_CHILDREN'];

		if(!$startFrom)
		{
			$conditions[] = array(
				'DEPTH_LEVEL' => 1
			);
		}

		// todo: combine (1) and (2) in one query, check perfomance change

		// (1)
		$res = self::getPathToNode($primary, array(
			'select' => array('ID')
		));

		$started = !$startFrom;
		while($item = $res->Fetch())
		{
			if($item['ID'] == $startFrom)
				$started = true;

			if(!$started)
				continue;

			if(!$showChildren && $item['ID'] == $primary)
				continue;

			$conditions[] = array(
				'PARENT_ID' => $item['ID']
			);
		}

		$conditions['LOGIC'] = 'OR';

		$parameters['filter'][] = $conditions;

		if(!is_array($parameters['order']) || empty($parameters['order']))
			$parameters['order'] = array('LEFT_MARGIN' => 'asc');

		// (2)
		return self::getList($parameters);
	}

	/////////////////////////
	/// PROTECTED
	/////////////////////////

	/**
	 * Do not call directly, only inside update()
	 * 
	 * @param int $primary Subtree`s root id to move
	 * @param int $primaryDst Item id to attach our subtree to
	 *
	 */
	protected final static function moveSubtree($primary, $primaryDst)
	{
		$node = self::getNodeInfo($primary);

		if(!($primaryDst = intval($primaryDst))) // move to root
		{
			$rm = self::getMaxMargin();

			$lDst = $rm + 1;
			$rDst = $rm + 2;
			$dDst = 0;
		}
		else
		{
			$nodeDst = self::getNodeInfo($primaryDst);

			$lDst = intval($nodeDst['LEFT_MARGIN']);
			$rDst = intval($nodeDst['RIGHT_MARGIN']);
			$dDst = intval($nodeDst['DEPTH_LEVEL']);
		}

		$lSub = intval($node['LEFT_MARGIN']);
		$rSub = intval($node['RIGHT_MARGIN']);
		$dSub = intval($node['DEPTH_LEVEL']);

		$tableName = static::getTableName();

		$sql = 	"update ".$tableName." set 

				DEPTH_LEVEL	= 
					case 
						when 
							LEFT_MARGIN between {$lSub} and {$rSub} 
						then 
							DEPTH_LEVEL + ".($dDst - $dSub + 1)."

						else 
							DEPTH_LEVEL 

					end, ";

		// DO NOT switch the column update order in the code below, it WILL NOT work correctly

		// subtree moves upwards along it`s path
		if ($lDst < $lSub && $rDst > $rSub && $dDst < ($dSub - 1))
		{
			$sql .= "

					RIGHT_MARGIN = 
						case 
							when
								RIGHT_MARGIN between ".($rSub + 1)." and ".($rDst - 1)."
							then
								RIGHT_MARGIN - ".($rSub - $lSub + 1)."

							when 
								LEFT_MARGIN between ".$lSub." and ".$rSub."
							then 
								RIGHT_MARGIN + ".((($rDst - $rSub - $dSub + $dDst) / 2) * 2 + $dSub - $dDst - 1)."

							else RIGHT_MARGIN
						end,

					LEFT_MARGIN =
						case 
							when 
								LEFT_MARGIN between ".($rSub + 1)." and ".($rDst - 1)." 
							then 
								LEFT_MARGIN - ".($rSub - $lSub + 1)." 

							when 
								LEFT_MARGIN between ".$lSub." and ".$rSub."
							then 
								LEFT_MARGIN + ".((($rDst - $rSub - $dSub + $dDst) / 2) * 2 + $dSub - $dDst - 1)."

							else 
								LEFT_MARGIN 
						end

					where LEFT_MARGIN between ".($lDst + 1)." and ".($rDst - 1);
		}
		elseif($lDst < $lSub) // subtree moves to the left of it`s path (to the left branch)
		{
			$sql .= "

					LEFT_MARGIN	= 
						case 
							when 
								LEFT_MARGIN between ".$rDst." and ".($lSub-1)."
							then 
								LEFT_MARGIN + ".($rSub - $lSub + 1)."

							when 
								LEFT_MARGIN between ".$lSub." and ".$rSub." 
							then 
								LEFT_MARGIN - ".($lSub - $rDst)."

							else 
								LEFT_MARGIN 
						end, 

					RIGHT_MARGIN = 
						case 
							when 
								RIGHT_MARGIN between ".$rDst." and ".$lSub." 
							then
								RIGHT_MARGIN + ".($rSub - $lSub + 1)."

							when
								RIGHT_MARGIN between ".$lSub." and ".$rSub."
							then
								RIGHT_MARGIN - ".($lSub - $rDst)." 

							else 
								RIGHT_MARGIN
						end 

					where LEFT_MARGIN between ".$lDst." and ".$rSub." or RIGHT_MARGIN between ".$lDst." and ".$rSub;
		}
		else // subtree moves to the right of it`s path (to the right branch)
		{
			$sql .= "

					LEFT_MARGIN	=
						case 
							when 
								LEFT_MARGIN between ".$rSub." and ".$rDst." 
							then 
								LEFT_MARGIN - ".($rSub - $lSub + 1)."

							when 
								LEFT_MARGIN between ".$lSub." and ".$rSub."
							then 
								LEFT_MARGIN + ".($rDst - $rSub - 1)." 
							
							else 
								LEFT_MARGIN 
						end, 

					RIGHT_MARGIN = 
						case 
							when 
								RIGHT_MARGIN between ".($rSub + 1)." and ".($rDst - 1)."
							then RIGHT_MARGIN - ".($rSub - $lSub + 1)."

							when 
								RIGHT_MARGIN between ".$lSub." and ".$rSub."
							then RIGHT_MARGIN + ".($rDst - $rSub - 1)." 

							else RIGHT_MARGIN
					end 

				where LEFT_MARGIN between ".$lSub." and ".$rDst." or RIGHT_MARGIN between ".$lSub." and ".$rDst;
		}

		Main\HttpApplication::getConnection()->query($sql);
	}

	protected final static function processInsertInstruction(&$data)
	{
		$data['INSERT_AFTER'] = intval($data['INSERT_AFTER']);
		$data['INSERT_BEFORE'] = intval($data['INSERT_BEFORE']);

		if($data['INSERT_AFTER'] || $data['INSERT_BEFORE'])
		{
			$neighbourId = $data['INSERT_BEFORE'] ? $data['INSERT_BEFORE'] : $data['INSERT_AFTER'];

			$sort = self::makeSortSpace(
				$neighbourId, 
				($data['INSERT_BEFORE'] ? self::SORT_FREE_BEFORE : self::SORT_FREE_AFTER),
				$data['PARENT_ID'], 
				isset($data['SORT']) ? $data['SORT'] : false
			);

			unset($data['INSERT_AFTER']);
			unset($data['INSERT_BEFORE']);

			if($sort != false)
				$data['SORT'] = $sort;
		}
	}

	protected final static function manageFreeSpace($right, $length = 2, $op = self::SPACE_ADD, $exceptId = false)
	{
		if($length <= 1 || $right <= 0)
			return;

		// LEFT_MARGIN & RIGHT_MARGIN are system fields, user should not know about them ever, so no orm events needed to be fired on update of them

		$sign = $op == self::SPACE_ADD ? '+' : '-';

		$tableName = static::getTableName();
		$exceptId = intval($exceptId);

		$query = "update {$tableName} set 
			LEFT_MARGIN = case when LEFT_MARGIN > {$right} then LEFT_MARGIN {$sign} {$length} else LEFT_MARGIN end,
			RIGHT_MARGIN = case when RIGHT_MARGIN >= {$right} then RIGHT_MARGIN {$sign} {$length} else RIGHT_MARGIN end 
			where RIGHT_MARGIN >= {$right}".($exceptId ? " and ID <> {$exceptId}" : "");
			
		$shifted = Main\HttpApplication::getConnection()->query($query);

		if(!$shifted)
			throw new Main\SystemException('Query failed: managing free space in a tree', 0, __FILE__, __LINE__); // SaleTreeSystemException
	}

	// act in assumption sort field is always defined for each node and also it`s value positive signed
	protected final static function makeSortSpace($primary, $direction = self::SORT_FREE_AFTER, $primaryParent, $knownSort = false)
	{
		$primary = Assert::expectIntegerPositive($primary, '$primary');
		$primaryParent = Assert::expectIntegerPositive($primary, '$primaryParent');

		$nodeFound = false;
		$sorts = array();

		$nextNodeId = false;
		$prevNodeId = false;

		$prev = false;
		$res = self::getChildren($primaryParent, array('select' => array('ID', 'SORT', 'CODE'), 'order' => array('SORT' => 'asc')));
		while($item = $res->Fetch())
		{
			if($nodeFound && !$nextNodeId)
				$nextNodeId = $item['ID'];

			if($item['ID'] == $primary)
			{
				$nodeFound = true;
				$prevNodeId = $prev;
			}

			$sorts[$item['ID']] = $item['SORT'];

			$prev = $item['ID'];
		}

		// no node exists or they are not neighbours
		if(!$nodeFound) 
			return false;

		// add extra items
		if(!$prevNodeId)
		{
			$sorts = array('FH' => 0) + $sorts;
			$prevNodeId = 'FH';
		}
		if(!$nextNodeId)
		{
			$sorts['FT'] = PHP_INT_MAX;
			$nextNodeId = 'FT';
		}

		// handle some obvious situations
		if($direction == self::SORT_FREE_BEFORE)
		{
			if($knownSort && ($knownSort < $sorts[$prevNodeId]) && ($knownSort < $sorts[$primary]))
				return $knownSort; // its okay, current sort fits

			// inequation above is not true, but there is free space between nodes
			if($sorts[$primary] - $sorts[$prevNodeId] > 1)
				return $sorts[$prevNodeId] + 1;

			$startShift = $primary;
			$return = $sorts[$prevNodeId] + self::SORT_HOLE_SIZE_HALF;
		}
		else
		{
			if($knownSort && ($knownSort < $sorts[$primary]) && ($knownSort < $sorts[$nextNodeId]))
				return $knownSort; // its okay, current sort fits

			// inequation above is not true, but there is free space between nodes
			if($sorts[$nextNodeId] - $sorts[$primary] > 1)
				return $sorts[$primary] + 1;

			$startShift = $nextNodeId;
			$return = $sorts[$primary] + self::SORT_HOLE_SIZE_HALF;
		}

		// .. or else we forced to make a hole
		$begin = false;
		$shift = $sorts[$startShift] + self::SORT_HOLE_SIZE;

		foreach($sorts as $id => $sVal)
		{
			if($id == $startShift)
				$begin = true;

			if($begin && $sVal <= $shift)
			{
				$shift = $sVal + self::SORT_HOLE_SIZE;
				parent::update($id, array('SORT' => $shift));
			}
		}

		return $return;
	}

	// in-deep tree walk
	protected final static function walkTreeInDeep($primary, $edges, &$nodes, $margin, $depth = 0, $dontCareEvents = false)
	{
		$lMargin = $margin;

		if(empty($edges[$primary]))
			$rMargin = $margin + 1;
		else
		{
			$offset = $margin + 1;
			foreach($edges[$primary] as $sNode)
				$offset = self::walkTreeInDeep($sNode, $edges, $nodes, $offset, $depth+1, $dontCareEvents);

			$rMargin = $offset;
		}

		// update !
		if($primary != 'ROOT')
		{
			$nodes[$primary]['LEFT_MARGIN'] = intval($lMargin);
			$nodes[$primary]['RIGHT_MARGIN'] = intval($rMargin);
			$nodes[$primary]['DEPTH_LEVEL'] = $depth;
		}

		return $rMargin + 1;
	}

	protected static function applyRestrictions(&$data)
	{
		unset($data['LEFT_MARGIN']);
		unset($data['RIGHT_MARGIN']);
		unset($data['DEPTH_LEVEL']);
	}

	protected static function getNodeInfo($primary)
	{
		$primary = Assert::expectIntegerPositive($primary, '$primary');

		$node = self::getById($primary)->fetch();
		if(!isset($node['ID']))
		{
			throw new Main\SystemException(Loc::getMessage('SALE_LOCATION_TREE_ENTITY_NODE_NOT_FOUND_EXCEPTION'));
		}

		return $node;
	}

	protected static function getMaxMargin()
	{
		$tableName = static::getTableName();

		// todo: write it in orm way
		$res = Main\HttpApplication::getConnection()->query("select A.RIGHT_MARGIN from {$tableName} A order by A.RIGHT_MARGIN desc")->fetch();
		return intval($res['RIGHT_MARGIN']);
	}

	public static function mergeRelationsFromTemporalTable($temporalTabName, $additinalFlds = array(), $fldMap = array())
	{
		$dbConnection = Main\HttpApplication::getConnection();
		$dbHelper = $dbConnection->getSqlHelper();

		$temporalTabName = Assert::expectStringNotNull($temporalTabName, false, 'Name of temporal table must be a non-zero length string');
		$temporalTabName = $dbHelper->forSql($temporalTabName);

		$entityTableName = static::getTableName();

		if(!is_array($additinalFlds))
			$additinalFlds = array();

		$additinalFlds = array_merge(array('LEFT_MARGIN', 'RIGHT_MARGIN', 'DEPTH_LEVEL'), $additinalFlds);

		$fldReplace = array();
		foreach($additinalFlds as &$fld)
		{
			$fld = $dbHelper->forSql($fld);
			$fldReplace[$fld] = is_array($fldMap) && isset($fldMap[$fld]) ? $dbHelper->forSql($fldMap[$fld]) : $fld;
		}

		$idReplace = is_array($fldMap) && isset($fldMap['ID']) ? $dbHelper->forSql($fldMap['ID']) : 'ID';

		if($dbConnection->getType() == 'mysql')
		{
			$sql = 'update '.$entityTableName.', '.$temporalTabName.' set ';
			$additFldCnt = count($additinalFlds);

			for($i = 0; $i < $additFldCnt; $i++)
			{
				$sql .= $entityTableName.'.'.$additinalFlds[$i].' = '.$temporalTabName.'.'.$fldReplace[$additinalFlds[$i]].($i == count($additinalFlds) - 1 ? '' : ', ');
			}

			$sql .= ' where '.$entityTableName.'.ID = '.$temporalTabName.'.'.$idReplace;
		}
		elseif($dbConnection->getType() == 'mssql')
		{
			$sql = 'update '.$entityTableName.' set ';
			$additFldCnt = count($additinalFlds);

			for($i = 0; $i < $additFldCnt; $i++)
			{
				$sql .= $additinalFlds[$i].' = '.$temporalTabName.'.'.$fldReplace[$additinalFlds[$i]].($i == count($additinalFlds) - 1 ? '' : ', ');
			}

			$sql .= ' from '.$entityTableName.' join '.$temporalTabName.' on '.$entityTableName.'.ID = '.$temporalTabName.'.'.$idReplace;
		}
		elseif($dbConnection->getType() == 'oracle')
		{
			// update tab1 set (aa,bb) = (select aa,bb from tab2 where tab2.id = tab1.id)

			$sql = 'update '.$entityTableName.' set ('.
				implode(', ', $additinalFlds).
			') = (select '.
				implode(', ', $fldReplace).
			' from '.$temporalTabName.' where '.$entityTableName.'.ID = '.$temporalTabName.'.'.$idReplace.')';
		}

		$dbConnection->query($sql);
	}

	public static function getCountByFilter($filter = array())
	{
		$params = array(
			'runtime' => array(
				'CNT' => array(
					'data_type' => 'integer',
					'expression' => array('COUNT(*)')
				)
			),
			'select' => array('CNT')
		);

		if(is_array($filter))
			$params['filter'] = $filter;

		$res = static::getList($params)->fetch();

		return intval($res['CNT']);
	}

	protected static function checkNodeThrowException($node)
	{
		// left margin MAY be equal to zero, right margin MAY NOT
		if(!is_numeric($node['LEFT_MARGIN']) || (int) $node['LEFT_MARGIN'] < 0 || !intval($node['RIGHT_MARGIN']) || !intval($node['ID']))
		{
			throw new Tree\NodeIncorrectException(
				false,
				array(
					'INFO' => array(
						'ID' => $node['ID'],
						'CODE' => $node['CODE'],
						'LEFT_MARGIN' => $node['LEFT_MARGIN'],
						'RIGHT_MARGIN' => $node['RIGHT_MARGIN']
			)));
		}
	}

	// deprecated
	protected static function checkNodeIsParentOfNodeByFilters($parentNodeFilter, $nodeFilter, $behaviour = array('CHECK_DIRECT' => false))
	{
		return static::checkNodeIsParentOfNodeByCondition($parentNodeFilter, $nodeFilter, $behaviour);
	}
}