<?php
/**
 * NOTICE OF LICENSE.
 *
 * Copyright 2022 Kosmonaft.dev
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 *  @author    Alexandre DEBUSSCHÈRE <alexandre@kosmonaft.dev>
 *  @copyright 2022 - 2023 Kosmonaft.dev
 *  @license   MIT
 */

if (!defined('_PS_VERSION_')) {
    exit;
}

/**
 * Class MRMaxHook
 */
class MRMaxHook extends Hook
{

    /** @var MRMax */
    protected $module;

    /** @var string[] */
    public static $hooks = [
        'actionValidateOrder',
        'actionObjectOrderUpdateAfter',
        'displayHeader',
        'displayAdminOrder',
        'displayBackOfficeHeader',
        'displayAfterBodyOpeningTag',
        'displayFooter',
        'displayBeforeCarrier',
        'displayCarrierExtraContent',
        'displayOrderDetail',
        'actionAdminOrdersListingFieldsModifier',
        'actionOrderGridDefinitionModifier',
        'actionOrderGridQueryBuilderModifier',
        'registerGDPRConsent',
        'actionDeleteGDPRCustomer',
        'actionExportGDPRData'
    ];

    /** @var string[] */
    public static $front_controllers = [
        'OrderController',
        'OrderOpcController',
        'AmzpaymentsAmzpaymentsModuleFrontController',
        'AmazonpayCheckoutModuleFrontController'
    ];

    /**
     * @param int|null $id
     * @param int|null $id_lang
     * @param int|null $id_shop
     * @param PrestaShopBundle\Translation\Translator|null $translator
     * @param MRMax|null $module
     * @throws PrestaShopDatabaseException
     * @throws PrestaShopException
     */
    public function __construct($id = null, $id_lang = null, $id_shop = null, $translator = null, $module = null)
    {
        parent::__construct($id, $id_lang, $id_shop, $translator);

        if ($module != null && !$module instanceof MRMax) {
            throw new InvalidArgumentException('Module is not an instance of ColissmoMax.');
        }

        $this->module = $module ?: new MRMax();
    }

    /**
     * @return bool
     * @throws PrestaShopDatabaseException
     * @throws PrestaShopException
     */
    public function addMondialRelayHooks()
    {
        $success = true;

        foreach (self::$hooks as $hook) {
            $success &= $this->module->registerHook($hook);
        }

        return $success;
    }

    /**
     * @return bool
     */
    public function removeMondialRelayHooks()
    {
        $success = true;

        foreach (self::$hooks as $hook) {
            $success &= $this->module->unregisterHook($hook);
        }

        return $success;
    }

    /**
     * @param Cart[]|Order[]|Customer[]|Currency[]|OrderState[] $params
     * @return bool
     * @throws PrestaShopDatabaseException
     * @throws PrestaShopException
     * @throws SoapFault
     */
    public function actionValidateOrder($params)
    {
        $carrier = new MRMaxCarrier($params['order']->id_carrier);
        if (!Validate::isLoadedObject($carrier)) {
            MRMaxTools::log(sprintf('%s: Unable to load carrier', __METHOD__));
            return false;
        }

        $carrier_references = MRMaxCarrier::getMondialRelayCarrierReferences();
        if (!in_array($carrier->id_reference, $carrier_references)) {
            MRMaxTools::log(sprintf(
                '%s: Order carrier reference (%s) not module carrier reference (%s)',
                __METHOD__,
                $carrier->id_reference,
                implode(', ', $carrier_references)
            ));

            $delivery = MRMaxDelivery::getByIdCart($params['cart']->id);
            if ($delivery instanceof MRMaxDelivery && Validate::isLoadedObject($delivery)) {
                $delivery->delete();
            }

            return true;
        }

        $delivery = MRMaxDelivery::getByIdCartOrNew($params['cart']->id);
        if (!Validate::isLoadedObject($delivery)) {
            $delivery = MRMaxDelivery::getByIdCustomerOrNew($params['cart']->id_customer);
        }

        $mode = Db::getInstance()->getValue(
            'SELECT `delivery_mode`
                FROM `'._DB_PREFIX_.'mrmax_carrier`
                WHERE `id_reference` = '.(int)$carrier->id_reference
        );

        // Pickup delivery case
        if (in_array($mode, ['24R', '24L', '24X', 'DRI'])) {
            $cache_key = 'pickups_by_id_delivery_address_'.$params['cart']->id_address_delivery;
            $id_pickup = $delivery->prid;

            $mr_api = new MRMaxAPI(
                Configuration::get('MRMAX_TRADING_NAME'),
                Configuration::get('MRMAX_BRAND_CODE'),
                Configuration::get('MRMAX_WS_KEY')
            );

            $address = new Address((int)$params['cart']->id_address_delivery);
            if (!Validate::isLoadedObject($address)) {
                MRMaxTools::log(sprintf(
                    '%s: Unable to load delivery address',
                    __METHOD__
                ));
                return false;
            }

            // Order from BeezUP saves the pickup in address->company and address->address2
            // So get it from there
            if (Tools::strtolower($params['order']->module) == 'beezup') {
                $company = Tools::strtolower($address->company);
                if (Tools::strlen($company) && Tools::strpos($company, 'relay')) {
                    $id_pickup = filter_var($company, FILTER_SANITIZE_NUMBER_INT) ?: null;
                }

                if (!Tools::strlen($id_pickup)) {
                    $address_line_2 = Tools::strtolower($address->address2);
                    if (Tools::strlen($address_line_2) && Tools::strpos($address_line_2, 'relay')) {
                        $id_pickup = filter_var($address_line_2, FILTER_SANITIZE_NUMBER_INT) ?: null;
                    }
                }
            }

            // If no pickup found in delivery then use the closest one from the address
            if (!Tools::strlen($id_pickup)) {
                $response = $mr_api->searchRelayPickup([
                    'Pays' => Country::getIsoById($address->id_country),
                    'Ville' => $address->address1,
                    'CP' => $address->postcode,
                    'Latitude' => '',
                    'Longitude' => '',
                    'Taille' => '',
                    'Poids' => '',
                    'Action' => '',
                    'DelaiEnvoi' => '0',
                    'RayonRecherche' => '20',
                    'NombreResultats' => '20'
                ]);

                if (empty($response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details[0]->Num)) {
                    $response = $mr_api->searchRelayPickup([
                        'Pays' => Country::getIsoById($address->id_country),
                        'Ville' => '',
                        'CP' => $address->postcode,
                        'Latitude' => '',
                        'Longitude' => '',
                        'Taille' => '',
                        'Poids' => '',
                        'Action' => '',
                        'DelaiEnvoi' => '0',
                        'RayonRecherche' => '20',
                        'NombreResultats' => '20'
                    ]);
                }

                if (!empty($response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details[0]->Num)) {
                    $id_pickup = trim(
                        $response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details[0]->Num
                    );
                }
            }

            $pickup = MRMaxTools::getPickupFromCache(
                $cache_key,
                $id_pickup,
                $mr_api
                    ->getRelayPickupById($id_pickup, Country::getIsoById($address->id_country))
                    ->WSI4_PointRelais_RechercheResult
                    ->PointsRelais
                    ->PointRelais_Details
            );

            // Create new address with pickup info (use cache to avoid calling API again)
            $id_address_new = MRMaxAddress::createAddressFromPickup(
                $pickup,
                $params['customer'],
                $address
            );
            if (!$id_address_new) {
                MRMaxTools::log(sprintf(
                    '%s: Unable to create new address from pickup (%s), id_pickup was (%s) and country was (%s)',
                    __METHOD__,
                    MRMaxTools::jsonEncode($pickup),
                    $id_pickup,
                    Country::getIsoById($address->id_country)
                ));
                return false;
            }

            // Save new address in the order
            $params['order']->id_address_delivery = $id_address_new;
            $params['order']->save();

            // Update for customizations
             MRMaxTools::updateIdAddressDeliveryForCustomizations(
                 $id_address_new,
                 $params['order']->id_cart
             );

             return true;
        }

        // Home delivery case
        $delivery = MRMaxDelivery::getByIdCartOrNew($params['cart']->id);
        $delivery->id_cart = $params['cart']->id;
        $delivery->id_customer = $params['cart']->id_customer;
        $delivery->type = $carrier->mode ?: 'HOM';
        $delivery->prid = null;

        return $delivery->save();
    }

    /**
     * Used when the carrier of the order is updated, so we can add/update information in MRMaxDelivery::class.
     *
     * @param Order[]|Cookie[]|Cart[] $params
     * @return void
     * @throws PrestaShopDatabaseException
     * @throws PrestaShopException
     */
    public function actionObjectOrderUpdateAfter($params)
    {
        if (!Context::getContext()->controller instanceof AdminController) {
            return;
        }

        $order = $params['object'];

        $carrier = new MRMaxCarrier($order->id_carrier);
        if (!Validate::isLoadedObject($carrier)) {
            return;
        }

        $mr_delivery = MRMaxDelivery::getByIdCartOrNew($order->id_cart);
        if (!Validate::isLoadedObject($mr_delivery)) {
            $mr_delivery = MRMaxDelivery::getByIdCustomerOrNew($order->id_customer);
        }
        $mr_references = MRMaxCarrier::getMondialRelayCarrierReferences();

        // If carrier is not MR then delete it from deliveries (if exists)
        if (!in_array($carrier->id_reference, $mr_references)) {
            $mr_delivery->delete();
            return;
        }

        $address = new Address($order->id_address_delivery);
        $id_pickup = filter_var($address->other, FILTER_SANITIZE_NUMBER_INT) ?: null;

        // Order from BeezUP saves the pickup in address->company and address->address2
        // So get it from there
        if (Tools::strtolower($order->module) == 'beezup') {
            $company = Tools::strtolower($address->company);
            if (Tools::strlen($company) && Tools::strpos($company, 'relay')) {
                $id_pickup = filter_var($company, FILTER_SANITIZE_NUMBER_INT) ?: null;
            }

            if (!Tools::strlen($id_pickup)) {
                $address_line_2 = Tools::strtolower($address->address2);
                if (Tools::strlen($address_line_2) && Tools::strpos($address_line_2, 'relay')) {
                    $id_pickup = filter_var($address_line_2, FILTER_SANITIZE_NUMBER_INT) ?: null;
                }
            }
        }

        // Else add the order info in MR Deliveries
        $mr_delivery->id_cart = $order->id_cart;
        $mr_delivery->type = $carrier->mode;
        $mr_delivery->prid = $id_pickup;
        $mr_delivery->save();
    }

    /**
     * @return void
     */
    public function displayHeader()
    {
        $controller_class = get_class(Context::getContext()->controller);
        $add_js_css = in_array($controller_class, self::$front_controllers);

        if ($controller_class == 'OrderController' &&
            property_exists(Context::getContext()->controller, 'step') &&
            Context::getContext()->controller->step != 2) {
            $add_js_css = false;
        }

        if ($add_js_css) {
            Context::getContext()->controller->addJS([
                $this->module->getPathUri().'views/js/jquery.plugin.mondialrelay.parcelshoppicker.min.js',
                $this->module->getPathUri().'views/js/leaflet.js',
                $this->module->getPathUri().'views/js/micromodal.min.js',
                $this->module->getPathUri().'views/js/front.js'
            ]);
            Context::getContext()->controller->addCSS([
                $this->module->getPathUri().'views/css/micromodal.css',
                $this->module->getPathUri().'views/css/front.css',
                $this->module->getPathUri().'views/css/leaflet.css'
            ]);
        }
    }

    /**
     * Used on PS 1.6 only.
     *
     * @param array $params
     * @return string|void
     * @throws PrestaShopDatabaseException
     * @throws PrestaShopException
     * @throws SmartyException
     */
    public function displayAdminOrder($params)
    {
        $order = new Order($params['id_order']);
        $carrier = new MRMaxCarrier($order->id_carrier);
        if (!Validate::isLoadedObject($carrier) || !in_array($carrier->mode, ['24R', '24L', '24X', 'DRI'])) {
            return;
        }

        if (version_compare(_PS_VERSION_, '1.7', '>=')) {
            $shipping_number = array_reduce($order->getShipping(), function ($number, $shipping) {
                if (!MRMaxTools::strlen($number) && MRMaxTools::strlen($shipping['tracking_number'])) {
                    $number = $shipping['tracking_number'];
                }

                return $number;
            }, '');

            $filename = _PS_MODULE_DIR_.$this->module->name.'/download/'.$shipping_number.'.pdf';
            if (!file_exists($filename)) {
                return;
            }

            Context::getContext()->smarty->assign([
                'mrmax_print_url' => Context::getContext()->link->getModuleLink($this->module->name, 'printlabels', [
                    'token' => Configuration::get('MRMAX_TOKEN'),
                    'ids' => $order->id
                ]),
                // 'mrmax_id_order' => $order->id,
                'mrmax_datetime' => date('d/m/Y', filemtime($filename)),
                'mrmax_shipping_number' => $shipping_number
            ]);

            return $this->smartyFetch(__FUNCTION__.'Documents', 'admin');
        }

        return '';
    }

    /**
     * @return void
     */
    public function displayBackOfficeHeader()
    {
        if (Tools::getValue('controller') == 'AdminLabelsMRMax') {
            return;
        }

        if (Tools::getValue('module_name', Tools::getValue('configure')) == $this->module->name) {
            Context::getContext()->controller->addJS([
                $this->module->getPathUri().'views/js/back.js'
            ]);
            Context::getContext()->controller->addCSS([
                $this->module->getPathUri().'views/css/back.css'
            ]);
        }
    }

    /**
     * @return string
     * @throws PrestaShopException
     * @throws SmartyException
     */
    public function displayAfterBodyOpeningTag()
    {
        if (!in_array(get_class(Context::getContext()->controller), self::$front_controllers)) {
            return '';
        }

        Context::getContext()->smarty->assign([
            'mrmax_widget_token' => Configuration::get('MRMAX_TRADING_NAME'),
            'mrmax_carrier_ids' => MRMaxCarrier::getMondialRelayCarrierIds(),
            'mrmax_carrier_modes' => MRMaxCarrier::getMondialRelayCarrierModes(),
            'mrmax_carrier_map' => MRMaxTools::getCarrierMapByContext(),
            'mrmax_delivery_url' => Context::getContext()->link->getModuleLink(
                $this->module->name,
                'delivery',
                [
                    'token' => Configuration::get('MRMAX_TOKEN')
                ]
            ),
            'mrmax_unselected_carriers' => Configuration::get('MRMAX_UNSELECTED_CARRIERS')
        ]);

        return $this->smartyFetch(__FUNCTION__);
    }

    /**
     * @return false|string
     * @throws PrestaShopException
     * @throws SmartyException
     */
    public function displayFooter()
    {
        if (version_compare(_PS_VERSION_, '1.7', '>=')) {
            return '';
        }

        return $this->displayAfterBodyOpeningTag();
    }

    /**
     * @param array $params
     * @return string
     * @throws SmartyException
     * @throws PrestaShopException
     */
    public function displayCarrierExtraContent($params)
    {
        if (!isset($params['carrier'])) {
            return '';
        }

        $carrier = $params['carrier'];
        $delivery_mode = Db::getInstance()->getValue(
            'SELECT `delivery_mode`
            FROM `'._DB_PREFIX_.'mrmax_carrier`
            WHERE `id_reference` = '.(int)$carrier['id_reference']
        );

        if (!in_array($delivery_mode, ['24R', '24L', '24X', 'DRI'])) {
            return '';
        }

        $address = new Address(Context::getContext()->cart->id_address_delivery);

        $pickups = [];

        $cache_key = 'pickups_by_id_delivery_address_'.Context::getContext()->cart->id_address_delivery;
        $cache = new MRMaxCache();
        if ($cache->has($cache_key)) {
            $pickups = MRMaxTools::jsonDecode($cache->get($cache_key), true);
        }

        if (!$pickups || !count($pickups)) {
            $trading = Configuration::get('MRMAX_TRADING_NAME');
            $brand = Configuration::get('MRMAX_BRAND_CODE');
            $code = Configuration::get('MRMAX_WS_KEY');

            if (!Tools::strlen($trading) || !Tools::strlen($code)) {
                return '';
            }

            $products_weight = sprintf(
                '%05d',
                array_reduce($carrier['product_list'], function ($acc, $cur) {
                    return $acc + MRMaxTools::convertToKg($cur['weight']) * $cur['quantity'];
                }, 0) * 1000
            );
            if ($products_weight == '00000' || (int)$products_weight < 100) {
                $products_weight = '00100';
            }

            $mr_api = new MRMaxAPI($trading, $brand, $code);
            $response = $mr_api->searchRelayPickup([
                'Pays' => Country::getIsoById($address->id_country),
                'Ville' => $address->city,
                'CP' => $address->postcode,
                'Latitude' => '',
                'Longitude' => '',
                'Poids' => $products_weight,
                'Action' => $delivery_mode,
                'RayonRecherche' => 20,
                'NombreResultats' => 20
            ]);

            if (isset($response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details)) {
                $pickups = $response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details;
            }

            if (is_array($pickups) && count($pickups)) {
                $cache->set($cache_key, MRMaxTools::jsonEncode($pickups));
            }
        }

        $carrier_map = MRMaxTools::getCarrierMapByContext(); // 1: list | 2: map
        $delivery = MRMaxDelivery::getByIdCart($params['cart']->id);
        if ($carrier_map != 1 && $delivery !== null) {
            $trading = Configuration::get('MRMAX_TRADING_NAME');
            $brand = Configuration::get('MRMAX_BRAND_CODE');
            $code = Configuration::get('MRMAX_WS_KEY');
            if (!Tools::strlen($trading) || !Tools::strlen($code)) {
                return '';
            }

            $address_line = '';

            $mr_api = new MRMaxAPI($trading, $brand, $code);
            $response = $mr_api->getRelayPickupById($delivery->prid, Country::getIsoById($address->id_country));
            if (!empty($response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details->Num)) {
                $pickup = $response->WSI4_PointRelais_RechercheResult->PointsRelais->PointRelais_Details;

                $address_line = sprintf(
                    '%s, %s, %s %s, %s',
                    $pickup->LgAdr1,
                    $pickup->LgAdr3,
                    $pickup->CP,
                    $pickup->Ville,
                    $pickup->Pays
                );
            }

            Context::getContext()->smarty->assign('mrmax_address_line', $address_line);

            return $this->smartyFetch(__FUNCTION__.'Summary');
        }

        if ($carrier_map == 1) {
            Context::getContext()->smarty->assign([
                'mrmax_pickups' => MRMaxTools::jsonDecode(
                    MRMaxTools::jsonEncode($pickups)
                ),
                'mrmax_selected_pickup_prid' => MRMaxDelivery::getPrIdByIdCart(Context::getContext()->cart->id)
            ]);

            return $this->smartyFetch(__FUNCTION__);
        }

        return '';
    }

    /**
     * @param $params
     * @return false|string
     * @throws SmartyException
     */
    public function displayBeforeCarrier($params)
    {
        unset($params);

        $address = new Address(Context::getContext()->cart->id_address_delivery);
        if (!Validate::isLoadedObject($address)) {
            return '';
        }

        $company_or_names = $address->company;
        if (!Tools::strlen($company_or_names)) {
            $company_or_names = sprintf('%s %s', $address->firstname, $address->lastname);
        }

        $lang = Context::getContext()->language->iso_code;
        $lang = Tools::substr($lang, 0, 2);
        $lang = Tools::strtoupper($lang);
        if (!in_array($lang, MRMaxLanguage::$enabled_languages)) {
            $lang = 'EN';
        }

        Context::getContext()->smarty->assign([
            'mrmax_lang' => $lang,
            'mrmax_country_list' => implode(',', MRMaxCountry::getEnabledCountriesForPickup()),
            'mrmax_address_company' => Tools::strtoupper($company_or_names),
            'mrmax_address_address1' => Tools::strtoupper($address->address1),
            'mrmax_address_zip' => Tools::strtoupper($address->postcode),
            'mrmax_address_city' => Tools::strtoupper($address->city),
            'mrmax_address_country' => Tools::strtoupper($address->country),
            'mrmax_address_country_iso' => Tools::strtoupper(Country::getIsoById($address->id_country))
        ]);

        return $this->smartyFetch(__FUNCTION__);
    }

    /**
     * @param Order[] $params
     * @return false|string
     * @throws PrestaShopDatabaseException
     * @throws SmartyException
     */
    public function displayOrderDetail($params)
    {
        $trackings = Db::getInstance()->executeS(
            (new DbQuery())
                ->select('*')
                ->from(MRMaxTracking::$definition['table'])
                ->where('`id_order` = '.(int)$params['order']->id)
                ->orderBy('`id_step` DESC')
        );

        if (!is_array($trackings) || !count($trackings)) {
            return false;
        }

        $trackings = array_map(function ($tracking) {
            $date = new DateTime($tracking['date']);
            $tracking['date'] = $date->format('d/m/Y');

            return $tracking;
        }, $trackings);

        $address = new Address($params['order']->id_address_delivery);

        Context::getContext()->smarty->assign(array(
            'trackings' => $trackings,
            'shipping_number' => $params['order']->shipping_number,
            'postcode' => $address->postcode
        ));

        return $this->smartyFetch(__FUNCTION__);
    }

    /**
     * @param array $params
     * @return void
     */
    public function actionAdminOrdersListingFieldsModifier(&$params)
    {
//        if (version_compare(_PS_VERSION_, '1.7.7', '<') &&
//            !Module::isInstalled('ambbocustomizer')) {
//            if (!isset($params['fields']['tracking_number']) && !isset($params['fields']['shipping_number'])) {
//                $params['fields']['tracking_number'] = array(
//                    'title' => $this->module->l('Tracking number', self::class),
//                    'align' => 'text-center',
//                    'class' => 'fixed-width-xs',
//                );
//            }
//
//            if (isset($params['select']) && !$this->trackingNumberAlreadyInSelect($params['select'])) {
//                $params['select'] = trim($params['select'], ', ').',
//                IF(a.`shipping_number`, a.`shipping_number`, oc.`tracking_number`) AS `tracking_number`';
//            }
//
//            if (isset($params['join']) && !$this->trackingNumberAlreadyInJoin($params['join'])) {
//                $params['join'] .= '
//                LEFT JOIN `'._DB_PREFIX_.'order_carrier` oc ON (a.`id_order` = oc.`id_order`)';
//            }
//        }
    }

    /**
     * @param array $params
     * @return void
     */
    public function actionOrderGridDefinitionModifier(&$params)
    {
//        /** @var PrestaShop\PrestaShop\Core\Grid\Definition\GridDefinition $definition */
//        $definition = $params['definition'];
//
//        $tracking_number_column = new \PrestaShop\PrestaShop\Core\Grid\Column\Type\DataColumn('tracking_number');
//        $tracking_number_column->setName($this->module->l('Tracking number', self::class));
//        $tracking_number_column->setOptions(array('field' => 'tracking_number'));
//
//        /** @var PrestaShop\PrestaShop\Core\Grid\Column\ColumnCollection */
//        $columns = $definition->getColumns();
//        $columns->addBefore('actions', $tracking_number_column);
//
//        $filter = new PrestaShop\PrestaShop\Core\Grid\Filter\Filter(
//            'tracking_number',
//            Symfony\Component\Form\Extension\Core\Type\TextType::class
//        );
//        $filter
//            ->setAssociatedColumn('tracking_number')
//            ->setTypeOptions(['required' => false]);
//
//        $definition->getFilters()->add($filter);
    }

    /**
     * @param array $params
     * @return void
     */
    public function actionOrderGridQueryBuilderModifier(&$params)
    {
//        /** @var Doctrine\DBAL\Query\QueryBuilder $search_query_builder */
//        $search_query_builder = $params['search_query_builder'];
//
//        $search_query_builder
//            ->addSelect('oc.`tracking_number` as tracking_number')
//            ->leftJoin(
//                'o',
//                _DB_PREFIX_.'order_carrier',
//                'oc',
//                'o.`id_order` = oc.`id_order`'
//            );
//
//        /** @var PrestaShop\PrestaShop\Core\Search\Filters\OrderFilters $search_criteria */
//        $search_criteria = $params['search_criteria'];
//
//        if ('tracking_number' === $search_criteria->getOrderBy()) {
//            $search_query_builder->orderBy('`tracking_number`', $search_criteria->getOrderWay());
//        }
//
//        foreach ($search_criteria->getFilters() as $name => $filter_value) {
//            if ('tracking_number' === $name) {
//                $search_query_builder->andWhere('`tracking_number` LIKE :tracking_number');
//                $search_query_builder->setParameter('tracking_number', '%'.$filter_value.'%');
//
//                if (!$filter_value) {
//                    $search_query_builder->orWhere('`tracking_number` IS NULL');
//                }
//
//                break;
//            }
//        }
    }

    /**
     * @param string $select
     * @return bool
     */
    private function trackingNumberAlreadyInSelect($select)
    {
//        $keywords = array(
//            'IF(a.`shipping_number`, a.`shipping_number`, oc.`tracking_number`) AS `tracking_number`',
//            'AS `tracking_number`',
//            'AS tracking_number'
//        );
//
//        foreach ($keywords as $keyword) {
//            if (strpos($select, $keyword) !== false) {
//                return true;
//            }
//        }
//
//        return false;
    }

    /**
     * @param string $join
     * @return bool
     */
    private function trackingNumberAlreadyInJoin($join)
    {
//        $keywords = array(
//            _DB_PREFIX_.'order_carrier',
//            'oc ON',
//            '= oc.`id_order`'
//        );
//
//        foreach ($keywords as $keyword) {
//            if (strpos($join, $keyword) !== false) {
//                return true;
//            }
//        }
//
//        return false;
    }

    /**
     * @return true
     */
    public function registerGDPRConsent()
    {
        return true;
    }

    /**
     * @return string
     */
    public function actionDeleteGDPRCustomer()
    {
        return MRMaxTools::jsonEncode(true);
    }

    /**
     * No personal data are saved, only id_order and/or id_cart is stored.
     *
     * @return string
     */
    public function actionExportGDPRData()
    {
        return MRMaxTools::jsonEncode([]);
    }

    /**
     * @param string $filename
     * @param string $folder
     * @return false|string
     * @throws SmartyException
     */
    protected function smartyFetch($filename, $folder = 'front')
    {
        return Context::getContext()->smarty->fetch(
            $this->module->getLocalPath().'views/templates/'.$folder.'/'.$filename.'.tpl'
        );
    }
}