<?php

namespace Yandex\Market\Export\Entity;

use Bitrix\Main;
use Yandex\Market;

Main\Localization\Loc::loadMessages(__FILE__);

class Data
{
	const TYPE_STRING = 'S';
	const TYPE_NUMBER = 'N';
	const TYPE_ENUM = 'L';
	const TYPE_IBLOCK_ELEMENT = 'E';
	const TYPE_IBLOCK_SECTION = 'G';
	/** @deprecated */
	const TYPE_SERVICE_CATEGORY = 'SERVICE_CATEGORY';
	const TYPE_MARKET_CATEGORY = 'MARKET_CATEGORY';
	const TYPE_MARKET_PARAMETERS = 'MARKET_PARAMETERS';
	const TYPE_FILE = 'F';
	const TYPE_BOOLEAN = 'BOOLEAN';
	const TYPE_URL = 'URL';
	const TYPE_DATE = 'DATE';
	const TYPE_DATETIME = 'DATETIME';
	const TYPE_CURRENCY = 'CURRENCY';
	const TYPE_CURRENCY_CONVERT = 'CURRENCY_CONVERT';
	const TYPE_DELIVERY_OPTIONS = 'DELIVERY_OPTIONS';
	const TYPE_DISTINCT = 'DISTINCT';

	const COMPARE_EQUAL = 'equal';
	const COMPARE_NOT_EQUAL = 'notEqual';
	const COMPARE_MORE = 'more';
	const COMPARE_MORE_OR_EQUAL = 'moreOrEqual';
	const COMPARE_LESS = 'less';
	const COMPARE_LESS_OR_EQUAL = 'lessOrEqual';
	const COMPARE_LIKE = 'like';
	const COMPARE_NOT_LIKE = 'notLike';
	const COMPARE_IN = 'in';
	const COMPARE_NOT_IN = 'notIn';
	const COMPARE_NOT_IN_STRICT = 'notInStrict';
	const COMPARE_COMPLEX = 'complex';
	const COMPARE_EMPTY = 'empty';
	const COMPARE_NOT_EMPTY = 'notEmpty';

	const SPECIAL_VALUE_EMPTY = 'special:empty';

	protected static $likeSpecialChars = [ '_', '%' ];

	public static function getType($type)
	{
		$typeList = static::getTypeList();

		if (!isset($typeList[$type]))
		{
			$langPrefix = static::getLangPrefix();

			throw new Main\SystemException(
				Market\Config::getLang($langPrefix . 'TYPE_UNDEFINED')
			);
		}

		return $typeList[$type];
	}

	/** @noinspection PhpDeprecationInspection */
	public static function getTypeList()
	{
		$stringDataTypes = [
			Market\Type\Manager::TYPE_STRING,
			Market\Type\Manager::TYPE_NUMBER,
			Market\Type\Manager::TYPE_COUNT,
			Market\Type\Manager::TYPE_VAT,
			Market\Type\Manager::TYPE_BARCODE,
			Market\Type\Manager::TYPE_HTML,
			Market\Type\Manager::TYPE_DATE,
			Market\Type\Manager::TYPE_DATEPERIOD,
			Market\Type\Manager::TYPE_PERIOD,
			Market\Type\Manager::TYPE_CURRENCY,
			Market\Type\Manager::TYPE_BOOLEAN,
			Market\Type\Manager::TYPE_AGE,
			Market\Type\Manager::TYPE_DIMENSIONS,
			Market\Type\Manager::TYPE_RECORDING_LENGTH,
			Market\Type\Manager::TYPE_ENUM,
			Market\Type\Manager::TYPE_DAYS,
			Market\Type\Manager::TYPE_TN_VED_CODE,
			Market\Type\Manager::TYPE_WEEKDAY,
		];

		if (Market\Config::isExpertMode())
		{
			$stringDataTypes[] = Market\Type\Manager::TYPE_URL;
		}

		return [
			static::TYPE_STRING => [
				'DATA' => array_merge(
					$stringDataTypes,
					[ Market\Type\Manager::TYPE_FILE ]
				),
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL,
					static::COMPARE_LIKE,
					static::COMPARE_NOT_LIKE,
					static::COMPARE_COMPLEX,
                    static::COMPARE_IN,
                    static::COMPARE_NOT_IN,
					static::COMPARE_NOT_IN_STRICT,
					static::COMPARE_EMPTY,
					static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_NUMBER => [
				'DATA' => [
					Market\Type\Manager::TYPE_STRING,
					Market\Type\Manager::TYPE_NUMBER,
					Market\Type\Manager::TYPE_COUNT,
					Market\Type\Manager::TYPE_VAT,
					Market\Type\Manager::TYPE_BARCODE,
					Market\Type\Manager::TYPE_BOOLEAN,
					Market\Type\Manager::TYPE_AGE,
					Market\Type\Manager::TYPE_DAYS,
					Market\Type\Manager::TYPE_TN_VED_CODE,
					Market\Type\Manager::TYPE_WEEKDAY,
					Market\Type\Manager::TYPE_DATEPERIOD,
					Market\Type\Manager::TYPE_PERIOD,
				],
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL,
					static::COMPARE_MORE,
					static::COMPARE_MORE_OR_EQUAL,
					static::COMPARE_LESS,
					static::COMPARE_LESS_OR_EQUAL,
                    static::COMPARE_COMPLEX,
                    static::COMPARE_IN,
                    static::COMPARE_NOT_IN,
					static::COMPARE_NOT_IN_STRICT,
                    static::COMPARE_EMPTY,
                    static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_ENUM => [
				'DATA' => $stringDataTypes,
				'COMPARE' => [
					static::COMPARE_IN,
					static::COMPARE_NOT_IN,
					static::COMPARE_NOT_IN_STRICT,
					static::COMPARE_EMPTY,
					static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_IBLOCK_ELEMENT => [
				'DATA' => $stringDataTypes,
				'COMPARE' => [
					static::COMPARE_IN,
					static::COMPARE_NOT_IN,
					static::COMPARE_NOT_IN_STRICT,
					static::COMPARE_EMPTY,
					static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_IBLOCK_SECTION => [
				'DATA' => [
					Market\Type\Manager::TYPE_CATEGORY
				],
				'COMPARE' => [
					static::COMPARE_IN,
					static::COMPARE_NOT_IN,
					static::COMPARE_NOT_IN_STRICT,
					static::COMPARE_EMPTY,
					static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_SERVICE_CATEGORY => [
				'DATA' => [
					Market\Type\Manager::TYPE_CATEGORY
				],
				'COMPARE' => [
					static::COMPARE_IN,
					static::COMPARE_NOT_IN,
					static::COMPARE_EMPTY,
					static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_FILE => [
				'DATA' => [
					Market\Type\Manager::TYPE_FILE
				],
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL
				]
			],
			static::TYPE_BOOLEAN => [
				'DATA' => $stringDataTypes,
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL
				]
			],
			static::TYPE_URL => [
				'DATA' => [
					Market\Type\Manager::TYPE_URL
				],
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL,
					static::COMPARE_LIKE,
					static::COMPARE_NOT_LIKE,
                    static::COMPARE_IN,
                    static::COMPARE_NOT_IN,
				]
			],
			static::TYPE_DATE => [
				'DATA' => [
					Market\Type\Manager::TYPE_DATE,
					Market\Type\Manager::TYPE_DATEPERIOD,
					Market\Type\Manager::TYPE_STRING
				],
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL,
					static::COMPARE_MORE,
					static::COMPARE_MORE_OR_EQUAL,
					static::COMPARE_LESS,
					static::COMPARE_LESS_OR_EQUAL,
                    static::COMPARE_COMPLEX,
                    static::COMPARE_IN,
                    static::COMPARE_NOT_IN,
                    static::COMPARE_EMPTY,
                    static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_DATETIME => [
				'DATA' => [
					Market\Type\Manager::TYPE_DATE,
                    Market\Type\Manager::TYPE_DATEPERIOD,
					Market\Type\Manager::TYPE_STRING
				],
				'COMPARE' => [
					static::COMPARE_EQUAL,
					static::COMPARE_NOT_EQUAL,
					static::COMPARE_MORE,
					static::COMPARE_MORE_OR_EQUAL,
					static::COMPARE_LESS,
					static::COMPARE_LESS_OR_EQUAL,
                    static::COMPARE_COMPLEX,
                    static::COMPARE_IN,
                    static::COMPARE_NOT_IN,
                    static::COMPARE_EMPTY,
                    static::COMPARE_NOT_EMPTY
				]
			],
			static::TYPE_CURRENCY => [
				'DATA' => [
					Market\Type\Manager::TYPE_CURRENCY,
					Market\Type\Manager::TYPE_STRING,
				],
				'COMPARE' => [
					static::COMPARE_IN,
					static::COMPARE_NOT_IN
				]
			],
			static::TYPE_CURRENCY_CONVERT => [
				'DATA' => [
					Market\Type\Manager::TYPE_CURRENCY,
				],
				'COMPARE' => []
			],
			static::TYPE_DELIVERY_OPTIONS => [
				'DATA' => [
					Market\Type\Manager::TYPE_DELIVERY_OPTIONS
				],
				'COMPARE' => []
			],
			static::TYPE_DISTINCT => [
				'DATA' => [],
				'COMPARE' => [
					static::COMPARE_EQUAL,
				]
			],
		];
	}

	public static function getDataTypes($dataType)
	{
		$typeList = static::getTypeList();
		$result = [];

		foreach ($typeList as $type => $config)
		{
			if (!isset($config['DATA']) || in_array($dataType, $config['DATA']))
			{
				$result[] = $type;
			}
		}

		return $result;
	}

	public static function getCompare($compare)
	{
		$compareList = static::getCompareList();

		if (!isset($compareList[$compare]))
		{
			$langPrefix = static::getLangPrefix();

			throw new Main\SystemException(
				Market\Config::getLang($langPrefix . 'COMPARE_UNDEFINED')
			);
		}

		return $compareList[$compare];
	}

	public static function getCompareTypes($compare)
	{
		$typeList = static::getTypeList();
		$result = [];

		foreach ($typeList as $type => $data)
		{
			foreach ($data['COMPARE'] as $typeCompare)
			{
				if ($typeCompare === $compare)
				{
					$result[] = $type;
					break;
				}
			}
		}

		return $result;
	}

	public static function getCompareList()
	{
		return [
			static::COMPARE_EQUAL => [
				'QUERY' => '=',
				'MULTIPLE' => false
			],
			static::COMPARE_NOT_EQUAL => [
				'QUERY' => '!',
				'MULTIPLE' => false
			],
			static::COMPARE_MORE => [
				'QUERY' => '>',
				'MULTIPLE' => false
			],
			static::COMPARE_MORE_OR_EQUAL => [
				'QUERY' => '>=',
				'MULTIPLE' => false
			],
			static::COMPARE_LESS => [
				'QUERY' => '<',
				'MULTIPLE' => false
			],
			static::COMPARE_LESS_OR_EQUAL => [
				'QUERY' => '<=',
				'MULTIPLE' => false
			],
			static::COMPARE_LIKE => [
				'QUERY' => '%',
				'MULTIPLE' => false
			],
			static::COMPARE_NOT_LIKE => [
				'QUERY' => '!%',
				'MULTIPLE' => false
			],
			static::COMPARE_IN => [
				'QUERY' => '',
				'MULTIPLE' => true
			],
			static::COMPARE_NOT_IN => [
				'QUERY' => '!',
				'MULTIPLE' => true
			],
			static::COMPARE_NOT_IN_STRICT => [
				'QUERY' => '!',
				'MULTIPLE' => true,
				'STRICT' => true,
				'HIDDEN' => !Market\Config::isExpertMode(),
			],
			static::COMPARE_COMPLEX => [
				'QUERY' => '?',
				'MULTIPLE' => false
			],
			static::COMPARE_EMPTY => [
				'QUERY' => '',
				'MULTIPLE' => false,
				'DEFINED' => static::SPECIAL_VALUE_EMPTY
			],
			static::COMPARE_NOT_EMPTY => [
				'QUERY' => '!',
				'MULTIPLE' => false,
				'DEFINED' => static::SPECIAL_VALUE_EMPTY
			]
		];
	}

	public static function getCompareTitle($compare)
	{
		$langPrefix = static::getLangPrefix();
		$compareUpper = Market\Data\TextString::toUpper($compare);

		return Market\Config::getLang($langPrefix . 'COMPARE_' . $compareUpper);
	}

	public static function optimizeCompareQuery($compareData, $compareValue)
	{
		$isNonStrictQuery = ($compareData['QUERY'] === '' || $compareData['QUERY'] === '!');
		$result = null;

		if ($isNonStrictQuery && !isset($compareData['DEFINED']) && !static::hasLikeSpecialChar($compareValue))
		{
			$result = $compareData;
			$result['QUERY'] .= '=';
		}

		return $result;
	}

	/** @noinspection PhpDeprecationInspection */
	public static function convertUserTypeToDataType($userTypeId)
	{
		$map = [
			'string' => static::TYPE_STRING,
			'integer' => static::TYPE_NUMBER,
			'double' => static::TYPE_NUMBER,
			'enumeration' => static::TYPE_ENUM,
			'hlblock' => static::TYPE_ENUM,
			'url' => static::TYPE_URL,
			'file' => static::TYPE_FILE,
			'boolean' => static::TYPE_BOOLEAN,
			'date' => static::TYPE_DATE,
			'datetime' => static::TYPE_DATETIME,
			'iblock_element' => static::TYPE_IBLOCK_ELEMENT,
			'iblock_section' => static::TYPE_IBLOCK_SECTION,
			'ym_service_category' => static::TYPE_SERVICE_CATEGORY
		];

		return isset($map[$userTypeId]) ? $map[$userTypeId] : static::TYPE_STRING;
	}

	protected static function getLangPrefix()
	{
		return 'EXPORT_ENTITY_DATA_';
	}

	protected static function hasLikeSpecialChar($compareValue)
	{
		$result = false;

		if (is_array($compareValue))
		{
			foreach ($compareValue as $option)
			{
				if (static::testVariableForLikeSpecialChar($option))
				{
					$result = true;
					break;
				}
			}
		}
		else if (static::testVariableForLikeSpecialChar($compareValue))
		{
			$result = true;
		}

		return $result;
	}

	protected static function testVariableForLikeSpecialChar($string)
	{
		$result = false;

		if (is_string($string))
		{
			foreach (static::$likeSpecialChars as $char)
			{
				if (Market\Data\TextString::getPosition($string, $char) !== false)
				{
					$result = true;
					break;
				}
			}
		}

		return $result;
	}
}