<?php
/**
 * Created by PhpStorm.
 * User: Alexey
 * Date: 09.01.2015
 * Time: 17:41
 */

namespace Bitrix\Sale;

use Bitrix\Main\ArgumentException;
use Bitrix\Main\ArgumentNullException;
use	Bitrix\Sale\Internals\Input,
	Bitrix\Sale\Internals\OrderPropsTable,
	Bitrix\Sale\Internals\OrderPropsValueTable,
	Bitrix\Sale\Internals\OrderPropsVariantTable,
	Bitrix\Main\Entity,
	Bitrix\Main\Event,
	Bitrix\Main\SystemException,
	Bitrix\Main\Localization\Loc;
use Bitrix\Sale\Internals\OrderPropsRelationTable;

class PropertyValue
	extends Internals\CollectableEntity
{
	protected $property = array();
	protected $savedValue;
	protected $deletedValue;

	protected static $mapFields;

	public static function create(PropertyValueCollection $collection, array $property = array())
	{
		$propertyValue = static::createPropertyValueObject($property);
		$propertyValue->setCollection($collection);
		return $propertyValue;
	}

	protected function __construct(array $property = null, array $value = null, array $relation = null)
	{
		if (! $property && ! $value)
			throw new SystemException('invalid arguments', 0, __FILE__, __LINE__);

		if ($property)
		{
			if (is_array($property['SETTINGS']))
			{
				$property += $property['SETTINGS'];
				unset ($property['SETTINGS']);
			}
		}
		else
		{
			$property = array(
				'TYPE' => 'STRING',
				'PROPS_GROUP_ID' => 0,
				'NAME' => $value['NAME'],
				'CODE' => $value['CODE'],
			);
		}

		if (! $value)
		{
			$value = array(
				'ORDER_PROPS_ID' => $property['ID'],
				'NAME' => $property['NAME'],
				'CODE' => $property['CODE']
			);
		}

		if (!isset($value['VALUE']) && !empty($property['DEFAULT_VALUE']))
		{
			$value['VALUE'] = $property['DEFAULT_VALUE'];
		}

		if (!empty($relation))
			$property['RELATION'] = $relation;

		$this->savedValue = $value['VALUE']; //Input\File::getValue($property, $value['VALUE']);

		switch($property['TYPE'])
		{
			case 'ENUM':

				if ($propertyId = $property['ID'])
					$property['OPTIONS'] = static::loadOptions($propertyId);

				break;

			case 'FILE':

				if ($defaultValue = &$property['DEFAULT_VALUE'])
					$defaultValue = Input\File::loadInfo($defaultValue);

				if ($orderValue = &$value['VALUE'])
					$orderValue = Input\File::loadInfo($orderValue);

				break;
		}

		$this->property = $property;

		parent::__construct($value); //TODO field
	}

	public function setValue($value)
	{
		if ($value && $this->property['TYPE'] == 'FILE')
			$value = Input\File::loadInfo($value);

		if ($this->property['TYPE'] == "STRING")
		{
			if ($this->property['IS_EMAIL'] === "Y" && !empty($value))
			{
				$value = trim((string)$value);
			}

			if (Input\StringInput::isMultiple($value))
			{
				$fields = $this->getFields();
				$baseValuesData = $fields->getValues();
				$baseValues = null;
				if (!empty($baseValuesData['VALUE']) && is_array($baseValuesData['VALUE']))
				{
					$baseValues = array_values($baseValuesData['VALUE']);
				}
				foreach ($value as $key => $data)
				{
					if (Input\StringInput::isDeletedSingle($data))
					{
						$this->deletedValue[] = $key;
						if (is_array($baseValues) && array_key_exists($key, $baseValues))
						{
							$value[$key] = $baseValues[$key];
						}
						else
						{
							$value[$key] = '';
						}

					}
				}
			}
		}

		$this->setField('VALUE', $value);
	}

	private function getValueForDB($value)
	{
		$property = $this->property;

		if ($property['TYPE'] == 'FILE')
		{
			$value = Input\File::asMultiple($value);

			foreach ($value as $i => $file)
			{
				if (Input\File::isDeletedSingle($file))
				{
					unset($value[$i]);
				}
				else
				{
					if (Input\File::isUploadedSingle($file)
						&& ($fileId = \CFile::SaveFile(array('MODULE_ID' => 'sale') + $file, 'sale/order/properties'))
						&& is_numeric($fileId))
					{
						$file = $fileId;
					}

					$value[$i] = Input\File::loadInfoSingle($file);
				}
			}

			$this->fields->set('VALUE', $value);
			$value = Input\File::getValue($property, $value);

			foreach (
				array_diff(
					Input\File::asMultiple(Input\File::getValue($property, $this->savedValue         )),
					Input\File::asMultiple(                                $value                     ),
					Input\File::asMultiple(Input\File::getValue($property, $property['DEFAULT_VALUE']))
				)
				as $fileId)
			{
				\CFile::Delete($fileId);
			}
		}
		elseif($property['TYPE'] == 'STRING')
		{
			if (!empty($this->deletedValue) && is_array($this->deletedValue))
			{
				if (!empty($value) && is_array($value))
				{
					foreach ($value as $i => $string)
					{
						if (in_array($i, $this->deletedValue))
						{
							unset($value[$i]);
							unset($this->deletedValue[$i]);
						}
					}
				}
			}
		}

		return $value;
	}

	/** @return Entity\Result */
	public function save()
	{
		$result = new Result();
		$value = self::getValueForDB($this->fields->get('VALUE'));

		$eventName = static::getEntityEventName();

		if ($valueId = $this->getId())
		{
			if ($value != $this->savedValue)
			{
				$r = Internals\OrderPropsValueTable::update($valueId, array('VALUE' => $value));

				if ($r->isSuccess())
					$this->savedValue = $value;
				else
					$result->addErrors($r->getErrors());
			}
		}
		else
		{
			if ($value !== null)
			{
				$property = $this->property;
				$r = Internals\OrderPropsValueTable::add(array(
					'ORDER_ID' => $this->getParentOrderId(),
					'ORDER_PROPS_ID' => $property['ID'],
					'NAME' => $property['NAME'],
					'VALUE' => $value,
					'CODE' => $property['CODE'],
				));
				if ($r->isSuccess())
				{
					$this->savedValue = $value;
					$this->setFieldNoDemand('ID', $r->getId());
				}
				else
				{
					$result->addErrors($r->getErrors());
				}
			}
		}

		if ($this->isChanged() && $eventName)
		{
			/** @var Event $event */
			$event = new Event('sale', 'On'.$eventName.'EntitySaved', array(
				'ENTITY' => $this,
				'VALUES' => $this->fields->getOriginalValues(),
			));
			$event->send();
		}

		return $result;
	}

	function setValueFromPost(array $post)
	{
		$result = new Result();
		$property = $this->property;

		$key = isset($property["ID"]) ? $property["ID"] : "n".$this->getId();

		if (is_array($post['PROPERTIES']) && array_key_exists($key, $post['PROPERTIES']))
		{
			$this->setValue($post['PROPERTIES'][$key]);
		}

		return $result;
	}

	public function checkValue($key, $value)
	{
		static $errorsList = array();
		$result = new Result();
		$property = $this->getProperty();

		if ($property['TYPE'] == "STRING" && ((int)$property['MAXLENGTH'] <= 0))
		{
			$property['MAXLENGTH'] = 500;
		}
		$error = Input\Manager::getError($property, $value);

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

		foreach ($error as &$message)
		{
			$message = Loc::getMessage(
				"SALE_PROPERTY_ERROR",
				array("#PROPERTY_NAME#" => $property['NAME'], "#ERROR_MESSAGE#" => $message)
			);
		}

		if (!is_array($value) && $property['IS_EMAIL'] == 'Y' && trim($value) !== '' && !check_email(trim($value), true))
		{
			$error['EMAIL'] = str_replace(
				array("#EMAIL#", "#NAME#"),
				array(htmlspecialcharsbx($value), htmlspecialcharsbx($property['NAME'])),
				Loc::getMessage("SALE_GOPE_WRONG_EMAIL")
			);
		}

		foreach ($error as $e)
		{
			if (!empty($e) && is_array($e))
			{
				foreach ($e as $errorMsg)
				{
					if (isset($errorsList[$property['ID']]) && in_array($errorMsg, $errorsList[$property['ID']]))
						continue;

					$result->addError(new ResultError($errorMsg, "PROPERTIES[$key]"));
					$result->addError(new ResultWarning($errorMsg, "PROPERTIES[$key]"));

					$errorsList[$property['ID']][] = $errorMsg;
				}
			}
			else
			{
				if (isset($errorsList[$property['ID']]) && in_array($e, $errorsList[$property['ID']]))
					continue;

				$result->addError(new ResultError($e, "PROPERTIES[$key]"));
				$result->addError(new ResultWarning($e, "PROPERTIES[$key]"));

				$errorsList[$property['ID']][] = $e;
			}
		}

		return $result;
	}

	/**
	 * @param $key
	 * @param $value
	 *
	 * @return Result
	 * @throws SystemException
	 */
	public function checkRequiredValue($key, $value)
	{
		static $errorsList = array();
		$result = new Result();
		$property = $this->getProperty();

		$error = Input\Manager::getRequiredError($property, $value);

		foreach ($error as $e)
		{
			if (!empty($e) && is_array($e))
			{
				foreach ($e as $errorMsg)
				{
					if (isset($errorsList[$property['ID']]) && in_array($errorMsg, $errorsList[$property['ID']]))
						continue;

					$result->addError(new ResultError($property['NAME'].' '.$errorMsg, "PROPERTIES[".$key."]"));

					$errorsList[$property['ID']][] = $errorMsg;
				}
			}
			else
			{
				if (isset($errorsList[$property['ID']]) && in_array($e, $errorsList[$property['ID']]))
					continue;

				$result->addError(new ResultError($property['NAME'].' '.$e, "PROPERTIES[$key]"));

				$errorsList[$property['ID']][] = $e;
			}
		}
		return $result;
	}

	private function getParentOrderId()
	{
		/** @var PaymentCollection $collection */
		$collection = $this->getCollection();
		$order = $collection->getOrder();
		return $order->getId();
	}

	/**
	 * @return array
	 */
	public static function getAvailableFields()
	{
		return array('VALUE');
	}

	/**
	 * @return array
	 */
	public static function getMeaningfulFields()
	{
		return array();
	}

	/**
	 * @return array
	 */
	public static function getAllFields()
	{
		if (empty(static::$mapFields))
		{
			static::$mapFields = parent::getAllFieldsByMap(Internals\OrderPropsValueTable::getMap());
		}
		return static::$mapFields;
	}

	function getProperty()
	{
		return $this->property;
	}

	function getViewHtml()
	{
		return Input\Manager::getViewHtml($this->property, $this->getValue());
	}

	function getEditHtml()
	{
		$key = isset($this->property["ID"]) ? $this->property["ID"] : "n".$this->getId();
		return Input\Manager::getEditHtml("PROPERTIES[".$key."]", $this->property, $this->getValue());
	}

	function getValue()
	{
		return $this->getField("VALUE");
	}

	function getValueId()
	{
		return $this->getField('ID');
	}

	function getPropertyId()
	{
		return $this->property['ID'];
	}

	function getPersonTypeId()
	{
		return $this->property['PERSON_TYPE_ID'];
	}

	function getGroupId()
	{
		return $this->property['PROPS_GROUP_ID'];
	}

	function getName()
	{
		return $this->property['NAME'];
	}

	function getRelations()
	{
		return $this->property['RELATION'];
	}

	function getDescription()
	{
		return $this->property['DESCRIPTION'];
	}

	function getType()
	{
		return $this->property['TYPE'];
	}

	function isRequired()
	{
		return $this->property['REQUIRED'] == 'Y';
	}

	function isUtil()
	{
		return $this->property['UTIL'] == 'Y';
	}

	/**
	 * @internal
	 *
	 * Delete order properties.
	 * 
	 * @param $idOrder
	 * @return Result
	 * @throws \Bitrix\Main\ObjectNotFoundException
	 */
	public static function deleteNoDemand($idOrder)
	{
		$result = new Result();
		
		$propertiesDataList = Internals\OrderPropsValueTable::getList(
			array(
				"filter" => array("=ORDER_ID" => $idOrder),
				"select" => array("ID")
			)	
		);
		
		while ($property = $propertiesDataList->fetch())
		{
			$r = Internals\OrderPropsValueTable::delete($property['ID']);
			if (!$r->isSuccess())
			{
				$result->addErrors($r->getErrors());
			}
		}
		
		return $result;
	}
	
	public static function getMeaningfulValues($personTypeId, $request)
	{
		$personTypeId = intval($personTypeId);
		if ($personTypeId <= 0)
			throw new ArgumentNullException("personTypeId");

		if (!is_array($request))
			throw new ArgumentNullException("request");

		$result = array();

		$db = OrderPropsTable::getList(array(
			'select' => array('ID', 'IS_LOCATION', 'IS_EMAIL', 'IS_PROFILE_NAME',
				'IS_PAYER', 'IS_LOCATION4TAX', 'CODE', 'IS_ZIP', 'IS_PHONE', 'IS_ADDRESS',
			),
			'filter' => array(
				'ACTIVE' => 'Y',
				'UTIL' => 'N',
				'PERSON_TYPE_ID' => $personTypeId
			)
		));
		while ($row = $db->fetch())
		{
			if (array_key_exists($row["ID"], $request))
			{
				foreach ($row as $key => $value)
				{
					if (($value === "Y") && (substr($key, 0, 3) === "IS_"))
					{
						$result[substr($key, 3)] = $request[$row["ID"]];
					}
				}
			}
		}

		return $result;
	}

	/**
	 * @param array|null $property
	 * @param array|null $value
	 * @param array|null $relation
	 * @return PropertyValue
	 */
	protected static function createPropertyValueObject(array $property = null, array $value = null, array $relation = null)
	{
		$registry = Registry::getInstance(Registry::REGISTRY_TYPE_ORDER);
		$propertyValueClassName = $registry->getPropertyValueClassName();

		return new $propertyValueClassName($property, $value, $relation);
	}

	public static function loadForOrder(Order $order)
	{
		$objects = array();

		$propertyValues = array();
		$propertyValuesMap = array();
		$properties = array();

		if ($order->getId() > 0)
		{
			$result = OrderPropsValueTable::getList(array(
				'select' => array('ID', 'NAME', 'VALUE', 'CODE', 'ORDER_PROPS_ID'),
				'filter' => array('ORDER_ID' => $order->getId())
			));
			while ($row = $result->fetch())
			{
				$propertyValues[$row['ID']] = $row;
				$propertyValuesMap[$row['ORDER_PROPS_ID']] = $row['ID'];
			}
		}

		$filter = array(
//			'=ACTIVE' => 'Y',
//			'=UTIL' => 'N',
		);

		if ($order->getPersonTypeId() > 0)
			$filter[] = array('=PERSON_TYPE_ID' => $order->getPersonTypeId());

		$result = OrderPropsTable::getList(array(
			'select' => array('ID', 'PERSON_TYPE_ID', 'NAME', 'TYPE', 'REQUIRED', 'DEFAULT_VALUE', 'SORT',
				'USER_PROPS', 'IS_LOCATION', 'PROPS_GROUP_ID', 'DESCRIPTION', 'IS_EMAIL', 'IS_PROFILE_NAME',
				'IS_PAYER', 'IS_LOCATION4TAX', 'IS_FILTERED', 'CODE', 'IS_ZIP', 'IS_PHONE', 'IS_ADDRESS',
				'ACTIVE', 'UTIL', 'INPUT_FIELD_LOCATION', 'MULTIPLE', 'SETTINGS'
			),
			'filter' => $filter,
			'order' => array('SORT' => 'ASC')
		));

		while ($row = $result->fetch())
			$properties[$row['ID']] = $row;

		$result = OrderPropsRelationTable::getList(array(
			'select' => array(
				'PROPERTY_ID', 'ENTITY_ID', 'ENTITY_TYPE'
			),
			'filter' => array(
				'PROPERTY_ID' => array_keys($properties)
			)
		));

		$propRelation = array();
		while ($row = $result->fetch())
		{
			if (empty($row))
				continue;

			if (!isset($propRelation[$row['PROPERTY_ID']]))
				$propRelation[$row['PROPERTY_ID']] = array();

			$propRelation[$row['PROPERTY_ID']][] = $row;
		}

		foreach ($properties as $property)
		{
			$id = $property['ID'];

			if (isset($propertyValuesMap[$id]))
			{
				$fields = $propertyValues[$propertyValuesMap[$id]];
				unset($propertyValues[$propertyValuesMap[$id]]);
				unset($propertyValuesMap[$id]);
			}
			else
			{
				if ($property['ACTIVE'] == 'N') // || $property['UTIL'] == 'Y')
					continue;

				$fields = null;
			}
			if (isset($propRelation[$id]))
				$objects[] = static::createPropertyValueObject($property, $fields, $propRelation[$id]);
			else
				$objects[] = static::createPropertyValueObject($property, $fields);
		}

		foreach ($propertyValues as $propertyValue)
		{
			$objects[] = static::createPropertyValueObject(null, $propertyValue);
		}

		return $objects;
	}

	public function loadOptions($propertyId)
	{
		$options = array();

		$result = OrderPropsVariantTable::getList(array(
			'select' => array('VALUE', 'NAME'),
			'filter' => array('ORDER_PROPS_ID' => $propertyId),
			'order' => array('SORT' => 'ASC')
		));

		while ($row = $result->fetch())
			$options[$row['VALUE']] = $row['NAME'];

		return $options;
	}

	/**
	 * @internal
	 * @param \SplObjectStorage $cloneEntity
	 *
	 * @return PropertyValue
	 */
	public function createClone(\SplObjectStorage $cloneEntity)
	{
		if ($this->isClone() && $cloneEntity->contains($this))
		{
			return $cloneEntity[$this];
		}

		$propertyValueClone = clone $this;
		$propertyValueClone->isClone = true;

		/** @var Internals\Fields $fields */
		if ($fields = $this->fields)
		{
			$propertyValueClone->fields = $fields->createClone($cloneEntity);
		}

		if (!$cloneEntity->contains($this))
		{
			$cloneEntity[$this] = $propertyValueClone;
		}

		if ($collection = $this->getCollection())
		{
			if (!$cloneEntity->contains($collection))
			{
				$cloneEntity[$collection] = $collection->createClone($cloneEntity);
			}

			if ($cloneEntity->contains($collection))
			{
				$propertyValueClone->collection = $cloneEntity[$collection];
			}
		}

		return $propertyValueClone;
	}

}