<?
namespace Bitrix\Main\SidePanel;

use Bitrix\Main\ArgumentException;
use Bitrix\Main\Data\Cache;
use Bitrix\Main\Result;
use Bitrix\Main\Type\DateTime;

class Toolbar
{
	private EO_Toolbar $entity;
	private const CACHE_TTL = 3600;
	private const CACHE_PATH = '/bx/main/sidepanel/toolbar/';

	private function __construct(EO_Toolbar $entity)
	{
		$this->entity = $entity;
	}

	public function getId(): int
	{
		return $this->entity->getId();
	}

	public function getContext(): string
	{
		return $this->entity->getContext();
	}

	public function getUserId(): int
	{
		return $this->entity->getUserId();
	}

	public function isCollapsed(): bool
	{
		return $this->entity->getCollapsed();
	}

	public static function get(string $context, int $userId = 0): ?static
	{
		$toolbarUserId = $userId > 0 ? $userId : (int)\Bitrix\Main\Engine\CurrentUser::get()->getId();

		$cache = Cache::createInstance();
		$cacheId = static::getCacheId('toolbar', $context, $toolbarUserId);
		$cachePath = static::getCachePath($toolbarUserId);
		if ($cache->initCache(static::CACHE_TTL, $cacheId, $cachePath))
		{
			$vars = $cache->getVars();
			$entity = is_array($vars['toolbar']) ? EO_Toolbar::wakeUp($vars['toolbar']) : null;

			return $entity ? new static($entity) : null;
		}

		$entity = ToolbarTable::getList([
			'filter' => [
				'=CONTEXT' => $context,
				'=USER_ID' => $toolbarUserId,
			]
		])->fetchObject();

		$cache->startDataCache();
		$cache->endDataCache(['toolbar' => $entity ? $entity->collectValues() : null]);

		return $entity ? new static($entity) : null;
	}

	public static function getOrCreate(string $context, int $userId = 0): static
	{
		$toolbarEntity = static::get($context, $userId);
		if ($toolbarEntity === null)
		{
			$toolbarEntity = new EO_Toolbar();
			$toolbarEntity->setContext($context);
			$toolbarEntity->setUserId($userId > 0 ? $userId : (int)\Bitrix\Main\Engine\CurrentUser::get()->getId());
			$result = $toolbarEntity->save();

			if (!$result->isSuccess())
			{
				throw new \Bitrix\Main\SystemException($result->getErrors()[0]->getMessage(), $result->getErrors()[0]->getCode());
			}

			$toolbar = new static($toolbarEntity);
			$toolbar->clearToolbarCache();

			return $toolbar;
		}

		return $toolbarEntity;
	}

	public static function getCacheId(string $prefix, string $context, int $userId): string
	{
		return $prefix . '_' . $userId . '_' . md5($context);
	}

	public static function getCachePath(int $userId): string
	{
		return static::CACHE_PATH . $userId . '/';
	}

	public function createOrUpdateItem(array $options): Result
	{
		$result = new Result();
		$entityType = $options['entityType'] ?? '';
		$entityId = $options['entityId'] ?? '';

		$item = $this->getItem($entityType, $entityId);
		if ($item === null)
		{
			$item = new EO_ToolbarItem();
			$item->setToolbarId($this->getId());
			$item->setEntityType($entityType);
			$item->setEntityId($entityId);
			$item->setTitle($options['title'] ?? '');
			$item->setUrl($options['url'] ?? '');
			$saveResult = $item->save();
			if (!$saveResult->isSuccess())
			{
				$result->addErrors($saveResult->getErrors());
			}
			else
			{
				$result->setData(['item' => $item]);
			}
		}
		else
		{
			$item->setLastUseDate(new DateTime());
			$item->save();
			$result->setData(['item' => $item]);
		}

		$this->clearItemsCache();

		return $result;
	}

	public function getItem(string $entityType, string $entityId): ?EO_ToolbarItem
	{
		return ToolbarItemTable::getList([
			'filter' => [
				'=TOOLBAR_ID' => $this->getId(),
				'=ENTITY_TYPE' => $entityType,
				'=ENTITY_ID' => $entityId,
			]
		])->fetchObject();
	}

	public function getItems(): EO_ToolbarItem_Collection
	{
		$cache = Cache::createInstance();
		$cacheId = static::getCacheId('items', $this->getContext(), $this->getUserId());
		$cachePath = static::getCachePath($this->getUserId());
		if ($cache->initCache(static::CACHE_TTL, $cacheId, $cachePath))
		{
			$vars = $cache->getVars();

			return EO_ToolbarItem_Collection::wakeUp($vars['items']);
		}

		$itemCollection = ToolbarItemTable::getList([
			'filter' => [
				'=TOOLBAR_ID' => $this->getId(),
			],
			'order' => ['LAST_USE_DATE' => 'DESC'],
			'limit' => 100,
		])->fetchCollection();

		$items = [];
		foreach ($itemCollection as $item)
		{
			$items[] = $item->collectValues();
		}

		$cache->startDataCache();
		$cache->endDataCache(['items' => $items]);

		return $itemCollection;
	}

	public function removeItem(string $entityType, string $entityId)
	{
		$item = $this->getItem($entityType, $entityId);
		$item?->delete();

		$this->clearItemsCache();
	}

	public function removeAll()
	{
		ToolbarItemTable::deleteByFilter([
			'=TOOLBAR_ID' => $this->getId(),
		]);

		$this->clearItemsCache();
	}

	public function clearCache(string $prefix)
	{
		$cache = Cache::createInstance();
		$cacheId = static::getCacheId($prefix, $this->getContext(), $this->getUserId());
		$cachePath = static::getCachePath($this->getUserId());
		$cache->clean($cacheId, $cachePath);
	}

	public function clearToolbarCache(): void
	{
		$this->clearCache('toolbar');
	}

	public function clearItemsCache(): void
	{
		$this->clearCache('items');
	}

	public function collapse(): void
	{
		$this->clearToolbarCache();

		$this->entity->setCollapsed(true);
		$this->entity->save();
	}

	public function expand(): void
	{
		$this->clearToolbarCache();

		$this->entity->setCollapsed(false);
		$this->entity->save();
	}
}