catalogprovider.php

<?php
namespace Bitrix\Catalog\Product;
 
use Bitrix\Catalog\Config\State;
use Bitrix\Catalog\Product\Store\BatchManager;
use Bitrix\Catalog\Product\Store\CostPriceCalculator;
use Bitrix\Main;
use Bitrix\Catalog;
use Bitrix\Iblock;
use Bitrix\Sale;
use Bitrix\Sale\SaleProviderBase as Base;
use Bitrix\Currency;
use Bitrix\Catalog\Product\Store\DistributionStrategy;
 
if (Main\Loader::includeModule('sale'))
{
    class CatalogProvider extends Base
    {
        private static $userCache = array();
 
        protected static $hitCache = array();
        protected static $priceTitleCache = array();
        protected static $clearAutoCache = array();
 
        protected $enableCache = true;
 
        protected const CACHE_USER_GROUPS = 'USER_GROUPS';
        protected const CACHE_ITEM_WITHOUT_RIGHTS = 'IBLOCK_ELEMENT_PERM_N';
        protected const CACHE_ITEM_RIGHTS = 'IBLOCK_ELEMENT';
        protected const CACHE_ITEM_WITH_RIGHTS = 'IBLOCK_ELEMENT_PERM_Y';
        protected const CACHE_ELEMENT_RIGHTS_MODE = 'ELEMENT_RIGHTS_MODE';
        protected const CACHE_ELEMENT_SHORT_DATA = 'IBLOCK_ELEMENT_SHORT';
        protected const CACHE_PRODUCT = 'CATALOG_PRODUCT';
        protected const CACHE_VAT = 'VAT_INFO';
        protected const CACHE_IBLOCK_RIGHTS = 'IBLOCK_RIGHTS';
        protected const CACHE_STORE = 'CATALOG_STORE';
        protected const CACHE_STORE_PRODUCT = 'CATALOG_STORE_PRODUCT';
        protected const CACHE_PARENT_PRODUCT_ACTIVE = 'PARENT_PRODUCT_ACTIVE';
        protected const CACHE_CATALOG_IBLOCK_LIST = 'CATALOG_IBLOCK_LIST';
        protected const CACHE_PRODUCT_STORE_LIST = 'CACHE_PRODUCT_STORE_LIST';
        protected const CACHE_PRODUCT_AVAILABLE_LIST = 'CACHE_PRODUCT_AVAILABLE_LIST';
 
        protected const CATALOG_PROVIDER_EMPTY_STORE_ID = Base::EMPTY_STORE_ID;
        protected const BUNDLE_TYPE = 1;
 
        protected const RESULT_PRODUCT_LIST = Base::SUMMMARY_PRODUCT_LIST;
        protected const RESULT_CATALOG_LIST = 'CATALOG_DATA_LIST';
 
        protected const USE_GATALOG_DATA = 'CATALOG_DATA';
 
        protected const AMOUNT_SRC_QUANTITY = 'QUANTITY';
        protected const AMOUNT_SRC_QUANTITY_LIST = Base::FLAT_QUANTITY_LIST;
        protected const AMOUNT_SRC_PRICE_LIST = 'PRICE_LIST';
        protected const AMOUNT_SRC_STORE_QUANTITY_LIST = Base::STORE_QUANTITY_LIST;
        protected const AMOUNT_SRC_RESERVED_LIST = Base::FLAT_RESERVED_QUANTITY_LIST;
        protected const AMOUNT_SRC_STORE_RESERVED_LIST = Base::STORE_RESERVED_QUANTITY_LIST;
 
        private const QUANTITY_FORMAT_STORE = 1;
        private const QUANTITY_FORMAT_SHIPMENT = 2;
 
        public function getProductData(array $products)
        {
            return $this->getData($products);
        }
 
        public function getCatalogData(array $products)
        {
            return $this->getData(
                $products,
                [self::USE_GATALOG_DATA]
            );
        }
 
        private function getData(array $products, array $options = array()): Sale\Result
        {
            $context = $this->getContext();
 
            $resultProductList = array_fill_keys(array_keys($products), false);
 
            $result = new Sale\Result();
 
            $userId = (int)($context['USER_ID'] ?? 0);
            if ($userId < 0)
            {
                $userId = 0;
            }
            $siteId = $context['SITE_ID'] ?? false;
            $currency = $context['CURRENCY'] ?? false;
            $currency = (is_string($currency) ? Currency\CurrencyManager::checkCurrencyID($context['CURRENCY']) : false);
            if ($currency === false)
            {
                $currency = Sale\Internals\SiteCurrencyTable::getSiteCurrency($siteId ?: SITE_ID);
            }
            $adminSection = (defined('ADMIN_SECTION') && ADMIN_SECTION === true);
 
            if (in_array('DISABLE_CACHE', $options))
            {
                $this->enableCache = false;
            }
 
            $catalogDataEnabled = self::isCatalogDataEnabled($options);
 
            $outputVariable = static::getOutputVariable($options);
 
            $productGetIdList = array();
            $correctProductIds = [];
 
            $iblockElementSelect = array('ID', 'IBLOCK_ID', 'IBLOCK_SECTION_ID', 'ACTIVE', 'ACTIVE_DATE', 'XML_ID');
            if (!$catalogDataEnabled)
            {
                $iblockElementSelect = array_merge($iblockElementSelect, array('NAME', 'DETAIL_PAGE_URL'));
            }
 
            $resultList = array();
            foreach ($products as $productId => $itemData)
            {
                $resultList[$productId] = false;
                if (!isset($itemData['ITEM_CODE']))
                {
                    $itemData['ITEM_CODE'] = $productId;
                    $products[$productId]['ITEM_CODE'] = $productId;
                }
 
                if (!isset($itemData['BASKET_CODE']))
                {
                    $itemData['BASKET_CODE'] = $productId;
                    $products[$productId]['BASKET_CODE'] = $productId;
                }
 
                $hash = $productId."|".$userId;
                $productCachedData = static::getHitCache(self::CACHE_ITEM_RIGHTS, $hash, $iblockElementSelect);
                if ($this->enableCache && !empty($productCachedData))
                {
                    $products[$productId]['PRODUCT_DATA'] = $productCachedData;
                    $correctProductIds[$productId] = true;
                }
                else
                {
                    $productGetIdList[] = $productId;
                }
            }
 
            if (!empty($productGetIdList))
            {
                $productDataList = $this->getElements(
                    $productGetIdList,
                    $iblockElementSelect,
                    ($adminSection ? $userId : null)
                );
 
                foreach ($productDataList as $productId => $productData)
                {
                    $products[$productId]['PRODUCT_DATA'] = $productData;
                    $hash = $productId."|".$userId;
                    static::setHitCache(self::CACHE_ITEM_RIGHTS, $hash, $productData);
                    $correctProductIds[$productId] = true;
                }
 
                $products = array_intersect_key(
                    $products,
                    $correctProductIds
                );
                if (empty($products))
                {
                    return static::getResultProvider($result, $outputVariable, $resultList);
                }
            }
            unset($correctProductIds);
 
            $iblockList = array();
            $iblockDataList = array();
            $iblockGetIdList = array();
            foreach ($products as $productId => $productData)
            {
                $iblockId = $productData['PRODUCT_DATA']['IBLOCK_ID'];
                $iblockList[$iblockId][] = $productId;
            }
 
            foreach ($iblockList as $iblockId => $iblockProductIdList)
            {
                $iblockData = static::getHitCache(self::CACHE_CATALOG_IBLOCK_LIST, $iblockId);
                if ($this->enableCache && !empty($iblockData))
                {
                    $iblockDataList[$iblockId] = $iblockData;
                }
                else
                {
                    $iblockGetIdList[] = $iblockId;
                }
            }
 
            if (!empty($iblockGetIdList))
            {
                $iblockDataList = $this->getIblockData($iblockGetIdList) + $iblockDataList;
            }
 
            $iblockList = array_intersect_key(
                $iblockList,
                $iblockDataList
            );
 
            $iblockProductMap = static::createIblockProductMap($iblockList, $iblockDataList);
 
            $correctProductList = static::checkSkuPermission($iblockProductMap);
 
            $products = array_intersect_key(
                $products,
                array_fill_keys($correctProductList, true)
            );
            if (empty($products))
            {
                return static::getResultProvider($result, $outputVariable, $resultList);
            }
 
            $products = static::changeSubscribeProductQuantity($products, $iblockProductMap);
 
            // catalog product
 
            $catalogSelect = array(
                'ID',
                'CAN_BUY_ZERO',
                'QUANTITY_TRACE',
                'QUANTITY',
                'QUANTITY_RESERVED',
                'MEASURE',
                'TYPE',
                'AVAILABLE',
            );
            if (!$catalogDataEnabled)
            {
                $catalogSelect = array_merge($catalogSelect, array(
                    'WEIGHT',
                    'WIDTH',
                    'HEIGHT',
                    'LENGTH',
                    'BARCODE_MULTI',
                ));
            }
            $catalogSelect = array_merge($catalogSelect, Catalog\Product\SystemField::getProviderSelectFields());
 
            $catalogProductDataList = static::getCatalogProducts(array_keys($products), $catalogSelect);
 
            $products = array_intersect_key($products, $catalogProductDataList);
            if (empty($products))
            {
                return static::getResultProvider($result, $outputVariable, $resultList);
            }
 
            // fill catalog xml id
            $products = self::fillCatalogXmlId($products, $iblockProductMap);
            // prepare offers xml id
            $products = self::fillOfferXmlId($products, $catalogProductDataList);
 
            // get prices and discounts
            $priceDataList = self::getPriceDataList(
                $products,
                [
                    'IS_ADMIN_SECTION' => $adminSection,
                    'USER_ID' => $userId,
                    'SITE_ID' => $siteId,
                    'CURRENCY' => $currency,
                ]
            );
            $discountList = self::getDiscountList($priceDataList);
 
            $productQuantityList = array();
            $productPriceList = array();
 
            $fullQuantityMode = in_array('FULL_QUANTITY', $options);
 
            foreach ($products as $productId => $productData)
            {
                $catalogProductData = $catalogProductDataList[$productId];
 
                $quantityList = array();
 
                if (array_key_exists('QUANTITY', $productData))
                {
                    $quantityList = array($productData['BASKET_CODE'] => $productData['QUANTITY']);
                }
 
                if (!empty($productData[Base::FLAT_QUANTITY_LIST]))
                {
                    $quantityList = $productData[Base::FLAT_QUANTITY_LIST];
                }
 
                $productQuantityList[$productData['BASKET_CODE']]['QUANTITY_RESERVED'] = $catalogProductData['QUANTITY_RESERVED'];
 
                $baseCatalogQuantity = (float)$catalogProductData['QUANTITY'];
 
                $allCount = count($quantityList);
                $sumQuantity = 0;
                foreach ($quantityList as $quantity)
                {
                    $sumQuantity += (float)abs($quantity);
                }
 
                $catalogQuantityForAvaialable = $baseCatalogQuantity;
                $checkCatalogQuantity = $baseCatalogQuantity;
 
                $isEnough = !($catalogProductData['CHECK_QUANTITY'] && $catalogQuantityForAvaialable < $sumQuantity);
                $setQuantity = $baseCatalogQuantity;
                foreach ($quantityList as $basketCode => $quantity)
                {
                    $quantity = (float)abs($quantity);
 
                    if (!$isEnough)
                    {
                        if ($catalogQuantityForAvaialable - $quantity < 0)
                        {
                            $quantity = $catalogQuantityForAvaialable;
                        }
 
                        $catalogQuantityForAvaialable -= $quantity;
                    }
 
                    $productQuantityList[$basketCode]['AVAILABLE_QUANTITY'] = (
                        $baseCatalogQuantity >= $quantity || !$catalogProductData['CHECK_QUANTITY']
                            ? $quantity
                            : $baseCatalogQuantity
                    );
 
                    if ($fullQuantityMode)
                    {
                        $checkCatalogQuantity -= $quantity;
                        $setQuantity = $quantity;
                        $allCount--;
 
                        if ($allCount == 0)
                        {
                            $setQuantity = $checkCatalogQuantity + $quantity;
                        }
                    }
                    else
                    {
                        if ($baseCatalogQuantity - $quantity > 0 || !$catalogProductData['CHECK_QUANTITY'])
                        {
                            $setQuantity = $quantity;
                        }
                    }
 
                    $productQuantityList[$basketCode]['QUANTITY'] = $setQuantity;
                }
                unset($basketCode, $quantity);
 
                foreach (array_keys($quantityList) as $basketCode)
                {
                    if (isset($priceDataList[$productId][$basketCode]))
                    {
                        $productPriceList[$basketCode] = $priceDataList[$productId][$basketCode];
                    }
                }
                unset($basketCode);
 
                $measure = isset($catalogProductData['MEASURE']) ? (int)$catalogProductData['MEASURE'] : null;
                $measureFields = static::getMeasure($measure);
                if (!empty($measureFields))
                {
                    $catalogProductDataList[$productId] = $measureFields + $catalogProductDataList[$productId];
                }
            }
 
            unset($fullQuantityMode);
 
            $resultData = static::setCatalogDataToProducts($products, $catalogProductDataList, $options);
 
            $priceResultList = static::createProductPriceList($products, $productPriceList, $discountList);
 
            $resultList = static::createProductResult($products, $resultData, $priceResultList, $productQuantityList);
 
            $resultList = $resultList + $resultProductList;
 
            return static::getResultProvider($result, $outputVariable, $resultList);
        }
 
        private static function getOutputVariable(array $options = array()): string
        {
            return (self::isCatalogDataEnabled($options)
                ? static::RESULT_CATALOG_LIST
                : Base::SUMMMARY_PRODUCT_LIST
            );
        }
 
        private static function getResultProvider(Sale\Result $result, $outputVariable, array $resultList = array()): Sale\Result
        {
            $result->setData(
                array(
                    $outputVariable => $resultList,
                )
            );
 
            return $result;
        }
 
        private function getElements(array $list, array $select, ?int $userId = null): array
        {
            $filter = array(
                'ID' => $list,
                'ACTIVE_DATE' => 'Y',
                'CHECK_PERMISSIONS' => 'Y',
                'MIN_PERMISSION' => 'R',
            );
            if ($userId !== null)
            {
                $filter['PERMISSIONS_BY'] = $userId;
            }
 
            $resultList = array();
            $dbIBlockElement = \CIBlockElement::GetList(
                array(),
                $filter,
                false,
                false,
                $select
            );
            while ($productData = $dbIBlockElement->GetNext())
            {
                $resultList[$productData['ID']] = $productData;
            }
            unset($dbIBlockElement);
 
            return $resultList;
        }
 
        public function getBundleItems(array $products)
        {
            $result = new Sale\Result();
 
            $resultList = array();
 
            $productIdList = array();
            static $proxyCatalogProductSet = array();
            static $proxyCatalogSkuData = array();
            $bundleItemList = array();
 
            $bundleIndex = array();
 
            foreach ($products as $productId => $productData)
            {
                $proxyCatalogProductSetKey = $productId."|".static::BUNDLE_TYPE;
                if (!empty($proxyCatalogProductSet[$proxyCatalogProductSetKey]) && is_array($proxyCatalogProductSet[$proxyCatalogProductSetKey]))
                {
                    $childItemList = $proxyCatalogProductSet[$proxyCatalogProductSetKey];
                }
                else
                {
                    $childItemList = \CCatalogProductSet::getAllSetsByProduct($productId, static::BUNDLE_TYPE);
                    if (!empty($childItemList) && is_array($childItemList))
                    {
                        $proxyCatalogProductSet[$proxyCatalogProductSetKey] = $childItemList;
                    }
                }
 
                if (!empty($childItemList))
                {
                    $bundleItemList = $childItemList + $bundleItemList;
                    $bundleItemListIds = array_keys($childItemList);
                    $bundleItemId = reset($bundleItemListIds);
                    unset($bundleItemListIds);
                    $bundleIndex[$bundleItemId] = $productId;
                }
            }
 
            $childIdList = array();
 
            if (empty($bundleItemList))
                return $result;
 
            $bundleChildList = array();
            $childProducts = array();
            $productIndexList = array();
            foreach ($bundleItemList as $parentItemid => $bundleItemData)
            {
                $productId = $bundleIndex[$parentItemid];
                foreach ($bundleItemData["ITEMS"] as $childItemid => $item)
                {
                    if (!isset($childIdList[$item['ITEM_ID']]))
                        $childIdList[$item['ITEM_ID']] = true;
 
                    $bundleChildList[$item['ITEM_ID']] = $item;
                    $childProducts[$item['ITEM_ID']] = array(
                        'ITEM_CODE' => $item['ITEM_ID'],
                        'PRODUCT_ID' => $item['ITEM_ID'],
                        Base::FLAT_QUANTITY_LIST => [$item['ITEM_ID'] => $item['QUANTITY']],
                        'BUNDLE_CHILD' => true,
                    );
 
                    $productIndexList[$item['ITEM_ID']] = array(
                        'PRODUCT_ID' => $productId,
                        'PARENT_ID' => $parentItemid,
                        'CHILD_ID' => $childItemid,
                    );
                }
            }
 
            $r = $this->getProductData($childProducts);
            if ($r->isSuccess())
            {
                $resultData = $r->getData();
                if (
                    !empty($resultData[Base::SUMMMARY_PRODUCT_LIST])
                    && is_array($resultData[Base::SUMMMARY_PRODUCT_LIST])
                )
                {
                    $resultDataList = $resultData[Base::SUMMMARY_PRODUCT_LIST];
                    foreach ($resultDataList as $itemCode => $itemData)
                    {
                        $item = $bundleChildList[$itemCode];
                        if (array_key_exists('QUANTITY_TRACE', $itemData))
                            unset($itemData['QUANTITY_TRACE']);
 
                        $itemData["PRODUCT_ID"] = $item["ITEM_ID"];
                        $itemData["MODULE"] = 'catalog';
                        $itemData["PRODUCT_PROVIDER_CLASS"] = Basket::getDefaultProviderName();
 
                        $productIdList[] = $item["ITEM_ID"];
 
                        $itemData["PROPS"] = array();
 
                        if (!empty($proxyCatalogSkuData[$item["ITEM_ID"]]) && is_array($proxyCatalogSkuData[$item["ITEM_ID"]]))
                        {
                            $parentSkuData = $proxyCatalogSkuData[$item["ITEM_ID"]];
                        }
                        else
                        {
                            $parentSkuData = \CCatalogSku::GetProductInfo($item["ITEM_ID"]);
                            if ($parentSkuData)
                            {
                                $proxyCatalogSkuData[$item["ITEM_ID"]] = $parentSkuData;
                            }
                        }
 
                        if (!empty($parentSkuData))
                        {
                            $childDataList = array();
                            $childIdGetList = array();
 
                            $iblockPropertyDataList = array();
                            $iblockPropertyIdList = array();
 
                            $propsSku = array();
 
                            foreach ($childIdList as $childId => $parentValue)
                            {
                                $productData = static::getHitCache(self::CACHE_ELEMENT_SHORT_DATA, $item["ITEM_ID"]);
                                if (!empty($productData))
                                {
                                    $childDataList[$childId] = $productData;
                                    if (!isset($iblockPropertyIdList[$productData['IBLOCK_ID']]))
                                    {
                                        $iblockPropertyIdList[$productData['IBLOCK_ID']] = true;
                                    }
                                }
                                else
                                {
                                    $childIdGetList[] = $childId;
                                }
                            }
 
                            if (!empty($childIdGetList))
                            {
                                $iterator = Iblock\ElementTable::getList([
                                    'select' => [
                                        'ID',
                                        'IBLOCK_ID',
                                        'NAME',
                                        'IBLOCK_SECTION_ID',
                                    ],
                                    'filter' => \CIBlockElement::getPublicElementsOrmFilter(['@ID' => $childIdGetList]),
                                ]);
                                while ($productData = $iterator->fetch())
                                {
                                    static::setHitCache(self::CACHE_ELEMENT_SHORT_DATA, $productData["ID"], $productData);
                                    $childDataList[$productData["ID"]] = $productData;
 
                                    if (!isset($iblockPropertyIdList[$productData['IBLOCK_ID']]))
                                    {
                                        $iblockPropertyIdList[$productData['IBLOCK_ID']] = true;
                                    }
                                }
                            }
 
                            foreach ($iblockPropertyIdList as $iblockPropertyId => $iblockPropertyValue)
                            {
                                if ($propsSku = static::getHitCache('IBLOCK_PROPERTY', $iblockPropertyId))
                                {
                                    $iblockPropertyDataList[$iblockPropertyId] = $propsSku;
                                }
                                else
                                {
                                    $dbOfferProperties = \CIBlock::GetProperties($iblockPropertyId, array(), array("!XML_ID" => "CML2_LINK"));
                                    while($offerProperties = $dbOfferProperties->Fetch())
                                    {
                                        $propsSku[] = $offerProperties["CODE"];
                                    }
                                    static::setHitCache('IBLOCK_PROPERTY', $iblockPropertyId, $propsSku);
                                }
                            }
 
                            $propSkuHash = (!empty($propsSku)) ? md5(join('|', $propsSku)): md5($item["ITEM_ID"]);
 
                            $proxyProductPropertyKey = $item["ITEM_ID"]."_".$parentSkuData["IBLOCK_ID"]."_".$propSkuHash;
 
                            $productProperties = static::getHitCache('PRODUCT_PROPERTY', $proxyProductPropertyKey);
                            if (empty($productProperties))
                            {
                                $productProperties = \CIBlockPriceTools::GetOfferProperties(
                                    $item["ITEM_ID"],
                                    $parentSkuData["IBLOCK_ID"],
                                    $propsSku
                                );
 
                                static::setHitCache('PRODUCT_PROPERTY', $proxyProductPropertyKey, $productProperties);
                            }
 
                            if (!empty($productProperties))
                            {
                                foreach ($productProperties as $propData)
                                {
                                    $itemData["PROPS"][] = array(
                                        "NAME" => $propData["NAME"],
                                        "CODE" => $propData["CODE"],
                                        "VALUE" => $propData["VALUE"],
                                        "SORT" => $propData["SORT"],
                                    );
                                }
                            }
 
                        }
 
                        $parentProductIndexData = $productIndexList[$itemCode];
 
                        $priceData = array();
                        if (!empty($itemData['PRICE_LIST']))
                        {
                            $priceData = reset($itemData['PRICE_LIST']);
                            unset($itemData['PRICE_LIST']);
                        }
 
                        if (array_key_exists('PRODUCT', $itemData))
                        {
                            unset($itemData['PRODUCT']);
                        }
 
                        $bundleItemList[$parentProductIndexData['PARENT_ID']]["ITEMS"][$parentProductIndexData['CHILD_ID']] = array_merge($item,  $itemData, $priceData);
                    }
                }
            }
 
            $elementList = static::getHitCache('IBLOCK_ELEMENT_LIST', $productId);
            if (empty($elementList))
            {
                $productRes = \CIBlockElement::GetList(
                    array(),
                    array('ID' => $productIdList),
                    false,
                    false,
                    array("ID", "IBLOCK_ID", "IBLOCK_SECTION_ID", "PREVIEW_PICTURE", "DETAIL_PICTURE", "IBLOCK_TYPE_ID", "XML_ID")
                );
                while ($productData = $productRes->GetNext())
                {
                    $elementList[$productData['ID']] = $productData;
                }
 
                if (!empty($elementList) && is_array($elementList))
                {
                    static::setHitCache('IBLOCK_ELEMENT_LIST', $productId, $elementList);
                }
            }
 
            if (!empty($elementList) && is_array($elementList))
            {
                foreach ($bundleItemList as $bundleParentId => $bundleItemData)
                {
                    foreach ($bundleItemData["ITEMS"] as $bundleChildId => $item)
                    {
                        if (!$elementList[$item["ITEM_ID"]])
                            continue;
 
                        $elementData = $elementList[$item["ITEM_ID"]];
 
                        $properties = array();
                        $strIBlockXmlID = (string)\CIBlock::GetArrayByID($elementData['IBLOCK_ID'], 'XML_ID');
                        if ($strIBlockXmlID != "")
                        {
                            $properties[] = array(
                                "NAME" => "Catalog XML_ID",
                                "CODE" => "CATALOG.XML_ID",
                                "VALUE" => $strIBlockXmlID,
                            );
 
                            $elementData['CATALOG_XML_ID'] = $strIBlockXmlID;
 
                        }
 
                        if (!empty($proxyCatalogSkuData[$item["ITEM_ID"]]) && strpos($elementData["XML_ID"], '#') === false)
                        {
                            $parentSkuData = $proxyCatalogSkuData[$item["ITEM_ID"]];
                            if (!empty($proxyParentData[$parentSkuData['ID']]) && is_array($proxyParentData[$parentSkuData['ID']]))
                            {
                                $parentData = $proxyParentData[$parentSkuData['ID']];
                            }
                            else
                            {
                                $parentIterator = Iblock\ElementTable::getList(
                                    array(
                                        'select' => array('ID', 'XML_ID'),
                                        'filter' => array('ID' => $parentSkuData['ID']),
                                    )
                                );
 
                                $parentData = $parentIterator->fetch();
                                if (!empty($parentData))
                                {
                                    $proxyParentData[$parentSkuData['ID']] = $parentData;
                                }
 
                                unset($parentIterator);
                            }
 
                            $elementData["XML_ID"] = $parentData['XML_ID'].'#'.$elementData["XML_ID"];
                            unset($parentData);
                        }
 
                        $properties[] = array(
                            "NAME" => "Product XML_ID",
                            "CODE" => "PRODUCT.XML_ID",
                            "VALUE" => $elementData["XML_ID"],
                        );
 
                        $bundleItemData = $bundleItemList[$bundleParentId]["ITEMS"][$bundleChildId];
 
                        $bundleItemProps = array();
                        if (is_array($elementData["PROPS"]) && !empty($elementData["PROPS"]))
                        {
                            $bundleItemProps = $elementData["PROPS"];
                        }
 
                        if (!empty($properties))
                        {
                            $bundleItemProps = $bundleItemProps + $properties;
                        }
 
                        $bundleItemList[$bundleParentId]["ITEMS"][$bundleChildId] = $bundleItemData + array(
                                'IBLOCK_ID' => $elementData["IBLOCK_ID"],
                                'IBLOCK_SECTION_ID' => $elementData["IBLOCK_SECTION_ID"],
                                'PREVIEW_PICTURE' => $elementData["PREVIEW_PICTURE"],
                                'DETAIL_PICTURE' => $elementData["DETAIL_PICTURE"],
 
                                'CATALOG_XML_ID' => $elementData["CATALOG_XML_ID"],
                                'PRODUCT_XML_ID' => $elementData["XML_ID"],
                            );
 
                        $bundleItemList[$bundleParentId]["ITEMS"][$bundleChildId]['PROPS'] = $bundleItemProps;
                    }
                }
 
            }
 
            foreach(GetModuleEvents("sale", "OnGetSetItems", true) as $eventData)
            {
                ExecuteModuleEventEx($eventData, array(&$bundleItemList));
            }
 
            if (!empty($bundleItemList))
            {
                foreach ($bundleItemList as $bundleParentId => $bundleData)
                {
                    if (empty($bundleIndex[$bundleParentId]))
                        continue;
 
                    $productId = $bundleIndex[$bundleParentId];
 
                    $resultList[$productId] = $bundleData;
                }
 
                $result->setData(
                    array(
                        'BUNDLE_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        protected static function getUserGroups($userId)
        {
            $userId = (int)$userId;
            if ($userId < 0)
                return false;
 
            if (!isset(self::$userCache[$userId]))
                self::$userCache[$userId] = Main\UserTable::getUserGroupIds($userId);
 
            return self::$userCache[$userId];
        }
 
        public function ship(array $products)
        {
            return $this->shipProducts($products);
        }
 
        public function unship(array $products)
        {
            $result = new Sale\Result();
 
            $r = $this->tryUnship($products);
            if (!$r->isSuccess())
            {
                $result->addErrors($r->getErrors());
                return $result;
            }
 
            $data = $r->getData();
 
            if (!empty($data['PRODUCTS_LIST_SHIPPED']))
            {
                $productsList = array();
                foreach ($data['PRODUCTS_LIST_SHIPPED'] as $productId => $value)
                {
                    if ($value && !empty($products[$productId]))
                    {
                        $productsList[$productId] = $products[$productId];
                    }
                }
 
                if (!empty($productsList))
                {
                    $this->shipProducts($productsList);
                }
            }
 
            return $result;
        }
 
        public function deliver(array $products)
        {
            $result = new Sale\Result();
 
            $resultList = array();
 
            $productOrderList = static::createOrderListFromProducts($products);
 
            $deliverProductList = array();
            foreach ($products as $productId => $productData)
            {
                $userId = null;
                $orderPaid = null;
                $orderId = null;
 
                if (isset($productData['USER_ID']))
                {
                    $userId = $productData['USER_ID'];
                }
 
                if (isset($productData['ORDER_ID']))
                {
                    $orderId = $productData['ORDER_ID'];
                }
 
                if (isset($productData['PAID']))
                {
                    $orderPaid = $productData['PAID'];
                }
 
                if (isset($productOrderList[$productId]))
                {
                    foreach ($productOrderList[$productId] as $orderId => $order)
                    {
                        if (!isset($resultList[$productId]))
                        {
                            $deliverProductList[] = array(
                                'PRODUCT_ID' => $productId,
                                'USER_ID' => $order->getUserId(),
                                'PAID' => $order->isPaid(),
                                'ORDER_ID' => $orderId,
                            );
                        }
                    }
                }
                else
                {
                    if (isset($productData['USER_ID']))
                    {
                        $userId = $productData['USER_ID'];
                    }
 
                    if (isset($productData['ORDER_ID']))
                    {
                        $orderId = $productData['ORDER_ID'];
                    }
 
                    if (isset($productData['PAID']))
                    {
                        $orderPaid = $productData['PAID'];
                    }
 
                    $deliverProductList[] = array(
                        'PRODUCT_ID' => $productId,
                        'USER_ID' => $userId,
                        'PAID' => $orderPaid,
                        'ORDER_ID' => $orderId,
                    );
                }
            }
 
            if (!empty($deliverProductList))
            {
                foreach ($deliverProductList as $productData)
                {
                    $productId = $productData['PRODUCT_ID'];
                    $resultList[$productId] = \CatalogPayOrderCallback(
                        $productId,
                        $productData['USER_ID'],
                        $productData['PAID'],
                        $productData['ORDER_ID']
                    );
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'DELIVER_PRODUCTS_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        public function viewProduct(array $products)
        {
            $result = new Sale\Result();
 
            $resultList = array();
 
            foreach ($products as $productId => $itemData)
            {
                if (!isset($resultList[$productId]))
                {
                    $context = $this->getContext();
 
                    $resultList[$productId] = \CatalogViewedProductCallback(
                        $productId,
                        $context['USER_ID'],
                        $context['SITE_ID']
                    );
                }
 
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'VIEW_PRODUCTS_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        public function recurring(array $items)
        {
            $result = new Sale\Result();
 
            $resultList = array();
 
            foreach ($items as $productId => $itemData)
            {
                if (!isset($resultList[$productId]))
                {
                    $context = $this->getContext();
 
                    $resultList[$productId] = \CatalogRecurringCallback(
                        $productId,
                        $context['USER_ID']
                    );
                }
 
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'RECURRING_PRODUCTS_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        public function checkBarcode(array $items)
        {
            $result = new Sale\Result();
 
            $resultList = array();
 
            foreach ($items as $barcodeParams)
            {
                $resultList[$barcodeParams['BARCODE']] = false;
                $dbres = \CCatalogStoreBarcode::GetList(
                    array(),
                    $barcodeParams
                );
                $resultList[$barcodeParams['BARCODE']] = (bool)($dbres->GetNext());
 
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'BARCODE_CHECK_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        protected function shipProducts(array $products)
        {
            $result = new Sale\Result();
 
            $resultList = array_fill_keys(array_keys($products), false);
 
            $availableItems = $this->createProductsListWithCatalogData($products);
 
            $productStoreDataList = [];
            if (Catalog\Config\State::isUsedInventoryManagement())
            {
                $r = $this->getProductListStores($products);
                if ($r->isSuccess())
                {
                    $data = $r->getData();
                    if (!empty($data['PRODUCT_STORES_LIST']))
                    {
                        $productStoreDataList = $data['PRODUCT_STORES_LIST'];
                    }
                    unset($data);
                }
                unset($r);
            }
 
            foreach ($availableItems as $productId => $productData)
            {
                $r = static::shipProduct(
                    $productData,
                    (!empty($productStoreDataList[$productId])
                        ? $productStoreDataList[$productId]
                        : []
                    )
                );
                if (!$r->isSuccess())
                {
                    $result->addErrors($r->getErrors());
                    $result->addWarnings($r->getErrors());
                }
 
                $resultList[$productId] = $r->isSuccess();
            }
 
            $result->setData([
                'SHIPPED_PRODUCTS_LIST' => $resultList,
            ]);
 
            return $result;
        }
 
        // private function
 
        private static function updateCatalogStoreAmount(array $quantityList): Sale\Result
        {
            $result = new Sale\Result();
            $resultList = array();
 
            if (empty($quantityList))
            {
                return $result;
            }
 
            foreach ($quantityList as $catalogStoreId => $amount)
            {
                $fields = [
                    'AMOUNT' => $amount['AMOUNT'],
                ];
                if (isset($amount['QUANTITY_RESERVED']))
                {
                    $fields['QUANTITY_RESERVED'] = $amount['QUANTITY_RESERVED'];
                }
 
                $internalResult = Catalog\StoreProductTable::update($catalogStoreId, $fields);
 
                $resultList[$catalogStoreId] = $internalResult->isSuccess();
            }
 
            $result->setData(
                array(
                    'AMOUNT_UPDATED_LIST' => $resultList,
                )
            );
 
            return $result;
        }
 
        private static function shipProduct(array $productData, array $productStoreDataList = array()): Sale\Result
        {
            $result = new Sale\Result();
 
            $productId = $productData['PRODUCT_ID'];
 
            $productQuantity = self::getTotalAmountFromQuantityList($productData);
 
            $needShip = ($productQuantity < 0);
 
            if (
                //Catalog\Config\State::isUsedInventoryManagement()
                $productData['PRODUCT']['USED_STORE_INVENTORY']
            )
            {
                if (empty($productStoreDataList) && $needShip)
                {
                    $result->addError(
                        new Sale\ResultError(
                            Main\Localization\Loc::getMessage(
                                "DDCT_DEDUCTION_STORE_ERROR",
                                array_merge(
                                    self::getProductCatalogInfo($productId),
                                    array("#PRODUCT_ID#" => $productId)
                                )
                            ), "DDCT_DEDUCTION_STORE_ERROR"
                        )
                    );
                    return $result;
                }
 
                $setQuantityList = array();
                $r = static::getSetableStoreQuantityProduct($productData, $productStoreDataList);
                if ($r->isSuccess())
                {
                    $resultData = $r->getData();
                    if (!empty($resultData[Base::FLAT_QUANTITY_LIST]))
                    {
                        $setQuantityList = $resultData[Base::FLAT_QUANTITY_LIST];
                    }
                }
                else
                {
                    return $r;
                }
 
                /*if (!$productData['PRODUCT']['USED_STORE_INVENTORY']) // product types without stores
                {
                    $setQuantityList = [];
                } */
 
                $r = static::updateCatalogStoreAmount($setQuantityList);
                if ($r->isSuccess())
                {
                    $resultData = $r->getData();
                    if (!empty($resultData['AMOUNT_UPDATED_LIST']))
                    {
                        foreach($resultData['AMOUNT_UPDATED_LIST'] as $catalogStoreIsUpdated)
                        {
                            if ($catalogStoreIsUpdated === true)
                            {
                                static::clearHitCache(self::CACHE_STORE_PRODUCT);
                                if ($needShip)
                                {
                                    $r = static::deleteBarcodes($productData);
                                }
                                else
                                {
                                    $r = static::addBarcodes($productData);
                                }
 
                                if (!$r->isSuccess())
                                {
                                    $result->addErrors($r->getErrors());
                                }
                            }
                        }
                    }
                }
                else
                {
                    return $r;
                }
 
                return static::shipQuantityWithStoreControl($productData);
            }
            elseif (isset($productData["CATALOG"]))
            {
                if ($productData["CATALOG"]["QUANTITY_TRACE"] == "N")
                {
                    return $result;
                }
            }
 
            return static::shipQuantityWithoutStoreControl($productData);
 
        }
 
        private static function shipQuantityWithStoreControl(array $productData): Sale\Result
        {
            $result = new Sale\Result();
 
            $productId = (int)$productData['PRODUCT_ID'];
 
            $productQuantity = self::getTotalAmountFromQuantityList($productData);
 
            $catalogData = $productData['CATALOG'];
 
            $isExistsReserve = static::isExistsCommonStoreReserve($productData) && static::isReservationEnabled();
            $isNeedShip = ($productQuantity < 0);
 
            $productQuantity = abs($productQuantity);
 
            $fields = array();
 
            $catalogReservedQuantity = (float)$catalogData['QUANTITY_RESERVED'];
            $catalogQuantity = self::getTotalAmountFromPriceList($catalogData);
 
            $sumCatalogQuantity = $catalogReservedQuantity + $catalogQuantity;
 
            if ($isNeedShip)
            {
                if ($isExistsReserve)
                {
                    if ($catalogReservedQuantity >= $productQuantity)
                    {
                        $fields["QUANTITY_RESERVED"] = $catalogReservedQuantity - $productQuantity;
                    }
                    elseif ($sumCatalogQuantity >= $productQuantity)
                    {
                        $fields["QUANTITY_RESERVED"] = 0;
                        $fields["QUANTITY"] = $catalogQuantity - ($productQuantity - $catalogReservedQuantity);
                    }
                    else
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_NOT_ENOUGHT_QUANTITY_PRODUCT",
                                    array_merge(
                                        self::getProductCatalogInfo($productId),
                                        array("#PRODUCT_ID#" => $productId)
                                    )
                                ), "DDCT_DEDUCTION_NOT_ENOUGHT_QUANTITY_PRODUCT"
                            )
                        );
                        return $result;
                    }
                }
                else
                {
                    if ($productQuantity <= $catalogQuantity)
                    {
                        $fields["QUANTITY"] = $catalogQuantity - $productQuantity;
                    }
                    elseif ($productQuantity <= $sumCatalogQuantity)
                    {
                        $fields["QUANTITY"] = 0;
                        $fields["QUANTITY_RESERVED"] = $catalogReservedQuantity - ($productQuantity - $catalogQuantity);
                    }
                    else
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_NOT_ENOUGHT_QUANTITY_PRODUCT",
                                    array_merge(
                                        self::getProductCatalogInfo($productId),
                                        array("#PRODUCT_ID#" => $productId)
                                    )
                                ), "DDCT_DEDUCTION_NOT_ENOUGHT_QUANTITY_PRODUCT"
                            )
                        );
                        return $result;
                    }
                }
            }
            else
            {
                if ($isExistsReserve)
                {
                    $fields["QUANTITY_RESERVED"] = $catalogReservedQuantity + $productQuantity;
                }
                else
                {
                    $fields["QUANTITY"] = $catalogQuantity + $productQuantity;
                }
            }
 
            if (!$productData['PRODUCT']['USED_RESERVATION'])
            {
                if (isset($fields['QUANTITY_RESERVED']))
                {
                    unset($fields['QUANTITY_RESERVED']);
                }
            }
 
            $isUpdated = false;
            if (!empty($fields))
            {
                $internalResult = Catalog\Model\Product::update($productId, $fields);
 
                if ($internalResult->isSuccess())
                {
                    $isUpdated = true;
                    $quantityValues = array();
 
                    if (isset($fields['QUANTITY']))
                    {
                        $quantityValues[QuantityControl::QUANTITY] = $fields['QUANTITY'];
                        QuantityControl::resetAvailableQuantity($productId);
                    }
 
                    if (isset($fields['QUANTITY_RESERVED']))
                    {
                        $quantityValues[QuantityControl::RESERVED_QUANTITY] = $fields['QUANTITY_RESERVED'];
                    }
 
                    if (!empty($quantityValues))
                    {
                        QuantityControl::setValues($productId, $quantityValues);
                    }
                }
                else
                {
                    self::convertErrors($internalResult);
                }
                unset($internalResult);
            }
 
            $result->setData(
                array(
                    'IS_UPDATED' => $isUpdated,
                )
            );
 
            return $result;
        }
 
        private static function shipQuantityWithoutStoreControl(array $productData): Sale\Result
        {
            $result = new Sale\Result();
            $productId = (int)$productData['PRODUCT_ID'];
 
            $catalogData = $productData['CATALOG'];
 
            $productQuantity = self::getTotalAmountFromQuantityList($productData);
 
            $catalogReservedQuantity = (float)$catalogData['QUANTITY_RESERVED'];
            $catalogQuantity = self::getTotalAmountFromPriceList($catalogData);
 
            $fields = array();
 
            $isExistsReserve = static::isExistsCommonStoreReserve($productData) && static::isReservationEnabled();
            $isNeedShip = ($productQuantity < 0);
 
            if ($isNeedShip)
            {
                $productQuantity = abs($productQuantity);
                if (($productQuantity <= $catalogReservedQuantity + $catalogQuantity) || $catalogData["CAN_BUY_ZERO"] == "Y")
                {
                    if ($isExistsReserve)
                    {
                        if ($productQuantity <= $catalogReservedQuantity)
                        {
                            $needReservedQuantity = $catalogReservedQuantity - $productQuantity;
                            $fields["QUANTITY_RESERVED"] = $needReservedQuantity;
                        }
                        else
                        {
                            $fields["QUANTITY_RESERVED"] = 0;
                            $fields["QUANTITY"] = $catalogQuantity - ($productQuantity - $catalogReservedQuantity);
                        }
                    }
                    else
                    {
                        $fields["QUANTITY"] = $catalogQuantity - $productQuantity;
                    }
 
                }
                else //not enough products - don't deduct anything
                {
                    $result->addError(
                        new Sale\ResultError(
                            Main\Localization\Loc::getMessage(
                                "DDCT_DEDUCTION_QUANTITY_ERROR",
                                array_merge(
                                    self::getProductCatalogInfo($productId),
                                    array("#PRODUCT_ID#" => $productId)
                                )
                            ), "DDCT_DEDUCTION_QUANTITY_ERROR"
                        )
                    );
                }
            }
            else
            {
                if ($isExistsReserve)
                {
                    $fields["QUANTITY_RESERVED"] = $catalogReservedQuantity + $productQuantity;
                }
                else
                {
                    $fields["QUANTITY"] = $catalogQuantity + $productQuantity;
                }
            }
 
            if (!$productData['PRODUCT']['USED_RESERVATION'])
            {
                if (isset($fields['QUANTITY_RESERVED']))
                {
                    unset($fields['QUANTITY_RESERVED']);
                }
            }
 
            if (!empty($fields))
            {
                $internalResult = Catalog\Model\Product::update($productId, $fields);
 
                if ($internalResult-> isSuccess())
                {
                    $quantityValues = array();
 
                    if (isset($fields['QUANTITY']))
                    {
                        $quantityValues[QuantityControl::QUANTITY] = $fields['QUANTITY'];
                        QuantityControl::resetAvailableQuantity($productId);
                    }
 
                    if (isset($fields['QUANTITY_RESERVED']))
                    {
                        $quantityValues[QuantityControl::RESERVED_QUANTITY] = $fields['QUANTITY_RESERVED'];
                    }
 
                    if (!empty($quantityValues))
                    {
                        QuantityControl::setValues($productId, $quantityValues);
                    }
                }
                else
                {
                    self::convertErrors($internalResult);
                }
                unset($internalResult);
            }
 
            return $result;
        }
 
        private static function isExistsCommonStoreReserve(array $productData): bool
        {
            if (
                empty($productData['NEED_RESERVE_BY_STORE_LIST'])
                || !is_array($productData['NEED_RESERVE_BY_STORE_LIST'])
            )
            {
                return false;
            }
 
            foreach ($productData['NEED_RESERVE_BY_STORE_LIST'] as $block)
            {
                if (empty($block) || !is_array($block))
                {
                    continue;
                }
                if (in_array(true, $block, true))
                {
                    return true;
                }
            }
 
            return false;
        }
 
        private static function getSetableStoreQuantityProduct(array $productData, array $productStoreDataList): Sale\Result
        {
            $result = new Sale\Result();
 
            $setQuantityList = array();
            $productQuantity = self::getTotalAmountFromQuantityList($productData);
            $isNeedShip = ($productQuantity < 0);
 
            $quantityByStore = self::getQuantityDataFromStore($productData);
            $needQuantityList = $quantityByStore['AMOUNT'];
 
            if (empty($needQuantityList))
            {
                $autoShipStore = static::getAutoShipStoreData($productData, $productStoreDataList);
 
                if (!empty($autoShipStore))
                {
                    $needQuantityList[$autoShipStore['STORE_ID']] = ($productQuantity > $autoShipStore['AMOUNT'] ? $autoShipStore['AMOUNT'] : abs($productQuantity));
 
                    $shipmentItemList = $productData['SHIPMENT_ITEM_LIST'];
                    foreach ($shipmentItemList as $index => $shipmentItem)
                    {
                        $shipmentItemStoreCollection = $shipmentItem->getShipmentItemStoreCollection();
                        if ($shipmentItemStoreCollection && $shipmentItemStoreCollection->count() === 0)
                        {
                            $item = $shipmentItemStoreCollection->createItem($shipmentItem->getBasketItem());
                            $item->setField('STORE_ID', $autoShipStore['STORE_ID']);
                            $item->setField('QUANTITY', abs($productData['SHIPMENT_ITEM_QUANTITY_LIST'][$index]));
                        }
                    }
                }
            }
 
            if (!empty($productStoreDataList))
            {
                $isReservationEnabled = Main\Config\Option::get("sale", "product_reserve_condition") != "S";
                $compileReserve = self::getCompileReserve($productData);
                foreach ($productStoreDataList as $storeId => $productStoreData)
                {
                    $productId = $productStoreData['PRODUCT_ID'];
 
                    if ($isNeedShip && (isset($needQuantityList[$storeId]) && $productStoreData['AMOUNT'] < $needQuantityList[$storeId]))
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    'DDCT_DEDUCTION_QUANTITY_STORE_ERROR_2',
                                    array_merge(
                                        self::getProductCatalogInfo($productId),
                                        [
                                            '#STORE_NAME#' => \CCatalogStoreControlUtil::getStoreName($storeId),
                                            '#STORE_ID#' => $storeId,
                                            '#PRODUCT_ID#' => $productId,
                                        ]
                                    )
                                ), 'DDCT_DEDUCTION_QUANTITY_STORE_ERROR'
                            )
                        );
                    }
                    else
                    {
                        $storeConfig = self::getUpdateStoreConfig(
                            $storeId,
                            $needQuantityList,
                            $compileReserve,
                            [
                                'RESERVATION_ENABLED' => $isReservationEnabled,
                            ]
                        );
                        if (!$storeConfig['AMOUNT'] && !$storeConfig['QUANTITY_RESERVED'])
                        {
                            continue;
                        }
 
                        $storeUpdate = [];
                        if ($storeConfig['AMOUNT'])
                        {
                            $setQuantity = $productQuantity;
 
                            if (isset($needQuantityList[$storeId]))
                            {
                                $setQuantity = ($isNeedShip ? -1 : 1) * $needQuantityList[$storeId];
                            }
 
                            $storeUpdate['AMOUNT'] = $productStoreData['AMOUNT'] + $setQuantity;
                            $storeUpdate['DELTA'] = $setQuantity;
                            $storeUpdate['OLD_AMOUNT'] = $productStoreData['AMOUNT'];
                            unset($setQuantity);
                        }
                        if ($storeConfig['QUANTITY_RESERVED'])
                        {
                            $setReserveQuantity = 0;
                            if (isset($needQuantityList[$storeId]))
                            {
                                $setReserveQuantity = ($isNeedShip ? -1 : 1) * $needQuantityList[$storeId];
                            }
                            if (isset($quantityByStore['QUANTITY_RESERVED'][$storeId]))
                            {
                                $setReserveQuantity = ($isNeedShip ? -1 : 1) * $quantityByStore['QUANTITY_RESERVED'][$storeId];
                            }
                            if ($setReserveQuantity != 0)
                            {
                                $storeUpdate['QUANTITY_RESERVED'] = $productStoreData['QUANTITY_RESERVED']
                                    + $setReserveQuantity;
                                $storeUpdate['OLD_QUANTITY_RESERVED'] = $productStoreData['QUANTITY_RESERVED'];
                                $storeUpdate['QUANTITY_RESERVED_DELTA'] = $setReserveQuantity;
                            }
                            unset($setReserveQuantity);
                        }
                        if (!empty($storeUpdate))
                        {
                            $setQuantityList[$productStoreData['ID']] = $storeUpdate;
                        }
                        unset($storeUpdate, $storeConfig);
                    }
                }
            }
 
            if (!empty($setQuantityList))
            {
                $result->addData(
                    array(
                        Base::FLAT_QUANTITY_LIST => $setQuantityList,
                    )
                );
            }
 
            return $result;
        }
 
        private static function getUpdateStoreConfig(int $storeId, array $quantityList, array $reserveList, array $config): array
        {
            $result = [
                'AMOUNT' => isset($quantityList[$storeId]),
                'QUANTITY_RESERVED' => false,
            ];
 
            if ($config['RESERVATION_ENABLED'])
            {
                $result['QUANTITY_RESERVED'] = isset($reserveList[$storeId]);
            }
 
            return $result;
        }
 
        private static function getCompileReserve(array $product): array
        {
            if (empty($product['NEED_RESERVE_BY_STORE_LIST']) || !is_array($product['NEED_RESERVE_BY_STORE_LIST']))
            {
                return [];
            }
 
            $result = [];
            foreach ($product['NEED_RESERVE_BY_STORE_LIST'] as $shipment)
            {
                if (empty($shipment) || !is_array($shipment))
                {
                    continue;
                }
                foreach ($shipment as $storeId => $flag)
                {
                    if ($flag === true)
                    {
                        $result[$storeId] = true;
                    }
                }
            }
 
            return $result;
        }
 
        private static function getQuantityDataFromStore(array $product): array
        {
            $result = [
                'AMOUNT' => [],
                'QUANTITY_RESERVED' => [],
            ];
 
            $storeDataExists = (
                !empty($product['STORE_DATA_LIST'])
                && is_array($product['STORE_DATA_LIST'])
            );
            $reserveDataExists = (
                !empty($product[self::AMOUNT_SRC_STORE_RESERVED_LIST])
                && is_array($product[self::AMOUNT_SRC_STORE_RESERVED_LIST])
            );
            if (!$storeDataExists && !$reserveDataExists)
            {
                return $result;
            }
 
            $found = false;
            if ($storeDataExists)
            {
                foreach ($product['STORE_DATA_LIST'] as $storeList)
                {
                    if (!is_array($storeList))
                    {
                        continue;
                    }
                    $found = true;
                    foreach ($storeList as $storeId => $store)
                    {
                        if (!isset($result['AMOUNT'][$storeId]))
                        {
                            $result['AMOUNT'][$storeId] = 0;
                        }
                        $result['AMOUNT'][$storeId] += (float)$store['QUANTITY'];
                        if (isset($store['RESERVED_QUANTITY']))
                        {
                            if (!isset($result['QUANTITY_RESERVED'][$storeId]))
                            {
                                $result['QUANTITY_RESERVED'][$storeId] = 0;
                            }
                            $result['QUANTITY_RESERVED'][$storeId] += (float)$store['RESERVED_QUANTITY'];
                        }
                    }
                }
            }
 
            if (!$found && $reserveDataExists)
            {
                switch (self::getQuantityFormat($product[self::AMOUNT_SRC_STORE_RESERVED_LIST]))
                {
                    case self::QUANTITY_FORMAT_STORE:
                        $internalResult = self::calculateQuantityFromStores($product[self::AMOUNT_SRC_STORE_RESERVED_LIST]);
                        break;
                    case self::QUANTITY_FORMAT_SHIPMENT:
                        $internalResult = self::calculateQuantityFromShipments($product[self::AMOUNT_SRC_STORE_RESERVED_LIST]);
                        break;
                    default:
                        $internalResult = null;
                        break;
                }
                if ($internalResult !== null)
                {
                    $result['QUANTITY_RESERVED'] = $internalResult;
                }
                unset($internalResult);
            }
 
            return $result;
        }
 
        private static function deleteBarcodes(array $productData): Sale\Result
        {
            $result = new Sale\Result();
 
            $storeData = $productData['STORE_DATA_LIST'];
            if (!empty($storeData))
            {
                foreach ($storeData as $storeDataList)
                {
                    foreach($storeDataList as $storeDataValue)
                    {
                        $r = static::deleteBarcode($storeDataValue);
                        if (!$r->isSuccess())
                        {
                            $result->addErrors($r->getErrors());
                        }
                    }
                }
            }
 
            return $result;
        }
 
        private static function deleteBarcode(array $storeData): Sale\Result
        {
            $result = new Sale\Result();
 
            $storeId = $storeData["STORE_ID"];
            $productId = $storeData["PRODUCT_ID"];
            $barcodeMulti = $storeData['IS_BARCODE_MULTI'];
 
            $barcodeList = $storeData['BARCODE'];
 
            foreach ($barcodeList as $barcodeValue)
            {
                if (trim($barcodeValue) == "" || !$barcodeMulti)
                {
                    continue;
                }
 
                $result = new Sale\Result();
                $barcodeFields = array(
                    "STORE_ID" => $storeId,
                    "BARCODE" => $barcodeValue,
                    "PRODUCT_ID" => $productId,
                );
 
                $dbres = \CCatalogStoreBarcode::GetList(
                    array(),
                    $barcodeFields,
                    false,
                    false,
                    array("ID", "STORE_ID", "BARCODE", "PRODUCT_ID")
                );
 
                $catalogStoreBarcodeRes = $dbres->Fetch();
                if ($catalogStoreBarcodeRes)
                {
                    \CCatalogStoreBarcode::Delete($catalogStoreBarcodeRes["ID"]);
                }
                else
                {
                    $result->addError(
                        new Sale\ResultError(
                            Main\Localization\Loc::getMessage(
                                "DDCT_DEDUCTION_BARCODE_ERROR",
                                array_merge(
                                    self::getProductCatalogInfo($productId),
                                    array("#BARCODE#" => $barcodeValue)
                                )
                            ), "DDCT_DEDUCTION_BARCODE_ERROR"
                        )
                    );
                }
            }
 
            return $result;
        }
 
        private static function addBarcodes(array $productData): Sale\Result
        {
            $result = new Sale\Result();
            $storeData = $productData['STORE_DATA_LIST'];
            if (!empty($storeData))
            {
                foreach ($storeData as $storeDataList)
                {
                    foreach($storeDataList as $storeDataValue)
                    {
                        $r = static::addBarcode($storeDataValue);
                        if (!$r->isSuccess())
                        {
                            $result->addErrors($r->getErrors());
                        }
                    }
                }
            }
 
            return $result;
        }
 
        private static function addBarcode(array $storeData): Sale\Result
        {
            $result = new Sale\Result();
 
            $storeId = $storeData["STORE_ID"];
            $productId = $storeData["PRODUCT_ID"];
            $barcodeMulti = $storeData['IS_BARCODE_MULTI'];
 
            $barcodeList = $storeData['BARCODE'];
 
            foreach ($barcodeList as $barcodeValue)
            {
                if (trim($barcodeValue) == "" || !$barcodeMulti)
                {
                    continue;
                }
 
                $result = new Sale\Result();
                $barcodeFields = array(
                    "STORE_ID" => $storeId,
                    "BARCODE" => $barcodeValue,
                    "PRODUCT_ID" => $productId,
                );
                \CCatalogStoreBarcode::Add($barcodeFields);
            }
 
            return $result;
        }
 
        public function reserve(array $products)
        {
            $result = new Sale\Result();
 
            $resultList = array();
 
            $availableItems = $this->createProductsListWithCatalogData($products);
            foreach ($availableItems as $productId => $productData)
            {
                $resultList[$productId] = false;
 
                $r = static::reserveProduct($productData);
                if ($r->isSuccess())
                {
                    $resultData = $r->getData();
                    if (!empty($resultData))
                    {
                        $resultList[$productId] = $resultData;
                    }
                }
                else
                {
                    $result->addErrors($r->getErrors());
                }
 
            }
 
            $result->setData(array(
                'RESERVED_PRODUCTS_LIST' => $resultList,
            ));
 
            return $result;
        }
 
        private static function reserveProduct(array $productData): Sale\Result
        {
            if (
                !static::isReservationEnabled()
                || !$productData['PRODUCT']['USED_RESERVATION']
            )
            {
                return static::reserveQuantityWithDisabledReservation($productData);
            }
 
            return self::reserveStoreQuantityWithEnabledReservation($productData);
 
        }
 
        private static function reserveStoreQuantityWithEnabledReservation(array $productData): Sale\Result
        {
            $result = new Sale\Result();
 
            $enableStoreControl = Catalog\Config\State::isUsedInventoryManagement();
 
            $resultFields = [];
            $fields = []; // fields for update products
            $storeFields = []; // rows for update reserve in store
            $needShipList = [];
 
            $productId = $productData['PRODUCT_ID'];
            $storeProductQuantity = self::getStoreQuantityFromQuantityList($productData); // quantity with stores
            // empty store can't updated if used inventory managment
            if ($enableStoreControl && isset($storeProductQuantity[Base::EMPTY_STORE_ID]))
            {
                return $result;
            }
 
            $productQuantity = self::getTotalAmountFromQuantityList($productData);
 
            $isNeedReserve = ($productQuantity > 0);
            $catalogData = $productData['CATALOG'];
 
            $catalogReservedQuantity = (float)$catalogData['QUANTITY_RESERVED'];
            $catalogQuantity = self::getTotalAmountFromPriceList($catalogData);
 
            $sumCatalogQuantity = $catalogQuantity + $catalogReservedQuantity;
 
            if (isset($productData['NEED_SHIP']))
            {
                $needShipList = $productData['NEED_SHIP'];
            }
 
            $setQuantityReserved = $catalogReservedQuantity;
 
            if (!empty($needShipList) && !empty($productData['SHIPMENT_ITEM_DATA_LIST']))
            {
                $shipmentItemList = $productData['SHIPMENT_ITEM_DATA_LIST'];
                foreach ($needShipList as $shipmentItemIndex => $isNeedShip)
                {
                    if ($setQuantityReserved <= 0)
                    {
                        $setQuantityReserved = 0;
                        break;
                    }
 
                    if ($isNeedShip === true)
                    {
                        $shipmentItemQuantity = $shipmentItemList[$shipmentItemIndex];
 
                        $setQuantityReserved -= $shipmentItemQuantity;
                    }
                }
            }
 
            if ($catalogData["QUANTITY_TRACE"] == "N")
            {
                $fields["QUANTITY_RESERVED"] = $setQuantityReserved;
                $resultFields['IS_UPDATED'] = true;
                $resultFields['QUANTITY_RESERVED'] = 0;
            }
            else
            {
                $resultFields['QUANTITY_RESERVED'] = $catalogReservedQuantity;
 
                if (
                    $productData['PRODUCT']['TYPE'] === Catalog\ProductTable::TYPE_PRODUCT
                    || $productData['PRODUCT']['TYPE'] === Catalog\ProductTable::TYPE_OFFER
                )
                {
                    $storeFields = $enableStoreControl
                        ? self::loadCurrentStoreReserve($productId, $storeProductQuantity)
                        : [];
                }
 
                if ($isNeedReserve)
                {
                    if ($catalogData["CAN_BUY_ZERO"] == "Y")
                    {
                        $fields["QUANTITY_RESERVED"] = $catalogReservedQuantity + $productQuantity;
                        $fields['QUANTITY'] = $catalogQuantity - $productQuantity;
                    }
                    else
                    {
                        if ($catalogQuantity >= $productQuantity)
                        {
                            $fields["QUANTITY"] = $catalogQuantity - $productQuantity;
                            $fields["QUANTITY_RESERVED"] = $catalogReservedQuantity + $productQuantity;
                        }
                        else
                        {
                            $resultFields["QUANTITY_NOT_RESERVED"] = $productQuantity - $catalogQuantity;
 
                            $fields["QUANTITY"] = 0;
                            $fields["QUANTITY_RESERVED"] = $sumCatalogQuantity;
 
                            $result->addWarning(
                                new Sale\ResultWarning(
                                    Main\Localization\Loc::getMessage(
                                        "RSRV_QUANTITY_NOT_ENOUGH_ERROR",
                                        self::getProductCatalogInfo($productId)
                                    ), "ERROR_NOT_ENOUGH_QUANTITY"
                                )
                            );
                        }
                    }
                }
                else //undo reservation
                {
                    $correctReserve = 0;
                    if ($enableStoreControl)
                    {
                        foreach (array_keys($storeFields) as $storeId)
                        {
                            if ($storeFields[$storeId]['ID'] === null)
                            {
                                continue;
                            }
                            $storeProductFields = $storeFields[$storeId];
                            $newReserve = $storeProductFields['QUANTITY_RESERVED'] + $storeProductFields['ADD_QUANTITY_RESERVED'];
                            if ($newReserve < 0)
                            {
                                $correctReserve -= $newReserve;
                                $storeFields[$storeId]['ADD_QUANTITY_RESERVED'] -= $newReserve;
                            }
                        }
                    }
 
                    $needQuantity = abs($productQuantity) - $correctReserve;
 
                    $fields["QUANTITY"] = $catalogQuantity + $needQuantity;
 
                    $needReservedQuantity = $catalogReservedQuantity - $needQuantity;
                    if ($needQuantity > $catalogReservedQuantity)
                    {
                        $needReservedQuantity = $catalogReservedQuantity;
                    }
 
                    $fields["QUANTITY_RESERVED"] = $needReservedQuantity;
 
                    if ($enableStoreControl)
                    {
                        foreach (array_keys($storeFields) as $storeId)
                        {
                            if ($storeFields[$storeId]['ID'] === null)
                            {
                                unset($storeFields[$storeId]);
                            }
                        }
                    }
                }
 
            } //quantity trace
 
            if (!$productData['PRODUCT']['USED_RESERVATION'])
            {
                if (isset($fields['QUANTITY_RESERVED']))
                {
                    unset($fields['QUANTITY_RESERVED']);
                }
            }
 
            if (!empty($fields) && is_array($fields))
            {
                $storeSuccess = true;
                if ($enableStoreControl)
                {
                    foreach (array_keys($storeFields) as $index)
                    {
                        if ($index === Base::EMPTY_STORE_ID)
                        {
                            $storeSuccess = false;
                        }
                        else
                        {
                            $storeProductFields = $storeFields[$index];
                            $id = $storeProductFields['ID'];
                            $storeProductFields['QUANTITY_RESERVED'] += $storeProductFields['ADD_QUANTITY_RESERVED'];
                            unset($storeProductFields['ID'], $storeProductFields['ADD_QUANTITY_RESERVED']);
                            if ($id === null)
                            {
                                $storeProductFields['AMOUNT'] = 0;
                                $internalResult = Catalog\StoreProductTable::add($storeProductFields);
                            }
                            else
                            {
                                unset($storeProductFields['STORE_ID'], $storeProductFields['PRODUCT_ID']);
                                $internalResult = Catalog\StoreProductTable::update($id, $storeProductFields);
                            }
                            if ($internalResult->isSuccess())
                            {
                                $storeFields[$index]['ID'] = (int)$internalResult->getId();
                            }
                            else
                            {
                                $storeFields[$index]['ERROR'] = true;
                                $storeFields[$index]['ERROR_MESSAGES'] = $internalResult->getErrorMessages();
                                $storeSuccess = false;
                            }
                        }
                        if (!$storeSuccess)
                        {
                            break;
                        }
                    }
                }
 
                if (!$storeSuccess)
                {
                    return $result;
                }
 
                $resultFields['IS_UPDATED'] = false;
                $internalResult = Catalog\Model\Product::update($productId, $fields);
                if ($internalResult->isSuccess())
                {
                    $resultFields['IS_UPDATED'] = true;
                    $quantityValues = array();
                    if (isset($fields['QUANTITY']))
                    {
                        $quantityValues[QuantityControl::QUANTITY] = $fields['QUANTITY'];
                        QuantityControl::resetAvailableQuantity($productId);
                    }
 
                    if (isset($fields['QUANTITY_RESERVED']))
                    {
                        $quantityValues[QuantityControl::RESERVED_QUANTITY] = $fields['QUANTITY_RESERVED'];
                    }
 
                    if (!empty($quantityValues))
                    {
                        QuantityControl::setValues($productId, $quantityValues);
                    }
                }
                else
                {
                    self::convertErrors($internalResult);
                }
                unset($internalResult);
            }
 
            if (isset($resultFields['IS_UPDATED']))
            {
                if (isset($fields['QUANTITY_RESERVED']))
                {
                    $needReserved = $fields["QUANTITY_RESERVED"] - $resultFields['QUANTITY_RESERVED'];
                    if ($resultFields['QUANTITY_RESERVED'] > $fields["QUANTITY_RESERVED"])
                    {
                        $needReserved = $fields["QUANTITY_RESERVED"];
                    }
                    $resultFields["QUANTITY_RESERVED"] = $needReserved;
                }
 
                if (!empty($resultFields))
                {
                    $result->setData($resultFields);
                }
            }
 
            return $result;
        }
 
        private static function reserveQuantityWithDisabledReservation(array $productData): Sale\Result
        {
            $result = new Sale\Result();
 
            $catalogData = $productData['CATALOG'];
 
            $isQuantityTrace = $catalogData["QUANTITY_TRACE"] == 'Y';
 
            $productQuantity = self::getTotalAmountFromQuantityList($productData);
            $catalogQuantity = self::getTotalAmountFromPriceList($catalogData);
 
            $isUpdated = true;
 
            $fields = array(
                'QUANTITY' => $catalogQuantity,
            );
 
            if ($isQuantityTrace)
            {
                $productId = $productData['PRODUCT_ID'];
                $fields['QUANTITY'] -= $productQuantity;
                if ($catalogData["CAN_BUY_ZERO"] != "Y" && ($catalogQuantity < $productQuantity))
                {
                    $result->addWarning(
                        new Sale\ResultWarning(
                            Main\Localization\Loc::getMessage(
                                "RESERVE_QUANTITY_NOT_ENOUGH_ERROR",
                                array_merge(
                                    self::getProductCatalogInfo($productId),
                                    array("#PRODUCT_ID#" => $productId)
                                )
                            ), "RESERVE_QUANTITY_NOT_ENOUGH_ERROR"
                        )
                    );
 
                    $fields['QUANTITY'] = 0;
                }
 
                $internalResult = Catalog\Model\Product::update($productId, $fields);
                if (!$internalResult->isSuccess())
                {
                    $isUpdated = false;
                    self::convertErrors($internalResult);
                }
                unset($internalResult);
            }
 
            if ($isUpdated)
            {
                $result->setData($fields);
            }
 
            return $result;
        }
 
        private static function checkParentActivity(array $productIds, int $iblockId = 0): array
        {
            $resultList = array();
 
            $productIdsToLoad = array();
 
            foreach ($productIds as $productId)
            {
                $cacheKey = $productId.'|'.$iblockId;
 
                if (static::isExistsHitCache(self::CACHE_PARENT_PRODUCT_ACTIVE, $cacheKey))
                {
                    if (static::getHitCache(self::CACHE_PARENT_PRODUCT_ACTIVE, $cacheKey) === 'Y')
                    {
                        $resultList[] = $productId;
                    }
                }
                else
                {
                    $productIdsToLoad[] = $productId;
                }
            }
 
            if (!empty($productIdsToLoad))
            {
                $productToOfferMap = array();
                $parentIds = array();
 
                $cacheResult = array_fill_keys($productIdsToLoad, 'N');
 
                $productList = \CCatalogSku::getProductList($productIdsToLoad);
                if (!empty($productList))
                {
                    foreach ($productList as $offerId => $productInfo)
                    {
                        $productToOfferMap[$productInfo['ID']][] = $offerId;
                        $parentIds[] = $productInfo['ID'];
                    }
 
                    $itemList = \CIBlockElement::GetList(
                        array(),
                        array(
                            'ID' => array_unique($parentIds),
                            'IBLOCK_ID' => $iblockId,
                            'ACTIVE' => 'Y',
                            'ACTIVE_DATE' => 'Y',
                            'CHECK_PERMISSIONS' => 'N',
                        ),
                        false,
                        false,
                        array('ID')
                    );
                    while ($item = $itemList->Fetch())
                    {
                        if (!empty($productToOfferMap[$item['ID']]))
                        {
                            foreach ($productToOfferMap[$item['ID']] as $productId)
                            {
                                $cacheResult[$productId] = 'Y';
                                $resultList[] = $productId;
                            }
                        }
                    }
                }
 
                foreach ($cacheResult as $productId => $value)
                {
                    static::setHitCache(self::CACHE_PARENT_PRODUCT_ACTIVE, $productId.'|'.$iblockId, $value);
                }
            }
 
            return $resultList;
        }
 
        protected static function getPriceTitle($priceType)
        {
            $priceType = (int)$priceType;
            if ($priceType <= 0)
                return '';
            if (!isset(self::$priceTitleCache[$priceType]))
            {
                self::$priceTitleCache[$priceType] = '';
                $priceTypeList = Catalog\GroupTable::getTypeList();
                if (isset($priceTypeList[$priceType]))
                {
                    $groupName = (string)$priceTypeList[$priceType]['NAME_LANG'];
                    self::$priceTitleCache[$priceType] = ($groupName != '' ? $groupName : $priceTypeList[$priceType]['NAME']);
                    unset($groupName);
                }
                unset($priceTypeList);
            }
            return self::$priceTitleCache[$priceType];
        }
 
        public function tryShip(array $products)
        {
            $result = new Sale\Result();
            $resultList = array();
 
            $filteredProducts = $this->createQuantityFilteredProducts($products);
 
            if (empty($filteredProducts))
            {
                $result->setData(
                    array(
                        'TRY_SHIP_PRODUCTS_LIST' => array_fill_keys(array_keys($products), true),
                    )
                );
 
                return $result;
            }
 
            $availableItems = $this->createProductsListWithCatalogData($filteredProducts);
            if (empty($availableItems))
            {
                $productIdList = array_keys($products);
                foreach($productIdList as $productId)
                {
                    $result->addError(
                        new Sale\ResultError(
                            Main\Localization\Loc::getMessage(
                                "SALE_PROVIDER_PRODUCT_NOT_AVAILABLE",
                                array_merge(
                                    self::getProductCatalogInfo($productId),
                                    array("#PRODUCT_ID#" => $productId)
                                )
                            ), "SALE_PROVIDER_PRODUCT_NOT_AVAILABLE"
                        )
                    );
                }
 
                $result->setData(
                    array(
                        'TRY_SHIP_PRODUCTS_LIST' => array_fill_keys($productIdList, false),
                    )
                );
 
                return $result;
            }
            else
            {
                foreach ($availableItems as $productId => $productData)
                {
                    $messageId = null;
                    if (
                        isset($productData['PRODUCT']['TYPE'])
                        && $productData['PRODUCT']['TYPE'] === Catalog\ProductTable::TYPE_SERVICE
                    )
                    {
                        if (
                            (!isset($productData['CATALOG']['ACTIVE']) || $productData['CATALOG']['ACTIVE'] !== 'Y')
                            || (!isset($productData['PRODUCT']['AVAILABLE']) || $productData['PRODUCT']['AVAILABLE'] !== 'Y')
                        )
                        {
                            $messageId = 'SALE_PROVIDER_PRODUCT_SERVICE_NOT_AVAILABLE';
                        }
                    }
                    else
                    {
                        if (!isset($productData['CATALOG']['ACTIVE']) || $productData['CATALOG']['ACTIVE'] !== 'Y')
                        {
                            $messageId = 'SALE_PROVIDER_PRODUCT_NOT_AVAILABLE';
                        }
                    }
                    if ($messageId !== null)
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    $messageId,
                                    array_merge(
                                        self::getProductCatalogInfo($productId),
                                        array("#PRODUCT_ID#" => $productId)
                                    )
                                ), "SALE_PROVIDER_PRODUCT_NOT_AVAILABLE"
                            )
                        );
 
                        $resultList[$productId] = false;
                        unset($availableItems[$productId]);
                    }
                }
            }
 
            if (!empty($availableItems))
            {
                if (Catalog\Config\State::isUsedInventoryManagement())
                {
                    $r = $this->checkProductsInStore($availableItems);
                    if ($r->isSuccess())
                    {
                        $data = $r->getData();
                        if (!empty($data['PRODUCTS_LIST_IN_STORE']))
                        {
                            $resultList = $resultList + $data['PRODUCTS_LIST_IN_STORE'];
                        }
                    }
                    else
                    {
                        $result->addErrors($r->getErrors());
                    }
                }
                else
                {
                    $r = $this->checkProductsQuantity($availableItems);
                    if ($r->isSuccess())
                    {
                        $data = $r->getData();
                        if (!empty($data['PRODUCTS_LIST_REQUIRED_QUANTITY']))
                        {
                            $resultList = $resultList + $data['PRODUCTS_LIST_REQUIRED_QUANTITY'];
                        }
                    }
                    else
                    {
                        $result->addErrors($r->getErrors());
                    }
 
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'TRY_SHIP_PRODUCTS_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        public function isNeedShip(array $products)
        {
            $result = new Sale\Result();
 
            $result->setData(
                array(
                    'IS_NEED_SHIP' => static::isReservationEnabled(),
                )
            );
            return $result;
        }
 
        private function createQuantityFilteredProducts(array $products): array
        {
            $resultList = array();
            foreach ($products as $productId => $productData)
            {
                $resultList[$productId] = $productData;
                if (array_key_exists('QUANTITY', $productData))
                {
                    if ($productData['QUANTITY'] > 0)
                    {
                        unset($resultList[$productId]);
                    }
                    else
                    {
                        $resultList[$productId] *= -1;
                    }
                }
                elseif (!empty($productData[Base::FLAT_QUANTITY_LIST]))
                {
                    foreach ($productData[Base::FLAT_QUANTITY_LIST] as $basketCode => $quantity)
                    {
                        if ($quantity > 0)
                        {
                            unset($resultList[$productId][Base::FLAT_QUANTITY_LIST][$basketCode]);
                        }
                        else
                        {
                            $resultList[$productId][Base::FLAT_QUANTITY_LIST][$basketCode] *= -1;
                        }
                    }
 
                    if (empty($resultList[$productId][Base::FLAT_QUANTITY_LIST]))
                    {
                        unset($resultList[$productId]);
                    }
                }
            }
 
            return $resultList;
        }
 
        public function tryUnship(array $products)
        {
            $result = new Sale\Result();
            $resultList = array();
            $availableItems = $this->createProductsListWithCatalogData($products);
 
            if (Catalog\Config\State::isUsedInventoryManagement())
            {
                $r = $this->checkProductsInStore($availableItems);
                if ($r->isSuccess())
                {
                    $data = $r->getData();
                    if (!empty($data['PRODUCTS_LIST_IN_STORE']))
                    {
                        $resultList = $data['PRODUCTS_LIST_IN_STORE'];
                    }
                }
            }
            else
            {
                $r = $this->checkProductsQuantity($availableItems);
                if ($r->isSuccess())
                {
                    $data = $r->getData();
                    if (!empty($data['PRODUCTS_LIST_REQUIRED_QUANTITY']))
                    {
                        $resultList = $data['PRODUCTS_LIST_REQUIRED_QUANTITY'];
                    }
                }
                else
                {
                    return $r;
                }
 
            }
 
            if (!empty($resultList))
            {
                $result->setData(array(
                    'PRODUCTS_LIST_SHIPPED' => $resultList,
                ));
            }
 
            return $result;
        }
 
        public function checkProductsInStore(array $products)
        {
            $result = new Sale\Result();
            $resultList = array();
 
            $r = $this->checkProductInStores($products);
            if (!$r->isSuccess())
            {
                return $r;
            }
 
            $storeProductMap = $this->createStoreProductMap($products);
 
            $r = $this->checkExistsProductsInStore($products, $storeProductMap);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data['PRODUCTS_LIST_EXISTS_IN_STORE']))
                {
                    $resultList = $data['PRODUCTS_LIST_EXISTS_IN_STORE'];
                }
            }
            else
            {
                return $r;
            }
 
            $r = $this->checkProductQuantityInStore($products);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data['PRODUCTS_LIST_REQUIRED_QUANTITY_IN_STORE']))
                {
                    $resultList = $data['PRODUCTS_LIST_REQUIRED_QUANTITY_IN_STORE'];
                }
            }
            else
            {
                $result->addErrors($r->getErrors());
            }
 
            if (!empty($resultList))
            {
                $result->addData(
                    array(
                        'PRODUCTS_LIST_IN_STORE' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        private function checkProductsQuantity(array $products): Sale\Result
        {
            $result = new Sale\Result();
 
            $resultList = array();
            $availableQuantityList = array();
            $r = $this->getAvailableQuantity($products);
            if ($r->isSuccess())
            {
                $resultData = $r->getData();
                if (!empty($resultData['AVAILABLE_QUANTITY_LIST']))
                {
                    $availableQuantityList = $resultData['AVAILABLE_QUANTITY_LIST'];
                }
 
            }
            else
            {
                return $r;
            }
 
            $enabledReservation = static::isReservationEnabled();
 
            foreach ($products as $productId => $productData)
            {
                if (empty($productData['CATALOG']))
                {
                    $resultList[$productId] = false;
                    $result->addError(
                        new Sale\ResultError(
                            Main\Localization\Loc::getMessage(
                                "SALE_PROVIDER_PRODUCT_NOT_AVAILABLE",
                                array_merge(
                                    self::getProductCatalogInfo($productId),
                                    array("#PRODUCT_ID#" => $productId)
                                )
                            ), "SALE_PROVIDER_PRODUCT_NOT_AVAILABLE"
                        )
                    );
 
                    continue;
                }
 
                $resultList[$productId] = true;
                $catalogData = $productData['CATALOG'];
 
 
                if ($catalogData["CHECK_QUANTITY"])
                {
                    $productQuantity = self::getTotalAmountFromQuantityList($productData);
 
                    $availableQuantity = 0;
 
                    if (isset($availableQuantityList[$productId]))
                    {
                        $availableQuantity = $availableQuantityList[$productId];
                    }
 
                    $availableQuantity += (float)$catalogData['QUANTITY_RESERVED'];
 
                    if ($enabledReservation && $productQuantity > $availableQuantity)
                    {
                        $resultList[$productId] = false;
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_QUANTITY_ERROR",
                                    array_merge(
                                        self::getProductCatalogInfo($productId),
                                        array("#PRODUCT_ID#" => $productId)
                                    )
                                ), "DDCT_DEDUCTION_QUANTITY_ERROR"
                            )
                        );
                    }
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'PRODUCTS_LIST_REQUIRED_QUANTITY' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        private function createProductsListWithCatalogData(array $products): array
        {
            $productDataList = array();
            $productIdList = array_fill_keys(array_keys($products), true);
            $r = $this->getData($products, [self::USE_GATALOG_DATA, 'FULL_QUANTITY']);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data[static::RESULT_CATALOG_LIST]))
                {
                    $productDataList = $data[static::RESULT_CATALOG_LIST];
                }
            }
 
            $resultList = array();
            $availableListId = array_intersect_key($productIdList, $productDataList);
            if (!empty($availableListId))
            {
                foreach (array_keys($availableListId) as $productId)
                {
                    if (empty($productDataList[$productId]) || !is_array($productDataList[$productId]))
                    {
                        continue;
                    }
                    $resultList[$productId] = $products[$productId];
                    $resultList[$productId]['PRODUCT'] = $productDataList[$productId]['PRODUCT'];
                    unset($productDataList[$productId]['PRODUCT']);
                    $resultList[$productId]['CATALOG'] = $productDataList[$productId];
                }
            }
 
            return $resultList;
        }
 
        protected function createStoreProductMap(array $products)
        {
            $productStoreDataList = array();
            $r = $this->getProductListStores($products);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data['PRODUCT_STORES_LIST']))
                {
                    $productStoreDataList = $data['PRODUCT_STORES_LIST'];
                }
            }
 
            $canAutoShipList = array();
            $r = $this->canProductListAutoShip($products);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data['PRODUCT_CAN_AUTOSHIP_LIST']))
                {
                    $canAutoShipList = $data['PRODUCT_CAN_AUTOSHIP_LIST'];
                }
            }
 
            $storeProductList = array();
            foreach ($products as $productId => $productData)
            {
                if (!empty($productData['STORE_DATA_LIST']) && static::isExistsBarcode($productData['STORE_DATA_LIST']))
                {
                    $storeProductList[$productId] = $productData['STORE_DATA_LIST'];
                }
                elseif (!empty($canAutoShipList[$productId]) && !empty($productStoreDataList[$productId]))
                {
                    $productQuantity = self::getTotalAmountFromQuantityList($productData);
                    foreach ($productData['SHIPMENT_ITEM_DATA_LIST'] as $shipmentItemIndex => $shipmentItemQuantity)
                    {
                        foreach ($productStoreDataList[$productId] as $productStoreData)
                        {
                            $storeId = $productStoreData['STORE_ID'];
                            $storeProductList[$productId][$shipmentItemIndex][$storeId] = array(
                                'PRODUCT_ID' => $productId,
                                'STORE_ID' => $storeId,
                                'IS_BARCODE_MULTI' => false,
                                'QUANTITY' => abs($productQuantity),
                            );
                        }
                    }
                }
            }
 
            return $storeProductList;
        }
 
        private function checkProductInStores($products): Sale\Result
        {
            $result = new Sale\Result();
            $productStoreDataList = array();
            $canAutoShipList = array();
            $r = $this->canProductListAutoShip($products);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data['PRODUCT_CAN_AUTOSHIP_LIST']))
                {
                    $canAutoShipList = $data['PRODUCT_CAN_AUTOSHIP_LIST'];
                }
            }
 
            $r = $this->getProductListStores($products);
            if ($r->isSuccess())
            {
                $data = $r->getData();
                if (!empty($data['PRODUCT_STORES_LIST']))
                {
                    $productStoreDataList = $data['PRODUCT_STORES_LIST'];
                }
            }
 
            foreach ($products as $productId => $productData)
            {
                if (!empty($productData['STORE_DATA_LIST']))
                {
                    if (!static::isExistsBarcode($productData['STORE_DATA_LIST']))
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_MULTI_BARCODE_EMPTY", self::getProductCatalogInfo($productId)
                                ), "DDCT_DEDUCTION_MULTI_BARCODE_EMPTY"
                            )
                        );
                    }
                }
                elseif ($canAutoShipList[$productId] === false)
                {
                    if (!isset($productStoreDataList[$productId]))
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_STORE_EMPTY_ERROR",
                                    self::getProductCatalogInfo($productId)
                                ), "DEDUCTION_STORE_ERROR1"
                            )
                        );
                    }
                    elseif (count($productStoreDataList[$productId]) > 1)
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_STORE_ERROR",
                                    self::getProductCatalogInfo($productId)
                                ), "DEDUCTION_STORE_ERROR1"
                            )
                        );
                    }
                }
            }
 
            return $result;
 
        }
 
        private static function isExistsBarcode(array $list): bool
        {
            $resultValue = false;
            foreach ($list as $storeDataList)
            {
                foreach ($storeDataList as $storeValue)
                {
                    if (is_array($storeValue['BARCODE']) && $storeValue['IS_BARCODE_MULTI'] === true)
                    {
                        foreach ($storeValue["BARCODE"] as $barcodeValue)
                        {
                            if (trim($barcodeValue) == "")
                            {
                                return $resultValue;
                            }
                        }
 
                        $resultValue = true;
 
                    }
                    else
                    {
                        return (!empty($storeValue['BARCODE']));
                    }
 
                }
            }
 
            return $resultValue;
        }
 
        protected function checkProductQuantityInStore(array $products)
        {
            $result = new Sale\Result();
 
            $resultList = array();
            $productQuantityList = array();
            $usedProductStoreQuantity = [];
 
            $productStoreDataList = self::loadCurrentProductStores(array_keys($products));
 
            foreach ($products as $productId => $productData)
            {
                if (empty($productData['CATALOG']))
                    continue;
                if (
                    isset($productData['PRODUCT'])
                    && !$productData['PRODUCT']['USED_STORE_INVENTORY'] //product types without stores
                )
                {
                    continue;
                }
 
                $productStoreData = $productStoreDataList[$productId] ?? [];
 
                $storeDataList = $productData['STORE_DATA_LIST'];
 
                if (!empty($storeDataList))
                {
                    foreach ($storeDataList as $barcodeList)
                    {
                        foreach($barcodeList as $storeId => $storeDataValue)
                        {
                            if (!empty($storeDataValue))
                            {
                                if (
                                    !isset($productStoreData[$storeId])
                                    || ($productStoreData[$storeId]["AMOUNT"] < $storeDataValue["QUANTITY"])
                                )
                                {
                                    $result->addError(
                                        new Sale\ResultError(
                                            Main\Localization\Loc::getMessage(
                                                'DDCT_DEDUCTION_QUANTITY_STORE_ERROR_2',
                                                array_merge(
                                                    self::getProductCatalogInfo($productId),
                                                    [
                                                        '#STORE_NAME#' => \CCatalogStoreControlUtil::getStoreName($storeId),
                                                        '#STORE_ID#' => $storeId,
                                                    ]
                                                )
                                            ), 'DDCT_DEDUCTION_QUANTITY_STORE_ERROR'
                                        )
                                    );
                                }
                                else
                                {
                                    if (!isset($productQuantityList[$productId]))
                                    {
                                        $productQuantityList[$productId] = 0;
                                    }
 
                                    $productQuantityList[$productId] += $storeDataValue["QUANTITY"];
 
                                    if (!isset($usedProductStoreQuantity[$productId]))
                                    {
                                        $usedProductStoreQuantity[$productId] = [];
                                    }
                                    $usedProductStoreQuantity[$productId][$storeId] = true;
 
                                    $r = static::checkProductBarcodes($productData, $productStoreData[$storeId], $storeDataValue);
                                    if ($r->isSuccess())
                                    {
                                        if (!array_key_exists($productId, $resultList))
                                        {
                                            $resultList[$productId] = true;
                                        }
                                    }
                                    else
                                    {
                                        $result->addErrors($r->getErrors());
                                    }
                                }
                            }
                            else
                            {
                                if (!array_key_exists($productId, $resultList))
                                {
                                    $resultList[$productId] = true;
                                }
                            }
                        }
                    }
                }
                else
                {
                    $resultList[$productId] = true;
 
                    if (!isset($productQuantityList[$productId]))
                    {
                        $productQuantityList[$productId] = 0;
                    }
 
                    if (
                        !empty($productData[Base::FLAT_QUANTITY_LIST])
                        && is_array($productData[Base::FLAT_QUANTITY_LIST])
                    )
                    {
                        $productQuantityList[$productId] = array_sum(
                            $productData[Base::FLAT_QUANTITY_LIST]
                        );
                    }
 
                }
            }
 
            if (!empty($productQuantityList))
            {
                foreach ($productQuantityList as $amountProductId => $amountValue)
                {
                    $product = $products[$amountProductId];
                    $catalogData = $product['CATALOG'];
 
                    $catalogQuantity = self::getTotalAmountFromPriceList($catalogData);
                    $catalogReservedQuantity = (float)$catalogData['QUANTITY_RESERVED'];
 
                    if ($product[Base::FLAT_RESERVED_QUANTITY_LIST][$product['BASKET_CODE']] > 0)
                    {
                        $catalogQuantity += $catalogReservedQuantity;
                    }
                    else
                    {
                        $unusedReserve = 0.0;
                        if (isset($usedProductStoreQuantity[$amountProductId]))
                        {
                            $usedProductStores = $usedProductStoreQuantity[$amountProductId];
                            $productStores = $productStoreDataList[$amountProductId];
                            foreach (array_keys($productStores) as $storeId)
                            {
                                if (isset($usedProductStores[$storeId]))
                                {
                                    continue;
                                }
                                $unusedReserve += $productStores[$storeId]['QUANTITY_RESERVED'];
                            }
                            unset($storeId);
                            unset($productStores, $usedProductStores);
                        }
                        $catalogQuantity += $unusedReserve;
                        unset($unusedReserve);
                    }
 
                    if ($amountValue > $catalogQuantity)
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_SHIPMENT_QUANTITY_NOT_ENOUGH",
                                    self::getProductCatalogInfo($amountProductId)
                                ), "SALE_PROVIDER_SHIPMENT_QUANTITY_NOT_ENOUGH"
                            )
                        );
                    }
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'PRODUCTS_LIST_REQUIRED_QUANTITY_IN_STORE' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        protected function checkExistsProductItemInStore(array $productData, array $storeDataList = array())
        {
            $result = new Sale\Result();
 
            if (!empty($storeDataList))
            {
                foreach ($storeDataList as $storeData)
                {
                    foreach ($storeData as $storeDataValue)
                    {
                        $storeId = $storeDataValue['STORE_ID'];
 
                        if ((int)$storeId < -1 || (int)$storeId == 0
                            || !isset($storeDataValue["QUANTITY"]) || (int)$storeDataValue["QUANTITY"] < 0)
                        {
                            $result->addError(
                                new Sale\ResultError(
                                    Main\Localization\Loc::getMessage(
                                        "DDCT_DEDUCTION_STORE_ERROR",
                                        self::getProductCatalogInfo($productData['PRODUCT_ID'])
                                    ), "DDCT_DEDUCTION_STORE_ERROR"
                                )
                            );
                            return $result;
                        }
                    }
                }
            }
            else
            {
                $result->addError( new Sale\ResultError(
                    Main\Localization\Loc::getMessage("DDCT_DEDUCTION_STORE_ERROR", self::getProductCatalogInfo($productData['PRODUCT_ID'])),
                    "DEDUCTION_STORE_ERROR1"
                ));
            }
 
            return $result;
        }
 
        protected function checkExistsProductsInStore(array $products, array $storeData = array())
        {
            $result = new Sale\Result();
 
            $resultList = array();
            if (!empty($storeData))
            {
                foreach ($products as $productId => $productData)
                {
                    $productStoreData = array();
                    if (!empty($storeData[$productId]))
                    {
                        $productStoreData = $storeData[$productId];
                    }
 
                    $resultList[$productId] = true;
 
                    if (
                        (
                            isset($productData['BUNDLE_PARENT'])
                            && $productData['BUNDLE_PARENT'] === true
                        )
                        || (
                            isset($productData['PRODUCT']['USED_STORE_INVENTORY'])
                            && !$productData['PRODUCT']['USED_STORE_INVENTORY']
                        )
                    )
                    {
                        continue;
                    }
 
                    $r = $this->checkExistsProductItemInStore($productData, $productStoreData);
                    if (!$r->isSuccess())
                    {
                        $result->addErrors($r->getErrors());
                        $resultList[$productId] = false;
                    }
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'PRODUCTS_LIST_EXISTS_IN_STORE' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        protected static function checkProductBarcodes(array $productData, array $productStoreData, array $storeData = array())
        {
            $result = new Sale\Result();
 
            $productId = $productData['PRODUCT_ID'];
            $storeId = $productStoreData['STORE_ID'];
 
            if (isset($storeData['BARCODE']) && count($storeData['BARCODE']) > 0)
            {
                foreach ($storeData['BARCODE'] as $barcodeValue)
                {
                    if (trim($barcodeValue) == "" && $storeData['IS_BARCODE_MULTI'] === true)
                    {
                        $result->addError(
                            new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_MULTI_BARCODE_EMPTY",
                                    array_merge(
                                        self::getProductCatalogInfo($productId),
                                        array("#STORE_ID#" => $storeId)
                                    )
                                ), "DDCT_DEDUCTION_MULTI_BARCODE_EMPTY"
                            )
                        );
                        continue;
                    }
                    if (!empty($barcodeValue))
                    {
                        $fields = [
                            '=STORE_ID' => static::CATALOG_PROVIDER_EMPTY_STORE_ID,
                            '=BARCODE' => $barcodeValue,
                            '=PRODUCT_ID' => $productId,
                        ];
 
                        if ($storeData['IS_BARCODE_MULTI'] === true)
                        {
                            $fields['=STORE_ID'] = $storeId;
                        }
                        $iterator = Catalog\StoreBarcodeTable::getList([
                            'select' => ['ID'],
                            'filter' => $fields,
                            'limit' => 1,
                        ]);
                        $row = $iterator->fetch();
                        unset($iterator);
 
                        if (empty($row))
                        {
                            $result->addError( new Sale\ResultError(
                                Main\Localization\Loc::getMessage(
                                    "DDCT_DEDUCTION_BARCODE_ERROR",
                                    array_merge(self::getProductCatalogInfo($productId), array("#BARCODE#" => $barcodeValue))
                                ),
                                "DDCT_DEDUCTION_BARCODE_ERROR"
                            ));
                        }
                    }
                }
            }
            else
            {
                $result->addError( new Sale\ResultError(
                    Main\Localization\Loc::getMessage(
                        "DDCT_DEDUCTION_MULTI_BARCODE_EMPTY",
                        array_merge(self::getProductCatalogInfo($productId), array("#STORE_ID#" => $storeId))
                    ),
                    "DDCT_DEDUCTION_MULTI_BARCODE_EMPTY"
                ));
            }
            return $result;
        }
 
        private function canProductListAutoShip(array $products): Sale\Result
        {
            $context = $this->getContext();
            if (empty($context['SITE_ID']))
            {
                throw new Main\ArgumentNullException('SITE_ID');
            }
 
            static $canAutoList = array();
 
            $resultList = array();
            $hasNew = false;
 
            $countStores = 0;
 
            $countStoresResult = $this->getStoresCount();
            if ($countStoresResult->isSuccess())
            {
                $countStores = $countStoresResult->get('STORES_COUNT');
            }
 
            $countStoresResult->getData();
            $defaultDeductionStore = (int)Main\Config\Option::get("sale", "deduct_store_id", "", $context['SITE_ID']);
            $isDefaultStore = ($defaultDeductionStore > 0);
            foreach ($products as $productId => $productData)
            {
                if (isset($canAutoList[$productId]))
                {
                    $resultList[$productId] = $canAutoList[$productId];
                    continue;
                }
 
                if (!$productData['PRODUCT']['USED_STORE_INVENTORY']) // product types without stores
                {
                    $canAutoList[$productId] = true;
                    $resultList[$productId] = true;
                    continue;
                }
 
                $isOneStore = ($countStores == 1 || $countStores == -1);
 
                $isOnlyOneStore = ($isOneStore || $isDefaultStore);
                $isMulti = false;
                if (isset($productData['STORE_DATA_LIST']))
                {
                    $storeData = array();
                    $shipmentItemStoreData = reset($productData['STORE_DATA_LIST']);
                    if (!empty($shipmentItemStoreData))
                    {
                        $storeData = reset($shipmentItemStoreData);
                    }
 
                    if (!empty($storeData))
                    {
                        $isMulti = isset($storeData['IS_BARCODE_MULTI']) && $storeData['IS_BARCODE_MULTI'] === true;
                    }
                }
                elseif (isset($productData['IS_BARCODE_MULTI']))
                {
                    $isMulti = $productData['IS_BARCODE_MULTI'] === true;
                }
 
                $resultList[$productId] = ($isOnlyOneStore && !$isMulti);
                $hasNew = true;
 
                if ($isMulti)
                {
                    $hasNew = false;
                }
            }
 
            if ($hasNew)
            {
                $productStoreList = [];
                $r = $this->getProductListStores($products);
                if ($r->isSuccess())
                {
                    $productStoreData = $r->getData();
                    if (
                        !empty($productStoreData['PRODUCT_STORES_LIST'])
                        && is_array($productStoreData['PRODUCT_STORES_LIST'])
                    )
                    {
                        $productStoreList = $productStoreData['PRODUCT_STORES_LIST'];
                    }
                }
 
                if (!empty($productStoreList))
                {
                    foreach ($products as $productId => $productData)
                    {
                        if (!empty($productStoreList[$productId]))
                        {
                            $countProductInStore = 0;
                            foreach ($productStoreList[$productId] as $storeData)
                            {
                                if ((float)$storeData['AMOUNT'] > 0)
                                {
                                    $countProductInStore++;
                                }
                            }
                            $resultList[$productId] = ($countProductInStore == 1);
                            $canAutoList[$productId] = $resultList[$productId];
                        }
                    }
                }
            }
 
            $result = new Sale\Result();
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'PRODUCT_CAN_AUTOSHIP_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        private static function getAutoShipStoreData(array $product, array $productStoreDataList)
        {
            $isMulti = false;
            if (isset($product['STORE_DATA_LIST']))
            {
                $storeData = [];
                $shipmentItemStoreData = reset($product['STORE_DATA_LIST']);
                if (!empty($shipmentItemStoreData))
                {
                    $storeData = reset($shipmentItemStoreData);
                }
 
                if (!empty($storeData))
                {
                    $isMulti = isset($storeData['IS_BARCODE_MULTI']) && $storeData['IS_BARCODE_MULTI'] === true;
                }
            }
            elseif (isset($product['IS_BARCODE_MULTI']))
            {
                $isMulti = $product['IS_BARCODE_MULTI'] === true;
            }
 
            if ($isMulti)
            {
                return false;
            }
 
            $outputStoreData = false;
 
            if (!empty($productStoreDataList))
            {
                $countProductInStore = 0;
 
                $storeProductData = false;
                foreach ($productStoreDataList as $storeData)
                {
                    if ((float)$storeData['AMOUNT'] > 0)
                    {
                        $countProductInStore++;
                        if (!$storeProductData)
                        {
                            $storeProductData = $storeData;
                        }
                    }
                }
 
                if ($countProductInStore == 1 && !empty($storeProductData))
                {
                    $outputStoreData = $storeProductData;
                }
            }
 
            return $outputStoreData;
        }
 
        protected function getCountProductsInStore(array $products)
        {
            $result = new Sale\Result();
 
            $productStoreList = array();
            $productStoreResult = $this->getProductListStores($products);
            if ($productStoreResult->isSuccess())
            {
                $productStoreData = $productStoreResult->getData();
 
                if (array_key_exists('PRODUCT_STORES_LIST', $productStoreData))
                {
                    $productStoreList = $productStoreData['PRODUCT_STORES_LIST'];
                }
            }
 
            if (empty($productStoreList))
            {
                return $result;
            }
 
            $resultList = array();
            foreach ($productStoreList as $productStoreDataList)
            {
                foreach ($productStoreDataList as $storeId =>$productStoreData)
                {
                    $productId = $productStoreData['PRODUCT_ID'];
                    if ($productStoreData['AMOUNT'] > 0)
                    {
                        if (!isset($resultList[$productId]))
                        {
                            $resultList[$productId] = [];
                        }
 
                        $resultList[$productId][$storeId] = $productStoreData['AMOUNT'];
                    }
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData(
                    array(
                        'RESULT_LIST' => $resultList,
                    )
                );
            }
 
            return $result;
        }
 
        public function getStoresCount()
        {
            $result = new Sale\Result();
 
            $count = -1;
 
            if (Catalog\Config\State::isUsedInventoryManagement())
            {
                $count = count($this->getStoreIds());
            }
 
            $result->setData(
                array(
                    'STORES_COUNT' => $count,
                )
            );
 
            return $result;
        }
 
        private function getStoreIds(): array
        {
            $context = $this->getContext();
 
            $filterId = [
                'ACTIVE' => 'Y',
            ];
            if (isset($context['SITE_ID']) && $context['SITE_ID'] !== '')
            {
                $filterId['+SITE_ID'] = $context['SITE_ID'];
            }
 
            $cacheId = md5(serialize($filterId));
            $storeIds = static::getHitCache(self::CACHE_STORE, $cacheId);
            if (empty($storeIds))
            {
                $storeIds = [];
 
                $filter = Main\Entity\Query::filter();
                $filter->where('ACTIVE', '=', 'Y');
                if (isset($context['SITE_ID']) && $context['SITE_ID'] != '')
                {
                    $subFilter = Main\Entity\Query::filter();
                    $subFilter->logic('or')->where('SITE_ID', '=', $context['SITE_ID'])->where('SITE_ID', '=', '')->whereNull('SITE_ID');
                    $filter->where($subFilter);
                    unset($subFilter);
                }
 
                $iterator = Catalog\StoreTable::getList([
                    'select' => ['ID', 'SORT'],
                    'filter' => $filter,
                    'order' => ['SORT' => 'ASC', 'ID' => 'ASC'],
                ]);
                while ($row = $iterator->fetch())
                {
                    $storeIds[] = (int)$row['ID'];
                }
                unset($row, $iterator, $filter);
                if (!empty($storeIds))
                {
                    static::setHitCache(self::CACHE_STORE, $cacheId, $storeIds);
                }
            }
            unset($cacheId, $filterId);
 
            return $storeIds;
        }
 
        public function getProductListStores(array $products)
        {
            $result = new Sale\Result();
 
            //without store control stores are used for information purposes only
            if (!Catalog\Config\State::isUsedInventoryManagement())
            {
                return $result;
            }
 
            $storeIds = $this->getStoreIds();
            if (empty($storeIds))
            {
                return $result;
            }
 
            $resultList = [];
            $productGetIdList = [];
            foreach (array_keys($products) as $productId)
            {
/*              $cacheId = md5($productId);
 
                $storeProductDataList = static::getHitCache(self::CACHE_STORE_PRODUCT, $cacheId);
                if (!empty($storeProductDataList))
                {
                    $resultList[$productId] = $storeProductDataList;
                }
                else
                {
                    $productGetIdList[$productId] = $productId;
                } */
                // remove cache because need clear cache after modify stores
                if (
                    isset($products[$productId]['PRODUCT']['USED_STORE_INVENTORY'])
                    && !$products[$productId]['PRODUCT']['USED_STORE_INVENTORY']
                ) // product types without stores
                {
                    continue;
                }
                $productGetIdList[$productId] = $productId;
            }
 
            if (!empty($productGetIdList))
            {
                $emptyProductStores = [];
                $iterator = Catalog\StoreTable::getList([
                    'select' => [
                        'ID',
                        'TITLE',
                    ],
                    'filter' => [
                        '@ID' => $storeIds,
                    ],
                    'order' => [
                        'ID' => 'ASC',
                    ],
                ]);
                while ($row = $iterator->fetch())
                {
                    $id = (int)$row['ID'];
                    $emptyProductStores[$id] = [
                        'ID' => 0,
                        'PRODUCT_ID' => 0,
                        'STORE_ID' => $row['ID'],
                        'AMOUNT' => 0,
                        'QUANTITY_RESERVED' => 0,
                        'STORE_NAME' => $row['TITLE'],
                    ];
                }
                unset($row, $iterator);
 
                foreach (array_chunk($productGetIdList, 500) as $pageIds)
                {
                    foreach ($pageIds as $productId)
                    {
                        $rows = $emptyProductStores;
                        foreach (array_keys($rows) as $storeId)
                        {
                            $rows[$storeId]['PRODUCT_ID'] = $productId;
                        }
                        $resultList[$productId] = $rows;
                        unset($rows);
                    }
                    unset($productId);
                    $iterator = Catalog\StoreProductTable::getList([
                        'select' => [
                            'ID',
                            'PRODUCT_ID',
                            'STORE_ID',
                            'AMOUNT',
                            'QUANTITY_RESERVED',
                        ],
                        'filter' => [
                            '=PRODUCT_ID' => $pageIds,
                            '@STORE_ID' => $storeIds,
                        ],
                        'order' => [
                            'PRODUCT_ID' => 'ASC',
                            'STORE_ID' => 'ASC',
                        ],
                    ]);
                    while ($row = $iterator->fetch())
                    {
                        $row['ID'] = (int)$row['ID'];
                        $row['PRODUCT_ID'] = (int)$row['PRODUCT_ID'];
                        $row['STORE_ID'] = (int)$row['STORE_ID'];
                        if (!isset($resultList[$row['PRODUCT_ID']]))
                        {
                            $resultList[$row['PRODUCT_ID']] = [];
                        }
                        $resultList[$row['PRODUCT_ID']][$row['STORE_ID']]['ID'] = $row['ID'];
                        $resultList[$row['PRODUCT_ID']][$row['STORE_ID']]['AMOUNT'] = (float)$row['AMOUNT'];
                        $resultList[$row['PRODUCT_ID']][$row['STORE_ID']]['QUANTITY_RESERVED'] = (float)$row['QUANTITY_RESERVED'];
                    }
                    unset($iterator, $row);
                }
                unset($pageIds);
 
/*              foreach ($productGetIdList as $productId)
                {
                    if (!empty($resultList[$productId]))
                    {
                        $cacheId = md5($productId);
                        static::setHitCache(self::CACHE_STORE_PRODUCT, $cacheId, $resultList[$productId]);
                    }
                } */
            }
 
            if (!empty($resultList))
            {
                $result->setData([
                    'PRODUCT_STORES_LIST' => $resultList,
                ]);
            }
 
            return $result;
        }
 
        protected static function getHitCache($type, $key, array $fields = array())
        {
            if (!empty(self::$hitCache[$type]) && !empty(self::$hitCache[$type][$key]))
            {
                if (static::isExistsHitCache($type, $key, $fields))
                {
                    return self::$hitCache[$type][$key];
                }
            }
 
            return false;
        }
 
        protected static function isExistsHitCache($type, $key, array $fields = []): bool
        {
            $isExists = false;
            if (!empty(self::$hitCache[$type]) && !empty(self::$hitCache[$type][$key]))
            {
                $isExists = true;
                if (!empty($fields) && is_array($fields) && is_array(self::$hitCache[$type][$key]))
                {
                    foreach ($fields as $name)
                    {
                        if (!array_key_exists($name, self::$hitCache[$type][$key]))
                        {
                            $isExists = false;
                            break;
                        }
                    }
                }
            }
 
            return $isExists;
        }
 
        protected static function setHitCache(string $type, $key, $value): void
        {
            if (!isset(self::$hitCache[$type]))
            {
                self::$hitCache[$type] = [];
            }
 
            if (!isset(self::$hitCache[$type][$key]))
            {
                self::$hitCache[$type][$key] = [];
            }
 
            self::$hitCache[$type][$key] = $value;
        }
 
        protected static function clearHitCache(?string $type = null): void
        {
            if ($type === null)
            {
                self::$hitCache = [];
            }
            elseif (isset(self::$hitCache[$type]))
            {
                unset(self::$hitCache[$type]);
            }
        }
 
        protected static function clearNotCacheFields($fields)
        {
            $resultFields = array();
            $clearFields = static::getNotCacheFields();
            foreach ($fields as $name => $value)
            {
                $clearName = $name;
                if (mb_substr($clearName, 0, 1) == '~')
                {
                    $clearName = mb_substr($clearName, 1, mb_strlen($clearName));
                }
 
                if (!in_array($clearName, $clearFields))
                {
                    $resultFields[$name] = $value;
                }
            }
 
            return $resultFields;
        }
 
        protected static function getNotCacheFields()
        {
            return array(
                'CAN_BUY_ZERO',
                'QUANTITY_TRACE',
                'QUANTITY',
                'CAN_BUY',
            );
        }
 
        protected static function checkNeedFields(array $fields, array $need)
        {
            foreach ($need as $name => $value)
            {
                if (!array_key_exists($name, $fields))
                {
                    return false;
                }
            }
 
            return true;
        }
 
        protected static function isNeedClearPublicCache($currentQuantity, $newQuantity, $quantityTrace, $canBuyZero, $ratio = 1): bool
        {
            return false;
        }
 
        protected static function clearPublicCache($productID, $productInfo = array()): void {}
 
        public function getAvailableQuantity(array $products)
        {
            $result = $this->getAvailableQuantityByStore($products);
            if (!$result->isSuccess())
            {
                return $result;
            }
            $data = $result->getData();
            if (empty($data[Base::STORE_AVAILABLE_QUANTITY_LIST]))
            {
                return $result;
            }
 
            $reservedList = $data[Base::STORE_AVAILABLE_QUANTITY_LIST];
            $resultList = [];
            foreach ($reservedList as $productId => $rows)
            {
                $resultList[$productId] = reset($rows);
            }
            unset($productId, $rows);
            unset($reservedList, $data);
 
            $result->setData([
                Base::FLAT_AVAILABLE_QUANTITY_LIST => $resultList,
            ]);
 
            return $result;
        }
 
        public function getAvailableQuantityByStore(array $products): Sale\Result
        {
            $result = new Sale\Result();
            $resultList = [];
 
            $isGotQuantityDataList = [];
 
            foreach ($products as $productId => $productData)
            {
                $catalogAvailableQuantity = QuantityControl::getAvailableQuantity($productId);
                $catalogQuantity = QuantityControl::getQuantity($productId);
 
                if ($catalogQuantity === null || $catalogAvailableQuantity === null)
                {
                    continue;
                }
 
                $productQuantity = self::getStoreAmountFromQuantityList($productData);
                if ($productQuantity === null)
                {
                    continue;
                }
                if ($catalogAvailableQuantity < array_sum($productQuantity))
                {
                    continue;
                }
 
                $isGotQuantityDataList[$productId] = true;
 
                $resultList[$productId] = $productQuantity;
            }
 
            if (count($resultList) != count($products))
            {
                if ($this->isExistsCatalogData($products))
                {
                    $items = $products;
                }
                else
                {
                    $items = $this->createProductsListWithCatalogData($products);
                }
 
                foreach ($items as $productId => $productData)
                {
                    if (isset($isGotQuantityDataList[$productId]))
                    {
                        continue;
                    }
 
                    if (empty($productData['CATALOG']) || !is_array($productData['CATALOG']))
                    {
                        continue;
                    }
 
                    $catalogData = $productData['CATALOG'];
 
                    $productQuantity = self::getStoreAmountFromQuantityList($productData);
                    if ($productQuantity === null)
                    {
                        $resultList[$productId] = [];
                        continue;
                    }
                    $resultList[$productId] = $productQuantity;
 
                    $catalogQuantity = self::getTotalAmountFromPriceList($catalogData, false);
 
                    QuantityControl::setQuantity($productId, $catalogQuantity);
 
                    if ($catalogData['CHECK_QUANTITY'])
                    {
                        $totalReservedQuantity = 0;
                        $reservedQuantity = self::getStoreReservedQuantityFromProduct($productData);
                        if ($reservedQuantity !== null)
                        {
                            $totalReservedQuantity = array_sum($reservedQuantity);
                        }
 
                        $needQuantity = (array_sum($productQuantity) - $totalReservedQuantity);
                        if ($catalogQuantity < $needQuantity)
                        {
                            $limitQuantity = $catalogQuantity;
                            $availableList = $resultList[$productId];
                            arsort($availableList, SORT_NUMERIC);
                            foreach (array_keys($availableList) as $storeId)
                            {
                                $storeQuantity = $resultList[$productId][$storeId];
                                if ($limitQuantity > $storeQuantity)
                                {
                                    $limitQuantity -= $storeQuantity;
                                }
                                else
                                {
                                    $storeQuantity = $limitQuantity;
                                    if ($limitQuantity > 0)
                                    {
                                        $limitQuantity = 0;
                                    }
                                }
                                $resultList[$productId][$storeId] = $storeQuantity;
                            }
                        }
                    }
                }
            }
 
            if (!empty($resultList))
            {
                $result->setData([
                    Base::STORE_AVAILABLE_QUANTITY_LIST => $resultList,
                ]);
            }
 
            return $result;
        }
 
        public function getAvailableQuantityAndPrice(array $products)
        {
            $result = new Sale\Result();
            $availableQuantityListResult = $this->getAvailableQuantity($products);
 
            if ($this->isExistsCatalogData($products))
            {
                $items = $products;
            }
            else
            {
                $items = $this->createProductsListWithCatalogData($products);
            }
 
            $priceDataList = array();
 
            foreach ($items as $productId => $productData)
            {
                $catalogData = $productData['CATALOG'];
 
                if (!empty($catalogData['PRICE_LIST']))
                {
                    $priceDataList[$productId] = $catalogData['PRICE_LIST'];
                }
 
            }
 
            $availableQuantityData = array();
 
            if ($availableQuantityListResult->isSuccess())
            {
                $availableQuantityList = $availableQuantityListResult->getData();
 
                if (isset($availableQuantityList[Base::FLAT_AVAILABLE_QUANTITY_LIST]))
                {
                    $availableQuantityData = $availableQuantityList[Base::FLAT_AVAILABLE_QUANTITY_LIST];
                }
            }
 
            $result->setData([
                Base::SUMMMARY_PRODUCT_LIST => [
                    Base::FLAT_PRICE_LIST => $priceDataList,
                    Base::FLAT_AVAILABLE_QUANTITY_LIST => $availableQuantityData,
                ],
            ]);
 
            return $result;
        }
 
        public function writeOffProductBatches(array $products): Sale\Result
        {
            $result = new Sale\Result();
 
            if (!Catalog\Config\State::isUsedInventoryManagement() || !State::isProductBatchMethodSelected())
            {
                return $result;
            }
 
            foreach ($products as $productId => $productData)
            {
                if (empty($productData['SHIPMENT_ITEM_LIST']) || !is_array($productData['SHIPMENT_ITEM_LIST']))
                {
                    continue;
                }
 
                $productBatch = new BatchManager($productId);
                foreach ($productData['SHIPMENT_ITEM_LIST'] as $item)
                {
                    foreach ($item->getShipmentItemStoreCollection() as $storeItem)
                    {
                        $quantity = $storeItem->getQuantity();
                        if ($quantity <= 0)
                        {
                            continue;
                        }
 
                        $distributor = new DistributionStrategy\ShipmentStore($productBatch, $storeItem);
                        $r = $distributor->writeOff($quantity);
                        if (!$r->isSuccess())
                        {
                            $result->addErrors($r->getErrors());
                        }
                    }
                }
            }
 
            return $result;
        }
 
        public function returnProductBatches(array $products): Sale\Result
        {
            $result = new Sale\Result();
 
            if (!Catalog\Config\State::isUsedInventoryManagement() || !State::isProductBatchMethodSelected())
            {
                return $result;
            }
 
            foreach ($products as $productId => $productData)
            {
                if (empty($productData['SHIPMENT_ITEM_LIST']) || !is_array($productData['SHIPMENT_ITEM_LIST']))
                {
                    continue;
                }
 
                $productBatch = new BatchManager($productId);
                foreach ($productData['SHIPMENT_ITEM_LIST'] as $item)
                {
                    foreach ($item->getShipmentItemStoreCollection() as $storeItem)
                    {
                        $distributor = new DistributionStrategy\ShipmentStore($productBatch, $storeItem);
                        $r = $distributor->return();
                        if (!$r->isSuccess())
                        {
                            $result->addErrors($r->getErrors());
                        }
                    }
                }
            }
 
            return $result;
        }
 
        private function isExistsCatalogData($products): bool
        {
            foreach ($products as $productData)
            {
                if (empty($productData['CATALOG']))
                {
                    return false;
                }
            }
            return true;
        }
 
        private function getIblockData(array $list): array
        {
            $resultList = [];
            $res = Catalog\CatalogIblockTable::getList([
                'select' => [
                    'IBLOCK_ID',
                    'SUBSCRIPTION',
                    'PRODUCT_IBLOCK_ID',
                    'CATALOG_XML_ID' => 'IBLOCK.XML_ID',
                ],
                'filter' => ['@IBLOCK_ID' => $list],
            ]);
            while($iblockData = $res->fetch())
            {
                $resultList[$iblockData['IBLOCK_ID']] = $iblockData;
                if ($this->enableCache)
                {
                    static::setHitCache(self::CACHE_CATALOG_IBLOCK_LIST, $iblockData['IBLOCK_ID'], $iblockData);
                }
            }
            unset($res, $iblockData);
 
            return $resultList;
        }
 
        private static function checkSkuPermission(array $iblockProductMap): array
        {
            $resultList = array();
 
            foreach ($iblockProductMap as $iblockData)
            {
                if ($iblockData['PRODUCT_IBLOCK_ID'] > 0 && !empty($iblockData['PRODUCT_LIST']))
                {
                    $resultList = array_merge(
                        $resultList,
                        static::checkParentActivity($iblockData['PRODUCT_LIST'], (int)$iblockData['PRODUCT_IBLOCK_ID'])
                    );
                }
                else
                {
                    foreach ($iblockData['PRODUCT_LIST'] as $productId)
                    {
                        $resultList[] = $productId;
                    }
                }
            }
 
            return $resultList;
        }
 
        private static function createIblockProductMap(array $iblockList, array $iblockDataList): array
        {
            $resultList = $iblockDataList;
            foreach ($iblockList as $iblockId => $iblockProductList)
            {
                if (isset($iblockDataList[$iblockId]))
                {
                    $resultList[$iblockId]['PRODUCT_LIST'] = $iblockProductList;
                }
            }
 
            return $resultList;
        }
 
        private static function changeSubscribeProductQuantity(array $products, array $iblockProductMap): array
        {
            $resultList = $products;
 
            foreach ($iblockProductMap as $iblockData)
            {
                if ($iblockData['SUBSCRIPTION'] != 'Y')
                    continue;
 
                if (empty($iblockData['PRODUCT_LIST']))
                    continue;
 
                foreach($iblockData['PRODUCT_LIST'] as $productId)
                {
                    if (isset($resultList[$productId]))
                    {
                        if (
                            !empty($resultList[$productId][Base::FLAT_QUANTITY_LIST])
                            && is_array($resultList[$productId][Base::FLAT_QUANTITY_LIST])
                        )
                        {
                            foreach (array_keys($resultList[$productId][Base::FLAT_QUANTITY_LIST]) as $index)
                            {
                                $resultList[$productId][Base::FLAT_QUANTITY_LIST][$index] = 1;
                            }
                        }
                    }
                }
            }
 
            return $resultList;
        }
 
        private static function getCatalogProducts(array $list, array $select): array
        {
            $usedStoreInventory = Catalog\Config\State::isUsedInventoryManagement();
 
            $typesWithoutStores = [
                Catalog\ProductTable::TYPE_SET => true,
                Catalog\ProductTable::TYPE_SKU => true,
                Catalog\ProductTable::TYPE_SERVICE => true,
            ];
            $typesWithoutReservation = [
                Catalog\ProductTable::TYPE_SET => true,
                Catalog\ProductTable::TYPE_SKU => true,
                Catalog\ProductTable::TYPE_SERVICE => true,
            ];
 
            if (empty($select))
            {
                $select = ['*'];
            }
            else
            {
                $select[] = 'ID';
                $select[] = 'TYPE';
                $select[] = 'AVAILABLE';
 
                $select = array_unique($select);
            }
            Main\Type\Collection::normalizeArrayValuesByInt($list, true);
            if (empty($list))
            {
                return [];
            }
            $resultList = [];
            foreach (array_chunk($list, 500) as $pageIds)
            {
                $iterator = Catalog\Model\Product::getList([
                    'select' => $select,
                    'filter' => [
                        '@ID' => $pageIds,
                    ],
                ]);
                while ($row = $iterator->fetch())
                {
                    $row['ID'] = (int)$row['ID'];
                    $row['TYPE'] = (int)$row['TYPE'];
                    $row['QUANTITY'] = (float)$row['QUANTITY'];
                    $row['QUANTITY_RESERVED'] = (float)$row['QUANTITY_RESERVED'];
                    $row['CHECK_QUANTITY'] = (
                        $row['TYPE'] !== Catalog\ProductTable::TYPE_SERVICE
                        && $row['QUANTITY_TRACE'] === Catalog\ProductTable::STATUS_YES
                        && $row['CAN_BUY_ZERO'] === Catalog\ProductTable::STATUS_NO
                    );
                    Catalog\Product\SystemField::prepareRow($row, Catalog\Product\SystemField::OPERATION_PROVIDER);
 
                    if (isset($typesWithoutStores[$row['TYPE']]))
                    {
                        $row['USED_STORE_INVENTORY'] = false;
                    }
                    else
                    {
                        $row['USED_STORE_INVENTORY'] = $usedStoreInventory;
                    }
                    if (isset($typesWithoutReservation[$row['TYPE']]))
                    {
                        $row['USED_RESERVATION'] = false;
                        $row['QUANTITY_RESERVED'] = 0;
                    }
                    else
                    {
                        $row['USED_RESERVATION'] = true;
                    }
 
                    $resultList[$row['ID']] = $row;
                }
                unset($row, $iterator);
            }
            unset($pageIds);
 
            return $resultList;
        }
 
        private static function getMeasure($id = null): array
        {
            static $measureList = array();
 
            if (!empty($measureList[$id]))
            {
                return $measureList[$id];
            }
 
            $fields = array(
                'MEASURE' => $id,
                'MEASURE_NAME' => $id,
                'MEASURE_CODE' => 0,
            );
 
            if ((int)$id <= 0)
            {
                $measure = \CCatalogMeasure::getDefaultMeasure(true, true);
                $fields['MEASURE_NAME'] = $measure['~SYMBOL_RUS'];
                $fields['MEASURE_CODE'] = $measure['CODE'];
            }
            else
            {
                $resMeasures = \CCatalogMeasure::getList(
                    array(),
                    array('ID' => $id),
                    false,
                    false,
                    array('ID', 'SYMBOL_RUS', 'CODE')
                );
                $measure = $resMeasures->fetch();
 
                if (!empty($measure))
                {
                    $fields['MEASURE_NAME'] = $measure['SYMBOL_RUS'];
                    $fields['MEASURE_CODE'] = $measure['CODE'];
                }
            }
 
            $measureList[$id] = $fields;
 
            return $fields;
        }
 
        private static function createProductPriceList(array $products, array $productPriceList, array $discountList = array()): array
        {
            $priceResultList = array();
 
            foreach ($productPriceList as $basketCode => $priceData)
            {
                if (!$priceData)
                    continue;
                $priceResultList[$basketCode]['PRODUCT_PRICE_ID'] = $priceData['RESULT_PRICE']['ID'];
                $priceResultList[$basketCode]['NOTES'] = $priceData['PRICE']['CATALOG_GROUP_NAME'];
                $priceResultList[$basketCode]['DISCOUNT_NAME'] = null;
                $priceResultList[$basketCode]['DISCOUNT_COUPON'] = null;
                $priceResultList[$basketCode]['DISCOUNT_VALUE'] = null;
                $priceResultList[$basketCode]['DISCOUNT_LIST'] = array();
 
                $discount = array();
                if (!empty($discountList[$priceData['PRODUCT_ID']][$basketCode]))
                {
                    $discount = $discountList[$priceData['PRODUCT_ID']][$basketCode];
                }
 
                $priceResultList[$basketCode]['PRICE_TYPE_ID'] = $priceData['RESULT_PRICE']['PRICE_TYPE_ID'];
                $priceResultList[$basketCode]['BASE_PRICE'] = $priceData['RESULT_PRICE']['BASE_PRICE'];
                $priceResultList[$basketCode]['PRICE'] = $priceData['RESULT_PRICE']['DISCOUNT_PRICE'];
                $priceResultList[$basketCode]['CURRENCY'] = $priceData['RESULT_PRICE']['CURRENCY'];
                $priceResultList[$basketCode]['DISCOUNT_PRICE'] = $priceData['RESULT_PRICE']['DISCOUNT'];
                if (isset($priceData['RESULT_PRICE']['PERCENT']))
                {
                    $priceResultList[$basketCode]['DISCOUNT_VALUE'] = ($priceData['RESULT_PRICE']['PERCENT'] > 0
                        ? $priceData['RESULT_PRICE']['PERCENT'] . '%' : null);
                }
                $priceResultList[$basketCode]['VAT_RATE'] = $priceData['RESULT_PRICE']['VAT_RATE'];
                $priceResultList[$basketCode]['VAT_INCLUDED'] = $priceData['RESULT_PRICE']['VAT_INCLUDED'];
 
                if (!empty($discount))
                {
                    $priceResultList[$basketCode]['DISCOUNT_LIST'] = $discount;
                }
 
                if (!empty($priceData['DISCOUNT']))
                {
                    $priceResultList[$basketCode]['DISCOUNT_NAME'] = '[' .
                        $priceData['DISCOUNT']['ID'] .
                        '] ' .
                        $priceData['DISCOUNT']['NAME'];
                    if (!empty($priceData['DISCOUNT']['COUPON']))
                    {
                        $priceResultList[$basketCode]['DISCOUNT_COUPON'] = $priceData['DISCOUNT']['COUPON'];
                    }
 
                    if (empty($priceResultList[$basketCode]['DISCOUNT_LIST']))
                    {
                        $priceResultList[$basketCode]['DISCOUNT_LIST'] = array($priceData['DISCOUNT']);
                    }
                }
            }
 
            $resultList = array();
            if (!empty($priceResultList))
            {
                foreach ($products as $productId => $productData)
                {
                    if (!empty($products[$productId]))
                    {
                        $productData = $products[$productId];
 
                        $quantityList = array();
 
                        if (array_key_exists('QUANTITY', $productData))
                        {
                            $quantityList = array(
                                $productData['BASKET_CODE'] => $productData['QUANTITY'],
                            );
                        }
                        if (!empty($productData[Base::FLAT_QUANTITY_LIST]))
                        {
                            $quantityList = $productData[Base::FLAT_QUANTITY_LIST];
                        }
 
                        foreach($quantityList as $basketCode => $quantity)
                        {
                            $resultList[$basketCode] = $priceResultList[$basketCode];
                        }
                    }
                }
            }
 
            return $resultList;
        }
 
        private static function createProductResult(array $products, array $items, array $priceList, array $productQuantityList): array
        {
            $resultList = array();
            foreach ($products as $productId => $productData)
            {
                $itemCode = $productData['ITEM_CODE'];
                $basketCode = $productData['BASKET_CODE'];
                $resultList[$productId] = $items[$productId];
 
                if (isset($productData['PRODUCT_DATA']['ACTIVE']))
                {
                    $resultList[$productId]['ACTIVE'] = $productData['PRODUCT_DATA']['ACTIVE'];
                }
 
                $resultList[$productId]['ITEM_CODE'] = $itemCode;
 
                QuantityControl::resetAllQuantity($productId);
                QuantityControl::setReservedQuantity($productId, $productQuantityList[$basketCode]['QUANTITY_RESERVED']);
 
                if (!isset($priceList[$basketCode]))
                {
                    $priceList[$basketCode] = array();
                }
 
                if (!empty($productData[Base::FLAT_QUANTITY_LIST]))
                {
                    foreach($productData[Base::FLAT_QUANTITY_LIST] as $basketCode => $quantity)
                    {
                        QuantityControl::addQuantity($productId, $productQuantityList[$basketCode]['QUANTITY']);
                        QuantityControl::addAvailableQuantity($productId, $productQuantityList[$basketCode]['AVAILABLE_QUANTITY']);
 
                        if (empty($priceList[$basketCode]))
                        {
                            continue;
                        }
 
                        $resultList[$productId]['PRICE_LIST'][$basketCode] = array_merge(
                            array(
                                'QUANTITY' => $productQuantityList[$basketCode]['QUANTITY'],
                                'AVAILABLE_QUANTITY' => $productQuantityList[$basketCode]['AVAILABLE_QUANTITY'],
                                "ITEM_CODE" => $itemCode,
                                "BASKET_CODE" => $basketCode,
                            ),
                            $priceList[$basketCode]
                        );
                    }
                }
                else
                {
                    $resultList[$productId]['QUANTITY'] = $productQuantityList[$basketCode]['QUANTITY'];
 
                    QuantityControl::addQuantity($productId, $productQuantityList[$basketCode]['QUANTITY']);
                    QuantityControl::addAvailableQuantity($productId, $productQuantityList[$basketCode]['AVAILABLE_QUANTITY']);
                    if (!empty($resultList[$productId]))
                    {
                        if (empty($priceList[$basketCode]))
                        {
                            continue;
                        }
 
                        $resultList[$productId] = $priceList[$basketCode] + $resultList[$productId];
                    }
                }
            }
 
            return $resultList;
        }
 
        private static function setCatalogDataToProducts(array $products, array $catalogDataList, array $options = array()): array
        {
            $catalogDataEnabled = self::isCatalogDataEnabled($options);
            $specialFields = [];
            foreach (Catalog\Product\SystemField::getProviderSelectFields() as $index => $value)
            {
                $specialFields[] = is_string($index) ? $index : $value;
            }
 
            $result = [];
            foreach ($products as $productId => $productData)
            {
                if (!isset($catalogDataList[$productId]))
                {
                    continue;
                }
 
                $row = $catalogDataList[$productId];
 
                $result[$productId] = [
                    'CAN_BUY' => (
                        $productData['PRODUCT_DATA']['ACTIVE'] === 'Y'
                        && $row['AVAILABLE'] === 'Y'
                        ? 'Y'
                        : 'N'
                    ),
                    'CAN_BUY_ZERO' => $row['CAN_BUY_ZERO'],
                    'QUANTITY_TRACE' => $row['QUANTITY_TRACE'],
                    'CHECK_QUANTITY' => $row['CHECK_QUANTITY'],
                    'QUANTITY_RESERVED' => (float)$row['QUANTITY_RESERVED'],
                    'CATALOG_XML_ID' => $productData['PRODUCT_DATA']['CATALOG_XML_ID'],
                    'PRODUCT_XML_ID' => $productData['PRODUCT_DATA']['~XML_ID'],
                    'PRODUCT' => $row,
                ];
 
                if (!$catalogDataEnabled)
                {
                    $basketRow = [
                        'NAME' => $productData['PRODUCT_DATA']['~NAME'],
                        'DETAIL_PAGE_URL' => $productData['PRODUCT_DATA']['~DETAIL_PAGE_URL'],
                        'MEASURE_ID' => $row['MEASURE'],
                        'MEASURE_NAME' => $row['MEASURE_NAME'],
                        'MEASURE_CODE' => $row['MEASURE_CODE'],
                        'BARCODE_MULTI' => $row['BARCODE_MULTI'],
                        'WEIGHT' => (float)$row['WEIGHT'],
                        'DIMENSIONS' => serialize(
                            [
                                'WIDTH' => $row['WIDTH'],
                                'HEIGHT' => $row['HEIGHT'],
                                'LENGTH' => $row['LENGTH'],
                            ]
                        ),
                    ];
                    switch ($row['TYPE'])
                    {
                        case Catalog\ProductTable::TYPE_SET:
                            $basketRow['TYPE'] = Sale\BasketItem::TYPE_SET;
                            break;
                        case Catalog\ProductTable::TYPE_SERVICE:
                            $basketRow['TYPE'] = Sale\BasketItem::TYPE_SERVICE;
                            break;
                        default:
                            $basketRow['TYPE'] = null;
                            break;
                    }
                    foreach ($specialFields as $index)
                    {
                        $basketRow[$index] = $row[$index];
                    }
 
                    $result[$productId] = array_merge(
                        $result[$productId],
                        $basketRow
                    );
                }
 
                $result[$productId]["VAT_INCLUDED"] = "Y";
            }
 
            return $result;
        }
 
        protected static function isReservationEnabled()
        {
            return !(Main\Config\Option::get("catalog", "enable_reservation") == "N"
                && Main\Config\Option::get("sale", "product_reserve_condition") != "S"
                && !Catalog\Config\State::isUsedInventoryManagement());
        }
 
        public static function createOrderListFromProducts(array $products)
        {
            $productOrderList = array();
            foreach ($products as $productId => $productData)
            {
                if (!empty($productData['SHIPMENT_ITEM_LIST']))
                {
                    foreach ($productData['SHIPMENT_ITEM_LIST'] as $shipmentItem)
                    {
                        $shipmentItemCollection = $shipmentItem->getCollection();
                        if (!$shipmentItemCollection)
                        {
                            throw new Main\ObjectNotFoundException('Entity "ShipmentItemCollection" not found');
                        }
 
                        $shipment = $shipmentItemCollection->getShipment();
                        if (!$shipment)
                        {
                            throw new Main\ObjectNotFoundException('Entity "Shipment" not found');
                        }
 
                        $shipmentCollection = $shipment->getCollection();
                        if (!$shipmentCollection)
                        {
                            throw new Main\ObjectNotFoundException('Entity "ShipmentCollection" not found');
                        }
 
                        $order = $shipmentCollection->getOrder();
                        if (!$order)
                        {
                            throw new Main\ObjectNotFoundException('Entity "Order" not found');
                        }
 
                        if (empty($productOrderList[$productId][$order->getId()]))
                        {
                            $productOrderList[$productId][$order->getId()] = $order;
                        }
                    }
                }
            }
 
            return $productOrderList;
        }
 
        private static function getProductCatalogInfo($productId): array
        {
            $productId = (int)$productId;
            if ($productId <= 0)
            {
                return [];
            }
 
            $product = static::getHitCache(self::CACHE_ELEMENT_SHORT_DATA, $productId);
            if (empty($product))
            {
                $iterator = Iblock\ElementTable::getList([
                    'select' => [
                        'ID',
                        'IBLOCK_ID',
                        'NAME',
                        'IBLOCK_SECTION_ID',
                    ],
                    'filter' => \CIBlockElement::getPublicElementsOrmFilter(['=ID' => $productId]),
                ]);
                $product = $iterator->fetch();
                if ($product)
                {
                    static::setHitCache(self::CACHE_ELEMENT_SHORT_DATA, $productId, $product);
                }
            }
 
            return (empty($product)
                ? []
                : [
                    "#PRODUCT_ID#" => $product['ID'],
                    "#PRODUCT_NAME#" => $product['NAME'],
                ]
            );
        }
 
        private static function getTotalAmountFromQuantityList(array $data): float
        {
            return self::getAmountFromSource(
                $data,
                [
                    self::AMOUNT_SRC_STORE_QUANTITY_LIST,
                    self::AMOUNT_SRC_QUANTITY,
                    self::AMOUNT_SRC_QUANTITY_LIST,
                ]
            );
        }
 
        private static function getTotalAmountFromPriceList(array $product, bool $direction = true): float
        {
            if ($direction)
            {
                $list = [
                    self::AMOUNT_SRC_QUANTITY,
                    self::AMOUNT_SRC_PRICE_LIST,
                ];
            }
            else
            {
                $list = [
                    self::AMOUNT_SRC_PRICE_LIST,
                    self::AMOUNT_SRC_QUANTITY,
                ];
            }
 
            return self::getAmountFromSource($product, $list);
        }
 
        private static function isCatalogDataEnabled(array $options): bool
        {
            return in_array(self::USE_GATALOG_DATA, $options);
        }
 
        private static function fillCatalogXmlId(array $products, array $iblockProductMap): array
        {
            foreach ($iblockProductMap as $entityData)
            {
                if (empty($entityData['PRODUCT_LIST']) || !is_array($entityData['PRODUCT_LIST']))
                {
                    continue;
                }
                foreach ($entityData['PRODUCT_LIST'] as $index)
                {
                    if (!isset($products[$index]))
                    {
                        continue;
                    }
                    $products[$index]['PRODUCT_DATA']['CATALOG_XML_ID'] = $entityData['CATALOG_XML_ID'];
                }
                unset($index);
            }
            unset($entityData);
 
            return $products;
        }
 
        private static function fillOfferXmlId(array $products, array $catalogProductDataList): array
        {
            $offerList = [];
            foreach ($catalogProductDataList as $entityData)
            {
                if ($entityData['TYPE'] != Catalog\ProductTable::TYPE_OFFER)
                {
                    continue;
                }
                if (strpos($products[$entityData['ID']]['PRODUCT_DATA']['~XML_ID'], '#') !== false)
                {
                    continue;
                }
                $offerList[] = $entityData['ID'];
            }
            unset($entityData);
            if (!empty($offerList))
            {
                $parentMap = [];
                $parentIdList = [];
                $parentList = \CCatalogSku::getProductList($offerList, 0);
                foreach ($parentList as $offerId => $offerData)
                {
                    $parentId = (int)$offerData['ID'];
                    if (!isset($parentMap[$parentId]))
                    {
                        $parentMap[$parentId] = [];
                    }
                    $parentMap[$parentId][] = $offerId;
                    $parentIdList[$parentId] = $parentId;
                }
                unset($offerId, $offerData, $parentList);
                if (!empty($parentMap))
                {
                    sort($parentIdList);
                    foreach (array_chunk($parentIdList, 500) as $pageIds)
                    {
                        $iterator = Iblock\ElementTable::getList([
                            'select' => [
                                'ID',
                                'XML_ID',
                            ],
                            'filter' => ['@ID' => $pageIds],
                        ]);
                        while ($row = $iterator->fetch())
                        {
                            $parentId = (int)$row['ID'];
                            if (empty($parentMap[$parentId]))
                            {
                                continue;
                            }
                            foreach ($parentMap[$parentId] as $index)
                            {
                                $products[$index]['PRODUCT_DATA']['~XML_ID'] = $row['XML_ID'] . '#'
                                    . $products[$index]['PRODUCT_DATA']['~XML_ID']
                                ;
                            }
                        }
                        unset($parentId, $index);
                        unset($row, $iterator);
                    }
                    unset($pageIds);
                }
                unset($parentIdList, $parentMap);
            }
            unset($offerList);
 
            return $products;
        }
 
        private static function getPriceDataList(array $products, array $config): array
        {
            /*
                'IS_ADMIN_SECTION' => $adminSection,
                'USER_ID' => $userId,
                'SITE_ID' => $siteId,
                'CURRENCY' => $currency,
            */
            $userGroups = self::getUserGroups($config['USER_ID']);
 
            \CCatalogProduct::GetVATDataByIDList(array_keys($products));
 
            if ($config['IS_ADMIN_SECTION'])
            {
                if ($config['USER_ID'] > 0)
                {
                    \CCatalogDiscountSave::SetDiscountUserID($config['USER_ID']);
                }
                else
                {
                    \CCatalogDiscountSave::Disable();
                }
            }
 
            Price\Calculation::pushConfig();
            Price\Calculation::setConfig([
                'CURRENCY' => $config['CURRENCY'],
                'PRECISION' => (int)Main\Config\Option::get('sale', 'value_precision'),
                'RESULT_WITH_VAT' => true,
                'RESULT_MODE' => Catalog\Product\Price\Calculation::RESULT_MODE_RAW,
            ]);
 
            $priceDataList = \CCatalogProduct::GetOptimalPriceList(
                $products,
                $userGroups,
                'N',
                [],
                ($config['IS_ADMIN_SECTION'] ? $config['SITE_ID'] : false)
            );
 
            if (empty($priceDataList))
            {
                $productsQuantityList = $products;
                $quantityCorrected = false;
 
                foreach ($productsQuantityList as $productId => $productData)
                {
                    $quantityList = array($productData['BASKET_CODE'] => $productData['QUANTITY']);
 
                    if (empty($productData[Base::FLAT_QUANTITY_LIST]))
                    {
                        $quantityList = $productData[Base::FLAT_QUANTITY_LIST];
                    }
 
                    if (empty($quantityList))
                    {
                        continue;
                    }
 
                    foreach ($quantityList as $basketCode => $quantity)
                    {
                        $nearestQuantity = \CCatalogProduct::GetNearestQuantityPrice($productId, $quantity, $userGroups);
                        if (!empty($nearestQuantity))
                        {
                            if (!empty($productData[Base::FLAT_QUANTITY_LIST]))
                            {
                                $productsQuantityList[$productId][Base::FLAT_QUANTITY_LIST][$basketCode]['QUANTITY'] = $nearestQuantity;
                            }
                            else
                            {
                                $productsQuantityList[$productId]['QUANTITY'] = $nearestQuantity;
                            }
 
                            $quantityCorrected = true;
                        }
                    }
                }
 
                if ($quantityCorrected)
                {
                    $priceDataList = \CCatalogProduct::GetOptimalPriceList(
                        $productsQuantityList,
                        $userGroups,
                        'N',
                        [],
                        ($config['IS_ADMIN_SECTION'] ? $config['SITE_ID'] : false)
                    );
                }
 
            }
 
            Price\Calculation::popConfig();
 
            if ($config['IS_ADMIN_SECTION'])
            {
                if ($config['USER_ID'] > 0)
                {
                    \CCatalogDiscountSave::ClearDiscountUserID();
                }
                else
                {
                    \CCatalogDiscountSave::Enable();
                }
            }
 
            if (!empty($priceDataList))
            {
                foreach ($priceDataList as $productId => $priceBasketDataList)
                {
                    foreach ($priceBasketDataList as $basketCode => $priceData)
                    {
                        if ($priceData === false)
                        {
                            continue;
                        }
 
                        if (empty($priceData['DISCOUNT_LIST']) && !empty($priceData['DISCOUNT']) && is_array($priceData['DISCOUNT']))
                        {
                            $priceDataList[$productId][$basketCode]['DISCOUNT_LIST'] = [$priceData['DISCOUNT']];
                        }
 
                        if (empty($priceData['PRICE']['CATALOG_GROUP_NAME']))
                        {
                            if (!empty($priceData['PRICE']['CATALOG_GROUP_ID']))
                            {
                                $priceName = self::getPriceTitle($priceData['PRICE']['CATALOG_GROUP_ID']);
                                if ($priceName !== '')
                                {
                                    $priceDataList[$productId][$basketCode]['PRICE']['CATALOG_GROUP_NAME'] = $priceName;
                                }
                                unset($priceName);
                            }
                        }
                    }
                }
            }
 
            return $priceDataList;
        }
 
        private static function getDiscountList(array $priceDataList): array
        {
            $discountList = array();
            if (!empty($priceDataList))
            {
                foreach ($priceDataList as $productId => $priceBasketDataList)
                {
                    foreach ($priceBasketDataList as $basketCode => $priceData)
                    {
                        if ($priceData === false)
                        {
                            continue;
                        }
 
                        if (empty($priceData['DISCOUNT_LIST']) && !empty($priceData['DISCOUNT']) && is_array($priceData['DISCOUNT']))
                        {
                            $priceDataList[$productId][$basketCode]['DISCOUNT_LIST'] = [$priceData['DISCOUNT']];
                        }
 
                        if (!empty($priceData['DISCOUNT_LIST']))
                        {
                            if (!isset($discountList[$productId]))
                            {
                                $discountList[$productId] = [];
                            }
                            if (!isset($discountList[$productId][$basketCode]))
                            {
                                $discountList[$productId][$basketCode] = [];
                            }
                            foreach ($priceData['DISCOUNT_LIST'] as $discountItem)
                            {
                                $discountList[$productId][$basketCode][] = \CCatalogDiscount::getDiscountDescription($discountItem);
                            }
                            unset($discountItem);
                        }
 
                        if (empty($priceData['PRICE']['CATALOG_GROUP_NAME']))
                        {
                            if (!empty($priceData['PRICE']['CATALOG_GROUP_ID']))
                            {
                                $priceName = self::getPriceTitle($priceData['PRICE']['CATALOG_GROUP_ID']);
                                if ($priceName != '')
                                {
                                    $priceDataList[$productId][$basketCode]['PRICE']['CATALOG_GROUP_NAME'] = $priceName;
                                }
                                unset($priceName);
                            }
                        }
                    }
                }
            }
 
            return $discountList;
        }
 
        public static function getDefaultStoreId(): int
        {
            $result = parent::getDefaultStoreId();
            if (Catalog\Config\State::isUsedInventoryManagement())
            {
                $storeId = Catalog\StoreTable::getDefaultStoreId();
                if ($storeId !== null)
                {
                    $result = $storeId;
                }
            }
 
            return $result;
        }
 
        private static function getAmountFromSource(array $product, array $sourceList): float
        {
            if (empty($product) || empty($sourceList))
            {
                return 0;
            }
 
            $result = 0;
            $found = false;
            foreach ($sourceList as $source)
            {
                switch ($source)
                {
                    case self::AMOUNT_SRC_QUANTITY:
                        if (array_key_exists($source, $product))
                        {
                            $result = $product[$source];
                            $found = true;
                        }
                        break;
                    case self::AMOUNT_SRC_QUANTITY_LIST:
                    case self::AMOUNT_SRC_RESERVED_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            $result = array_sum($product[$source]);
                            $found = true;
                        }
                        break;
                    case self::AMOUNT_SRC_PRICE_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            foreach ($product[$source] as $row)
                            {
                                if (!is_array($row) || !isset($row['QUANTITY']))
                                {
                                    continue;
                                }
                                $result += (float)$row['QUANTITY'];
                            }
                            unset($row);
                            $found = true;
                        }
                        break;
                    case self::AMOUNT_SRC_STORE_QUANTITY_LIST:
                    case self::AMOUNT_SRC_STORE_RESERVED_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            switch (self::getQuantityFormat($product[$source]))
                            {
                                case self::QUANTITY_FORMAT_STORE:
                                    $internalResult = self::calculateQuantityFromStores($product[$source]);
                                    break;
                                case self::QUANTITY_FORMAT_SHIPMENT:
                                    $internalResult = self::calculateQuantityFromShipments($product[$source]);
                                    break;
                                default:
                                    $internalResult = null;
                                    break;
                            }
                            if ($internalResult !== null)
                            {
                                $result += array_sum($internalResult);
                                $found = true;
                            }
                            unset($internalResult);
                        }
                        break;
                }
                if ($found)
                {
                    break;
                }
            }
 
            return (float)$result;
        }
 
        private static function getStoreAmountFromQuantityList(array $data): ?array
        {
            return self::getStoreAmountFromSource(
                $data,
                [
                    self::AMOUNT_SRC_STORE_QUANTITY_LIST,
                    self::AMOUNT_SRC_QUANTITY_LIST,
                    self::AMOUNT_SRC_QUANTITY,
                ]
            );
        }
 
        private static function getStoreReservedQuantityFromProduct(array $product): ?array
        {
            return self::getStoreAmountFromSource(
                $product,
                [
                    self::AMOUNT_SRC_STORE_RESERVED_LIST,
                    self::AMOUNT_SRC_RESERVED_LIST,
                ]
            );
        }
 
        private static function getStoreAmountFromPriceList(array $product, bool $direction = true): ?array
        {
            if ($direction)
            {
                $list = [
                    self::AMOUNT_SRC_QUANTITY,
                    self::AMOUNT_SRC_PRICE_LIST,
                ];
            }
            else
            {
                $list = [
                    self::AMOUNT_SRC_PRICE_LIST,
                    self::AMOUNT_SRC_QUANTITY,
                ];
            }
 
            return self::getStoreAmountFromSource($product, $list);
        }
 
        private static function getStoreAmountFromSource(array $product, array $sourceList): ?array
        {
            if (empty($product) || empty($sourceList))
            {
                return null;
            }
 
            $result = [];
            $found = false;
            foreach ($sourceList as $source)
            {
                switch ($source)
                {
                    case self::AMOUNT_SRC_STORE_QUANTITY_LIST:
                    case self::AMOUNT_SRC_STORE_RESERVED_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            switch (self::getQuantityFormat($product[$source]))
                            {
                                case self::QUANTITY_FORMAT_STORE:
                                    $internalResult = self::calculateQuantityFromStores($product[$source]);
                                    break;
                                case self::QUANTITY_FORMAT_SHIPMENT:
                                    $internalResult = self::calculateQuantityFromShipments($product[$source]);
                                    break;
                                default:
                                    $internalResult = null;
                                    break;
                            }
                            if ($internalResult !== null)
                            {
                                $result = $internalResult;
                                $found = true;
                            }
                            unset($internalResult);
                        }
                        break;
                    case self::AMOUNT_SRC_QUANTITY_LIST:
                    case self::AMOUNT_SRC_RESERVED_LIST:
                        /*
                        'QUANTITY_LIST' =>
                            array (
                                289 => 1.0,
                                290 => 3.0,
                                291 => 4.0,
                            ),
                         */
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            $result[static::getDefaultStoreId()] = array_sum($product[$source]);
                            $found = true;
                        }
                        break;
                    case self::AMOUNT_SRC_QUANTITY:
                        if (array_key_exists($source, $product))
                        {
                            $result[static::getDefaultStoreId()] = (float)$product[$source];
                            $found = true;
                        }
                        break;
                }
                if ($found)
                {
                    break;
                }
            }
 
            return (!empty($result) ? $result : null);
        }
 
        private static function getQuantityFormat(array $list): ?int
        {
            /*
            first variant
            'RESERVED_QUANTITY_LIST_BY_STORE' =>
            array (
                20 => basket code
                    array (
                        '0_0' => shipment index
                            array (
                                3 => 10.0, store id -> quantity
                            ),
                    ),
            ),
 
            second variant
            'RESERVED_QUANTITY_LIST_BY_STORE' =>
            array (
                20 => basket code
                    array (
                        3 => 10.0, store id -> quantity
                    ),
            ),
 
            'QUANTITY_LIST_BY_STORE' =>
            array (
                289 => basket code
                    array (
                        5 => 1.0,  store id => quantity
                    ),
                290 =>
                    array (
                        5 => 3.0,
                    ),
                291 =>
                    array (
                        5 => 4.0,
                    ),
                ),
            ),
            */
 
            $basketRow = reset($list);
            if (
                empty($basketRow)
                || !is_array($basketRow)
            )
            {
                return null;
            }
 
            $row = reset($basketRow);
            if (is_array($row))
            {
                return self::QUANTITY_FORMAT_SHIPMENT;
            }
 
            return self::QUANTITY_FORMAT_STORE;
        }
 
        private static function calculateQuantityFromStores(array $list): ?array
        {
            $result = [];
            $found = false;
            foreach ($list as $basketItemStores)
            {
                if (
                    empty($basketItemStores)
                    || !is_array($basketItemStores)
                )
                {
                    continue;
                }
                foreach ($basketItemStores as $storeId => $quantity)
                {
                    if (!isset($result[$storeId]))
                    {
                        $result[$storeId] = 0.0;
                    }
                    $result[$storeId] += (float)$quantity;
                    $found = true;
                }
                unset($storeId, $quantity);
            }
            unset($basketItemStores);
 
            return ($found ? $result : null);
        }
 
        private static function calculateQuantityFromShipments(array $list): ?array
        {
            $result = [];
            $found = false;
            foreach ($list as $basketItemShipments)
            {
                if (
                    empty($basketItemShipments)
                    || !is_array($basketItemShipments)
                )
                {
                    continue;
                }
                foreach ($basketItemShipments as $basketItemStores)
                {
                    foreach ($basketItemStores as $storeId => $quantity)
                    {
                        if (!isset($result[$storeId]))
                        {
                            $result[$storeId] = 0;
                        }
                        $result[$storeId] += (float)$quantity;
                        $found = true;
                    }
                }
            }
 
            return ($found ? $result : null);
        }
 
        private static function getStoreQuantityFromQuantityList(array $product): array
        {
            return self::getStoreQuantityFromSource(
                $product,
                [
                    self::AMOUNT_SRC_STORE_QUANTITY_LIST,
                    self::AMOUNT_SRC_QUANTITY_LIST,
                ]
            );
        }
 
        private static function getStoreQuantityFromSource(array $product, array $sourceList): array
        {
            if (empty($product) || empty($sourceList))
            {
                return [static::getDefaultStoreId() => 0.0];
            }
 
            $result = [];
            $found = false;
            foreach ($sourceList as $source)
            {
                switch ($source)
                {
                    case self::AMOUNT_SRC_QUANTITY_LIST:
                    case self::AMOUNT_SRC_RESERVED_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            $result = [
                                static::getDefaultStoreId() => (float)array_sum($product[$source]),
                            ];
                            $found = true;
                        }
                        break;
                    /*case self::AMOUNT_SRC_PRICE_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            foreach ($product[$source] as $row)
                            {
                                if (!is_array($row) || !isset($row['QUANTITY']))
                                {
                                    continue;
                                }
                                $result += (float)$row['QUANTITY'];
                            }
                            unset($row);
                            $found = true;
                        }
                        break; */
                    case self::AMOUNT_SRC_STORE_QUANTITY_LIST:
                    case self::AMOUNT_SRC_STORE_RESERVED_LIST:
                        if (
                            !empty($product[$source])
                            && is_array($product[$source])
                        )
                        {
                            switch (self::getQuantityFormat($product[$source]))
                            {
                                case self::QUANTITY_FORMAT_STORE:
                                    $internalResult = self::calculateQuantityFromStores($product[$source]);
                                    break;
                                case self::QUANTITY_FORMAT_SHIPMENT:
                                    $internalResult = self::calculateQuantityFromShipments($product[$source]);
                                    break;
                                default:
                                    $internalResult = null;
                                    break;
                            }
                            if ($internalResult !== null)
                            {
                                $result = $internalResult;
                                $found = true;
                            }
                        }
                        break;
                }
                if ($found)
                {
                    break;
                }
            }
 
            return (!empty($result)
                ? $result
                : [static::getDefaultStoreId() => 0.0]
            );
        }
 
        private static function loadCurrentStoreReserve(int $productId, array $reserve): array
        {
            $result = [];
            foreach ($reserve as $storeId => $quantity)
            {
                $result[$storeId] = [
                    'ID' => null,
                    'PRODUCT_ID' => $productId,
                    'STORE_ID' => $storeId,
                    'ADD_QUANTITY_RESERVED' => $quantity,
                    'QUANTITY_RESERVED' => 0.0,
                ];
            }
 
            $iterator = Catalog\StoreProductTable::getList([
                'select' => [
                    'ID',
                    'STORE_ID',
                    'QUANTITY_RESERVED',
                ],
                'filter' => [
                    '=PRODUCT_ID' => $productId,
                    '@STORE_ID' => array_keys($reserve),
                ],
            ]);
            while ($row = $iterator->fetch())
            {
                $storeId = (int)$row['STORE_ID'];
                $result[$storeId]['ID'] = (int)$row['ID'];
                $result[$storeId]['QUANTITY_RESERVED'] = (float)$row['QUANTITY_RESERVED'];
            }
            unset($row, $iterator);
 
            return $result;
        }
 
        private static function loadCurrentProductStores(array $list): array
        {
            Main\Type\Collection::normalizeArrayValuesByInt($list, true);
            if (empty($list))
            {
                return [];
            }
 
            $result = [];
            foreach (array_chunk($list, 500) as $pageIds)
            {
                $iterator = Catalog\StoreProductTable::getList([
                    'select' => [
                        'ID',
                        'STORE_ID',
                        'PRODUCT_ID',
                        'AMOUNT',
                        'QUANTITY_RESERVED',
                    ],
                    'filter' => [
                        '@PRODUCT_ID' => $pageIds,
                        '=STORE.ACTIVE' => 'Y',
                    ],
                    'order' => [
                        'PRODUCT_ID' => 'ASC',
                        'STORE_ID' => 'ASC',
                    ],
                ]);
                while ($row = $iterator->fetch())
                {
                    $row['ID'] = (int)$row['ID'];
                    $row['PRODUCT_ID'] = (int)$row['PRODUCT_ID'];
                    $row['STORE_ID'] = (int)$row['STORE_ID'];
                    $row['AMOUNT'] = (float)$row['AMOUNT'];
                    $row['QUANTITY_RESERVED'] = (float)$row['QUANTITY_RESERVED'];
 
                    $productId = $row['PRODUCT_ID'];
                    $storeId = $row['STORE_ID'];
                    if (!isset($result[$productId]))
                    {
                        $result[$productId] = [];
                    }
                    $result[$productId][$storeId] = $row;
                }
                unset($productId, $storeId);
                unset($row, $iterator);
            }
            unset($pageIds);
 
            return $result;
        }
 
        private static function convertErrors(Main\Entity\Result $result): void
        {
            global $APPLICATION;
 
            $oldMessages = [];
            foreach ($result->getErrorMessages() as $errorText)
            {
                $oldMessages[] = [
                    'text' => $errorText,
                ];
            }
            unset($errorText);
 
            if (!empty($oldMessages))
            {
                $error = new \CAdminException($oldMessages);
                $APPLICATION->ThrowException($error);
                unset($error);
            }
            unset($oldMessages);
        }
    }
}