<?php

/**
 * Hutko - Платіжний сервіс, який рухає бізнеси вперед.
 *
 * Запускайтесь, набирайте темп, масштабуйтесь – ми підстрахуємо всюди.
 *
 * @author    panariga
 * @copyright 2025 Hutko
 * @license   http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */


use PrestaShop\PrestaShop\Core\Payment\PaymentOption;

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

class Hutko extends PaymentModule
{

    public $order_separator =  '#';
    public $redirect_url =  'https://pay.hutko.org/api/checkout/redirect/';
    public $checkout_url =  'https://pay.hutko.org/api/checkout/url/';
    public $refund_url = 'https://pay.hutko.org/api/reverse/order_id';
    public $status_url = 'https://pay.hutko.org/api/status/order_id';


    public $settingsList = [
        'HUTKO_MERCHANT',
        'HUTKO_SECRET_KEY',
        'HUTKO_SHIPPING_INCLUDE',
        'HUTKO_SHIPPING_PRODUCT_NAME',
        'HUTKO_SHIPPING_PRODUCT_CODE',
        'HUTKO_NEW_ORDER_STATUS_ID',
        'HUTKO_SUCCESS_STATUS_ID',
        'HUTKO_SHOW_CARDS_LOGO',
        'HUTKO_SAVE_LOGS',
        'HUTKO_INCLUDE_DISCOUNT_TO_TOTAL'
    ];
    public $postErrors = [];

    public function __construct()
    {
        $this->name = 'hutko';
        $this->tab = 'payments_gateways';
        $this->version = '1.3.1';
        $this->author = 'Hutko';
        $this->bootstrap = true;
        $this->need_instance = false;
        parent::__construct();
        $this->ps_versions_compliancy = array('min' => '1.7', 'max' => _PS_VERSION_);
        //Do not translate displayName as it is used for payment identification
        $this->displayName = 'Hutko Payments';
        $this->description = $this->trans('Hutko is a payment platform whose main function is to provide internet acquiring.', array(), 'Modules.Hutko.Admin');
    }

    public function install(): bool
    {
        $success = parent::install()
            && $this->registerHook('paymentOptions');

        // If the initial mandatory hooks failed, stop here.
        if (!$success) {
            return false;
        }

        // Now, conditionally register the order content/tab hook based on PS version.
        // We only need to check if the *required* hook for this version was successfully registered.
        $conditionalHookSuccess = true; // Assume success until we try to register one and it fails

        // Check if PrestaShop version is 1.7.x (>= 1.7 and < 1.7.7)
        if (version_compare(_PS_VERSION_, '1.7', '>=') && version_compare(_PS_VERSION_, '1.7.7', '<')) {
            // Register the 1.7 hook
            $conditionalHookSuccess = $this->registerHook('displayAdminOrderContentOrder');
        }
        // Check if PrestaShop version is 1.7.7 or 9.x (>= 1.7.7 and < 10.0)
        elseif (version_compare(_PS_VERSION_, '1.7.7', '>=') && version_compare(_PS_VERSION_, '10.0', '<')) {
            // Register the 8.x/9.x hook
            $conditionalHookSuccess = $this->registerHook('displayAdminOrderTabContent');
        }
        // Note: If it's a different version (e.g., 1.6, 10.0+), neither of these specific hooks will be registered,
        // and $conditionalHookSuccess remains true, which is the desired behavior based on the requirement.

        // The module installation is successful only if the initial hooks passed AND the conditional hook (if attempted) passed.
        return $success && $conditionalHookSuccess;
    }

    public function uninstall()
    {
        foreach ($this->settingsList as $val) {
            if (!Configuration::deleteByName($val)) {
                return false;
            }
        }
        if (!parent::uninstall()) {
            return false;
        }
        return true;
    }


    /**
     * Load the configuration form
     */
    public function getContent(): string
    {
        /**
         * If values have been submitted in the form, process.
         */
        $err = '';
        if (((bool)Tools::isSubmit('submitHutkoModule')) == true) {
            $this->postValidation();
            if (!sizeof($this->postErrors)) {
                $this->postProcess();
            } else {
                foreach ($this->postErrors as $error) {
                    $err .= $this->displayError($error);
                }
            }
        }

        return $err . $this->renderForm() . $this->context->smarty->fetch('module:hutko/views/templates/admin/help.tpl') . $this->displayLastDayLog();
    }

    /**
     * Create the form that will be displayed in the configuration of your module.
     */
    public function renderForm()
    {
        $helper = new HelperForm();

        $helper->show_toolbar = false;
        $helper->table = $this->table;
        $helper->module = $this;
        $helper->default_form_language = $this->context->language->id;
        $helper->allow_employee_form_lang = Configuration::get('PS_BO_ALLOW_EMPLOYEE_FORM_LANG', 0);

        $helper->identifier = $this->identifier;
        $helper->submit_action = 'submitHutkoModule';
        $helper->currentIndex = $this->context->link->getAdminLink('AdminModules', false)
            . '&configure=' . $this->name . '&tab_module=' . $this->tab . '&module_name=' . $this->name;
        $helper->token = Tools::getAdminTokenLite('AdminModules');

        $helper->tpl_vars = array(
            'fields_value' => $this->getConfigFormValues(), /* Add values for your inputs */
            'languages' => $this->context->controller->getLanguages(),
            'id_language' => $this->context->language->id,
        );

        return $helper->generateForm(array($this->getConfigForm()));
    }

    /**
     * Create the structure of your form.
     */
    public function getConfigForm()
    {


        $options = [];

        foreach (OrderState::getOrderStates($this->context->language->id) as $state) {  // getting all Prestashop statuses
            if (empty($state['module_name'])) {
                $options[] = ['status_id' => $state['id_order_state'], 'name' => $state['name'] . " [ID: $state[id_order_state]]"];
            }
        }

        return array(
            'form' => array(
                'legend' => array(
                    'title' => $this->trans('Please specify the Hutko account details for customers', array(), 'Modules.Hutko.Admin'),
                    'icon' => 'icon-cogs',
                ),
                'input' => array(
                    array(
                        'col' => 4,
                        'type' => 'text',
                        'prefix' => '<i class="icon icon-user"></i>',
                        'desc' => $this->trans('Enter a merchant id. Use 1700002 for test setup.', array(), 'Modules.Hutko.Admin'),
                        'name' => 'HUTKO_MERCHANT',
                        'label' => $this->trans('Merchant ID.', array(), 'Modules.Hutko.Admin'),
                    ),
                    array(
                        'col' => 4,
                        'type' => 'text',
                        'prefix' => '<i class="icon icon-key"></i>',
                        'name' => 'HUTKO_SECRET_KEY',
                        'desc' => $this->trans('Enter a secret key. Use "test" for test setup', array(), 'Modules.Hutko.Admin'),
                        'label' => $this->trans('Secret key', array(), 'Modules.Hutko.Admin'),
                    ),
                    array(
                        'type' => 'select',
                        'prefix' => '<i class="icon icon-key"></i>',
                        'name' => 'HUTKO_SUCCESS_STATUS_ID',
                        'label' => $this->trans('Status after success payment', array(), 'Modules.Hutko.Admin'),
                        'options' => array(
                            'query' => $options,
                            'id' => 'status_id',
                            'name' => 'name'
                        )
                    ),
                    array(
                        'type' => 'select',
                        'prefix' => '<i class="icon icon-key"></i>',
                        'name' => 'HUTKO_NEW_ORDER_STATUS_ID',
                        'label' => $this->trans('Status for new orders before payment', array(), 'Modules.Hutko.Admin'),
                        'options' => array(
                            'query' => $options,
                            'id' => 'status_id',
                            'name' => 'name'
                        )
                    ),
                    array(
                        'type' => 'radio',
                        'name' => 'HUTKO_SHIPPING_INCLUDE',
                        'label' => $this->trans('Include shipping cost to payment', array(), 'Modules.Hutko.Admin'),
                        'is_bool' => true,
                        'values' => array(
                            array(
                                'id' => 'show_cards',
                                'value' => 1,
                                'label' => $this->trans('Yes', array(), 'Modules.Hutko.Admin')
                            ),
                            array(
                                'id' => 'hide_cards',
                                'value' => 0,
                                'label' => $this->trans('No', array(), 'Modules.Hutko.Admin')
                            )
                        ),
                    ),
                    array(
                        'type' => 'text',
                        'name' => 'HUTKO_SHIPPING_PRODUCT_NAME',
                        'label' => $this->trans('Shipping Name', array(), 'Modules.Hutko.Admin'),
                        'desc' => $this->trans('Name of product/service to use in fiscalization for shipping amount', array(), 'Modules.Hutko.Admin'),

                    ),
                    array(
                        'type' => 'text',
                        'name' => 'HUTKO_SHIPPING_PRODUCT_CODE',
                        'label' => $this->trans('Shipping Code', array(), 'Modules.Hutko.Admin'),
                        'desc' => $this->trans('Code of product/service to use in fiscalization for shipping amount', array(), 'Modules.Hutko.Admin'),

                    ),
                    array(
                        'type' => 'radio',
                        'label' => $this->trans('Show Visa/MasterCard logo', array(), 'Modules.Hutko.Admin'),
                        'name' => 'HUTKO_SHOW_CARDS_LOGO',
                        'is_bool' => true,
                        'values' => array(
                            array(
                                'id' => 'show_cards',
                                'value' => 1,
                                'label' => $this->trans('Yes', array(), 'Modules.Hutko.Admin')
                            ),
                            array(
                                'id' => 'hide_cards',
                                'value' => 0,
                                'label' => $this->trans('No', array(), 'Modules.Hutko.Admin')
                            )
                        ),
                    ),
                    array(
                        'type' => 'radio',
                        'label' => $this->trans('Include fixed amount discounts to Payment amount calculation', array(), 'Modules.Hutko.Admin'),
                        'name' => 'HUTKO_INCLUDE_DISCOUNT_TO_TOTAL',
                        'is_bool' => true,
                        'values' => array(
                            array(
                                'id' => 'include_discount_to_total',
                                'value' => 1,
                                'label' => $this->trans('Yes', array(), 'Modules.Hutko.Admin')
                            ),
                            array(
                                'id' => 'discard_discount_to_total',
                                'value' => 0,
                                'label' => $this->trans('No', array(), 'Modules.Hutko.Admin')
                            )
                        ),
                    ),
                    array(
                        'type' => 'radio',
                        'label' => $this->trans('Save Logs', array(), 'Modules.Hutko.Admin'),
                        'name' => 'HUTKO_SAVE_LOGS',
                        'is_bool' => true,
                        'values' => array(
                            array(
                                'id' => 'save_logs',
                                'value' => 1,
                                'label' => $this->trans('Yes', array(), 'Modules.Hutko.Admin')
                            ),
                            array(
                                'id' => 'discard_logs',
                                'value' => 0,
                                'label' => $this->trans('No', array(), 'Modules.Hutko.Admin')
                            )
                        ),
                    ),
                ),

                'submit' => array(
                    'title' =>  $this->trans('Save', array(), 'Modules.Hutko.Admin'),
                    'class' => 'btn btn-default pull-right'
                ),
            ),
        );
    }

    /**
     * Set values for the inputs.
     */
    public function getConfigFormValues(): array
    {
        foreach ($this->settingsList as $settingName) {
            $list[$settingName] =  Configuration::get($settingName);
        }
        return $list;
    }

    /**
     * Save form data.
     */
    public function postProcess()
    {
        foreach ($this->settingsList as $settingName) {
            Configuration::updateValue($settingName, Tools::getValue($settingName));
        }
    }

    /**
     * Validates the configuration submitted through the module's settings form.
     *
     * This method checks if the form has been submitted and then validates the
     * Merchant ID and Secret Key provided by the user. It adds error messages
     * to the `$this->postErrors` array if any of the validation rules fail.
     */
    public function postValidation(): void
    {
        // Check if the module's configuration form has been submitted.
        if (Tools::isSubmit('submitHutkoModule')) {
            // Retrieve the submitted Merchant ID and Secret Key.
            $merchantId = Tools::getValue('HUTKO_MERCHANT');
            $secretKey = Tools::getValue('HUTKO_SECRET_KEY');

            // Validate Merchant ID:
            if (empty($merchantId)) {
                $this->postErrors[] = $this->trans('Merchant ID is required.', [], 'Modules.Hutko.Admin');
            }
            if (!is_numeric($merchantId)) {
                $this->postErrors[] = $this->trans('Merchant ID must be numeric.', [], 'Modules.Hutko.Admin');
            }

            // Validate Secret Key:
            if (empty($secretKey)) {
                $this->postErrors[] = $this->trans('Secret key is required.', [], 'Modules.Hutko.Admin');
            }
            if ($secretKey != 'test' && (Tools::strlen($secretKey) < 10 || is_numeric($secretKey))) {
                $this->postErrors[] = $this->trans('Secret key must be at least 10 characters long and cannot be entirely numeric.', [], 'Modules.Hutko.Admin');
            }
        }
    }


    /**
     * Hook for displaying payment options on the checkout page.
     *
     * This hook is responsible for adding the Hutko payment option to the list
     * of available payment methods during the checkout process. It checks if the
     * module is active, if the necessary configuration is set, and if the cart's
     * currency is supported before preparing the payment option.
     *
     * @param array $params An array of parameters passed by the hook, containing
     * information about the current cart.
     * @return array|false An array containing the Hutko PaymentOption object if
     * the module is active, configured, and the currency is supported, otherwise false.
     */
    public function hookPaymentOptions($params)
    {
        // 1. Check if the module is active. If not, do not display the payment option.
        if (!$this->active) {
            return false;
        }

        // 2. Check if the merchant ID and secret key are configured. If not, do not display the option.
        if (!Configuration::get("HUTKO_MERCHANT") || !Configuration::get("HUTKO_SECRET_KEY")) {
            return false;
        }

        // 3. Check if the cart's currency is supported by the module. If not, do not display the payment option.
        if (!$this->checkCurrency($params['cart'])) {
            return false;
        }

        // 4. Assign template variables to be used in the payment option's additional information.
        $this->context->smarty->assign([
            'hutko_logo_path' => $this->context->link->getMediaLink(__PS_BASE_URI__ . 'modules/' . $this->name . '/views/img/logo.png'),
            'hutko_description' => $this->trans('Pay via payment system Hutko', [], 'Modules.Hutko.Admin'),
        ]);

        // 5. Create a new PaymentOption object for the Hutko payment method.
        $newOption = new PaymentOption();

        // 6. Configure the PaymentOption object.
        $newOption->setModuleName($this->name)
            ->setCallToActionText($this->trans('Pay via Hutko', [], 'Modules.Hutko.Admin'))
            ->setAction($this->context->link->getModuleLink($this->name, 'redirect', [], true))
            ->setAdditionalInformation($this->context->smarty->fetch('module:hutko/views/templates/front/hutko.tpl'));

        // 7. Optionally set a logo for the payment option if the corresponding configuration is enabled.
        if (Configuration::get("HUTKO_SHOW_CARDS_LOGO")) {
            $newOption->setLogo(Tools::getHttpHost(true) . $this->_path . 'views/img/hutko_logo_cards.svg');
        }

        // 8. Return an array containing the configured PaymentOption object.
        return [$newOption];
    }


    /**
     * Builds an array of input parameters required for the payment gateway.
     *
     * This method gathers necessary information such as order ID, merchant ID,
     * order description, amount, currency, callback URLs, customer email,
     * reservation data, and generates a signature for the request.
     *
     * @return array An associative array containing the input parameters for the
     * payment gateway. This array includes the generated signature.
     */
    public function buildPaymentRequestData(Order $order, ?float $amount, ?Currency $currency, ?Customer $customer): array
    {
        // 1. Generate a unique order ID combining the cart ID and current timestamp.
        $orderId = $order->id . $this->order_separator . time();

        // 2. Retrieve the merchant ID from the module's configuration.
        $merchantId = Configuration::get('HUTKO_MERCHANT');

        // 3. Create a description for the order.
        $orderDescription = $this->trans('Order payment #', [], 'Modules.Hutko.Admin') . $order->reference;
        // 4. Calculate the order amount in the smallest currency unit.
        if (!$amount) {
            if (Configuration::get('HUTKO_SHIPPING_INCLUDE') && $order->total_shipping_tax_incl > 0) {
                $amount = $order->total_products_wt + $order->total_shipping_tax_incl;
            } else {
                $amount = $order->total_products_wt;
            }
        }
        if (Configuration::get('HUTKO_INCLUDE_DISCOUNT_TO_TOTAL')) {
            $amount -= $order->total_discounts_tax_incl;
        }


        $amountInt = round($amount * 100);
        // 5. Get the currency ISO code of the current cart.
        if (!$currency) {
            $currency = new Currency($order->id_currency);
        }
        $currencyISO = $currency->iso_code;

        // 6. Generate the server callback URL.
        $serverCallbackUrl = $this->context->link->getModuleLink($this->name, 'callback', [], true);
        // 7. Retrieve the customer's email address.
        if (!$customer) {
            $customer = new Customer($order->id_customer);
        }
        $customerEmail = $customer->email;

        // 8. Generate the customer redirection URL after payment.
        $responseUrl = $this->context->link->getModuleLink($this->name, 'return', ['hutkoPV' => $this->urlSafeEncode(json_encode([
            'id_cart' => $order->id_cart,
            'id_module' => $this->id,
            'id_order' => $order->id,
            'key' => $customer->secure_key,
        ]))], true);


        // 9. Build the reservation data as a base64 encoded JSON string.
        $reservationData = $this->buildReservationData($order);

        // 10. Construct the data array with all the collected parameters.
        $data = [
            'order_id' => $orderId,
            'merchant_id' => $merchantId,
            'order_desc' => $orderDescription,
            'amount' => $amountInt,
            'currency' => $currencyISO,
            'server_callback_url' => $serverCallbackUrl,
            'response_url' => $responseUrl,
            'sender_email' => $customerEmail,
            'reservation_data' => $reservationData,
        ];

        // 11. Generate the signature for the data array using the merchant's secret key.
        $data['signature'] = $this->getSignature($data);

        // 12. Return the complete data array including the signature.
        return $data;
    }


    /**
     * Builds a base64 encoded JSON string containing reservation-related data.
     *
     * This method gathers information about the current cart, customer's delivery
     * address, shop details, and products in the cart to create an array. This
     * array is then encoded as a JSON string and subsequently base64 encoded
     * for transmission or storage.
     *
     * @return string A base64 encoded JSON string containing the reservation data.
     */
    public function buildReservationData(Order $order): string
    {
        // 1. Retrieve the delivery address for the current cart.
        $address = new Address((int)$order->id_address_delivery, $order->id_lang);

        // 2. Fetch the customer's state name, if available.
        $customerState = '';
        if ($address->id_state) {
            $state = new State((int) $address->id_state, $order->id_lang);
            $customerState = $state->name;
        }

        // 3. Construct the data array.
        $data = [
            "cms_name" => "Prestashop",
            "cms_version" => _PS_VERSION_,
            "shop_domain" => Tools::getShopDomainSsl(),
            "path" => 'https://' . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI'],
            "phonemobile" => empty($address->phone_mobile) ? $address->phone : $address->phone_mobile,
            "customer_address" => $this->getSlug($address->address1),
            "customer_country" => $this->getSlug($address->country),
            "customer_state" => $this->getSlug($customerState),
            "customer_name" => $this->getSlug($address->lastname . ' ' . $address->firstname),
            "customer_city" => $this->getSlug($address->city),
            "customer_zip" => $address->postcode,
            "account" => $order->id_customer,
            "uuid" => hash('sha256', _COOKIE_KEY_ . Tools::getShopDomainSsl()),
            "products" => $this->getProducts($order),
        ];


        return base64_encode(json_encode($data));
    }


    /**
     * Retrieves an array of product details from the current cart.
     *
     * This method iterates through the products in the current customer's cart
     * using the context and extracts relevant information such as ID, name,
     * unit price, total amount for each product (price multiplied by quantity),
     * and the quantity itself.
     *
     * @return array An array where each element is an associative array containing
     * the details of a product in the cart. The keys for each product are:
     * - 'id': The product ID.
     * - 'name': The name of the product.
     * - 'price': The unit price of the product.
     * - 'total_amount': The total price of the product in the cart (price * quantity), rounded to two decimal places.
     * - 'quantity': The quantity of the product in the cart.
     */
    public function getProducts(Order $order): array
    {
        $products = [];
        foreach ($order->getProductsDetail() as $productDetail) {
            $products[] = [
                "id" => $productDetail['product_id'] . '_' . $productDetail['product_attribute_id'] . '_' . $productDetail['id_customization'],
                "name" => $productDetail['product_name'],
                "price" => round((float)$productDetail['unit_price_tax_incl'], 2),
                "total_amount" => round((float) $productDetail['total_price_tax_incl'], 2),
                "quantity" => (int)$productDetail['product_quantity'],
            ];
        }

        if (Configuration::get('HUTKO_SHIPPING_INCLUDE') && $order->total_shipping_tax_incl > 0) {
            $products[] = [
                "id" => Configuration::get('HUTKO_SHIPPING_PRODUCT_CODE', null, null, null, '0_0_1'),
                "name" => Configuration::get('HUTKO_SHIPPING_PRODUCT_NAME', null, null, null, 'Package material'),
                "price" => round((float)$order->total_shipping_tax_incl, 2),
                "total_amount" => round((float) $order->total_shipping_tax_incl, 2),
                "quantity" => 1,
            ];
        }
        return $products;
    }


    /**
     * Generates a URL-friendly slug from a given text.
     *
     * This method transliterates non-ASCII characters to their closest ASCII equivalents,
     * removes any characters that are not alphanumeric or spaces, trims leading/trailing
     * spaces, optionally replaces spaces with hyphens, and optionally converts the
     * entire string to lowercase.
     *
     * @param string $text The input string to convert into a slug.
     * @param bool $removeSpaces Optional. Whether to replace spaces with hyphens (true) or keep them (false). Defaults to false.
     * @param bool $lowerCase Optional. Whether to convert the resulting slug to lowercase (true) or keep the original casing (false). Defaults to false.
     * @return string The generated slug.
     */
    public function getSlug(string $text, bool $removeSpaces = false, bool $lowerCase = false): string
    {
        // 1. Transliterate non-ASCII characters to ASCII.
        $text = iconv('utf-8', 'us-ascii//TRANSLIT', $text);

        // 2. Remove any characters that are not alphanumeric or spaces.
        $text = preg_replace("/[^a-zA-Z0-9 ]/", "", $text);

        // 3. Trim leading and trailing spaces.
        $text = trim($text, ' ');

        // 4. Optionally replace spaces with hyphens.
        if ($removeSpaces) {
            $text = str_replace(' ', '-', $text);
        }

        // 5. Optionally convert the slug to lowercase.
        if ($lowerCase) {
            $text = strtolower($text);
        }

        // 6. Return the generated slug.
        return $text;
    }


    /**
     * Checks if the cart's currency is supported by the module.
     *
     * This method retrieves the currency of the provided cart and then checks if this
     * currency is present within the list of currencies supported by the module.
     *
     * @param Cart $cart The cart object whose currency needs to be checked.
     * @return bool True if the cart's currency is supported by the module, false otherwise.
     */
    private function checkCurrency(Cart $cart): bool
    {
        // 1. Get the currency object of the order from the cart.
        $orderCurrency = new Currency((int)$cart->id_currency);

        // 2. Get the list of currencies supported by this module.
        $moduleCurrencies = $this->getCurrency((int)$cart->id_currency);

        // 3. Check if the module supports any currencies.
        if (is_array($moduleCurrencies)) {
            // 4. Iterate through the module's supported currencies.
            foreach ($moduleCurrencies as $moduleCurrency) {
                // 5. If the order currency ID matches a supported currency ID, return true.
                if ($orderCurrency->id === (int)$moduleCurrency['id_currency']) {
                    return true;
                }
            }
        }

        // 6. If no matching currency is found, return false.
        return false;
    }


    /**
     * Generates a signature based on the provided data and a secret password.
     *
     * This method filters out empty and null values from the input data, sorts the remaining
     * data alphabetically by key, concatenates the values with a pipe delimiter, prepends
     * the secret password, and then generates a SHA1 hash of the resulting string.
     *
     * @param array $data An associative array of data to be included in the signature generation.
     * Empty strings and null values in this array will be excluded.
     * @param string $password The secret key used to generate the signature. This should be
     * kept confidential.
     * @param bool $encoded Optional. Whether to return the SHA1 encoded signature (true by default)
     * or the raw string before encoding (false).
     * @return string The generated signature (SHA1 hash by default) or the raw string.
     */
    public function getSignature(array $data, bool $encoded = true): string
    {
        $password = Configuration::get('HUTKO_SECRET_KEY');
        if (!$password || empty($password)) {
            throw new PrestaShopException('Merchant secret not set');
        }
        // 1. Filter out empty and null values from the data array.
        $filteredData = array_filter($data, function ($value) {
            return $value !== '' && $value !== null;
        });

        // 2. Sort the filtered data array alphabetically by key.
        ksort($filteredData);

        // 3. Construct the string to be hashed. Start with the password.
        $stringToHash = $password;

        // 4. Append the values from the sorted data array, separated by a pipe.
        foreach ($filteredData as $value) {
            $stringToHash .= '|' . $value;
        }

        // 5. Return the SHA1 hash of the string or the raw string based on the $encoded flag.
        if ($encoded) {
            return sha1($stringToHash);
        } else {
            return $stringToHash;
        }
    }


    /**
     * Validates the signature of a payment gateway response.
     *
     * This method verifies that the received response originates from the expected merchant
     * and that the signature matches the calculated signature based on the response data
     * and the merchant's secret key.
     *
     * @param array $response An associative array containing the payment gateway's response data.
     * This array is expected to include keys 'merchant_id' and 'signature'.
     * It might also contain temporary signature-related keys that will be unset
     * during the validation process.
     * @return bool True if the response is valid (merchant ID matches and signature is correct),
     * false otherwise.
     */
    public function validateResponse(array $response): bool
    {
        // 1. Verify the Merchant ID
        if ((string)Configuration::get('HUTKO_MERCHANT') != (string)$response['merchant_id']) {
            return false;
        }

        // 2. Prepare Response Data for Signature Verification
        $responseSignature = $response['signature'];

        // Unset signature-related keys that should not be part of the signature calculation.
        // This ensures consistency with how the signature was originally generated.
        unset($response['response_signature_string'], $response['signature']);

        // 3. Calculate and Compare Signatures
        $calculatedSignature = $this->getSignature($response);

        return hash_equals($calculatedSignature, $responseSignature);
    }


    /**
     * Helper method to update order status and add to history.
     *
     * @param int $orderId The ID of the order to update.
     * @param int $newStateId The ID of the new order state.
     * @param string $message A message to log with the status change.
     * @return void
     */
    public function updateOrderStatus(int $orderId, int $newStateId): void
    {
        $order = new Order($orderId);
        // Only update if the order is loaded and the current state is different from the new state.
        if (Validate::isLoadedObject($order) && (int)$order->getCurrentState() != $newStateId) {
            $history = new OrderHistory();
            $history->id_order = $orderId;
            $history->changeIdOrderState($newStateId, $orderId);
            $history->addWithemail();
        }
    }


    /**
     * Hook implementation for PrestaShop 1.7.x to display content in the admin order page.
     *
     * This hook is typically used to add content *below* the main order details
     * but before the tabbed section. It's often used for specific sections
     * rather than entire tabs in 1.7. However, in this case, it's likely
     * being used as a fallback or alternative for displaying the payment content
     * depending on the module's design or compatibility needs for 1.7.
     *
     * @param array $params Contains context information, including the 'order' object.
     * @return string The HTML content to be displayed in the admin order page.
     */
    public function hookdisplayAdminOrderContentOrder(array $params)
    {
        // Delegate the actual content generation to a shared function
        // to avoid code duplication.
        return $this->displayAdminOrderContent($params);
    }


    /**
     * Hook implementation for PrestaShop 8.x and 9.x to display content
     * within a specific tab on the admin order page.
     *
     * This hook is the standard way in newer PS versions to add a custom tab
     * and populate its content on the order detail page.
     *
     * @param array $params Contains context information, including the 'order' object.
     * @return string The HTML content to be displayed within the module's custom tab.
     */
    public function hookdisplayAdminOrderTabContent(array $params)
    {
        $params['order'] = new Order((int) $params['id_order']);
        // Delegate the actual content generation to a shared function
        // to avoid code duplication.
        return $this->displayAdminOrderContent($params);
    }


    /**
     * Common function to display content related to Hutko payments on the admin order page.
     *
     * This function handles the logic for processing potential form submissions (like refunds
     * or status updates) and preparing data to be displayed in a template.
     *
     * It is called by different hooks depending on the PrestaShop version
     * (displayAdminOrderContentOrder for 1.7.x, displayAdminOrderTabContent for 8.x/9.x).
     *
     * @param array $params Contains context information from the hook, typically including the 'order' object.
     * @return string The rendered HTML content from the template.
     */
    public function displayAdminOrderContent(array $params): string
    {
        if (!Configuration::get('HUTKO_MERCHANT') || empty(Configuration::get('HUTKO_MERCHANT') || !Configuration::get('HUTKO_SECRET_KEY') || empty(Configuration::get('HUTKO_SECRET_KEY')))) {
            return '';
        }

        // Ensure the 'order' object is present in the parameters
        if (!isset($params['order']) || !$params['order'] instanceof Order) {
            // Log an error or return an empty string if the order object is missing
            // depending on how critical it is. Returning empty string is safer
            // to avoid crashing the admin page.
            PrestaShopLogger::addLog(
                'Hutko Module: Order object missing in displayAdminOrderContent hook.',
                1, // Error level
                null,
                'Module',
                (int)$this->id
            );
            return '';
        }

        // Check if a refund form has been submitted
        if (Tools::isSubmit('hutkoRefundsubmit')) {
            // Process the refund logic. 
            $this->processRefundForm();
        }

        // Check payment status
        if (Tools::getValue('hutkoOrderPaymentStatus')) {

            // Process the requested order status check. 
            $this->renderOrderPaymentStatus(Tools::getValue('hutkoOrderPaymentStatus'));
        }

        // Get the Order object from the parameters
        $order = $params['order'];

        // Fetch all OrderPayment records associated with this order
        // that were processed specifically by this payment module (based on display name)
        // and have a transaction ID matching a specific pattern (order ID prefix).
        // The transaction_id pattern suggests it's linked to the order ID for easy lookup.
        $hutkoPayments = new PrestaShopCollection('OrderPayment');
        $hutkoPayments->where('order_reference', '=', $order->reference); // Filter by order reference
        $hutkoPayments->where('payment_method', '=', $this->displayName); // Filter by this module's payment method name
        // Filter by transaction ID pattern: Starts with the order ID followed by the configured separator.
        // This assumes transaction IDs generated by this module follow this format.
        $hutkoPayments->where('transaction_id', 'like', '' . $order->id . $this->order_separator . '%');

        // Assign data to Smarty to be used in the template
        $this->context->smarty->assign([
            // Pass the fetched Hutko payment records to the template as an array
            'hutkoPayments' => $hutkoPayments,
            // Pass the order ID to the template
            'id_order' => $order->id,
            'currency' => new Currency($order->id_currency),
            'hutkoOrderPaymentStatus' => $this->context->session->get('hutkoOrderPaymentStatus'),
        ]);
        // Render the template located at 'views/templates/admin/order_payment_refund.tpl'
        // This template will display the fetched payment information and potentially refund/status forms.
        return $this->display(__FILE__, 'views/templates/admin/order_payment_refund.tpl');
    }
    public function renderOrderPaymentStatus(string $order_id)
    {

        $data = $this->getOrderPaymentStatus($order_id);

        $this->context->session->set('hutkoOrderPaymentStatus', $this->displayArrayInNotification($data['response']));
        Tools::redirectAdmin($this->context->controller->currentIndex);
    }
    public function getOrderPaymentStatus(string $order_id): array
    {
        $data = [
            'order_id' => $order_id,
            'merchant_id' => Configuration::get('HUTKO_MERCHANT'),
            'version' => '1.0',
        ];
        $data['signature'] = $this->getSignature($data);

        return  $this->sendAPICall($this->status_url, $data);
    }

    public function processRefundForm()
    {
        $orderPaymentId = (int) Tools::getValue('orderPaymentId');
        $amount = (float) Tools::getValue('refund_amount');
        $comment = mb_substr(Tools::getValue('comment', ''), 0, 1024);
        $id_order = (int) Tools::getValue('id_order');
        $result =   $this->processRefund($orderPaymentId, $id_order, $amount,  $comment);
        $link =   $this->context->link->getAdminLink('AdminOrders', true, [], ['id_order' => $id_order, 'vieworder' => true]);
        if ($result->error) {
            $this->context->controller->errors[] = $result->description;
        }
        if ($result->success) {
            $this->context->controller->informations[] = $result->description;
        }
        Tools::redirectAdmin($link);
    }

    /**
     * Processes a payment refund via the Hutko gateway and updates PrestaShop order.
     *
     * This method initiates a refund request to the Hutko payment gateway for a specific
     * order payment. Upon successful refund from Hutko, it creates an OrderSlip (if partial),
     * updates the order history, and logs the action.
     *
     * @param int    $orderPaymentId The ID of the OrderPayment record to refund.
     * @param int    $id_order The ID of the Order to refund.
     * @param float  $amount         The amount to refund.
     * @param string $comment        A comment or reason for the refund.
     * @return stdClass Result description.
     * @throws Exception If the OrderPayment is not found, invalid, or refund fails.
     */
    public function processRefund(int $orderPaymentId, int $id_order, float $amount, string $comment = ''): stdClass
    {
        $result = new stdClass();
        $result->error = false;

        $order = new Order($id_order);
        $orderPayment = new OrderPayment($orderPaymentId);
        $currency = new Currency($orderPayment->id_currency);
        if (!Validate::isLoadedObject($orderPayment)) {
            PrestaShopLogger::addLog(
                'Hutko Refund: OrderPayment object not found for ID: ' . $orderPaymentId,
                3, // Error
                null,
                'OrderPayment',
                $orderPaymentId,
                true
            );
            throw new Exception($this->trans('Order payment not found.', [], 'Modules.Hutko.Admin'));
        }

        // Validate the transaction_id format and extract cart ID.
        // Assuming transaction_id is in the format "orderID#timestamp"
        $transactionIdParts = explode($this->order_separator, $orderPayment->transaction_id);
        $cartId = (int)$transactionIdParts[0];

        if (!$cartId) {
            PrestaShopLogger::addLog(
                'Hutko Refund: Invalid transaction ID format for OrderPayment ID: ' . $orderPaymentId . ' Transaction ID: ' . $orderPayment->transaction_id,
                3, // Error
                null,
                'OrderPayment',
                $orderPaymentId,
                true
            );
            throw new Exception($this->trans('Invalid transaction ID format.', [], 'Modules.Hutko.Admin'));
        }


        $response = $this->refundAPICall($orderPayment->transaction_id, $amount, $currency->iso_code, $comment);
        if ($response['response']['reverse_status'] === 'approved' && $response['response']['response_status'] === 'success') {
            $result->success = true;
            $result->description = $this->trans('Refund success.', [], 'Modules.Hutko.Admin');
        } else {
            PrestaShopLogger::addLog(
                'Hutko Refund: refund failure response: ' . json_encode($response),
                3, // Info
                null,
                'OrderPayment',
                $orderPaymentId,
                true
            );
            $this->addOrderMessage($order, $this->trans('Refund Failed. Please check actual amount in Hutko account page.', [], 'Modules.Hutko.Admin'));
            $result->error = true;
            $result->description = $response['response']['error_message'];
            return $result;
        }
        $amountFloat = round((int)$response['response']['reversal_amount'] / 100, 2);

        $this->addOrderMessage($order, $this->trans('Refund success.', [], 'Modules.Hutko.Admin') . ' ' . $currency->iso_code . $amountFloat . '. [' . $comment . ']');
        $order->addOrderPayment($amountFloat, $this->displayName,  $orderPayment->transaction_id . '_refund', $currency);
        $order->setCurrentState((int)Configuration::get('PS_OS_REFUND'));


        return $result;
    }

    public function addOrderMessage(Order $order, string $message)
    {
        try {
            $customer = new Customer($order->id_customer);

            $thread = CustomerThread::getIdCustomerThreadByEmailAndIdOrder($customer->email, $order->id);

            if (is_int((int) $thread) && $thread != 0) {
                $thread = (int) $thread;
            } else {
                $customer_thread = new CustomerThread();
                $customer_thread->id_contact = 0;
                $customer_thread->id_customer = (int) $order->id_customer;
                $customer_thread->id_shop = (int) $order->id_shop;
                $customer_thread->id_order = (int) $order->id;
                $customer_thread->id_lang = (int) $this->context->language->id;
                $customer_thread->email = $customer->email;
                $customer_thread->status = 'open';
                $customer_thread->token = Tools::passwdGen(12);
                $customer_thread->add();
                $thread = $customer_thread->id;
            }


            $customer_message = new CustomerMessage();
            $customer_message->id_customer_thread =   $thread;
            $customer_message->id_employee = 1;
            $customer_message->message = $message;
            $customer_message->private = 1;
            if (false === $customer_message->validateField('message', $customer_message->message)) {
                throw new Exception('Invalid reply message');
            }

            if (false === $customer_message->add()) {
                throw new Exception('Failed to add customer message');
            }
        } catch (Throwable $e) {
            PrestaShopLogger::addLog('failed add message to order. ' . $e->getMessage() . ' | ' . $message, 3);
        }
    }


    public function addRefundPayment(Order $order, OrderPayment $purchaseOrderPayment, float $amount)

    {
        $order_payment = new OrderPayment();
        $order_payment->order_reference = $order->reference;
        $order_payment->id_currency = $purchaseOrderPayment->id_currency;
        $order_payment->payment_method = $purchaseOrderPayment->payment_method;
        $order_payment->transaction_id =  $purchaseOrderPayment->transaction_id . $this->order_separator . 'refund';
        $order_payment->amount =  $amount;
        $order_payment->id_employee = 0;
        $order_payment->add();
        $order->total_paid_real = $order->total_paid_real - $amount;
        $order->update();
    }
    /**
     * Initiates a refund (reverse) request via Hutko API.
     *
     * @param string $order_id The gateway's order ID to refund.
     * @param float $amount The amount to refund (in base units, e.g., 100.50).
     * @param string $currency The currency code (e.g., 'UAH').
     * @param string $comment Optional comment for the refund.
     * @return array Decoded API response array. Returns an error structure on failure.
     */
    public function refundAPICall(string $order_id, float $amount, string $currencyISO, string $comment = ''): array
    {
        // 1. Prepare the data payload
        $data = [
            'order_id' => $order_id,
            // Assuming Configuration::get is available to fetch the merchant ID
            'merchant_id' => Configuration::get('HUTKO_MERCHANT'),
            'version' => '1.0',
            // Amount should be in minor units (cents, kopecks) and converted to string as per API example
            'amount' => round($amount * 100),
            'currency' => $currencyISO,
        ];

        if (!empty($comment)) {
            $data['comment'] = $comment;
        }

        // 2. Calculate the signature based on the data array *before* wrapping in 'request'
        $data['signature'] = $this->getSignature($data);
        return $this->sendAPICall($this->refund_url, $data);
    }

    /**
     * Initiates a request via Hutko API.
     *
     * @param string $url The gateway's url.
     * @param array $data The data.
     * @return array Decoded API response array. Returns an error structure on failure.
     */
    public function sendAPICall(string $url, array $data, int $timeout = 60): array
    {
        if (Configuration::get('HUTKO_SAVE_LOGS')) {
            $this->log($url . ' <= ' . json_encode($data));
        }

        // Wrap the prepared data inside the 'request' key as required by the API
        $requestPayload = ['request' => $data];

        // Convert the payload to JSON string
        $jsonPayload = json_encode($requestPayload);

        if ($jsonPayload === false) {
            // Handle JSON encoding error
            return [
                'response' => [
                    'response_status' => 'failure',
                    'error_message' => 'Failed to encode request data to JSON: ' . json_last_error_msg(),
                    'error_code' => 'JSON_ENCODE_ERROR'
                ]
            ];
        }

        // Initialize CURL
        $ch = curl_init();

        // 4. Set CURL options
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_POST, true); // Use POST method
        curl_setopt($ch, CURLOPT_POSTFIELDS, $jsonPayload); // Set the JSON body
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); // Return the response as a string
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Content-Type: application/json',
            'Content-Length: ' . strlen($jsonPayload), // Good practice
        ]);

        // Recommended for production: Verify SSL certificate
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
        curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); // Verify hostname against certificate


        curl_setopt($ch, CURLOPT_TIMEOUT, $timeout); // Timeout in seconds

        // Execute the CURL request
        $response = curl_exec($ch);

        // Check for CURL errors
        $curl_error = curl_error($ch);
        $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($curl_error) {
            // Log the error or handle it appropriately
            curl_close($ch);
            return [
                'response' => [
                    'response_status' => 'failure',
                    'error_message' => 'CURL Error: ' . $curl_error,
                    'error_code' => 'CURL_' . curl_errno($ch),
                    'http_code' => $http_code // Include http code for context
                ]
            ];
        }

        // Close CURL handle
        curl_close($ch);
        if (Configuration::get('HUTKO_SAVE_LOGS')) {
            $this->log($url . ' => ' . $response);
        }
        // Process the response
        // Decode the JSON response into a PHP array
        $responseData = json_decode($response, true);

        // Check if JSON decoding failed
        if (json_last_error() !== JSON_ERROR_NONE) {
            // Log the error or handle it appropriately
            return [
                'response' => [
                    'response_status' => 'failure',
                    'error_message' => 'Invalid JSON response from API: ' . json_last_error_msg(),
                    'error_code' => 'JSON_DECODE_ERROR',
                    'http_code' => $http_code,
                    'raw_response' => $response // Include raw response for debugging
                ]
            ];
        }
        return $responseData;
    }


    /**
     * Displays an array's contents in a PrestaShop notification box.
     *
     * This function is intended for debugging or displaying API responses/structured data
     * in the PrestaShop back office notifications.
     *
     * @param array $data The array to display.
     */
    protected function displayArrayInNotification(array $data): string
    {
        if (isset($data['response_signature_string'])) {
            unset($data['response_signature_string']);
        }
        if (isset($data['additional_info'])) {
            $data['additional_info_decoded'] = json_decode($data['additional_info'], true);
            if (isset($data['additional_info_decoded']['reservation_data'])) {
                $data['additional_info_decoded']['reservation_data_decoded'] = json_decode($data['additional_info_decoded']['reservation_data'], true);
                unset($data['additional_info_decoded']['reservation_data']);
            }
            unset($data['additional_info']);
        }
        $retStr = '<ul>';
        if (is_array($data)) {
            foreach ($data as $key => $val) {
                if (is_array($val)) {
                    $retStr .= '<li>' . $key . ' => ' . $this->displayArrayInNotification($val) . '</li>';
                } else {
                    $retStr .= '<li>' . $key . ' => ' . $val . '</li>';
                }
            }
        }
        $retStr .= '</ul>';
        return $retStr;
    }


    /**
     * Check if the module uses the new translation system.
     *
     * @return bool
     */
    public function isUsingNewTranslationSystem()
    {
        return true;
    }


    public function log($data)
    {
        if (!is_string($data)) {
            $data =  json_encode($data, JSON_UNESCAPED_UNICODE);
        }
        $logdirectory = _PS_ROOT_DIR_ . '/var/modules/' . $this->name . '/logs/' . date("Y") . '/' . date("m") . '/' . date("d") . '/';
        if (!is_dir($logdirectory)) {
            mkdir($logdirectory, 0750, true);
        }
        $logger = new \FileLogger(0); //0 == debug level, logDebug() won’t work without this.
        $logger->setFilename($logdirectory . 'dayly.log');
        $logger->logInfo($data);
    }
    public function displayLastDayLog()
    {
        $baseLogDir = _PS_ROOT_DIR_ . '/var/modules/' . $this->name . '/logs/';
        $daysToCheck = 30; // How many recent days to check for logs

        $latestLogFile = false;
        $logDate = null;

        // Find the latest log file by iterating backward from today
        for ($i = 0; $i < $daysToCheck; $i++) {
            // Use \DateTime for clarity as we might be in a different namespace
            $date = new \DateTime("-$i days");
            $year = $date->format("Y");
            $month = $date->format("m");
            $day = $date->format("d");

            $potentialDir = $baseLogDir . $year . '/' . $month . '/' . $day . '/';
            $potentialFile = $potentialDir . 'dayly.log';

            if (is_dir($potentialDir) && file_exists($potentialFile)) {
                $latestLogFile = $potentialFile;
                $logDate = $date; // Store the date of the found log
                break; // Found the latest one, stop searching
            }
        }

        // Prepare HTML output
        $html = '<div class="panel">';
        // Use translation function for the heading
        $html .= '<div class="panel-heading"><i class="icon-align-left"></i> ' . $this->trans('Hutko Module Logs', [], 'Modules.Hutko.Admin') . '</div>';
        $html .= '<div class="panel-body">';

        if ($latestLogFile) {
            // Add a heading indicating the date of the log file
            $html .= '<h4>' . sprintf($this->trans('Log file for %s', [], 'Modules.Hutko.Admin'), $logDate->format("Y-m-d")) . '</h4>';

            // Read the file line by line into an array
            // FILE_IGNORE_NEW_LINES: removes the trailing newline character from each element
            // FILE_SKIP_EMPTY_LINES: skips empty lines
            $lines = file($latestLogFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

            if ($lines !== false) { // Check if file() succeeded
                if (empty($lines)) {
                    $html .= '<p>' . $this->trans('The log file is empty.', [], 'Modules.Hutko.Admin') . '</p>';
                } else {
                    // Output each line wrapped in a <p> tag
                    foreach ($lines as $line) {
                        // Use htmlspecialchars to prevent HTML injection and display characters correctly
                        // Add word-wrap style for long lines
                        $html .= '<p style="word-wrap: break-word;">' . htmlspecialchars($line, ENT_QUOTES, 'UTF-8') . '</p>';
                    }
                }
            } else {
                // Error reading the file
                $html .= '<div class="alert alert-warning">' . $this->trans('Could not read the log file:', [], 'Modules.Hutko.Admin') . ' ' . $latestLogFile . '</div>';
            }
        } else {
            // No log file found in the specified range
            $html .= '<div class="alert alert-info">' . sprintf($this->trans('No log file found in the last %d days.', [], 'Modules.Hutko.Admin'), $daysToCheck) . '</div>';
        }

        $html .= '</div>'; // End panel-body
        $html .= '</div>'; // End panel

        return $html;
    }

    /**
     * URL-safe encodes a string using a Base64-like approach.
     * Replaces '+' with '-', '/' with '_', and removes trailing '=' padding.
     * Useful for encoding arbitrary binary data into a URL-friendly format
     * that can be safely passed in URLs (e.g., within query parameters
     * or path segments without needing standard percent encoding for + and /).
     *
     * @param string $string The string or binary data to encode.
     * @return string The URL-safe encoded string.
     */
    public  function urlSafeEncode($string)
    {
        // Standard Base64 encode
        $encoded = base64_encode($string);

        // Replace '+' with '-' and '/' with '_'
        // This avoids characters that have special meaning in URLs
        $encoded = str_replace(['+', '/'], ['-', '_'], $encoded);

        // Remove trailing '=' padding
        // Padding is not necessary for decoding if the length is known or can be inferred.
        // Removing it makes the string shorter and avoids another problematic character (=).
        $encoded = rtrim($encoded, '=');

        return $encoded;
    }

    /**
     * Decodes a URL-safe encoded string back to its original form.
     * Replaces '-' with '+', '_' with '/', and adds back trailing '=' padding.
     *
     * @param string $string The URL-safe encoded string.
     * @return string|false The decoded string, or false on failure (if the input is not valid base64 after adjustments).
     */
    public function urlSafeDecode($string)
    {
        // Replace '-' with '+' and '_' with '/'
        $decoded = str_replace(['-', '_'], ['+', '/'], $string);

        // Add back trailing '=' padding.
        // Base64 strings (before decoding) must have a length that is a multiple of 4.
        // We calculate how many characters short we are from a multiple of 4
        // and add the corresponding number of '=' characters back.
        $padding = strlen($decoded) % 4;
        if ($padding > 0) {
            $decoded .= str_repeat('=', 4 - $padding);
        }

        // Standard Base64 decode
        // base64_decode returns the original data or FALSE on failure.
        return base64_decode($decoded);
    }
}