<?php

namespace Bitrix\Disk;

use Bitrix\Disk\Internals\Error\Error;
use Bitrix\Disk\Internals\Error\ErrorCollection;
use Bitrix\Disk\Internals\StorageTable;
use Bitrix\Disk\Internals\VersionTable;
use Bitrix\Disk\Security\SecurityContext;
use Bitrix\Main\Application;
use Bitrix\Main\Entity\ExpressionField;
use Bitrix\Main\Entity\Query;
use Bitrix\Main\Entity\Result;
use Bitrix\Main\Event;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\SystemException;

Loc::loadMessages(__FILE__);

final class Storage extends Internals\Model
{
	const ERROR_NOT_EXISTS_ROOT_OBJECT = 'DISK_ST_22001';
	const ERROR_RENAME_ROOT_OBJECT     = 'DISK_ST_22002';
	const ERROR_ROOT_OBJECT_NOT_FOLDER = 'DISK_ST_22003';

	/** @var string */
	protected $name;
	/** @var string */
	protected $code;
	/** @var string */
	protected $xmlId;
	/** @var string */
	protected $moduleId;
	/** @var string */
	protected $entityType;
	/** @var string */
	protected $entityId;
	/** @var string */
	protected $entityMiscData;
	/** @var int */
	protected $rootObjectId;
	/** @var  Folder */
	protected $rootObject;
	/** @var bool */
	protected $useInternalRights;
	/** @var string */
	protected $siteId;
	/** @var SecurityContext[] */
	protected $cacheSecurityContext = array();
	/** @var ProxyType\Base */
	protected $proxyType;

	/**
	 * @var Storage[]
	 */
	protected static $loadedStorages = array();

	/**
	 * Gets the fully qualified name of table class which belongs to current model.
	 * @throws \Bitrix\Main\NotImplementedException
	 * @return string
	 */
	public static function getTableClassName()
	{
		return StorageTable::className();
	}

	/**
	 * @param SecurityContext $securityContext
	 * @return bool
	 */
	public function canAdd(SecurityContext $securityContext)
	{
		$folder = $this->getRootObject();

		return $folder ? $folder->canAdd($securityContext) : false;
	}

	/**
	 * @param SecurityContext $securityContext
	 * @return bool
	 */
	public function canRead(SecurityContext $securityContext)
	{
		$folder = $this->getRootObject();

		return $folder ? $folder->canRead($securityContext) : false;
	}

	/**
	 * @param SecurityContext $securityContext
	 * @return bool
	 */
	public function canChangeSettings(SecurityContext $securityContext)
	{
		return $securityContext->canChangeSettings($this->rootObjectId);
	}

	/**
	 * @param SecurityContext $securityContext
	 * @return bool
	 */
	public function canChangeRights(SecurityContext $securityContext)
	{
		return $securityContext->canChangeRights($this->rootObjectId);
	}

	/**
	 * @param SecurityContext $securityContext
	 * @return bool
	 */
	public function canCreateWorkflow(SecurityContext $securityContext)
	{
		return $securityContext->canCreateWorkflow($this->rootObjectId);
	}

	/**
	 * @return string
	 */
	public function getCode()
	{
		return $this->code;
	}

	/**
	 * @return string
	 */
	public function getXmlId()
	{
		return $this->xmlId;
	}

	/**
	 * @return string
	 */
	public function getEntityId()
	{
		return $this->entityId;
	}

	/**
	 * @return string
	 */
	public function getEntityType()
	{
		return $this->entityType;
	}

	/**
	 * @return string
	 */
	public function getEntityMiscData()
	{
		return $this->entityMiscData;
	}

	/**
	 * @return array
	 */
	protected function getUnserializedMiscData()
	{
		if(!empty($this->entityMiscData) && is_string($this->entityMiscData))
		{
			return unserialize($this->entityMiscData);
		}

		return array();
	}

	/**
	 * @param $entityMiscData
	 * @return null|string
	 */
	protected function getSerializedMiscData($entityMiscData)
	{
		if(!empty($entityMiscData))
		{
			return serialize($entityMiscData);
		}

		return null;
	}

	protected function getValueMiscData($name)
	{
		$miscData = $this->getUnserializedMiscData();
		if(is_array($miscData) && isset($miscData[$name]))
		{
			return $miscData[$name];
		}

		return null;
	}

	protected function setValueInMiscData($name, $value)
	{
		$entityMiscDataArray = $this->getUnserializedMiscData();
		$entityMiscDataArray[$name] = $value;
		$entityMiscData = $this->getSerializedMiscData($entityMiscDataArray);
		if(empty($entityMiscData))
		{
			return false;
		}

		return $this->update(array(
			'ENTITY_MISC_DATA' => $entityMiscData
		));
	}

	/**
	 * Enable BizProc
	 * @return bool
	 */
	public function enableBizProc()
	{
		if($this->getProxyType() instanceof ProxyType\User)
		{
			$this->errorCollection->addOne(new Error('Could not enable bizproc in user storage.'));

			return false;
		}

		return $this->setValueInMiscData('BIZPROC_ENABLED', true);
	}

	/**
	 * Disable BizProc
	 * @return bool
	 */
	public function disableBizProc()
	{
		return $this->setValueInMiscData('BIZPROC_ENABLED', false);
	}

	public function isEnabledBizProc()
	{
		return $this->getValueMiscData('BIZPROC_ENABLED');
	}

	/**
	 * Enable Transformation
	 * @return bool
	 */
	public function enableTransformation()
	{
		return $this->setValueInMiscData('TRANSFORMATION_ENABLED', true);
	}

	/**
	 * Disable Transformation
	 * @return bool
	 */
	public function disableTransformation()
	{
		return $this->setValueInMiscData('TRANSFORMATION_ENABLED', false);
	}

	/**
	 * @return bool
	 */
	public function isEnabledTransformation()
	{
		return $this->getValueMiscData('TRANSFORMATION_ENABLED') || $this->getValueMiscData('TRANSFORMATION_ENABLED') === null;
	}

	public function enableShowExtendedRights()
	{
		return $this->setValueInMiscData('SHOW_EXTENDED_RIGHTS', true);
	}

	public function disableShowExtendedRights()
	{
		return $this->setValueInMiscData('SHOW_EXTENDED_RIGHTS', false);
	}

	/**
	 * Returns size limit for the storage.
	 * Size in bytes.
	 *
	 * @return int|null
	 */
	public function getSizeLimit()
	{
		if(!Configuration::isEnabledStorageSizeRestriction())
		{
			return null;
		}

		return $this->getValueMiscData('SIZE_LIMIT');
	}

	/**
	 * Tells if size limit restriction is enabled for the storage.
	 *
	 * @return bool
	 */
	public function isEnabledSizeLimitRestriction()
	{
		return $this->getSizeLimit() !== null;
	}

	/**
	 * Sets max size storages in bytes. If set to null, then limit will be disabled.
	 *
	 * @param int $bytes Max size in bytes.
	 * @return bool
	 */
	public function setSizeLimit($bytes)
	{
		if(!Configuration::isEnabledStorageSizeRestriction())
		{
			return false;
		}

		if($bytes !== null)
		{
			$bytes = (int)$bytes;
		}

		return $this->setValueInMiscData('SIZE_LIMIT', $bytes);
	}

	/**
	 * Returns size of all files with versions from storage without symbolic links.
	 * Size in bytes.
	 *
	 * @return null|int
	 */
	private function getSize()
	{
		return $this->getRootObject()->countSizeOfVersions();
	}

	/**
	 * Tells if is possible to upload new content, which has size $fileSize, to the storage.
	 *
	 * @param int $fileSize Size in bytes.
	 * @return bool
	 * @internal
	 */
	public function isPossibleToUpload($fileSize)
	{
		if(!$this->isEnabledSizeLimitRestriction())
		{
			return true;
		}

		return $this->getSizeLimit() >= $this->getSize() + $fileSize;
	}

	/**
	 * @return bool|null
	 */
	public function isEnabledShowExtendedRights()
	{
		return $this->getValueMiscData('SHOW_EXTENDED_RIGHTS');
	}

	/**
	 * Changes base url of storage (ProxyType/Common)
	 * @param string $baseUrl Base url of storage.
	 * @return bool
	 */
	public function changeBaseUrl($baseUrl)
	{
		if(!$this->getProxyType() instanceof ProxyType\Common)
		{
			$this->errorCollection->addOne(new Error('Could not set base url to storage. Storage must have ProxyType\Common'));

			return false;
		}

		$success = $this->setValueInMiscData('BASE_URL', $baseUrl);
		if($success)
		{
			$this->rebuildProxyType();
		}

		return $success;
	}

	/**
	 * @return string
	 */
	public function getModuleId()
	{
		return $this->moduleId;
	}

	/**
	 * @return string
	 */
	public function getName()
	{
		return $this->name;
	}

	/**
	 * @return int
	 */
	public function getRootObjectId()
	{
		return $this->rootObjectId;
	}

	/**
	 * @return Folder|null
	 */
	public function getRootObject()
	{
		if(!$this->rootObjectId)
		{
			return null;
		}

		if(isset($this->rootObject) && $this->rootObjectId === $this->rootObject->getId())
		{
			return $this->rootObject;
		}
		//todo - Storage - knows about Folder ^( Nu i pust'
		$this->rootObject = Folder::loadById($this->rootObjectId);

		return $this->rootObject;
	}

	/**
	 * @return string
	 */
	public function getSiteId()
	{
		return $this->siteId;
	}

	/**
	 * @return bool
	 */
	public function getUseInternalRights()
	{
		return $this->isUseInternalRights();
	}

	/**
	 * @return bool
	 */
	public function isUseInternalRights()
	{
		return $this->useInternalRights;
	}

	/**
	 * @return Security\SecurityContext
	 */
	public static function getFakeSecurityContext()
	{
		return Driver::getInstance()->getFakeSecurityContext();
	}

	/**
	 * @param $user
	 * @return Security\SecurityContext
	 */
	public function getSecurityContext($user)
	{
		//todo Mistake? We decided, SecurityContext should parse USER self. But we would not create typical SecurityContext (cache. cache)
		$userId = null;
		if($user instanceof \CUser)
		{
			if($user->isAuthorized())
			{
				$userId = $user->getId();
			}
		}
		elseif((int)$user > 0)
		{
			$userId = (int)$user;
		}

		if($userId === null)
		{
			return $this->getProxyType()->getSecurityContextByUser($user);
		}
		if(!isset($this->cacheSecurityContext[$userId]))
		{
			$this->cacheSecurityContext[$userId] = $this->getProxyType()->getSecurityContextByUser($user);
		}

		return $this->cacheSecurityContext[$userId];
	}

	/**
	 * @return Security\SecurityContext
	 */
	public function getCurrentUserSecurityContext()
	{
		global $USER;

		return $this->getSecurityContext($USER);
	}

	/**
	 * Creates or loads folder for saving created files (ex. in cloud services)
	 * @return Folder|null
	 */
	public function getFolderForCreatedFiles()
	{
		return $this->getSpecificFolderByCode(SpecificFolder::CODE_FOR_CREATED_FILES);
	}

	/**
	 * Creates or loads folder for saving "saved" files
	 * @return Folder|null
	 */
	public function getFolderForSavedFiles()
	{
		return $this->getSpecificFolderByCode(SpecificFolder::CODE_FOR_SAVED_FILES);
	}

	/**
	 * Creates or loads folder for saving "uploaded" files
	 * @return Folder|null
	 */
	public function getFolderForUploadedFiles()
	{
		return $this->getSpecificFolderByCode(SpecificFolder::CODE_FOR_UPLOADED_FILES);
	}

	/**
	 * Creates or loads folder for saving "recorded" files
	 * @return Folder|null
	 */
	public function getFolderForRecordedFiles()
	{
		return $this->getSpecificFolderByCode(SpecificFolder::CODE_FOR_RECORDED_FILES);
	}

	/**
	 * Creates or loads specific folder by symbolic code.
	 * @param string $code Code of specific folder.
	 * @return Folder|null Specific folder.
	 */
	public function getSpecificFolderByCode($code)
	{
		return SpecificFolder::getFolder($this, $code);
	}

	/**
	 * @return ProxyType\Base
	 */
	public function getProxyType()
	{
		if($this->proxyType === null)
		{
			$this->proxyType = $this->initializeProxyType();
		}

		return $this->proxyType;
	}

	/**
	 * @return ProxyType\Base
	 */
	public function rebuildProxyType()
	{
		if($this->proxyType !== null)
		{
			unset($this->proxyType);
		}

		return $this->getProxyType();
	}

	/**
	 * @throws \Bitrix\Main\SystemException
	 * @throws \Bitrix\Main\LoaderException
	 * @return ProxyType\Base
	 */
	protected function initializeProxyType()
	{
		if(Driver::INTERNAL_MODULE_ID != $this->moduleId && !Loader::includeModule($this->moduleId))
		{
			throw new SystemException("Could not include module {$this->moduleId}");
		}

		/** @var ProxyType\Base $entityTypeClassName */
		$entityTypeClassName = $this->entityType;
		/** @var ProxyType\Base $proxyType */
		$proxyType = new $entityTypeClassName($this->entityId, $this, $this->entityMiscData);

		if(!$proxyType instanceof ProxyType\Base)
		{
			throw new SystemException('Invalid class for ProxyType. Must be instance of ProxyType\Base');
		}

		return $proxyType;
	}

	/**
	 * @param SecurityContext $securityContext
	 * @param array           $parameters
	 * @return array|BaseObject[]
	 */
	public function getChildren(SecurityContext $securityContext, array $parameters = array())
	{
		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			return array();
		}

		return $rootFolder->getChildren($securityContext, $parameters);
	}

	/**
	 * Returns first child by filter.
	 * @param array $filter Filter.
	 * @param array $with List of eager loading.
	 *
	 * @return Folder|File|BaseObject
	 */
	public function getChild(array $filter, array $with = array())
	{
		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			return null;
		}

		return $rootFolder->getChild($filter, $with);
	}

	/**
	 * @param SecurityContext $securityContext
	 * @param array           $parameters
	 * @param int             $orderDepthLevel
	 * @return array|\Object[]
	 */
	public function getDescendants(SecurityContext $securityContext, array $parameters = array(), $orderDepthLevel = SORT_ASC)
	{
		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			return array();
		}

		return $rootFolder->getDescendants($securityContext, $parameters, $orderDepthLevel);
	}

	/**
	 * Add new file to folder.
	 * @param array $fileArray structure like $_FILES
	 * @param array $data contains additional fields (CREATED_BY, NAME, etc).
	 * @param array $rights
	 * @param bool  $generateUniqueName
	 * @return File|null
	 */
	public function uploadFile(array $fileArray, array $data, array $rights = array(), $generateUniqueName = false)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return null;
		}
		$fileModel = $rootFolder->uploadFile($fileArray, $data, $rights, $generateUniqueName);
		if(!$fileModel)
		{
			$this->errorCollection->add($rootFolder->getErrors());

			return null;
		}

		return $fileModel;
	}

	/**
	 * Create in folder blank file (size 0 byte).
	 * @param array $data
	 * @param array $rights
	 * @param bool  $generateUniqueName
	 * @return File|null
	 * @throws \Bitrix\Main\ArgumentException
	 */
	public function addBlankFile(array $data, array $rights = array(), $generateUniqueName = false)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return null;
		}
		$fileModel = $rootFolder->addBlankFile($data, $rights, $generateUniqueName);
		if(!$fileModel)
		{
			$this->errorCollection->add($rootFolder->getErrors());

			return null;
		}

		return $fileModel;
	}

	/**
	 * @param array $data
	 * @param array $rights
	 * @param bool  $generateUniqueName
	 * @return File|null
	 */
	public function addFile(array $data, array $rights = array(), $generateUniqueName = false)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return null;
		}
		$fileModel = $rootFolder->addFile($data, $rights, $generateUniqueName);
		if(!$fileModel)
		{
			$this->errorCollection->add($rootFolder->getErrors());

			return null;
		}

		return $fileModel;
	}

	/**
	 * @param File $sourceFile
	 * @param array $data
	 * @param array $rights
	 * @param bool $generateUniqueName
	 * @return FileLink|null
	 */
	public function addFileLink(File $sourceFile, array $data, array $rights = array(), $generateUniqueName = false)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return null;
		}
		$fileLinkModel = $rootFolder->addFileLink($sourceFile, $data, $rights, $generateUniqueName);
		if(!$fileLinkModel)
		{
			$this->errorCollection->add($rootFolder->getErrors());

			return null;
		}

		return $fileLinkModel;
	}

	/**
	 * @param array $data
	 * @param array $rights
	 * @param bool  $generateUniqueName
	 * @return Folder|null
	 */
	public function addFolder(array $data, array $rights = array(), $generateUniqueName = false)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return null;
		}
		$folderModel = $rootFolder->addSubFolder($data, $rights, $generateUniqueName);
		if(!$folderModel)
		{
			$this->errorCollection->add($rootFolder->getErrors());

			return null;
		}

		return $folderModel;
	}

	/**
	 * @param Folder $sourceFolder
	 * @param array  $data
	 * @param array  $rights
	 * @param bool   $generateUniqueName
	 * @return FolderLink|null
	 */
	public function addFolderLink(Folder $sourceFolder, array $data, array $rights = array(), $generateUniqueName = false)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return null;
		}
		if(!$rootFolder instanceof Folder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_ROOT_OBJECT_NOT_FOLDER)));

			return null;
		}
		$folderLinkModel = $rootFolder->addSubFolderLink($sourceFolder, $data, $rights, $generateUniqueName);
		if(!$folderLinkModel)
		{
			$this->errorCollection->add($rootFolder->getErrors());

			return null;
		}

		return $folderLinkModel;
	}

	/*
	 * @inheritdoc
	 */
	public static function add(array $data, ErrorCollection $errorCollection)
	{
		if(!is_subclass_of($data['ENTITY_TYPE'], ProxyType\Base::className()))
		{
			throw new SystemException('Invalid class for ProxyType. Must be subclass of ProxyType\Base');
		}

		$rootObjectData = array();
		if(!empty($data['ROOT_OBJECT']))
		{
			$rootObjectData = $data['ROOT_OBJECT'];
			unset($data['ROOT_OBJECT']);
		}

		$storage = parent::add($data, $errorCollection);
		if(!$storage)
		{
			return null;
		}

		$folderData = array_merge(array_intersect_key($rootObjectData, array(
			'CREATE_TIME' => true,
			'UPDATE_TIME' => true,
			'XML_ID' => true,
		)), array(
			'NAME' => Ui\Text::correctFilename($storage->getName()),
			'STORAGE_ID' => $storage->getId(),
		));

		$folder = Folder::add($folderData, $errorCollection);

		if(!$folder)
		{
			return null;
		}

		$success = $storage->update(array('ROOT_OBJECT_ID' => $folder->getId()));
		if(!$success)
		{
			return null;
		}

		$storage->rootObject = $folder;

		$event = new Event(Driver::INTERNAL_MODULE_ID, "onAfterAddStorage", array($storage));
		$event->send();

		$storage->clearByTagCommonStorages();

		return $storage;
	}

	/**
	 * Changes name of storage.
	 * @param string $name New name for storage.
	 * @return bool
	 */
	public function rename($name)
	{
		$this->errorCollection->clear();

		$rootFolder = $this->getRootObject();
		if(!$rootFolder)
		{
			$this->errorCollection->add(array(new Error("Storage doesn't have root folder.", self::ERROR_NOT_EXISTS_ROOT_OBJECT)));

			return false;
		}
		if(!$rootFolder->rename(Ui\Text::correctFilename($name)))
		{
			$this->errorCollection->add(array(new Error("Could not rename name of root folder.", self::ERROR_RENAME_ROOT_OBJECT)));

			return false;
		}

		return $this->update(array('NAME' => $name));
	}

	public function delete($deletedBy)
	{
		if($this->getRootObject() && !$this->getRootObject()->deleteTree($deletedBy))
		{
			return false;
		}
		$status = parent::deleteInternal();
		if($status)
		{
			$event = new Event(Driver::INTERNAL_MODULE_ID, "onAfterDeleteStorage", array($this->getId(), $deletedBy));
			$event->send();

			$this->clearByTagCommonStorages();
		}

		return $status;
	}

	private function clearByTagCommonStorages()
	{
		if(defined('BX_COMP_MANAGED_CACHE') && $this->getProxyType() instanceof ProxyType\Common)
		{
			Application::getInstance()->getTaggedCache()->clearByTag('disk_common_storage');
		}
	}

	/**
	 * @inheritdoc
	 */
	public static function loadById($id, array $with = array())
	{
		if(self::isLoaded($id))
		{
			return self::$loadedStorages[$id];
		}
		self::$loadedStorages[$id] = parent::loadById($id, $with);

		return self::$loadedStorages[$id];
	}

	public static function isLoaded($id)
	{
		return isset(self::$loadedStorages[$id]);
	}

	/**
	 * Builds model from array.
	 * @param array $attributes Model attributes.
	 * @param array &$aliases Aliases.
	 * @internal
	 * @return static
	 */
	public static function buildFromArray(array $attributes, array &$aliases = null)
	{
		if(self::isLoaded($attributes['ID']))
		{
			return self::$loadedStorages[$attributes['ID']];
		}
		self::$loadedStorages[$attributes['ID']] = parent::buildFromArray($attributes, $aliases);

		return self::$loadedStorages[$attributes['ID']];
	}

	/**
	 * Builds model from \Bitrix\Main\Entity\Result.
	 * @param Result $result Query result.
	 * @return static
	 * @throws \Bitrix\Main\ArgumentException
	 */
	public static function buildFromResult(Result $result)
	{
		/** @var Storage $model */
		$model = parent::buildFromResult($result);
		self::$loadedStorages[$model->getId()] = $model;

		return $model;
	}

	/**
	 * Returns readable storages by SecurityContext.
	 * Be careful! The method works under FolderTable and $parameters belongs to FolderTable.
	 *
	 * @param SecurityContext $securityContext SecurityContext.
	 * @param array           $parameters Parameters to getList.
	 * @return Storage[]
	 */
	public static function getReadableList(SecurityContext $securityContext, array $parameters = array())
	{
		$filter = array(
			'=PARENT_ID' => null,
			'=STORAGE.MODULE_ID' => Driver::INTERNAL_MODULE_ID,
			'=RIGHTS_CHECK' => true,
		);
		if(empty($parameters['with']))
		{
			$parameters['with'] = array();
		}
		if(empty($parameters['filter']))
		{
			$parameters['filter'] = array();
		}
		$parameters['with'] = array_merge($parameters['with'], array('STORAGE'));
		$parameters['filter'] = array_merge($parameters['filter'], $filter);

		$parameters = Driver::getInstance()->getRightsManager()->addRightsCheck($securityContext, $parameters, array(
			'ID',
			'CREATED_BY'
		));

		/** @var Folder[] $items */
		$items = Folder::getModelList($parameters);
		$storages = array();
		foreach($items as $item)
		{
			$item->getStorage()->setAttributes(array('ROOT_OBJECT' => $item));
			$storages[] = $item->getStorage();
		}
		unset($item);

		return $storages;
	}

	/*
	 * @inheritdoc
	 */
	public static function getMapAttributes()
	{
		return array(
			'ID' => 'id',
			'NAME' => 'name',
			'CODE' => 'code',
			'XML_ID' => 'xmlId',
			'MODULE_ID' => 'moduleId',
			'ENTITY_TYPE' => 'entityType',
			'ENTITY_ID' => 'entityId',
			'ENTITY_MISC_DATA' => 'entityMiscData',
			'ROOT_OBJECT_ID' => 'rootObjectId',
			'ROOT_OBJECT' => 'rootObject',
			'USE_INTERNAL_RIGHTS' => 'useInternalRights',
			'SITE_ID' => 'siteId',
		);
	}

	/*
	 * @inheritdoc
	 */
	public static function getMapReferenceAttributes()
	{
		return array(
			'ROOT_OBJECT' => Folder::className(),
		);
	}

	protected static function prepareGetListParameters(array $parameters)
	{
		if(isset($parameters['filter']['ENTITY_TYPE']))
		{
			$parameters['filter']['=ENTITY_TYPE'] = $parameters['filter']['ENTITY_TYPE'];
			unset($parameters['filter']['ENTITY_TYPE']);
		}
		if(isset($parameters['filter']['ENTITY_ID']))
		{
			$parameters['filter']['=ENTITY_ID'] = $parameters['filter']['ENTITY_ID'];
			unset($parameters['filter']['ENTITY_ID']);
		}
		if(isset($parameters['filter']['CODE']))
		{
			$parameters['filter']['=CODE'] = $parameters['filter']['CODE'];
			unset($parameters['filter']['CODE']);
		}
		if(isset($parameters['filter']['XML_ID']))
		{
			$parameters['filter']['=XML_ID'] = $parameters['filter']['XML_ID'];
			unset($parameters['filter']['XML_ID']);
		}
		if(isset($parameters['filter']['MODULE_ID']))
		{
			$parameters['filter']['=MODULE_ID'] = $parameters['filter']['MODULE_ID'];
			unset($parameters['filter']['MODULE_ID']);
		}

		return parent::prepareGetListParameters($parameters);
	}
}