<?php

namespace Lpost\Delivery;

use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Web\Json;
use Bitrix\Sale\Order;
use Lpost\Delivery\Api\Action\ActionCreateStrategy;
use Lpost\Delivery\Api\Action\ActionOrderSaver;
use Lpost\Delivery\Api\Action\ActionUpdateStrategy;
use Lpost\Delivery\Components\Soa;
use Lpost\Delivery\Exceptions\DeliverySendError;
use Lpost\Delivery\Handlers\Pvz;
use Lpost\Delivery\Handlers\Zone;
use Lpost\Delivery\Order\FieldIntegration\FieldIntegrationCode;
use Lpost\Delivery\Order\FieldIntegration\FieldIntegrationFlat;
use Lpost\Delivery\Order\FieldIntegration\FieldIntegrationFloor;
use Lpost\Delivery\Order\FieldIntegration\FieldIntegrationPorch;
use Lpost\Delivery\Order\OrderManager;
use Lpost\Delivery\Order\OrderMarkerError;
use Lpost\Delivery\Order\OrderShipmentParams\OrderParams;
use Lpost\Delivery\Order\OrderShipmentParams\OrderParamsPvz;
use Lpost\Delivery\Order\OrderShipmentParams\OrderParamsZone;
use Lpost\Delivery\Order\Property;
use Lpost\Delivery\Order\Property\Entity\PropertyTimeDelivery;
use Lpost\Delivery\Repository\RepositoryTracking;

\Bitrix\Main\Loader::includeModule('sale');
\Bitrix\Main\Loader::IncludeModule("catalog");
\Bitrix\Main\Loader::includeModule("lpost.delivery");

/*if(!function_exists('pp')){
    function pp($arr, $name = '', $die = false) {
        
        global $USER;
        if (in_array($USER->GetID(), [4546, 7])) {
            echo '<pre style="position: relative; z-index: 800; background: #fbfbfb; color: black;max-height: 550px; overflow: auto; border: 1px solid #111; ">'.$name.' ';
            print_r($arr);
            echo '</pre>';
            if($die)
                die();
        }
    }
}*/

/**
 * ���������� �� ������
 */
class EventManager
{
    use \Lpost\Delivery\Base;
    
    private static $instances = [];

    /**
     * �������� �� �������� �������� �� ������� ����������� �������� ������ �� �����
     * ��� ��� ������� ������� ��� ��������� ������
     * @var array
     */
    private static $disabledOrderHandlerIds = [];

    public static function getInstance()
    {
        $cls = static::class;
        if (!isset(self::$instances[$cls])) {
            self::$instances[$cls] = new static();
        }

        return self::$instances[$cls];
    }

    /**
     * ������ ��������� �� �������� ������
     *
     * @param int $orderId
     * @return void
     */
    private static function disabledHandlerForOrder(int $orderId)
    {
        if(!in_array($orderId, self::$disabledOrderHandlerIds)) {
            self::$disabledOrderHandlerIds[] = $orderId;
        }
    }

    /**
     * �������� �� �������� ���������� �������� ������
     *
     * @param $orderId
     * @return bool
     */
    private static function isDisabledHandlerOrderSave($orderId): bool
    {
        return in_array($orderId, self::$disabledOrderHandlerIds);
    }

    /**
     * @param $items
     * @return void
     * @throws \Bitrix\Main\ArgumentException
     */
    public static function editRestructionMenu(&$items) {
        global $APPLICATION;
        if (
            $APPLICATION->GetCurPage() == '/bitrix/admin/sale_delivery_service_edit.php'
            || $APPLICATION->GetCurPage() == '/bitrix/admin/sale_delivery_ajax.php'
        ) {
            $activeDeliverys = \Bitrix\Sale\Delivery\Services\Manager::getActiveList();
            $id = 0;
            if (!empty($_REQUEST['ID'])) {
                $id = $_REQUEST['ID'];
            } elseif (!empty($_REQUEST['deliveryId'])) {
                $id = $_REQUEST['deliveryId'];
            }
            if (
                !empty($id)
                && !empty($activeDeliverys[$id])
                && (
                    strpos($activeDeliverys[$id]['CLASS_NAME'], '\Lpost\Delivery') !== false
                    || strpos($activeDeliverys[$id]['CLASS_NAME'], 'Lpost_deliveryHandler') !== false
                )
            ) {
                if (!empty($items[0]['MENU']) && strpos($items[0]['MENU'][0]['ACTION'], 'BX.Sale.Delivery.getRestrictionParamsHtml') !== false) {
                    $newMenu = [];
                    foreach ($items[0]['MENU'] as $nextMenu) {
                        if (
                            strpos($nextMenu['ACTION'], '\\\\Bitrix\\\\Sale\\\\Delivery\\\\Restrictions\\\\ByWeight') !== false
                            || strpos($nextMenu['ACTION'], '\\\\Bitrix\\\\Sale\\\\Delivery\\\\Restrictions\\\\ByDimensions') !== false
                        ) {
                            continue;
                        }
                        $newMenu[] = $nextMenu;
                    }
                    $items[0]['MENU'] = $newMenu;
                }
            } elseif (
                !empty($id)
                && !empty($activeDeliverys[$id])
                && (
                    strpos($activeDeliverys[$id]['CLASS_NAME'], '\Lpost\Delivery') === false
                    || strpos($activeDeliverys[$id]['CLASS_NAME'], 'Lpost_deliveryHandler') === false
                )
            ) {
                if (!empty($items[0]['MENU']) && strpos($items[0]['MENU'][0]['ACTION'], 'BX.Sale.Delivery.getRestrictionParamsHtml') !== false) {
                    $newMenu = [];
                    foreach ($items[0]['MENU'] as $nextMenu) {
                        if (
                            strpos($nextMenu['ACTION'], '\\\\Lpost\\\\Delivery\\\\Restrictions\\\\ByWeight') !== false
                            || strpos($nextMenu['ACTION'], '\\\\Lpost\\\\Delivery\\\\Restrictions\\\\ByDimensions') !== false
                        ) {
                            continue;
                        }
                        $newMenu[] = $nextMenu;
                    }
                    $items[0]['MENU'] = $newMenu;
                }
            }
        }
    }

    /**
     * ������� ��� � ��� �������������� ������
     *
     * @return \Bitrix\Main\EventResult
     */
    public static function addDeliveryRestrictions() {
        return new \Bitrix\Main\EventResult(
            \Bitrix\Main\EventResult::SUCCESS,
            array(
                '\Lpost\Delivery\Restrictions\ByWeight' => '/bitrix/modules/lpost.delivery/lib/restrictions/byweight.php',
                '\Lpost\Delivery\Restrictions\ByDimensions' => '/bitrix/modules/lpost.delivery/lib/restrictions/bydimensions.php'
            )
        );
    }

    /**
     * ��������� ������ ����� ����������
     *
     * @throws \Bitrix\Main\ObjectPropertyException
     * @throws \Bitrix\Main\NotImplementedException
     * @throws \Bitrix\Main\ArgumentException
     * @throws \Bitrix\Main\SystemException
     */
    public static function changeOrderBeforeSaving($event)
    {

        $order = $event->getParameter("ENTITY");
        $orderManager = new OrderManager($order);

        if(!$orderManager->isLpost()) {
            return false;
        }

        if (!array_key_exists('LPOST_PVZ_ID', $_REQUEST) AND
            !array_key_exists('LPOST_ZONE_NUMBER_ID', $_REQUEST)) {
            return false;
        }
        
        try {
            if(!\Lpost\Delivery\Tools::isValidPhone($orderManager->getOrderPhone())) {
                throw new \ErrorException(Loc::getMessage("LPOST_DELIVERY_DANGER_ALERT_FOR_PHONE"));
            }
            
            $orderId = $order->getId();
            if($orderManager->getTypeDeliveryById($orderManager->getDeliveryId()) == Pvz::TYPE) {
                
                $deliveryId = $orderManager->getDeliveryId();

                if(empty($_REQUEST['LPOST_PVZ_ADDRESS']) || is_array($_REQUEST['LPOST_PVZ_ADDRESS']) && empty($_REQUEST['LPOST_PVZ_ADDRESS'][$deliveryId])) { 
                    throw new \ErrorException(loc::getMessage("LPOST_DELIVERY_DANGER_ALERT_FOR_ADDRESS_PVZ"));
                }
                
                $orderParams = new OrderParamsPvz();
                if(!empty($_REQUEST['LPOST_PVZ_ADDRESS']) && is_array($_REQUEST['LPOST_PVZ_ADDRESS']) && !empty($_REQUEST['LPOST_PVZ_ADDRESS'][$deliveryId])){
                    $orderParams->setId($_REQUEST['LPOST_PVZ_ID'][$deliveryId]);
                    $orderParams->setDay($_REQUEST['LPOST_PVZ_DAY'][$deliveryId]);
                    $address = $_REQUEST['LPOST_PVZ_ADDRESS'][$deliveryId];
                    $orderParams->setAddress($address);
                }
                else{
                    $orderParams->setId($_REQUEST['LPOST_PVZ_ID']);
                    $orderParams->setDay($_REQUEST['LPOST_PVZ_DAY']);
                    $address = $_REQUEST['LPOST_PVZ_ADDRESS'];
                    $orderParams->setAddress($address);
                }

                $orderManager->getShipment()->setField("PARAMS", Json::encode($orderParams->getArrayFields()));
                $orderManager->setOrderAddress($address);

                if(
                    $field_to_save_id_pickup_point = Settings::getInstance()
                        ->getOption("integration_field_to_save_id_pickup_point")
                ) {
                    $orderManager->writeAdditionalDataToField(
                        $field_to_save_id_pickup_point,
                        $orderParams->getId(), true
                    );
                }
            }
            if($orderManager->getTypeDeliveryById($orderManager->getDeliveryId()) == Zone::TYPE) {

                if(isset($_REQUEST['LPOST_ZONE_COORDS']) AND empty($_REQUEST['LPOST_ZONE_COORDS'])) {
                    throw new \ErrorException(loc::getMessage("LPOST_DELIVERY_DANGER_ALERT_FOR_ZONE_COORDS"));
                }

                if(isset($_REQUEST['LPOST_ZONE_ADDRESS']) AND empty($_REQUEST['LPOST_ZONE_ADDRESS'])) {
                    throw new \ErrorException(loc::getMessage("LPOST_DELIVERY_DANGER_ALERT_FOR_ADDRESS_COURIER"));
                }

                $orderParams = new OrderParamsZone();
                $orderParams->setId($_REQUEST['LPOST_ZONE_NUMBER_ID']);
                $orderParams->setAddress($_REQUEST['LPOST_ZONE_ADDRESS']);
                $orderParams->setCoords($_REQUEST['LPOST_ZONE_COORDS']);
                $orderParams->setDateDay($_REQUEST['LPOST_ZONE_DATE_DAY_DELIVERY']);
                $orderParams->setDateTime($_REQUEST['LPOST_ZONE_DATE_TIME_DELIVERY']);

                if (Settings::getInstance()->getOption('show_additional_fields') == 'Y') {

                    self::writeValuesOfAdditionalFields($orderId);

                    $orderParams->setFlat($_REQUEST['LPOST_ZONE_FLAT']);
                    $orderParams->setFloor($_REQUEST['LPOST_ZONE_FLOOR']);
                    $orderParams->setPorch($_REQUEST['LPOST_ZONE_PORCH']);
                    $orderParams->setCode($_REQUEST['LPOST_ZONE_CODE']);
                }

                $orderManager->getShipment()->setField("PARAMS", Json::encode($orderParams->getArrayFields()));

                $orderManager->setOrderAddress($_REQUEST['LPOST_ZONE_ADDRESS']);

                if($field_to_save_coordinates = Settings::getInstance()->getOption("integration_field_to_save_coordinates"))
                    $orderManager->writeAdditionalDataToField(
                        $field_to_save_coordinates, $orderParams->getCoords(), true
                    );

                if($field_to_save_date = Settings::getInstance()->getOption("integration_field_to_save_date"))
                    $orderManager->writeAdditionalDataToField(
                        $field_to_save_date, $orderParams->getDateDay()
                    );
                
                if($field_to_save_time = Settings::getInstance()->getOption("integration_field_to_save_time"))
                    $orderManager->writeAdditionalDataToField(
                        $field_to_save_time, $orderParams->getDateTime()
                    );
                
                if($field_porch = Settings::getInstance()->getOption("integration_field_porch"))
                    $orderManager->writeAdditionalDataToField(
                        $field_porch, $orderParams->getPorch()
                    );
                    
                if($field_floor = Settings::getInstance()->getOption("integration_field_floor"))
                    $orderManager->writeAdditionalDataToField(
                        $field_floor, $orderParams->getFloor()
                    );
                    
                if($field_code = Settings::getInstance()->getOption("integration_field_code"))
                    $orderManager->writeAdditionalDataToField(
                        $field_code, $orderParams->getCode()
                    );
                if($field_flat= Settings::getInstance()->getOption("integration_field_flat"))
                    $orderManager->writeAdditionalDataToField(
                        $field_flat, $orderParams->getFlat()
                    );
            }
        }
        catch (\ErrorException $e) {
            return $event->addResult(new \Bitrix\Main\EventResult(
                \Bitrix\Main\EventResult::ERROR,
                new \Bitrix\Sale\ResultError($e->getMessage(), 'LPOST_DELIVERY_ERROR')
            ));
        }
        
        return true;

    }

    /**
     * ��������� ����� � ������������ ���
     *
     * @return void
     */
    /*private static function writeValuesOfAdditionalFields($orderId)
    {
        $additionalCodeFieldList = [
            (new FieldIntegrationFlat())->getOptionCode(),
            (new FieldIntegrationFloor())->getOptionCode(),
            (new FieldIntegrationPorch())->getOptionCode(),
            (new FieldIntegrationCode())->getOptionCode(),
        ];
        $properties = \CSaleOrderPropsValue::GetList([], ['ORDER_ID' => $orderId, "%CODE" => [$additionalCodeFieldList]]);
        
        while ($row = $properties->fetch()) {
            foreach ($additionalCodeFieldList as $fieldCode) {
                if ($fieldCode == $row['CODE']) {

                    \CSaleOrderPropsValue::Update($row['ID'], [
                        "VALUE" => $_REQUEST["LPOST_ZONE_$fieldCode"]
                    ]);
                }
            }
        }
    }*/
    
    private static function writeValuesOfAdditionalFields($orderId)
    {
        $additionalCodeFieldList = [
            (new FieldIntegrationFlat())->getOptionCode(),
            (new FieldIntegrationFloor())->getOptionCode(),
            (new FieldIntegrationPorch())->getOptionCode(),
            (new FieldIntegrationCode())->getOptionCode(),
        ];
        foreach($additionalCodeFieldList as $fieldCode){
            
            $properties = \CSaleOrderPropsValue::GetList([], ['ORDER_ID' => $orderId, "CODE" => $fieldCode]);
            if ($row = $properties->fetch()) {
                if ($fieldCode == $row['CODE']) {
                    \CSaleOrderPropsValue::Update($row['ID'], [
                        "VALUE" => $_REQUEST["LPOST_ZONE_$fieldCode"]
                    ]);
                }
            }
        }
    }

    /**
     * ��������� ������ �� ���
     *
     * @param $event
     * @param $order
     * @param $ignore_status
     * @return bool
     */
    public static function savedOrder($event, $order = false, $ignore_status = false)
    {
        
        if (Settings::getInstance()->getOption('is_send_to_api') == 'N') {
            return false;
        }

        try {
            if(empty($order) AND !empty($event)) {
                $order = $event->getParameter("ENTITY");
            }

            $orderManager = new OrderManager($order);
            
            /*
             *
             * To avoid recursion, need to remember the handler
             *
             */
            if(self::isDisabledHandlerOrderSave($order->getId())) {
                throw new \Exception("This handler is disabled");
            }

            if(!$orderManager->isLpost()) {
                throw new \Exception("This delivery not lpost");
            }
            
            ////tologfile(Settings::getInstance()->checkOrderStatus($order), 'savedOrder checkOrderStatus');

            if (!Settings::getInstance()->checkOrderStatus($order) && !$ignore_status) {
                throw new \Exception("Status order not valid");
            }

            try {
                $actionOrderSaver = new ActionOrderSaver();
                $actionOrderSaver->setOrderManager($orderManager);
                $actionOrderSaver->createDataSent();

                /*
                 * generation hash key to prevent recursion
                 */
                $hashDataSent = $actionOrderSaver->getHashDataSent();
                if(!empty($orderManager->getTrackerNumber())) {
                    $actionStrategy = new ActionUpdateStrategy($actionOrderSaver->getDataSent());

                    if($orderManager->getParamField(OrderParams::FIELD_HASH_UPDATE_PARAM) == $hashDataSent) {
                        throw new \Exception("the sending key is the same");
                    }

                } else {
                    $actionStrategy = new ActionCreateStrategy($actionOrderSaver->getDataSent());
                }
                //$this->setDebug('savedOrder actionStrategy', $actionStrategy);
                $actionOrderSaver->setStrategy($actionStrategy);
                $actionStrategy->setOrderManager($orderManager);

                $trackerNumber = $actionOrderSaver->send();

                $orderManager->setShipmentField("TRACKING_NUMBER", $trackerNumber);
                $orderManager->setParamField(OrderParams::FIELD_HASH_UPDATE_PARAM, $hashDataSent);

                OrderMarkerError::delete($orderManager->getOrder());

            }
            catch (DeliverySendError $e) {
                (new static())->setError($e->getMessage(), true, $e->getData()); 
            }
            catch (\ErrorException $e) {
                OrderMarkerError::create(
                    $orderManager->getOrder(),
                    $orderManager->getShipment(),
                    $e->getMessage()
                );
            }

            /*
             *
             * Remembering the handler
             *
             */
            self::disabledHandlerForOrder($order->getId());


            /*
             *
             * Save all the added parameters from the API
             *
             */
            if(!$order->isNew())
                $orderManager->saveOrder();
            else
                $orderManager->saveShipment();

        }
        catch (\Exception $e) {
            return false;
        }


        return true;
    }
    
    /**
     * ��������� �������� �� ���
     *
     * @param $event
     * @param $order
     * @param $ignore_status
     * @return bool
     */
    public static function savedReturn($event, $order = false, $ignore_status = false)
    {

        if (Settings::getInstance()->getOption('is_send_to_api') == 'N') {
            return false;
        }

        try {
            if(empty($order) AND !empty($event)) {
                $order = $event->getParameter("ENTITY");
            }

            $orderManager = new OrderManager($order);

            /*
             *
             * To avoid recursion, need to remember the handler
             *
             */
            if(self::isDisabledHandlerOrderSave($order->getId())) {
                throw new \Exception("This handler is disabled");
            }

            if(!$orderManager->isLpost()) {
                throw new \Exception("This delivery not lpost");
            }

            if (!Settings::getInstance()->checkOrderStatus($order) && !$ignore_status) {
                throw new \Exception("Status order not valid");
            }

            try {
                $actionOrderSaver = new ActionOrderSaver();
                $actionOrderSaver->setOrderManager($orderManager);
                $actionOrderSaver->createReturnDataSent();

                /*
                 * generation hash key to prevent recursion
                 */
                $hashDataSent = $actionOrderSaver->getHashDataSent();
                
                $actionStrategy = new ActionCreateStrategy($actionOrderSaver->getDataSent());

                $actionOrderSaver->setStrategy($actionStrategy);
                $actionStrategy->setOrderManager($orderManager);

                $trackerNumber = $actionOrderSaver->send();

                //$orderManager->setShipmentField("TRACKING_NUMBER", $trackerNumber);
                //$orderManager->setParamField(OrderParams::FIELD_HASH_UPDATE_PARAM, $hashDataSent);

                OrderMarkerError::delete($orderManager->getOrder());

            }
            catch (DeliverySendError $e) {
                (new static())->setError($e->getMessage(), true, $e->getData());
            }
            catch (\ErrorException $e) {
                OrderMarkerError::create(
                    $orderManager->getOrder(),
                    $orderManager->getShipment(),
                    $e->getMessage()
                );
            }

            /*
             *
             * Remembering the handler
             *
             */
            self::disabledHandlerForOrder($order->getId());


            /*
             *
             * Save all the added parameters from the API
             *
             */
            /*if(!$order->isNew())
                $orderManager->saveOrder();
            else
                $orderManager->saveShipment();*/

        }
        catch (\Exception $e) {
            return false;
        }


        return true;
    }

    /**
     * ��������� ��� ���������� ������
     *
     * @param $orderId
     * @param $isPayment
     * @return false|void
     * @throws \Bitrix\Main\ArgumentException
     * @throws \Bitrix\Main\ArgumentNullException
     */
    public static function payOrder($orderId, $isPayment)
    {
        if (Settings::getInstance()->getOption('is_send_to_api') == 'N') {
            return false;
        }

        if($isPayment)
        {
            $eventManager = new EventManager();
            $order = Order::load($orderId);
            $trackingNumber = false;
            $result = [];

            $ShipmentCollection = $order->getShipmentCollection();
            foreach ($ShipmentCollection as $ship) {
                if (!$ship->isSystem()) {
                    $trackingNumber = $ship->getField("TRACKING_NUMBER");
                }
            }

            if($trackingNumber) {
                $result = $eventManager->getData(
                    "UpdateOrders",
                    [
                        "token" => $eventManager->getToken(),
                        "json" => Json::encode([
                            "Order" => [
                                [
                                    "ID_Order" => $trackingNumber,
                                    "SumPayment" => 0,
                                    "SumPrePayment" => $order->getPrice()
                                ]
                            ]
                        ])
                    ], "PUT"
                );
            }
            else {
                self::savedOrder(false, $order);
            }

        }
    }
    
    

    /**
     * ��������� ������ �������� ����� ��������
     *
     * @return string
     * @throws \Bitrix\Main\ArgumentException
     * @throws \Bitrix\Main\ArgumentNullException
     */
    public function handleCheckDeliveryStatus(): string
    {

        try {

            $arTrackers = (new RepositoryTracking())->getActiveListKeyLpostOrderId();
            if(empty($arTrackers)) {
                throw new \ErrorException("not found trackers");
            }

            $prepareData = [];

            foreach($arTrackers as $trackerId => $arTracker){
                $prepareData[] = [
                    "ID_Order" => $trackerId
                ];
            }
            
            $preparesData = array_chunk($prepareData, 500);
            unset($prepareData);
            
            foreach($preparesData as $prepareData){

                $arStateTrackers = $this->getData(
                    "GetStateOrders",
                    [
                        "token" => $this->getToken(),
                        "json" => Json::encode($prepareData)
                    ],
                    'POST'
                );

                if(empty($arStateTrackers['JSON_TXT'])) {

                    if(!empty($arStateTrackers['errorMessage']) OR !empty($arStateTrackers['Message']) OR empty($arStateTrackers)){
                        (new static())->setError(
                            "Error get status delivery in the api",
                            true,
                            [$prepareData, $arStateTrackers]
                        );
                    }

                    throw new \ErrorException("Error get status delivery in the api");
                }

                $arStateTrackers = Json::decode($arStateTrackers['JSON_TXT']);
                foreach($arStateTrackers as $arStateTracker){

                    $trackerId = $arStateTracker['ID_Order'];
                    $orderNewState = $orderNewStateOrder = null;
                    if(!empty($arStateTracker['StateReturn'])){
                        $orderNewState = $arStateTracker['StateReturn'];
                        $orderNewStateOrder = 'R';
                    }
                    elseif(!empty($arStateTracker['StateDelivery'])){
                        $orderNewState = $arStateTracker['StateDelivery'];
                        $orderNewStateOrder = 'D';
                    }
                    
                    if($orderNewState && $arTrackers[$trackerId]['state'] == $orderNewState && $arTrackers[$trackerId]['state_order'] == $orderNewStateOrder) {
                        \Lpost\Delivery\Entity\TrackingTable::update(
                            $arTrackers[$trackerId]['id'],
                            [
                                'params' => \Bitrix\Main\Web\Json::encode($arStateTracker),
                            ]
                        );
                        continue;
                    }
                    elseif($arStateTracker['Message'] && $arStateTracker['Message'] == Loc::getMessage("LPOST_ORDER_NOT_FOUND")){
                        $orderNewState = 'CANCELLED';
                    }
                    
                    if(!$orderNewState)
                        continue;

                    $order = Order::load($arTrackers[$trackerId]['id_order']);

                    if($order){
                    
                        if(in_array($orderNewState, ['CREATED', 'ACT_CREATED', 'DONE'])){
                            \Lpost\Delivery\Tracking::updateStateShipment(
                                $order,
                                $orderNewState,
                                true
                            );
                        }

                        if ($orderNewState == 'PLACED_IN_PICKUP_POINT') {
                            $orderManager = new OrderManager($order);
                            $statusOption = $orderNewState . '_' . strtoupper($orderManager->getTypeDelivery());
                        } else {
                            $statusOption = $orderNewStateOrder == 'R' ? 'RETURN_'.$orderNewState : $orderNewState;
                        }

                        if($status = Settings::getInstance()->getOption($statusOption)) {

                            \CSaleOrder::StatusOrder(
                                $order->getId(),
                                $status
                            );
                        }
                    }

                    $arParamsUpd = [
                        "state" => $orderNewState,
                        "params" => \Bitrix\Main\Web\Json::encode($arStateTracker),
                    ];
                    if($orderNewStateOrder)
                        $arParamsUpd['state_order'] = $orderNewStateOrder;
  
                    \Lpost\Delivery\Entity\TrackingTable::update(
                        $arTrackers[$trackerId]['id'],
                        $arParamsUpd
                    );
                }
                
            }

        } catch (\ErrorException $e) {
        }

        return "\Lpost\Delivery\EventManager::getInstance()->handleCheckDeliveryStatus();";
    }

    /**
     * ��������� ��������� ��� �� �������� ������� ������
     *
     * @param $items
     * @return false|void
     * @throws \Bitrix\Main\ArgumentException
     * @throws \Bitrix\Main\ArgumentNullException
     */
    public static function orderDetailAdminContextMenuShow(&$items)
    {

        if (
            $_SERVER['REQUEST_METHOD'] == 'GET'
            && $GLOBALS['APPLICATION']->GetCurPage() == '/bitrix/admin/sale_order_view.php'
            && $_REQUEST['ID'] > 0
        ) {

            $request = \Bitrix\Main\Context::getCurrent()->getRequest();
            $orderId = $request->get("ID");
            $order = Order::load($orderId);

            foreach ($order->getShipmentCollection() as $shipment) {
                if (
                    !$shipment->isSystem()
                    and Soa::isProfileLpost($order, $shipment->getDeliveryId())
                ) {

                    if (!$shipment->getField("PARAMS")) {
                        return false;
                    }

                    $params = Json::decode($shipment->getField("PARAMS"));

                    $items[] = [
                        "TEXT" => Loc::getMessage("LPOST_DELIVERY_ORDER_BUTTON"),
                        "TITLE" => Loc::getMessage("LPOST_DELIVERY_ORDER_BUTTON"),
                        "LINK"  => "javascript:void(0)",
                        "ICON" => 'popup'
                    ];

                    if (empty($params['LabelUml'])) {
                        return false;
                    }

                    $items[] = [
                        "TEXT"  => loc::getMessage("LPOST_DELIVERY_LABEL_UML_PRINT"),
                        "LINK"  => $params['LabelUml'] . Settings::getInstance()->getOption("lpost_token"),
                        "TITLE" => loc::getMessage("LPOST_DELIVERY_LABEL_UML_PRINT"),
                        "ICON"  => "adm-btn",
                    ];


                }
            }

        }
    }

    /**
     * ��������� ��������, ��������� �� ������ ������
     *
     * @return void
     * @throws \Bitrix\Main\LoaderException
     */
    public static function adminIncludeExtension()
    {
        $request = \Bitrix\Main\Context::getCurrent()->getRequest();
        
        $context = \Bitrix\Main\Application::getInstance()->getContext();
        $server = $context->getServer();
        $requestUri = $server->getRequestUri();

        if(
            $request->isAdminSection() && !$request->isAjaxRequest() && 
            (
                strpos($requestUri, 'bitrix/admin/sale_order_create.php') !== false || 
                strpos($requestUri, 'bitrix/admin/sale_order_view.php') !== false || 
                strpos($requestUri, 'bitrix/admin/sale_order_edit.php') !== false || 
                strpos($requestUri, 'bitrix/admin/sale_order_shipment_edit.php') !== false
            )
        ) {

            \Bitrix\Main\UI\Extension::load('lpost.delivery.managers');
            \Bitrix\Main\UI\Extension::load('lpost.delivery.map');
            \Bitrix\Main\UI\Extension::load("lpost.delivery.FormDeliveryOrderEdit");

            $yandexKey = Settings::getInstance()->getOption("yandex_map_api_key");
            $yandexKeySuggest = Settings::getInstance()->getOption("yandex_geo_suggest_api_key");
            //$yandexMapActive = Settings::getInstance()->getOption("yandex_map_active");
            if(!empty($yandexKey)){
                
                global $APPLICATION;
                $APPLICATION->AddHeadString(
                    '<script type="text/javascript" src="https://api-maps.yandex.ru/2.1/?lang=ru_RU&amp;coordorder=latlong&amp;apikey='.$yandexKey.'&amp;suggest_apikey='.$yandexKeySuggest.'"></script>',
                    true, false, \Bitrix\Main\Page\AssetLocation::AFTER_JS_KERNEL
                );
            }
        }
    }
}