<?php

namespace Yandex\Market\Component\Data;

use Bitrix\Main;
use Yandex\Market;

class GridList extends Market\Component\Base\GridList
{
	public function getDefaultSort()
	{
		$param = $this->getComponentParam('DEFAULT_SORT');

		if (!empty($param) && is_array($param))
		{
			$result = $param;
		}
		else
		{
			$result = [];
		}

		return $result;
	}

	public function getDefaultFilter()
	{
		$param = $this->getComponentParam('DEFAULT_FILTER');

		if (!empty($param) && is_array($param))
		{
			$result = $param;
		}
		else
		{
			$result = [];
		}

		return $result;
	}

	public function getFields(array $select = [])
	{
		$dataClass = $this->getDataClass();
		$fields = $dataClass::getMapDescription();

		if (empty($select))
		{
			$result = $fields;
		}
		else
		{
			$result = [];

			foreach ($select as $fieldName)
			{
				if (isset($fields[$fieldName]))
				{
					$result[$fieldName] = $fields[$fieldName];
				}
			}
		}

		$this->extendFieldsBySortable($result);

		return $result;
	}

	protected function extendFieldsBySortable(&$fields)
	{
		$referenceFields = $this->getReferenceFields();

		foreach ($fields as $fieldName => &$field)
		{
			$field['SORTABLE'] = !isset($referenceFields[$fieldName]);
		}
	}

	public function load(array $queryParameters = [])
	{
		$dataClass = $this->getDataClass();
		$result = [];

		if ($dataClass)
		{
			$index = 0;
			$mapPrimaryToIndex = [];
			$externalSelect = null;
			$primary = $this->getComponentParam('PRIMARY');
			$primaryList = [];
			$isMultiplePrimary = (count($primary) > 1);

			if (isset($queryParameters['filter']))
			{
				$queryParameters['filter'] = $this->normalizeQueryFilter((array)$queryParameters['filter']);
			}

			if (isset($queryParameters['order']))
			{
				$queryParameters['order'] = $this->normalizeQueryOrder((array)$queryParameters['order']);
			}

			if (isset($queryParameters['select']))
			{
				list($scalarSelect, $externalSelect) = $this->normalizeQuerySelect((array)$queryParameters['select']);

				$queryParameters['select'] = $scalarSelect;
			}

			$hasExternalSelect = !empty($externalSelect);

			// row data

			$query = $dataClass::getList($queryParameters);

			while ($item = $query->fetch())
			{
				$result[] = $this->normalizeQueryResult($item);

				if ($hasExternalSelect)
				{
					$itemPrimary = $isMultiplePrimary ? [] : null;

					foreach ($primary as $field)
					{
						if ($isMultiplePrimary)
						{
							$itemPrimary[$field] = $item[$field];
						}
						else
						{
							$itemPrimary = $item[$field];
						}
					}

					$primaryList[] = $itemPrimary;

					if ($isMultiplePrimary)
					{
						$mapPrimaryToIndex[implode(':', $itemPrimary)] = $index;
					}
					else
					{
						$mapPrimaryToIndex[$itemPrimary] = $index;
					}
				}

				$index++;
			}

			// external data

			if ($hasExternalSelect && !empty($primaryList))
			{
				$externalDataList = $dataClass::loadExternalReference($primaryList, $externalSelect);

				foreach ($externalDataList as $id => $externalData)
				{
					if (isset($mapPrimaryToIndex[$id]))
					{
						$index = $mapPrimaryToIndex[$id];

						$result[$index] += $externalData;
					}
				}
			}
		}

		return $result;
	}

	public function loadTotalCount(array $queryParameters = [])
	{
		$result = null;
		$dataClass = $this->getDataClass();

		if (isset($queryParameters['limit'])) { unset($queryParameters['limit']); }
		if (isset($queryParameters['offset'])) { unset($queryParameters['offset']); }
		if (isset($queryParameters['order'])) { unset($queryParameters['order']); }

		if (isset($queryParameters['filter']))
		{
			$queryParameters['filter'] = $this->normalizeQueryFilter((array)$queryParameters['filter']);
		}

		$queryParameters['select'] = [ 'CNT' ];
		$queryParameters['runtime'] = [
			new Main\Entity\ExpressionField('CNT', 'COUNT(1)')
		];

		$query = $dataClass::getList($queryParameters);

		if ($row = $query->fetch())
		{
			$result = (int)$row['CNT'];
		}

		return $result;
	}

	public function deleteItem($id)
	{
		$dataClass = $this->getDataClass();

		$deleteResult = $dataClass::delete($id);

		Market\Result\Facade::handleException($deleteResult);
	}

	public function processAjaxAction($action, $data)
	{
		if ($action === 'delete')
		{
			return $this->processDeleteAction($data);
		}

		parent::processAjaxAction($action, $data);
		return null;
	}

	protected function processDeleteAction($data)
	{
		if ($this->isAllowBatch())
		{
			$selectedIds = [];
			$dataClass = $this->getDataClass();
			$parameters = [
				'filter' => $this->getActionSelectedFilter($data),
			];

			$dataClass::deleteBatch($parameters);
		}
		else
		{
			$selectedIds = $this->getActionSelectedIds($data);

			foreach ($selectedIds as $id)
			{
				$this->deleteItem($id);
			}
		}

		return $selectedIds;
	}

	protected function getActionSelectedFilter($data)
	{
		if (!empty($data['IS_ALL']))
		{
			$result = !empty($data['FILTER'])
				? $this->normalizeQueryFilter($data['FILTER'])
				: [];
		}
		else
		{
			$requestedIds = !empty($data['ID']) ? $data['ID'] : -1;
			$result = [ '=ID' => $requestedIds ];
		}

		return $result;
	}

	protected function getActionSelectedIds($data)
	{
		if (!empty($data['IS_ALL']))
		{
			$result = [];
			$parameters = [
				'select' => [ 'ID' ]
			];

			if (!empty($data['FILTER']))
			{
				$parameters['filter'] = $this->normalizeQueryFilter((array)$data['FILTER']);
			}

			$items = $this->load($parameters);

			foreach ($items as $item)
			{
				$result[] = $item['ID'];
			}
		}
		else
		{
			$result = (array)$data['ID'];
		}

		return $result;
	}

	protected function isAllowBatch()
	{
		return $this->getComponentParam('ALLOW_BATCH') === 'Y';
	}

	/** @return class-string<Market\Reference\Storage\Table> */
	protected function getDataClass()
	{
		$className = $this->getComponentParam('DATA_CLASS_NAME');

		Market\Reference\Assert::nonEmptyString($className, 'arParams[DATA_CLASS_NAME]');
		Market\Reference\Assert::isSubclassOf($className, Market\Reference\Storage\Table::class);

		return $className;
	}

	protected function normalizeQuerySelect(array $select)
	{
		$scalarFields = $this->getScalarFields();
		$scalarFieldsMap = array_flip($scalarFields);
		$linkList = $this->getReferenceFields();
		$scalarResult = [];
		$externalResult = [];

		foreach ($select as $fieldName)
		{
			if (isset($linkList[$fieldName]))
			{
				$externalResult[] = $fieldName;
			}
			else if (!isset($scalarFieldsMap[$fieldName]))
			{
				$scalarResult[$fieldName . '_REF'] = $fieldName . '.ID';
			}
			else
			{
				$scalarResult[] = $fieldName;
			}
		}

		return [ $scalarResult, $externalResult ];
	}

	protected function normalizeQueryFilter(array $filter)
	{
		$scalarFields = $this->getScalarFields();
		$scalarFieldsMap = array_flip($scalarFields);
		$newFilter = $filter;

		foreach ($filter as $filterName => $filterValue)
		{
			if (!is_numeric($filterName))
			{
				$fieldName = $filterName;

				if (preg_match('/^[^A-Za-z]+(.+)$/', $filterName, $match))
				{
					$fieldName = $match[1];
				}

				if (!isset($scalarFieldsMap[$fieldName]) && !preg_match('/\.ID$/', $fieldName))
				{
					$newFilter[$filterName . '.ID'] = $filterValue;
					unset($newFilter[$fieldName]);
				}
			}
		}

		return $newFilter;
	}

	protected function normalizeQueryOrder(array $order)
	{
		$scalarFields = $this->getScalarFields();
		$scalarFieldsMap = array_flip($scalarFields);
		$newOrder = $order;

		foreach ($order as $fieldName => $orderDirection)
		{
			if (!isset($scalarFieldsMap[$fieldName]) && !preg_match('/\.ID$/', $fieldName))
			{
				$newOrder[$fieldName . '.ID'] = $orderDirection;
				unset($newOrder[$fieldName]);
			}
		}

		return $newOrder;
	}

	protected function normalizeQueryResult($item)
	{
		$referenceMarker = '_REF';
		$result = $item;

		foreach ($item as $key => $value)
		{
			$referencePosition = Market\Data\TextString::getLastPosition($key, $referenceMarker);

			if ($referencePosition !== false)
			{
				$keyWithoutReference = Market\Data\TextString::getSubstring($key, 0, $referencePosition);

				if ($keyWithoutReference . $referenceMarker === $key)
				{
					$result[$keyWithoutReference] = $value;
					unset($result[$key]);
				}
			}
		}

		return $result;
	}

	protected function getScalarFields()
	{
		$dataClass = $this->getDataClass();

		return $dataClass::getScalarMap();
	}

	protected function getReferenceFields()
	{
		$dataClass = $this->getDataClass();

		return $dataClass::getReference();
	}
}