<?php
/**
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Software License Agreement
 * that is bundled with this package in the file LICENSE.txt.
 *
 * @author    Peter Sliacky (Zelarg)
 * @copyright Peter Sliacky (Zelarg)
 * @license   http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 */

use PrestaShop\PrestaShop\Adapter\Product\PriceFormatter;
use \PrestaShop\PrestaShop\Core\Module\WidgetInterface;
use PrestaShop\PrestaShop\Adapter\ObjectPresenter;
use module\thecheckout\Config;
use module\thecheckout\SocialLogin;


//include_once(_PS_MODULE_DIR_ . $this->name . '/classes/CheckoutCartController.php');

class TheCheckoutModuleFrontController extends ModuleFrontController
{

    public $php_self = 'order'; // stripe_official needs this to load assets

    private $name = 'thecheckout';
    private $module_root = '';
    private $availableCountries;

    private $selected_payment_option;

    // $checkoutProcess property is Necessary for Prestashop Checkout module - which goes directly to controller class
    // through reflection
    private $checkoutProcess;

    /** @var $module TheCheckout */
    public $module;

    private $amazonpayOngoingSession = false;

    public function __construct()
    {
        $_GET['module'] = $this->name;

        $this->module = Module::getInstanceByName($this->name);

        if (!$this->module->active) {
            Tools::redirect('index');
        }

        parent::__construct();
        $this->page_name = 'checkout';
    }

    public function init()
    {
        $this->wrapInNonZeroCustomerIdForVATDeduction(function () {
            parent::init();
        });

        $this->checkAndMakeSubmitReorderRequest();

//        if (0 == $this->context->cart->nbProducts() && empty($this->errors)) {
//            Tools::redirect('index');
//        }

        $this->module_root = _PS_MODULE_DIR_ . $this->name;
    }


    // oyejorge/less.php v1.7.1
    private function autoCompileLess($inputFile, $outputFile)
    {
        require_once $this->module_root . "/lib/less.php_1.7.0.10/Less.php";

        $cacheDir      = _PS_CACHE_DIR_ . 'thecheckout/';
        $less_files    = array($inputFile => '');
        $options       = array(
            'cache_dir'        => $cacheDir,
            'sourceMap'        => true,
            'sourceMapWriteTo' => $outputFile . '.map',
            /*'compress' => true*/
        );

        try {
            $css_file_name = @Less_Cache::Get($less_files, $options, array());
        } catch (Exception $ex) {
            print_r($ex);
        }

        if (!file_exists($outputFile) || filemtime($cacheDir . $css_file_name) > filemtime($outputFile)) {
            $compiled = Tools::file_get_contents($cacheDir . $css_file_name);
            file_put_contents($outputFile, $compiled);
        }
    }


//
//   lessc 0.4 implementation
//   private function autoCompileLess($inputFile, $outputFile)
//    {
//        require $this->module_root . "/lib/lessc.inc.php";
//
//        $cacheFile = $inputFile . ".cache";
//
//        if (file_exists($cacheFile)) {
//            $cache = unserialize(file_get_contents($cacheFile));
//        } else {
//            $cache = $inputFile;
//        }
//
//        $less = new lessc;
//        if (!$this->module->debug) {
//            $less->setFormatter("compressed");
//        }
//
//        $forceCompile = ($this->module->debug) ? true : false;
//
//        $newCache = $less->cachedCompile($cache, $forceCompile);
//
//        if (!is_array($cache) || $newCache["updated"] > $cache["updated"]) {
//            file_put_contents($cacheFile, serialize($newCache));
//            file_put_contents($outputFile, $newCache['compiled']);
//        }
//    }


    private function compileLess()
    {
        try {
            $this->autoCompileLess($this->module_root . "/views/css/front.less",
                $this->module_root . "/views/css/front.less.css");
            $this->autoCompileLess($this->module_root . "/views/css/custom.less",
                $this->module_root . "/views/css/custom.less.css");
            $substyleFileName = $this->module_root . "/views/css/styles/" . $this->module->config->checkout_substyle . ".less";
            if (file_exists($substyleFileName)) {
                $this->autoCompileLess($substyleFileName,
                    $this->module_root . "/views/css/styles/" . $this->module->config->checkout_substyle . ".less.css");
            }
        } catch (Exception $e) {
            if ($this->module->debug) {
                $this->module->logError($e->getMessage());
            } // otherwise, just die gracefully
        }
    }

    public function setMedia()
    {
        parent::setMedia();

        // Remove theme's CSS files, for distraction free checkout styling
        //$this->unregisterStylesheet('theme-main');

        $this->compileLess();

        if ($this->module->debug) {
            $this->module->logInfo('--- DEBUG MODE ACTIVE---');
        }

        // Include font CSS, if custom font is selected
        $i = 0;
        if ("theme-default" !== $this->module->config->font) {
            $this->context->controller->registerStylesheet('modules-thecheckout-' . ($i++),
                '//fonts.googleapis.com/css?family=' . $this->module->config->font . ":" . $this->module->config->fontWeight,
                array('media' => 'all', 'priority' => 140, 'server' => 'remote'));
        }

        // Include all views/css/*.css and views/js/*.js files
        foreach (glob(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/views/css/*.css") as $filename) {
            $this->context->controller->registerStylesheet('modules-thecheckout-' . ($i++),
                Tools::substr($filename, Tools::strlen(_PS_ROOT_DIR_) + 1),
                array(
                    'media'    => 'all',
                    'priority' => ('front.less.css' == Tools::substr($filename, -14)) ? 1150 : 1200
                ));
        }

        $this->context->controller->registerJavascript('modules-thecheckout-' . ($i++),
            Tools::substr(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/lib/compute-scroll-into-view.min.js",
                Tools::strlen(_PS_ROOT_DIR_) + 1),
            array('position' => 'bottom', 'priority' => 1140));
        $this->context->controller->registerJavascript('modules-thecheckout-' . ($i++),
            Tools::substr(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/lib/toastify-js.js",
                Tools::strlen(_PS_ROOT_DIR_) + 1),
            array('position' => 'bottom', 'priority' => 1140));

        foreach (glob(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/views/js/*.js") as $filename) {
            $this->context->controller->registerJavascript('modules-thecheckout-' . ($i++),
                Tools::substr($filename, Tools::strlen(_PS_ROOT_DIR_) + 1),
                array('position' => 'bottom', 'priority' => 1150));
        }
        foreach (glob(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/views/js/parsers/*.js") as $filename) {
            $this->context->controller->registerJavascript('modules-thecheckout-' . ($i++),
                Tools::substr($filename, Tools::strlen(_PS_ROOT_DIR_) + 1),
                array('position' => 'bottom', 'priority' => 1160));
        }
        if ($this->module->config->checkout_steps) {
            if (file_exists(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/views/js/includes/checkout-steps.js")) {
                $this->context->controller->registerJavascript('modules-thecheckout-checkout-steps',
                    Tools::substr(_PS_ROOT_DIR_ . '/modules/' . $this->name . "/views/js/includes/checkout-steps.js",
                        Tools::strlen(_PS_ROOT_DIR_) + 1),
                    array('position' => 'bottom', 'priority' => 205));
            }
        }

        $additionalStyles   = array();
        $additionalStyles[] = _PS_ROOT_DIR_ . '/modules/' . $this->name . '/views/css/themes-overrides/' . _THEME_NAME_ . '.css';
        $additionalStyles[] = _PS_ROOT_DIR_ . '/modules/' . $this->name . '/views/css/styles/' . $this->module->config->checkout_substyle . '.less.css';
//        $additionalStyles[] = _PS_ROOT_DIR_ . '/modules/' . $this->name . '/lib/toast.style.min.css';

        $sendcloud_moduleName = 'sendcloud';
        if (Module::isInstalled($sendcloud_moduleName) && Module::isEnabled($sendcloud_moduleName)) {
            $additionalStyles[] = _PS_ROOT_DIR_ . '/modules/' . $sendcloud_moduleName . '/views/css/front.css';
        }

        foreach ($additionalStyles as $filename) {
            if (file_exists($filename)) {
                $this->context->controller->registerStylesheet('modules-thecheckout-' . ($i++),
                    Tools::substr($filename, Tools::strlen(_PS_ROOT_DIR_) + 1),
                    array('media' => 'all', 'priority' => 1160));
            }
        }

        // Register CDN's JS - we will not use Vue.js right now
//        $this->context->controller->registerJavascript('modules-thecheckout-' . ($i++),
//        'https://cdn.jsdelivr.net/npm/vue',
//        ['position' => 'bottom', 'priority' => 140, 'server' => 'remote']);
    }

    private function usingExtraFields()
    {
        // TODO: Logic need to be changed for 'other' field; in 'other', all other extras will be stored
    }

    private function addExtraFields()
    {
    }

    // PS copied method
    private function getFieldLabel($field)
    {
        // Country:name => Country, Country:iso_code => Country,
        // same label regardless of which field is used for mapping.
        $field = explode(':', $field)[0];

        switch ($field) {
            case 'email':
                return $this->translator->trans('Email', array(), 'Shop.Forms.Labels');
            case 'password':
                return $this->translator->trans('Password', array(), 'Shop.Forms.Labels');
            case 'id_gender':
                return $this->translator->trans('Social title', array(), 'Shop.Forms.Labels');
            case 'company':
                return $this->translator->trans('Company', array(), 'Shop.Forms.Labels');
            case 'siret':
                return $this->translator->trans('Identification number', array(), 'Shop.Forms.Labels');
            case 'birthday':
            case 'birthdate':
                return $this->translator->trans('Birthdate', array(), 'Shop.Forms.Labels');
            case 'optin':
                return $this->translator->trans('Receive offers from our partners', array(),
                    'Shop.Theme.Customeraccount');
            case 'alias':
                return $this->translator->trans('Alias', array(), 'Shop.Forms.Labels');
            case 'firstname':
                return $this->translator->trans('First name', array(), 'Shop.Forms.Labels');
            case 'lastname':
                return $this->translator->trans('Last name', array(), 'Shop.Forms.Labels');
            case 'address1':
                return $this->translator->trans('Address', array(), 'Shop.Forms.Labels');
            case 'address2':
                return $this->translator->trans('Address Complement', array(), 'Shop.Forms.Labels');
            case 'postcode':
                return $this->translator->trans('Zip/Postal Code', array(), 'Shop.Forms.Labels');
            case 'city':
                return $this->translator->trans('City', array(), 'Shop.Forms.Labels');
            case 'Country':
            case 'id_country':
                return $this->translator->trans('Country', array(), 'Shop.Forms.Labels');
            case 'State':
            case 'id_state':
                return $this->translator->trans('State', array(), 'Shop.Forms.Labels');
            case 'phone':
                return $this->translator->trans('Phone', array(), 'Shop.Forms.Labels');
            case 'phone_mobile':
                return $this->translator->trans('Mobile phone', array(), 'Shop.Forms.Labels');
            case 'company':
                return $this->translator->trans('Company', array(), 'Shop.Forms.Labels');
            case 'vat_number':
                return $this->translator->trans('VAT number', array(), 'Shop.Forms.Labels');
            case 'dni':
                return $this->translator->trans('Identification number', array(), 'Shop.Forms.Labels');
            case 'other':
                return $this->translator->trans('Other', array(), 'Shop.Forms.Labels');
            case 'extra1':
                return $this->module->getTranslation('Extra field No.1');// Legacy translations system necessary here
            case 'extra2':
                return $this->module->getTranslation('Extra field No.2');
            case 'extra3':
                return $this->module->getTranslation('Extra field No.3');
            case 'extra4':
                return $this->module->getTranslation('Extra field No.4');
            case 'extra5':
                return $this->module->getTranslation('Extra field No.5');
            case 'required-checkbox-1':
                return $this->module->getTranslation('Required Checkbox No.1');
            case 'required-checkbox-2':
                return $this->module->getTranslation('Required Checkbox No.2');
            case 'sdi':
            case 'ei_sdi':
            case 'eisdi':
            case 'sdicode':
                return $this->module->getTranslation('SDI');
            case 'pec':
            case 'ei_pec':
            case 'eipec':
            case 'emailpec':
                return $this->module->getTranslation('PEC');
            case 'ei_pa':
            case 'eipa':
                return $this->module->getTranslation('PA');
            default:
                return $field;
        }
    }

    private function generateFormFields($fields, $addressData, $isInvoiceAddress)
    {
        if (!empty($addressData) && isset($addressData->id_country)) {
            $country = new Country($addressData->id_country);
        } else {
            // When country is not set (first expand of secondary address), we can set context->country,
            // which effectively is invoice country; however, in Carrier::getAvailableCarrierList, when
            // address is not set, country is taken as country_default option, so better adhere to that.
            // Except, GEO location module enabled, then as default country, choose the context's one
            if (Module::isEnabled('geotargetingpro') || (isset($this->context->country) && $this->context->country)) {
                $country = $this->context->country;
            } else {
                $country = new Country(Configuration::get('PS_COUNTRY_DEFAULT'));
            }

        }

        $fields['country_iso_hidden'] = array('visible' => false, 'required' => false, 'width' => 100, 'live' => false);
        // general_error will be hidden and would serve as anchor for context error reporting
        $fields['general_error'] = array('visible' => false, 'required' => false, 'width' => 100, 'live' => false);

        $autoCompleteAttributes = array(
            'dni'       => 'dni',
            // though, this is not valid attribute value, we need to prevent filling in anything else
            'firstname' => 'given-name',
            'lastname'  => 'family-name',
            'address1'  => 'street-address'
        );

        $format = array();
        foreach ($fields as $fieldName => $fieldOptions) {
            $formField = new CheckoutFormField();
            $formField->setName($fieldName);

            $fieldParts = explode(':', $fieldName, 2);

            if (count($fieldParts) === 1) {
//                if ($fieldName === 'id_gender') {
//                    $formField->setType('radio-buttons');
//                    foreach (Gender::getGenders($this->context->language->id) as $gender) {
//                        $formField->addAvailableValue($gender->id, $gender->name);
//                    }
//                }
                if ($fieldName === 'postcode') {
                    // Postcode is either visible and required or hidden; visible and non-required is not defined
                    if ($country->need_zip_code) {
                        $formField->setRequired(true);
                    } else {
                        $formField->setHidden(true);
                    }
                }
                if ($fieldName === 'dni') {
                    // DNI is special, it is managed in TheCheckout and Country, the logic will be:
                    // if DNI is set to be required on country level, we will show and require it on checkout;
                    // BUT, only when it's set to be visible also in TheCheckout module, so that we can control its
                    // appearance in delivery address; in invoice, it will be always forced
                    // if it's not, we'll respect settings in TheCheckout module
                    if ($country->need_identification_number && ($fieldOptions["visible"] || $isInvoiceAddress)) {
                        $formField->setRequired(true);
                        $formField->setCssClass('need-dni');
                    }
                }
                if ('phone' === Tools::substr($fieldName, 0, Tools::strlen('phone'))) {
                    $formField->setType('tel');
                    $formField->setCustomData(array('call_prefix' => $country->call_prefix));
                    if ($this->module->config->show_call_prefix) {
                        $formField->setCssClass('has-call-prefix');
                    }
                }
                if ($fieldName === 'country_iso_hidden') {
                    // country ISO is required e.g. by Paypal or Stripe official modules
                    $formField->setValue($country->iso_code);
                    $formField->setType('hidden');
                }
                if ($fieldName === 'general_error') {
                    // serves only as anchor for context reporting of general validation error triggered
                    // by other modules, not bound to specific field
                    $formField->setType('hidden');
                }
            } elseif (count($fieldParts) === 2) {
                list($entity, $entityField) = $fieldParts;

                // Fields specified using the Entity:field
                // notation are actually references to other
                // entities, so they should be displayed as a select
                $formField->setType('select');

                // Also, what we really want is the id of the linked entity
                $formField->setName('id_' . Tools::strtolower($entity));

                if ($entity === 'Country') {
                    $formField->setType('countrySelect');

                    $guessCountry = false;
                    $thisLang = "not-set";
                    // Unselect country if we just initiated session and force_customer_to_choose_country is ON
                    if ($this->module->config->force_customer_to_choose_country && empty($addressData)) {
                        $guessCountry = true; // Guess country based on selected language
                        $thisLang = Tools::strtolower($this->context->language->locale);
                        $thisLang = Tools::substr($thisLang, strpos($thisLang, '-') + 1);
                        $formField->setValue('');
                    } else {
                        $formField->setValue($country->id);
                    }

                    foreach ($this->availableCountries as $countryDetail) {
                        if ($guessCountry &&
                            $thisLang == Tools::strtolower($countryDetail['iso_code'])) {
                            $formField->setValue($countryDetail['id_country']);
                        }
                        $formField->addAvailableValue(
                            $countryDetail['id_country'],
                            array(
                                "label"       => $countryDetail[$entityField],
                                "option_data" => 'data-iso-code=' . $countryDetail['iso_code']
                            )
                        );
                    }
                    $formField->setLive(true);
                } elseif ($entity === 'State') {
                    if ($country->contains_states) {
                        $states = State::getStatesByIdCountry($country->id, true); // true = only active states
// Sort states by alphabet
//                        usort($states, function ($a, $b) {
//                            $ax = strtr($a['name'], 'Ñ', 'N');
//                            $bx = strtr($b['name'], 'Ñ', 'N');
//                            return strcmp($ax, $bx);
//                        });
// Set default state ID
//                       if (isset($country) && $country->id && $country->id == 21 && !$addressData->id_state) {
//                            $formField->setValue(8);
//                       }
                        foreach ($states as $state) {
                            $formField->addAvailableValue(
                                $state['id_state'],
                                $state[$entityField]
                            );
                        }
                        // State field, if visible, is always required
                        $formField->setRequired(true);
                    }
                    $formField->setLive(true);
                }
            }

            $formField->setLabel($this->getFieldLabel($fieldName));

            // If it's not already required (other reasons than our config)...
            if (!$formField->isRequired()) {
                // Only trust the $required array for fields
                // that are not marked as required.
                // $required doesn't have all the info, and fields
                // may be required for other reasons than what
                // AddressFormat::getFieldsRequired() says.
                $formField->setRequired(
                    $fieldOptions["required"] && $fieldOptions["visible"] && $fieldName != "State:name"
                );
            }

            $formField->setLive(
                $fieldOptions["live"] || $formField->getLive()
            );

            // id_state will be always visible, if assigned enabled for country, regardless of settings
            // in TheCheckout config - even though, state visibility shall not be directly configurable
            // Postcode visibility is also strictly bound to it's 'required' status
            if (!('State:name' == $fieldName ||
                'postcode' == $fieldName
            )) {
                $formField->setHidden(
                    !$fieldOptions["visible"] || $formField->getHidden()
                );
            }


            $formField->setWidth(
                $fieldOptions["width"]
            );

            if (!empty($addressData) && isset($addressData->{$formField->getName()})) {
                // Exception for 'dni', where default value would be '0', so we won't set it in this case
                if (
                    ('dni' === $formField->getName() && '0' === $addressData->{$formField->getName()}) ||
                    ('id_state' === $formField->getName() && '0' === $addressData->{$formField->getName()})
                ) {
                    // do nothing
                } else {
                    $formField->setValue(trim($addressData->{$formField->getName()}));
                }
            }

            if (isset($autoCompleteAttributes[$formField->getName()])) {
                $formField->setAutoCompleteAttribute($autoCompleteAttributes[$formField->getName()]);
            }

            $format[$formField->getName()] = $formField;
        }
        return $format;
    }

    private function formatLoginFormFields()
    {
        return array(
            'back'     => (new CheckoutFormField)
                ->setName('back')
                ->setType('hidden'),
            'email'    => (new CheckoutFormField)
                ->setName('email')
                ->setType('email')
                ->setRequired(true)
                ->setLabel($this->translator->trans(
                    'Email', array(), 'Shop.Forms.Labels'
                ))
                ->addConstraint('isEmail'),
            'password' => (new CheckoutFormField)
                ->setName('password')
                ->setType('password')
                ->setRequired(true)
                ->setLabel($this->translator->trans(
                    'Password', array(), 'Shop.Forms.Labels'
                ))
                ->addConstraint('isPasswd'),
        );
    }

    private function setupFormFieldsInvoice()
    {
        $addressData = array();
        // pre-fill address only when invoice address is visible on form - that is in case
        // when it's primary address OR when it's different then shipping address
        if (
            (Config::ADDRESS_TYPE_INVOICE === $this->module->config->primary_address
                || $this->context->cart->id_address_invoice != $this->context->cart->id_address_delivery)
            && $this->context->cart->id_address_invoice > 0
        ) {
            $addressData = new Address($this->context->cart->id_address_invoice);
        }
        // If there's no address and by any chance customer is already logged in, let's use
        // their firstname / lastname as initial values
        elseif ($this->context->customer->isLogged()) {
            if (isset($this->context->customer->firstname) && '' != $this->context->customer->firstname) {
                $addressData['firstname'] = $this->context->customer->firstname;
            }
            if (isset($this->context->customer->lastname) && '' != $this->context->customer->lastname) {
                $addressData['lastname'] = $this->context->customer->lastname;
            }
            $addressData = (object)$addressData;
        }

        return $this->generateFormFields($this->module->config->invoice_fields, $addressData, true);
    }

    private function setupFormFieldsDelivery()
    {
        $addressData = array();
        if (
            (Config::ADDRESS_TYPE_DELIVERY === $this->module->config->primary_address
                || $this->context->cart->id_address_delivery != $this->context->cart->id_address_invoice)
            && $this->context->cart->id_address_delivery > 0
        ) {
            $addressData = new Address($this->context->cart->id_address_delivery);
        }

        return $this->generateFormFields($this->module->config->delivery_fields, $addressData, false);
    }


    private function setupFormFieldsAccount()
    {
        $loggedIn = $this->context->customer->isLogged();

        $additionalCustomerFormFields = Hook::exec(
            'additionalCustomerFormFields',
            array('get-tc-required-checkboxes' => 1),
            null,
            true
        );
        $moduleFields                 = array();
        $separateModuleFields         = array();

        $opc_form_checkboxes = json_decode($this->context->cookie->opc_form_checkboxes, true);

        if (is_array($additionalCustomerFormFields)) {
            foreach ($additionalCustomerFormFields as $moduleName => $additionnalFormFields) {

                if (!is_array($additionnalFormFields)) {
                    continue;
                }

                foreach ($additionnalFormFields as $formField) {
                    $checkoutFormField             = new CheckoutFormField($formField);
                    $checkoutFormField->moduleName = $moduleName;

                    // Special treatment for newsletter, if customer ticked it before, in registration form
                    if (("ps_emailsubscription" == $moduleName || "stnewsletter" == $moduleName) &&
                        !isset($opc_form_checkboxes['newsletter']) &&
                        ($this->context->customer->newsletter || $this->module->config->newsletter_checked)
                    ) {
                        $checkoutFormField->setValue(true);
                    } else {
                        $checkoutFormField->setValue(
                            isset($opc_form_checkboxes[$checkoutFormField->getName()]) &&
                            "true" === $opc_form_checkboxes[$checkoutFormField->getName()]
                        );
                    }


                    // For newsletter, psgdpr and customer_privacy modules, we have separate blocks created, so no need
                    // to output them in account hook; but let's return them for further processing
                    if (in_array($moduleName,
                        array("ps_emailsubscription", "psgdpr", "ps_dataprivacy", "thecheckout"))) {
                        $separateModuleFields[$moduleName . '_' . $checkoutFormField->getName()] = $checkoutFormField;
                    } else {
                        $moduleFields[$formField->getName()] = $checkoutFormField;
                    }
                }
            }
        }

        $format = array(
            'back'       => (new CheckoutFormField)
                ->setName('back')
                ->setType('hidden'),
            'id_address' => (new CheckoutFormField)
                ->setName('id_address')
                ->setType('hidden'),
            'token'      => (new CheckoutFormField)
                ->setName('token')
                ->setType('hidden')
                ->setValue($this->makeAddressPersister()->getToken()),
        );

        foreach ($this->module->config->customer_fields as $fieldName => $fieldOptions) {
            $formField = new CheckoutFormField();
            $formField->setName($fieldName);

//            // Third party module's injected fields (by default newsletter, psgdpr, customer_privacy
//            // will be handled separately; for all of them, position will be controlled from
//            // Thecheckout config page, for 'newsletter' (i.e. it's not required) also visibility will be controlled
//            // from Thecheckout config page.
//            if (in_array($fieldName, $this->module->config->module_customer_fields)) {
//                if (isset($moduleFields[$fieldName]) && $fieldOptions['visible']) {
//                    $format[$moduleFields[$fieldName]->moduleName . '_' . $checkoutFormField->getName()] = $moduleFields[$fieldName];
//                }
//                // continue anyway, even when $moduleField is not set; because for module fields, we do not
//                // provide default behavior (e.g. customer_privacy)
//                continue;
//            }

            if ($fieldName === 'email') {
                $formField
                    ->setType('email')
                    ->setHidden($loggedIn)
                    ->addConstraint('isEmail')
                    ->setValue($this->context->customer->email);
            }
            if ($fieldName === 'password') {
                $formField
                    ->setType('password')
                    ->setHidden($loggedIn)
                    ->addConstraint('isPasswd')
                    ->setRequired(!Configuration::get('PS_GUEST_CHECKOUT_ENABLED'))
                    ->setHidden($loggedIn ||
                        (Configuration::get('PS_GUEST_CHECKOUT_ENABLED') && !$fieldOptions["visible"]));
            }

            if ($fieldName === 'id_gender') {
                $formField
                    ->setType('radio-buttons');

                foreach (Gender::getGenders($this->context->language->id) as $gender) {
                    $formField->addAvailableValue($gender->id, $gender->name);
                }

                $opc_form_radios = json_decode($this->context->cookie->opc_form_radios, true);
                if (isset($opc_form_radios['id_gender'])) {
                    $formField->setValue((int)$opc_form_radios['id_gender']);
                } else {
                    $formField->setValue($this->context->customer->id_gender);
                }
            }

            if ($fieldName === 'birthday') {
                $formField
                    ->setValue(("0000-00-00" !== $this->context->customer->birthday) ? $this->context->customer->birthday : '')
                    ->addAvailableValue('placeholder', Tools::getDateFormat())
                    ->addAvailableValue(
                        'comment',
                        $this->translator->trans('(E.g.: %date_format%)',
                            array('%date_format%' => Tools::formatDateStr('31 May 1970')), 'Shop.Forms.Help')
                    );
            }

            if ($fieldName === 'siret') {
                $formField
                    ->setValue($this->context->customer->siret);
            }

            if ($fieldName === 'company') {
                $formField
                    ->setValue($this->context->customer->company);
            }

            if ($fieldName === 'firstname') {
                $formField
                    ->setValue($this->context->customer->firstname);
            }

            if ($fieldName === 'lastname') {
                $formField
                    ->setValue($this->context->customer->lastname);
            }

            if ($fieldName === 'optin') {
                if (isset($opc_form_checkboxes['optin'])) {
                    $optin_value = ("true" === $opc_form_checkboxes['optin']);
                } else {
                    $optin_value = $this->context->customer->optin;
                }
                $formField
                    ->setType('checkbox')
                    ->setValue($optin_value);
            }

            // If it's not already required (other reasons than our config)...
            if (!$formField->isRequired() && $fieldName !== 'password') {
                // Only trust the $required array for fields
                // that are not marked as required.
                // $required doesn't have all the info, and fields
                // may be required for other reasons than what
                // AddressFormat::getFieldsRequired() says.
                $formField->setRequired(
                    $fieldOptions["required"] && $fieldOptions["visible"]
                );
            }

            if ($fieldName !== 'password') {
                $formField->setHidden(
                    !$fieldOptions["visible"] || $formField->getHidden()
                );
            }

            $formField->setLabel($this->getFieldLabel($fieldName));
            $formField->setWidth(
                $fieldOptions["width"]
            );

            $format[$formField->getName()] = $formField;
        }

        // Place any third party checkboxes / fields, at the end of customer fields;
        // e.g. x13privacymanager module
        foreach ($moduleFields as $moduleField) {
            $format[$moduleField->moduleName . '_' . $moduleField->getName()] = $moduleField;
        }

        /*
        $format = [
            'back'       => (new CheckoutFormField)
                ->setName('back')
                ->setType('hidden'),
            'email'      => (new CheckoutFormField)
                ->setName('email')
                ->setType('email')
                ->setRequired($this->module->config->customer_fields['email']['required'])
                ->setLabel($this->translator->trans(
                    'Email', array(), 'Shop.Forms.Labels'
                ))
                ->setHidden($loggedIn)
                ->addConstraint('isEmail')
                ->setValue($this->context->customer->email)
                ->setWidth($this->module->config->customer_fields['email']['width']),
            'password'   => (new CheckoutFormField)
                ->setName('password')
                ->setType('password')
                ->setRequired(!Configuration::get('PS_GUEST_CHECKOUT_ENABLED'))
                ->setLabel($this->translator->trans(
                    'Password', array(), 'Shop.Forms.Labels'
                ))
                ->setHidden($loggedIn ||
                    (Configuration::get('PS_GUEST_CHECKOUT_ENABLED')
                        && !$this->module->config->customer_fields['password']['visible']))
                ->addConstraint('isPasswd')
                ->setWidth($this->module->config->customer_fields['password']['width']),
            'id_address' => (new CheckoutFormField)
                ->setName('id_address')
                ->setType('hidden'),
//            'id_customer' => (new CheckoutFormField)
//                ->setName('id_customer')
//                ->setType('hidden'),
            'token'      => (new CheckoutFormField)
                ->setName('token')
                ->setType('hidden')
                ->setValue($this->makeAddressPersister()->getToken()),
//            'alias'      => (new CheckoutFormField)
//                ->setName('alias')
//                ->setLabel(
//                    $this->getFieldLabel('alias')
//                )
        ];


        if ($this->module->config->customer_fields['gender']['visible']) {
            $genderField = (new CheckoutFormField)
                ->setName('id_gender')
                ->setType('radio-buttons')
                ->setRequired($this->module->config->customer_fields['gender']['required'])
                ->setLabel(
                    $this->translator->trans(
                        'Social title', array(), 'Shop.Forms.Labels'
                    )
                );
            foreach (Gender::getGenders($this->context->language->id) as $gender) {
                $genderField->addAvailableValue($gender->id, $gender->name);
            }

            $opc_form_radios = json_decode($this->context->cookie->opc_form_radios, true);
            if (isset($opc_form_radios['id_gender'])) {
                $genderField->setValue((int)$opc_form_radios['id_gender']);
            } else {
                $genderField->setValue($this->context->customer->id_gender);
            }

            $format[$genderField->getName()] = $genderField;
        }
*/

        /*
        if (Configuration::get('PS_B2B_ENABLE')) {
            $format['company'] = (new CheckoutFormField)
                ->setName('company')
                ->setType('text')
                ->setValue($this->context->customer->company)
                ->setLabel($this->translator->trans(
                    'Company', array(), 'Shop.Forms.Labels'
                ));
            $format['siret']   = (new CheckoutFormField)
                ->setName('siret')
                ->setType('text')
                ->setValue($this->context->customer->siret)
                ->setLabel($this->translator->trans(
                // Please localize this string with the applicable registration number type in your country. For example : "SIRET" in France and "Código fiscal" in Spain.
                    'Identification number', array(), 'Shop.Forms.Labels'
                ));
        }
        */

        /*
        if ($this->module->config->customer_fields['birthdate']['visible']) {
            $format['birthday'] = (new CheckoutFormField)
                ->setName('birthday')
                ->setType('text')
                ->setRequired($this->module->config->customer_fields['birthdate']['required'])
                ->setLabel(
                    $this->translator->trans(
                        'Birthdate', array(), 'Shop.Forms.Labels'
                    )
                )
                ->setWidth($this->module->config->customer_fields['birthdate']['width'])
                ->setValue(("0000-00-00" !== $this->context->customer->birthday) ? $this->context->customer->birthday : '')
                ->addAvailableValue('placeholder', Tools::getDateFormat())
                ->addAvailableValue(
                    'comment',
                    $this->translator->trans('(E.g.: %date_format%)',
                        array('%date_format%' => Tools::formatDateStr('31 May 1970')), 'Shop.Forms.Help')
                );
        }
        */
        /*
                $opc_form_checkboxes = json_decode($this->context->cookie->opc_form_checkboxes, true);

                if ($this->module->config->customer_fields['optin']['visible']) {
                    if (isset($opc_form_checkboxes['optin'])) {
                        $optin_value = ("true" === $opc_form_checkboxes['optin']);
                    } else {
                        $optin_value = $this->context->customer->optin;
                    }
                    $format['optin'] = (new CheckoutFormField)
                        ->setName('optin')
                        ->setType('checkbox')
                        ->setValue($optin_value)
                        ->setRequired($this->module->config->customer_fields['optin']['required'])
                        ->setLabel(
                            $this->translator->trans(
                                'Receive offers from our partners', array(), 'Shop.Theme.Customeraccount'
                            )
                        );
                }
        */

        return array($format, $separateModuleFields);
    }

    public function api_getAddressSelectionTplVars()
    {
        return $this->getAddressesSelectionTplVars();
    }

    private function getAddressesSelectionTplVars()
    {
        $addressesNonZero   = $this->context->cart->id_address_invoice != 0 && $this->context->cart->id_address_delivery != 0;
        $addressesDifferent = $this->context->cart->id_address_invoice !== $this->context->cart->id_address_delivery;

        // show second address only if:
        // - both addresses are different and set
        // - on of address is not yet set and expand option is enabled
        $showSecondAddress = ($this->module->config->expand_second_address && !$addressesNonZero) ||
            ($addressesDifferent && $addressesNonZero);

        $isInvoiceAddressPrimary = (Config::ADDRESS_TYPE_INVOICE === $this->module->config->primary_address);

        if ($isInvoiceAddressPrimary) {
            $showBillToDifferentAddress = false;
            $showShipToDifferentAddress = $showSecondAddress;
            $isInvoiceAddressPrimary    = true;
        } else {
            $showBillToDifferentAddress = $showSecondAddress;
            $showShipToDifferentAddress = false;
        }

        // *** For logged-in customer, prepare deliveryAddressSelection and invoiceAddressSelection comboboxes
        // Same combo for both delivery and invoice addresses; actual cart addresses will be disabled in markup
        $customerAddresses          = array();
        $addressesList              = array();
        $lastOrderInvoiceAddressId  = 0;
        $lastOrderDeliveryAddressId = 0;

        if ($this->context->customer->isLogged()) {
            $customerAddresses = $this->context->customer->getSimpleAddresses();
            foreach ($customerAddresses as &$a) {
                $a['formatted'] = AddressFormat::generateAddress(new Address($a['id']), array(), '<br>');
            }
            $allCustomerUsedAddresses = $this->getAllCustomerUsedAddresses();

            $usedDeliveryAddresses = array();
            $usedInvoiceAddresses  = array();
            foreach ($allCustomerUsedAddresses as $addressPair) {
                if (count($addressPair)) {
                    if (isset($addressPair['id_address_delivery'])) {
                        $usedDeliveryAddresses[] = $addressPair['id_address_delivery'];
                    }
                    if (isset($addressPair['id_address_invoice'])) {
                        $usedInvoiceAddresses[] = $addressPair['id_address_invoice'];
                    }
                }
            }
            foreach ($customerAddresses as $addressId => $addressItem) {

                if (null == $addressItem) {
                    // Do nothing for now; $addressItem object is just prepared here for customization (if any)
                }

                $usedForDelivery = in_array($addressId, $usedDeliveryAddresses);
                $usedForInvoice  = in_array($addressId, $usedInvoiceAddresses);

                // Add to delivery addresses list? All except addresses used exclusively for invoicing
                if ($usedForDelivery || !$usedForInvoice) {
                    $addressesList['delivery'][$addressId] = $customerAddresses[$addressId];
                }
                // Add to invoice addresses list? All except addresses used exclusively for delivery
                if ($usedForInvoice || !$usedForDelivery) {
                    $addressesList['invoice'][$addressId] = $customerAddresses[$addressId];
                }
                // Data preparation for other purposes, e.g. setting up this address filter in PS 'addresses'
                // For that, controllers/front/AddressesController.php needs to include this in initContent():
                //
                //        if (file_exists(_PS_MODULE_DIR_ . 'thecheckout/controllers/front/front.php')) {
                //            include_once(_PS_MODULE_DIR_ . 'thecheckout/controllers/front/front.php');
                //            $tc_frontController = new TheCheckoutModuleFrontController();
                //            $delivery_invoice_addresses = $tc_frontController->api_getAddressSelectionTplVars();
                //
                //            $this->context->smarty->assign('delivery_invoice_addresses', $delivery_invoice_addresses);
                //        }
                //
                // And respective template, /themes/classic/templates/customer/addresses.tpl shall be also updated
                // $addressesList['invoice'] + $addressesList['usedDeliveryExclusive'] make up "full set",
                // as 'invoice' includes also addresses we can't exactly say are invoice or delivery:
                //
                //  {if isset($delivery_invoice_addresses) && isset($delivery_invoice_addresses.addressesList)}
                //    {if isset($delivery_invoice_addresses.addressesList.invoice)}
                //      <div class="invoice-primary-addresses" style="float:left;width:100%">
                //      <h2>{l s='Primary and invoice addresses' d='Shop.Theme.Customeraccount'}</h2>
                //      {foreach $delivery_invoice_addresses.addressesList.invoice as $address}
                //          <div class="col-lg-4 col-md-6 col-sm-6">
                //          {block name='customer_address'}
                //            {include file='customer/_partials/block-address.tpl' address=$address}
                //          {/block}
                //          </div>
                //      {/foreach}
                //      </div>
                //    {/if}
                //  {/if}
                //
                //  {if isset($delivery_invoice_addresses) && isset($delivery_invoice_addresses.addressesList)}
                //    {if isset($delivery_invoice_addresses.addressesList.usedDeliveryExclusive)}
                //      <div class="delivery-addresses" style="float:left;width:100%">
                //      <h2>{l s='Delivery addresses' d='Shop.Theme.Customeraccount'}</h2>
                //      {foreach $delivery_invoice_addresses.addressesList.usedDeliveryExclusive as $address}
                //          <div class="col-lg-4 col-md-6 col-sm-6">
                //          {block name='customer_address'}
                //            {include file='customer/_partials/block-address.tpl' address=$address}
                //          {/block}
                //          </div>
                //      {/foreach}
                //      </div>
                //    {/if}
                //  {/if}
                //
                if ($usedForDelivery && !$usedForInvoice) {
                    $addressesList['usedDeliveryExclusive'][$addressId] = $customerAddresses[$addressId];
                }
                if ($usedForInvoice && !$usedForDelivery) {
                    $addressesList['usedInvoiceExclusive'][$addressId] = $customerAddresses[$addressId];
                }
                if (!$usedForInvoice && !$usedForDelivery) {
                    $addressesList['notUsed'][$addressId] = $customerAddresses[$addressId];
                }
            }

            $lastOrderAddresses = $this->getCustomerLastUsedAddresses($allCustomerUsedAddresses);
            if (count($lastOrderAddresses)) {
                $lastOrderInvoiceAddressId  = $lastOrderAddresses['id_address_invoice'];
                $lastOrderDeliveryAddressId = $lastOrderAddresses['id_address_delivery'];
            }
        }


        return array(
            "addressesList"              => $addressesList,
            "idAddressInvoice"           => $this->context->cart->id_address_invoice,
            "idAddressDelivery"          => $this->context->cart->id_address_delivery,
            "isInvoiceAddressPrimary"    => $isInvoiceAddressPrimary,
            "showBillToDifferentAddress" => $showBillToDifferentAddress,
            "showShipToDifferentAddress" => $showShipToDifferentAddress,
            "lastOrderInvoiceAddressId"  => $lastOrderInvoiceAddressId,
            "lastOrderDeliveryAddressId" => $lastOrderDeliveryAddressId,
        );
    }

    private function getBusinessDisabledFields()
    {
        return array_map('trim', explode(',', $this->module->config->business_disabled_fields));
    }

    private function getBusinessFields()
    {
        $businessFields = array_map('trim', explode(',', $this->module->config->business_fields));
        return array_diff($businessFields, $this->getBusinessDisabledFields());
    }

    private function getPrivateFields()
    {
        $privateFields = array_map('trim', explode(',', $this->module->config->private_fields));
        return $privateFields;
    }

    private function getCheckoutFields()
    {
        $formFieldsLogin = $this->formatLoginFormFields();
        list($formFieldsAccount, $separateModuleFields) = $this->setupFormFieldsAccount();
        $formFieldsInvoice  = $this->setupFormFieldsInvoice();
        $formFieldsDelivery = $this->setupFormFieldsDelivery();

        $formFieldsInvoiceMapped = array_map(
            function (CheckoutFormField $field) {
                return $field->toArray();
            },
            $formFieldsInvoice
        );

        // By default, hide business fields; unless, there is some field in invoice address section with non-empty value
        $hideBusinessFields = true;
        foreach ($this->getBusinessFields() as $businessFieldName) {
            if (
                '' != $businessFieldName &&
                isset($formFieldsInvoiceMapped[$businessFieldName]) &&
                null != trim($formFieldsInvoiceMapped[$businessFieldName]['value']) &&
                'id_state' !== $formFieldsInvoiceMapped[$businessFieldName]['name'] &&
                'id_country' !== $formFieldsInvoiceMapped[$businessFieldName]['name'] &&
                ('dni' !== $businessFieldName || 'need-dni' !== $formFieldsInvoice['dni']->getCssClass())
            ) {
                $hideBusinessFields = false;
            }
        }

        $hidePrivateFields = true;
        // if businessFields are visible (=not $hideBusinessFields), private fields will be hidden; otherwise, let's make check:
        if ($hideBusinessFields) {
            foreach ($this->getPrivateFields() as $privateFieldName) {
                if (
                    '' != $privateFieldName &&
                    isset($formFieldsInvoiceMapped[$privateFieldName]) &&
                    null != trim($formFieldsInvoiceMapped[$privateFieldName]['value']) &&
                    'id_state' !== $formFieldsInvoiceMapped[$privateFieldName]['name'] &&
                    'id_country' !== $formFieldsInvoiceMapped[$privateFieldName]['name'] &&
                    ('dni' !== $privateFieldName || 'need-dni' !== $formFieldsInvoice['dni']->getCssClass())
                ) {
                    $hidePrivateFields = false;
                }
            }
        }

        // Same for delivery address fields:
        $formFieldsDeliveryMapped = array_map(
            function (CheckoutFormField $field) {
                return $field->toArray();
            },
            $formFieldsDelivery
        );

        // By default, hide business fields; unless, there is some field in invoice address section with non-empty value
        $hideBusinessFieldsDelivery = true;
        foreach ($this->getBusinessFields() as $businessFieldName) {
            if (
                '' != $businessFieldName &&
                isset($formFieldsDeliveryMapped[$businessFieldName]) &&
                null != trim($formFieldsDeliveryMapped[$businessFieldName]['value']) &&
                'id_state' !== $formFieldsDeliveryMapped[$businessFieldName]['name'] &&
                'id_country' !== $formFieldsDeliveryMapped[$businessFieldName]['name'] &&
                ('dni' !== $businessFieldName || 'need-dni' !== $formFieldsInvoice['dni']->getCssClass())
            ) {
                $hideBusinessFieldsDelivery = false;
            }
        }

        $hidePrivateFieldsDelivery = true;
        // if businessFields are visible (=not $hideBusinessFields), private fields will be hidden; otherwise, let's make check:
        if ($hideBusinessFieldsDelivery) {
            foreach ($this->getPrivateFields() as $privateFieldName) {
                if (
                    '' != $privateFieldName &&
                    isset($formFieldsDeliveryMapped[$privateFieldName]) &&
                    null != trim($formFieldsDeliveryMapped[$privateFieldName]['value']) &&
                    'id_state' !== $formFieldsDeliveryMapped[$privateFieldName]['name'] &&
                    'id_country' !== $formFieldsDeliveryMapped[$privateFieldName]['name'] &&
                    ('dni' !== $privateFieldName || 'need-dni' !== $formFieldsInvoice['dni']->getCssClass())
                ) {
                    $hidePrivateFieldsDelivery = false;
                }
            }
        }

        // Old code, when business fields were hard-coded
//        $hideBusinessFields =
//            (null == trim($formFieldsInvoiceMapped['company']['value'])) &&
//            (null == trim($formFieldsInvoiceMapped['dni']['value'])) &&
//            (null == trim($formFieldsInvoiceMapped['vat_number']['value']));


        $checkoutFields = array(
            'formFieldsLogin'      => array_map(
                function (CheckoutFormField $field) {
                    return $field->toArray();
                },
                $formFieldsLogin
            ),
            'action'               => $this->getCurrentURL(),
            'urls'                 => $this->getTemplateVarUrls(),
            'formFieldsAccount'    => array_map(
                function (CheckoutFormField $field) {
                    return $field->toArray();
                },
                $formFieldsAccount
            ),
            'formFieldsInvoice'    => $formFieldsInvoiceMapped,
            'hideBusinessFields'   => $hideBusinessFields,
            'hidePrivateFields'    => $hidePrivateFields,
            'formFieldsDelivery'   => $formFieldsDeliveryMapped,
            'hideBusinessFieldsDelivery'   => $hideBusinessFieldsDelivery,
            'hidePrivateFieldsDelivery'    => $hidePrivateFieldsDelivery,
            'separateModuleFields' => array_map(
                function (CheckoutFormField $field) {
                    return $field->toArray();
                },
                $separateModuleFields
            ),
        );

        return array_merge($checkoutFields, $this->getAddressesSelectionTplVars());
    }

    public function parentInitContent()
    {
        static $initContent_called = false;
        if ($initContent_called) {
            return;
        } else {
            $initContent_called = true;
        }

        $this->wrapInNonZeroCustomerIdForVATDeduction(function () {
            parent::initContent();
        });

        $amazonPayHelperClass = 'AmazonPayHelper';
        if (class_exists($amazonPayHelperClass) && method_exists($amazonPayHelperClass,
                'isAmazonPayCheckout') && $amazonPayHelperClass::isAmazonPayCheckout()) {
            $this->amazonpayOngoingSession                = true;
            $this->isAmazonPayCheckout                    = true;
            $this->module->config->default_payment_method = "amazonpay";
        }
    }

    private function checkAndMakeSubmitReorderRequest()
    {
        if (!$this->context->customer->isLogged()) {
            return;
        }
        if (Tools::isSubmit('submitReorder') && $id_order = (int)Tools::getValue('id_order')) {
            $oldCart     = new Cart(Order::getCartIdStatic($id_order, $this->context->customer->id));
            $duplication = $oldCart->duplicate();
            if (!$duplication || !Validate::isLoadedObject($duplication['cart'])) {
                $this->errors[] = $this->trans('Sorry. We cannot renew your order.', array(),
                    'Shop.Notifications.Error');
            } elseif (!$duplication['success']) {
                $this->errors[] = $this->trans(
                    'Some items are no longer available, and we are unable to renew your order.', array(),
                    'Shop.Notifications.Error'
                );
            } else {
                $this->context->cookie->id_cart = $duplication['cart']->id;
                $context                        = $this->context;
                $context->cart                  = $duplication['cart'];
                CartRule::autoAddToCart($context);
                $this->context->cookie->write();
                Tools::redirect('index.php?controller=order');
            }
        }
    }

    public function initContent()
    {
        // Can we skip it for ajax calls? parent::initContent set caches for delivery options,
        // if enabled here, we'd need to flush caches before ajax call
        //parent::initContent();

        // Initiate checkoutProcess object for ps_checkout module
        if (version_compare(_PS_VERSION_, '1.7.3') >= 0 &&
            Module::isInstalled('xps_checkout') && Module::isEnabled('xps_checkout')) {
            $deliveryOptionsFinder = new DeliveryOptionsFinder(
                $this->context,
                $this->getTranslator(),
                new ObjectPresenter(),
                new PriceFormatter()
            );

            $session               = new CheckoutSession(
                $this->context,
                $deliveryOptionsFinder
            );
            $this->checkoutProcess = new CheckoutProcess($this->context, $session);
        }


        if (Configuration::get('PS_RESTRICT_DELIVERED_COUNTRIES')) {
            $this->availableCountries = Carrier::getDeliveredCountries($this->context->language->id, true, true);
        } else {
            $this->availableCountries = Country::getCountries($this->context->language->id, true);
        }

        $this->context->cart->setNoMultishipping();

        if (Tools::getValue('ajax_request')) {
            // $this->parentInitContent(); cannot be called prior to address_id modification in cart!
            // otherwise, cached delivery methods will be used and would not reflect actual address change
            // we need to call then parentInitContent only after address modification
            // E.g. on 'updateQuantity' action, the cache key does not change and Cart::getPackageShippingCost returns
            // same shipping amount for carriers (quantity is not part of cache_key)
            $action = Tools::getValue('action');
            if (!in_array($action,
                array(
                    'modifyAccountAndAddress',
                    'modifyAddressSelection',
                    'modifyAccount',
                    'updateQuantity',
                    'deleteFromCart'
                ))) {
                $this->parentInitContent();
            }
            return $this->ajaxCall();
        } else {
            $this->parentInitContent();

            // Remove potentially unwanted JS includes from payment method - if we include them in hook call
            //print_r($this->context->controller->getJavascript());
            $this->context->controller->unregisterJavascript('paypal-plus-payment-js');
            $this->context->controller->unregisterJavascript('stripe_official-payments');

            $blocksLayout = $this->module->config->blocks_layout;

            $excludeBlocks = array();

            // Remove html-box-X from layout, if it's empty
            if (empty($this->module->config->html_box_1)) {
                $excludeBlocks[] = "html-box-1";
            }
            if (empty($this->module->config->html_box_2)) {
                $excludeBlocks[] = "html-box-2";
            }
            if (empty($this->module->config->html_box_3)) {
                $excludeBlocks[] = "html-box-3";
            }
            if (empty($this->module->config->html_box_4)) {
                $excludeBlocks[] = "html-box-4";
            }
            if (empty($this->module->config->required_checkbox_1)) {
                $excludeBlocks[] = "required-checkbox-1";
            }
            if (empty($this->module->config->required_checkbox_2)) {
                $excludeBlocks[] = "required-checkbox-2";
            }
            if ($this->module->config->move_login_to_account == 1) {
                $excludeBlocks[] = "login-form";
            }

            if ($this->context->customer->isLogged()) {
                $excludeBlocks[] = "login-form";

                // If customer is already logged-in AND this is first time he visited checkout form with his session
                // let's reset his addresses to ones used with last order (if any)
                if ($this->context->cart->id != $this->context->cookie->addreses_reset_at_cart_id) {
                    $lastOrderAddresses = $this->getCustomerLastUsedAddresses($this->getAllCustomerUsedAddresses());
                    if (count($lastOrderAddresses)) {
                        $this->context->cart->id_address_invoice  = $lastOrderAddresses['id_address_invoice'];
                        $this->context->cart->id_address_delivery = $lastOrderAddresses['id_address_delivery'];
                        $this->context->cart->update();
                        $this->context->cart->setNoMultishipping();
                        $this->updateAddressIdInDeliveryOptions();
                        $this->context->cookie->addreses_reset_at_cart_id = $this->context->cart->id;
                    }
                }
            }

            $conditionsToApproveFinder = new ConditionsToApproveFinder(
                $this->context,
                $this->getTranslator()
            );

            $conditionsToApprove = $conditionsToApproveFinder->getConditionsToApproveForTemplate();

            $this->context->smarty->assign($this->getCheckoutFields());

            // disable entirely customer fields blocks, if their content will be empty
            // this is just to fix visual issue, so that no block container is rendered in front.tpl
            $separateModuleFields = $this->context->smarty->getTemplateVars('separateModuleFields');
            if (!in_array('ps_emailsubscription_newsletter', array_keys($separateModuleFields))) {
                $excludeBlocks[] = 'newsletter';
            }
            if (!in_array('psgdpr_psgdpr', array_keys($separateModuleFields))) {
                $excludeBlocks[] = 'psgdpr';
            }
            if (!in_array('ps_dataprivacy_customer_privacy', array_keys($separateModuleFields))) {
                $excludeBlocks[] = 'data-privacy';
            }

            $ps_config = array();
            foreach (array('PS_GUEST_CHECKOUT_ENABLED') as $configName) {
                $ps_config[$configName] = Configuration::get($configName);
            }

            $force_email_overlay = false;
            if ($this->module->config->force_email_overlay && !$this->context->customer->isLogged() && !$this->context->customer->id && Configuration::get('PS_GUEST_CHECKOUT_ENABLED')) {
                $force_email_overlay = true;
            }

            // myparcel loads iframe picker, and thus markup is always same even though, we need to change iframe content always
            $forceRefreshShipping = Module::isInstalled('myparcel');

            // Logged-in customer groups
            $customer_groups     = $this->context->customer->getGroups();
            $customer_groups_cls = "gg";
            if (is_array($customer_groups)) {
                $customer_groups_cls = "g" . join('g', $customer_groups) . "g";
            }

            $page                                                           = $this->context->smarty->tpl_vars['page']->value; // parent::getTemplateVarPage();
            $page["page_name"]                                              = "checkout";
            $page["body_classes"]["logged-in"]                              = $this->context->customer->isLogged();
            $page["body_classes"]["mark-required"]                          = $this->module->config->mark_required_fields;
            $page["body_classes"][$this->module->config->checkout_substyle] = true;
            $page["body_classes"]["using-material-icons"]                   = $this->module->config->using_material_icons;
            $page["body_classes"]["font-" . $this->module->config->font]    = true;
            $page["body_classes"]["social-btn-style-"
            . $this->module->config->social_login_btn_style]                = true;
            $page["body_classes"]["is-empty-cart"]                          = (0 == $this->context->cart->nbProducts());
            $page["body_classes"]["is-virtual-cart"]                        = $this->context->cart->isVirtualCart();
            $page["body_classes"]["is-test-mode"]                           = $this->module->config->test_mode;
            $page["body_classes"]["compact-cart"]                           = $this->module->config->compact_cart;
            // Force email overlay can work only when guest checkout is enabled - because we need to have silent registration working
            $page["body_classes"]["force-email-overlay"]       = $force_email_overlay && Configuration::get('PS_GUEST_CHECKOUT_ENABLED');
            $page["body_classes"]["separate-payment"]          = $this->module->config->separate_payment;
            $page["body_classes"]["amazonpay-ongoing-session"] = $this->amazonpayOngoingSession;
            $page["body_classes"][$customer_groups_cls]        = true;
            $page["body_classes"]["is-invoice-address-primary"]= (Config::ADDRESS_TYPE_INVOICE === $this->module->config->primary_address);
            $page["body_classes"]["is-checkout-steps"]         = $this->module->config->checkout_steps;
            $page["body_classes"]["collapse-shipping-methods"] = $this->module->config->collapse_shipping_methods;
            $page["body_classes"]["collapse-payment-methods"]  = $this->module->config->collapse_payment_methods;
            $page["body_classes"]["fetchifyuk-enabled"]        = Module::isEnabled('fetchifyuk'); // formerly craftyclicks

            if ((Configuration::get('PAYPAL_EXPRESS_CHECKOUT_SHORTCUT') || Configuration::get('PAYPAL_EXPRESS_CHECKOUT_SHORTCUT_CART')) && (isset($this->context->cookie->paypal_ecs) || isset($this->context->cookie->paypal_pSc))) {
                $page["body_classes"]["paypal-express-checkout-session"] = true;
            }
            $installedModules = array();
            foreach (array('mondialrelay', 'einvoicingprestalia') as $moduleName) {
                $installedModules[$moduleName] = Module::isInstalled($moduleName) && Module::isEnabled($moduleName);
            }

            $sendcloud_moduleName = 'sendcloud';
            $sendcloud_script     = '';
            if (Module::isInstalled($sendcloud_moduleName) && Module::isEnabled($sendcloud_moduleName)) {
                $sendcloud_moduleInstance = Module::getInstanceByName($sendcloud_moduleName);
                if (isset($sendcloud_moduleInstance->connector) && $sendcloud_moduleInstance->connector) {
                    $sendcloud_script = $sendcloud_moduleInstance->connector->getServicePointScript();
                }
            }

            // for certain (mostly shipping) modules, create address as the very first step, when visiting checkout form
            // using default country; but only when address is not yet created!
            if (!$this->context->cart->id_address_invoice) {

                $forceAddressCreation = false;
                if ($this->module->config->initialize_address) {
                    $forceAddressCreation = true;
                } else {
                    $needAddressModules = array('paypal', 'sendcloud', 'mondialrelay', 'omniva', 'multisafepay');
                    foreach ($needAddressModules as $moduleName) {
                        if (Module::isInstalled($moduleName) && Module::isEnabled($moduleName)) {
                            $forceAddressCreation = true;
                            break;
                        }
                    }
                }

                if ($forceAddressCreation) {
                    $this->modifyInvoiceAddress(
                        array('token' => Tools::getToken(true, $this->context)),
                        false
                    );
                    $this->unifyAddresses(true, false);
                }
            }

            $this->context->smarty->assign(array(
                "blocksLayout"               => $blocksLayout,
                "excludeBlocks"              => $excludeBlocks,
                "config"                     => $this->module->config,
                "businessFieldsList"         => $this->getBusinessFields(),
                "businessDisabledFieldsList" => $this->getBusinessDisabledFields(),
                "privateFieldsList"          => $this->getPrivateFields(),
                "ps_config"                  => $ps_config,
                "debugJsController"          => $this->module->debugJsController,
                'conditions_to_approve'      => $conditionsToApprove,

                "loadEmpty"                          => true,// Do not "fill" blocks with content, load only container
                "page"                               => $page,
                "hook_displayPersonalInformationTop" => Hook::exec('displayPersonalInformationTop'),
                "hook_create_account_form"           => Hook::exec('displayCustomerAccountForm'),
                "opc_form_checkboxes"                => json_decode($this->context->cookie->opc_form_checkboxes, true),
                'delivery_message'                   => (version_compare(_PS_VERSION_,
                        '1.7.3') >= 0) ? html_entity_decode($this->getCheckoutSession()->getMessage()) : '',
                'isEmptyCart'                        => (0 == $this->context->cart->nbProducts()),
                'forceRefreshShipping'               => $forceRefreshShipping,
                'installedModules'                   => $installedModules,
                'separatePaymentKeyName'             => Config::SEPARATE_PAYMENT_KEY_NAME,
                'sendcloud_script'                   => $sendcloud_script
            ));

            $amazonPayCheckoutSessionClass = "AmazonPayCheckoutSession";
            if (class_exists($amazonPayCheckoutSessionClass) &&
                method_exists($amazonPayCheckoutSessionClass,'checkStatus') &&
                method_exists($amazonPayCheckoutSessionClass,'getAmazonPayCheckoutSessionId'))
            {
                $amazonPayCheckoutSession = new $amazonPayCheckoutSessionClass(false);

                if ($amazonPayCheckoutSession->checkStatus()) {
                    $sessionId = $amazonPayCheckoutSession->getAmazonPayCheckoutSessionId();
                    $this->context->smarty->assign("tc_amazonPaySessionId", $sessionId);
                }
            }

            $metas = Meta::getMetaByPage('order', $this->context->language->id);
            if (isset($metas) && is_array($metas) && count($metas) && isset($metas['title'])) {
                if (isset($this->context->smarty->tpl_vars) && isset($this->context->smarty->tpl_vars['page'])) {
                    $page                         = $this->context->smarty->tpl_vars['page'];
                    $page->value['meta']['title'] = $metas['title'];
                }
            }

            $this->setTemplate('module:' . $this->name . '/views/templates/front/front.tpl');
        }
    }

    // PS copied method
    protected function getCheckoutSession()
    {
        $deliveryOptionsFinder = new DeliveryOptionsFinder(
            $this->context,
            $this->getTranslator(),
            $this->objectPresenter,
            new PriceFormatter()
        );

        $session = new CheckoutSession(
            $this->context,
            $deliveryOptionsFinder
        );

        return $session;
    }


    // PS copied method
    private function getGiftCostForLabel($giftCost, $includeTaxes, $displayTaxLabel)
    {
        if ($giftCost != 0) {
            $taxLabel       = '';
            $priceFormatter = new PriceFormatter();

            if ($includeTaxes && $displayTaxLabel) {
                $taxLabel .= ' tax incl.';
            } elseif ($includeTaxes) {
                $taxLabel .= ' tax excl.';
            }

            return $this->getTranslator()->trans(
                ' (additional cost of %giftcost% %taxlabel%)',
                array(
                    '%giftcost%' => $priceFormatter->convertAndFormat($giftCost),
                    '%taxlabel%' => $taxLabel,
                ),
                'Shop.Theme.Checkout'
            );
        }

        return '';
    }

    private function updateAddressIdInDeliveryOptions()
    {
        if ($this->context->cart->id_address_delivery > 0) {
            if (version_compare(_PS_VERSION_, '1.7.3') >= 0) {
                $actualDeliveryOptions = json_decode($this->context->cart->delivery_option, true);
            } else {
                $actualDeliveryOptions = Tools::unSerialize($this->context->cart->delivery_option);
            }

            if (false !== $actualDeliveryOptions && null !== $actualDeliveryOptions) {
                $newDeliveryOptions = array();
                foreach ($actualDeliveryOptions as $dlvOption) {
                    $newDeliveryOptions[$this->context->cart->id_address_delivery] = $dlvOption;
                }
                if (version_compare(_PS_VERSION_, '1.7.3') >= 0) {
                    $this->context->cart->delivery_option = json_encode($newDeliveryOptions);
                } else {
                    $this->context->cart->delivery_option = serialize($newDeliveryOptions);
                }
            }
            $this->context->cart->autosetProductAddress();
        }
    }

    // PS copied method (partial)
    public function getShippingOptions()
    {

        $recyclablePackAllowed = (bool)Configuration::get('PS_RECYCLABLE_PACK');
        $giftAllowed           = (bool)Configuration::get('PS_GIFT_WRAPPING');


        //if ((int)$this->context->cart->id_customer) {
        $includeTaxes = (!Product::getTaxCalculationMethod((int)$this->context->cart->id_customer)
            && (int)Configuration::get('PS_TAX'));
        //} else {
        //    $includeTaxes = PS_TAX_EXC;
        //}


        $displayTaxLabels = (Configuration::get('PS_TAX') && !Configuration::get('AEUC_LABEL_TAX_INC_EXC'));
        $giftCost         = $this->context->cart->getGiftWrappingPrice($includeTaxes);

        $this->context->cart->save();
        $this->context->cart->setNoMultishipping();
        $this->updateAddressIdInDeliveryOptions();

        $self = $this;
        $deliveryOptions = $this->wrapInNonZeroCustomerIdForVATDeduction(function () use(&$self) {
            return $self->getCheckoutSession()->getDeliveryOptions();
        });

        return
            array(
                'hookDisplayBeforeCarrier' => Hook::exec('displayBeforeCarrier',
                    array('cart' => $this->getCheckoutSession()->getCart())),
                'hookDisplayAfterCarrier'  => Hook::exec('displayAfterCarrier',
                    array('cart' => $this->getCheckoutSession()->getCart())),
                'id_address'               => $this->getCheckoutSession()->getIdAddressDelivery(),
                'delivery_options'         => $deliveryOptions,
                'delivery_option'          => $this->getCheckoutSession()->getSelectedDeliveryOption(),
                'recyclable'               => $this->getCheckoutSession()->isRecyclable(),
                'recyclablePackAllowed'    => $recyclablePackAllowed,
                'delivery_message'         => (version_compare(_PS_VERSION_,
                        '1.7.3') >= 0) ? $this->getCheckoutSession()->getMessage() : '',
                'gift'                     => array(
                    'allowed' => $giftAllowed,
                    'isGift'  => $this->getCheckoutSession()->getGift()['isGift'],
                    'label'   => $this->getTranslator()->trans(
                        'I would like my order to be gift wrapped %cost%',
                        array('%cost%' => $this->getGiftCostForLabel($giftCost, $includeTaxes, $displayTaxLabels)),
                        'Shop.Theme.Checkout'
                    ),
                    'message' => $this->getCheckoutSession()->getGift()['message'],
                ),
            );
    }

//    public function selectPaymentOption(array $requestParams = array())
//    {
//        if (isset($requestParams['select_payment_option'])) {
//            $this->selected_payment_option = $requestParams['select_payment_option'];
//        }
//
//        $this->setTitle(
//            $this->getTranslator()->trans(
//                'Payment',
//                array(),
//                'Shop.Theme.Checkout'
//            )
//        );
//    }

    public function getPaymentOptions()
    {
        $isFree               = 0 == (float)$this->getCheckoutSession()->getCart()->getOrderTotal(true, Cart::BOTH);
        $paymentOptionsFinder = new PaymentOptionsFinder();
        $paymentOptions       = $paymentOptionsFinder->present($isFree);

        if ($this->amazonpayOngoingSession &&
            !empty($paymentOptions) && array_key_exists("amazonpay", $paymentOptions)) {
            // remove other options from a list of payment methods, if we're in the middle of session
            $amazonPayOption             = $paymentOptions["amazonpay"];
            $paymentOptions              = array();
            $paymentOptions["amazonpay"] = $amazonPayOption;
        }

        return array(
            'is_free'                 => $isFree,
            'payment_options'         => $paymentOptions,
            'selected_payment_option' => $this->selected_payment_option,
            //'selected_delivery_option' => $selectedDeliveryOption,
            'show_final_summary'      => Configuration::get('PS_FINAL_SUMMARY_ENABLED'),
        );
    }

    public function ajaxCall()
    {
        // @error_reporting(E_ALL & ~E_NOTICE);
        // multisafepay fix BEGIN
        // multisafepay.php:hasSetApiKey(), loads multisafepay.sdk_service, but the $kernel is not started in this ajax request yet
        // Commented out due to validator requirements (no globals), uncomment for multisafepay support
//        global $kernel;
//        if(!$kernel){
//            require_once _PS_ROOT_DIR_.'/app/AppKernel.php';
//            $kernel = new \AppKernel('prod', false);
//            $kernel->boot();
//        }
        // multisafepay fix END

        if ($this->module->debug) {
            $this->module->logDebug("[AJAX*Start] " . Tools::getValue('action'));
        }

        $action = Tools::ucfirst(Tools::getValue('action'));

        if (!empty($action) && method_exists($this, 'ajax' . $action)) {
            $this->context->smarty->assign("tc_config", $this->module->config);
            $result = $this->{'ajax' . $action}();
        } else {
            $result = (array('error' => 'Ajax parameter used, but action \'' . Tools::getValue('action') . '\' is not defined'));
        }

        if ($this->module->debug) {
            $this->module->logDebug("[AJAX*End] " . Tools::getValue('action'));
        }

        // ob_clean caused problems on certain PHP configuration
        // ob_clean();
        // header('Content-Type: application/json');

        die(json_encode($result));
    }

    public function updateDelivery(array $requestParams = array())
    {
        if (isset($requestParams['delivery_option'])) {
            $opc_form_radios                    = json_decode($this->context->cookie->opc_form_radios, true);
            $opc_form_radios['delivery_option'] = $requestParams['delivery_option'];

            $this->context->cookie->opc_form_radios = json_encode($opc_form_radios);
        }

        if (isset($requestParams['delivery_option'])) {
            @$this->getCheckoutSession()->setDeliveryOption(
                $requestParams['delivery_option']
            );
            @$this->getCheckoutSession()->setRecyclable(
                isset($requestParams['recyclable']) ? $requestParams['recyclable'] : false
            );
            @$this->getCheckoutSession()->setGift(
                isset($requestParams['gift']) ? $requestParams['gift'] : false,
                (isset($requestParams['gift']) && isset($requestParams['gift_message'])) ? $requestParams['gift_message'] : ''
            );
        }

        if (isset($requestParams['delivery_message'])) {
            $this->getCheckoutSession()->setMessage($requestParams['delivery_message']);
        }

        Hook::exec('actionCarrierProcess', array('cart' => $this->getCheckoutSession()->getCart()));
    }

    private function ajaxSelectDeliveryOption()
    {

        $this->updateDelivery(Tools::getAllValues());

        return $this->getDynamicCheckoutBlocks();

    }

    private function ajaxSelectPaymentOption()
    {
        // selects payment option here (may go to cookie?), but most importantly, set fee
        // if fee value has been sent from client

        $result = array();

        $paymentFee = Tools::getValue('payment_fee');
        $result     = $this->getCartSummaryBlock($paymentFee);

        return $result;

    }

    private function ajaxSetDeliveryMessage()
    {
        if (Tools::getIsset('delivery_message')) {
            $this->getCheckoutSession()->setMessage(Tools::getValue('delivery_message'));
        }
        return array('result' => 1);
    }

    private function ajaxSocialLoginFacebook()
    {
        $access_token = Tools::getValue("access_token");

        $social = new SocialLogin(SocialLogin::FACEBOOK,
            $this->module->config->social_login_fb_app_id,
            $this->module->config->social_login_fb_app_secret);

        list($email, $firstname, $lastname) = $social->validateFacebookAccessToken($access_token);

        $errors = $this->loginOrRegister($email, $firstname, $lastname);

        return array('errors' => $errors, 'hasErrors' => !empty($errors), 'email' => $email);
    }

    private function ajaxSocialLoginGoogle()
    {
        $id_token  = Tools::getValue("id_token");
        $firstname = Tools::getValue("firstname");
        $lastname  = Tools::getValue("lastname");

        $social = new SocialLogin(SocialLogin::GOOGLE,
            $this->module->config->social_login_google_client_id,
            $this->module->config->social_login_google_client_secret);

        $email = $social->validateGoogleIdToken($id_token);

        $errors = $this->loginOrRegister($email, $firstname, $lastname);

        return array('errors' => $errors, 'hasErrors' => !empty($errors), 'email' => $email);
    }

    private function loginOrRegister($email, $firstname, $lastname)
    {
        if (!$email || !Validate::isEmail($email)) {
            return $this->translator->trans('Invalid email address.', array(), 'Shop.Notifications.Error');
        }
        $customer       = new Customer();
        $authentication = $customer->getByEmail(
            $email
        );

        $errors = array();

        if (isset($authentication->active) && !$authentication->active) {
            $errors[] = $this->translator->trans('Your account isn\'t available at this time, please contact us',
                array(),
                'Shop.Notifications.Error');
        } elseif (!$authentication || !$customer->id || $customer->is_guest) {
            // Create new account
            //$this->silentRegistration($email);

            // Make sure customer's first and lastname are valid, as the 'login' is automated
            if (Tools::strlen($firstname) < 1) {
                $firstname = 'a';
            }
            if (Tools::strlen($lastname) < 1) {
                $lastname = 'a';
            }

            $ret = $this->modifyAccount(
                array(
                    'email'      => $email,
                    'password'   => sha1(time() . uniqid(rand(), true)),
                    'newsletter' => $this->module->config->newsletter_checked,
                    'psgdpr'     => true,
                    'customer_privacy' => true,
                    'required-checkbox-1' => true,
                    'required-checkbox-2' => true
                ), $firstname, $lastname, false, false);

            // print_r($ret);

        } else {

            $this->context->updateCustomer($authentication);

            // Login information have changed, so we check if the cart rules still apply
            CartRule::autoRemoveFromCart($this->context);
            CartRule::autoAddToCart($this->context);
        }
    }

    // "sanitize" request data before posting to backend; make sure required fields are all set
    private function prepareAddressData($existingAddressId, $formData, $requiredFields, $previousErrors = array())
    {
        $addressData = $formData;

        foreach ($requiredFields as $fieldName) {
            if (!isset($addressData[$fieldName]) || empty($addressData[$fieldName])
                || (isset($previousErrors[$fieldName]) && count($previousErrors[$fieldName]))
            ) {
                if (in_array($fieldName, array('dni'))) {
                    // for 'dni' simulated value is empty string (up to PS 1.7.5); since 1.7.6 we need to set to: '0', due to
                    // added method Address::validateField, where need_identification_number is checked for non-empty
                    $addressData[$fieldName] = '0';
                } else {
                    $addressData[$fieldName] = ' '; // simulated value
                }
            }
        }
        // handle id_state specifically, as it might be not sent by jQuery.serialize() when empty
        if (!key_exists('id_state', $addressData)) {
            $addressData['id_state'] = 0;
        }
        if ($existingAddressId > 0) {
            $addressData['id_address'] = $existingAddressId;
        }
        return $addressData;
    }

    private function getCustomerSignInArea()
    {
        if ($this->context->customer->id == 0 || $this->context->customer->isGuest()) {
            return array();
        }

        $this->parentInitContent();
        $customerSignInArea = array();
        // Re-render header (Sign-in/out and customer name)
        if ($moduleInstance = Module::getInstanceByName('ps_customersignin')) {
            if ($moduleInstance->active && $moduleInstance instanceof WidgetInterface) {
                $customerSignInArea['displayNav2'] = $moduleInstance->renderWidget('displayNav2', array());
            }
        }

        if (!isset($customerSignInArea['displayNav2']) && $moduleInstance = Module::getInstanceByName('stcustomersignin')) {
            if ($moduleInstance->active && $moduleInstance instanceof WidgetInterface) {
                $customerSignInArea['displayNav2'] = $moduleInstance->renderWidget('displayNav2', array());
            }
        }

        $customerForTpl = array_merge($this->objectPresenter->present($this->context->customer),
            array('is_logged' => $this->context->customer->logged));
        $this->context->smarty->assign('s_customer', $customerForTpl);

        $customerSignInArea['staticCustomerInfo'] = $this->context->smarty->fetch(
            'module:' . $this->name . '/views/templates/front/_partials/static-customer-info.tpl');

        return array('customerSignInArea' => $customerSignInArea);
    }

    private function getShippingOptionsBlock()
    {
        $this->parentInitContent();

        // setDeliveryOption() call would flush delivery_options cache (used in cart->getDeliveryOption())
        // Prior to this call, TheCheckout does not set cache, but other modules possibly can, causing
        // delivery options not matching id_address selected on checkout = no carriers available
        if (version_compare(_PS_VERSION_, '1.7.3') >= 0) {
            $actualDeliveryOptions = json_decode($this->context->cart->delivery_option, true);
        } else {
            $actualDeliveryOptions = Tools::unSerialize($this->context->cart->delivery_option);
        }
        if (!empty($actualDeliveryOptions)) {
            @$this->getCheckoutSession()->setDeliveryOption(
                array($this->context->cart->id_address_delivery => reset($actualDeliveryOptions))
            );
        }

        $shippingOptions         = $this->getShippingOptions();
        $externalShippingModules = array();
        foreach ($shippingOptions["delivery_options"] as $optionId => $options) {
            if (/*"1" === $options['is_module'] && */"" !== $options['external_module_name']) {
                $externalShippingModules[$options['external_module_name']][] = $optionId;
            }
        }

        // add dateofdelivery module name into external shipping modules list, so that its parser is loaded at JS level
        $dateofdelivery_moduleName = 'dateofdelivery';
        if (Module::isInstalled($dateofdelivery_moduleName) && Module::isEnabled($dateofdelivery_moduleName)) {
            $externalShippingModules[$dateofdelivery_moduleName] = 0;
        }

        $this->getCheckoutSession()->setDeliveryOption(
            array($this->context->cart->id_address_delivery => $shippingOptions["delivery_option"])
        );

        $shippingCountryName = '';
        if ($this->module->config->show_shipping_country_in_carriers) {
            $shippingAddressNotice = array();
            $tmpDeliveryAddress    = new Address($this->context->cart->id_address_delivery);
            if (isset($tmpDeliveryAddress->id_country)) {
                $tmpIdCountry = (int)$tmpDeliveryAddress->id_country;
            } else {
                $tmpIdCountry = Configuration::get('PS_COUNTRY_DEFAULT');
            }

            // localized country name
            $tmpCountry = new Country($tmpIdCountry, $this->context->language->id);
            if (isset($tmpCountry) && isset($tmpCountry->name)) {
                $shippingCountryName     = $tmpCountry->name;
                $shippingAddressNotice[] = $shippingCountryName;
            }

            $shipping_required_fields = explode(',', $this->module->config->shipping_required_fields);
            if (count($shipping_required_fields)) {
                $cart_delivery_address_id = $this->context->cart->id_address_delivery;
                if ($cart_delivery_address_id) {
                    $cart_delivery_address = new Address($cart_delivery_address_id);
                    foreach ($shipping_required_fields as $shipping_required_field) {
                        $req_field = trim($shipping_required_field);
                        if (
                            isset($cart_delivery_address->$req_field)
                            && (bool)trim($cart_delivery_address->$req_field)
                        ) {
                            // Special treatment for id_state and postcode (do not have to be required for all countries)
                            if ($cart_delivery_address->id_country && in_array($req_field, array('id_state'))) {
                                $country = new Country($cart_delivery_address->id_country);
                                // Localized state name
                                if ('id_state' == $req_field && $country->contains_states) {
                                    $state                   = new State($cart_delivery_address->id_state,
                                        $this->context->language->id);
                                    $shippingAddressNotice[] = $state->name;
                                }
                            } else {
                                $shippingAddressNotice[] = trim($cart_delivery_address->$req_field);
                            }
                        }
                    }
                }
            }

            $this->context->smarty->assign('shippingAddressNotice', $shippingAddressNotice);

        }

        $customerSelectedDeliveryOption = null;
        $opc_form_radios                = json_decode($this->context->cookie->opc_form_radios, true);
        if (isset($opc_form_radios['delivery_option'])) {
            $this->context->smarty->assign('customerSelectedDeliveryOption',
                reset($opc_form_radios['delivery_option']));
        }
        $this->context->smarty->assign('forceToChooseCarrier',
            (bool)$this->module->config->force_customer_to_choose_carrier);

        $this->context->smarty->assign($shippingOptions);
        $shippingBlock = $this->context->smarty->fetch('module:' . $this->name . '/views/templates/front/blocks/shipping.tpl');


        return array(
            'externalShippingModules' => $externalShippingModules,
            'shippingBlock'           => $shippingBlock,
            'shippingBlockChecksum'   => md5($shippingBlock),
            'shippingCountry'         => $shippingCountryName,
            'totalWeight'             => $this->context->cart->getTotalWeight(),
            'customerDeliveryOption'  => $customerSelectedDeliveryOption
        );
    }

//    public function isZeroDecimalCurrency($currency)
//    {
//        // @see: https://support.stripe.com/questions/which-zero-decimal-currencies-does-stripe-support
//        $zeroDecimalCurrencies = array(
//            'BIF',
//            'CLP',
//            'DJF',
//            'GNF',
//            'JPY',
//            'KMF',
//            'KRW',
//            'MGA',
//            'PYG',
//            'RWF',
//            'UGX',
//            'VND',
//            'VUV',
//            'XAF',
//            'XOF',
//            'XPF'
//        );
//        return in_array($currency, $zeroDecimalCurrencies);
//    }

    private function getPaymentOptionsBlock()
    {
        if ($this->module->config->separate_payment) {
            return array(
                'paymentBlock'         => "",
                'paymentBlockChecksum' => "none",
                'paymentMethodsList'   => array()
            );
        }


        $this->parentInitContent();
        if (Configuration::get('PS_FINAL_SUMMARY_ENABLED')) {
            // if $this->context->customer->id and addresses assigned.. only then continue
            //$this->parentInitContent();
//            $cart = $this->cart_presenter->present(
//                $this->context->cart
//            );
//
//
//            $this->context->smarty->assign(array('cart' => $cart));
//            $this->context->smarty->assign(array('customer' => $this->getTemplateVarCustomer(2)));
        }

        $paymentMethods = $this->getPaymentOptions();

        $this->context->smarty->assign($paymentMethods);

        // // Payment data, used by Stripe payment for live refresh (and possibly other modules in future)

        // $currency = $this->context->currency->iso_code;
        // $orderTotal = $this->context->cart->getOrderTotal();
        // $stripeAmount = Tools::ps_round($orderTotal, 2);
        // $stripeAmount = $this->isZeroDecimalCurrency($currency) ? $stripeAmount : $stripeAmount * 100;

        // $paymentData = array(
        //     'order_total'       => $orderTotal,
        //     'stripe_amount'     => $stripeAmount,
        //     'stripe_currency'   => Tools::strtolower($currency),
        //     'stripe_fullname'   => $this->context->customer->firstname . ' ' . $this->context->customer->lastname,
        //     'stripe_address_country_code' => Country::getIsoById($this->context->country->id),
        //     'stripe_email'      => $this->context->customer->email,
        // );

        // We need to delivery conditions to approve status (ticket by customer earlier in session)
        $this->context->smarty->assign(array(
                'opc_form_checkboxes' => json_decode($this->context->cookie->opc_form_checkboxes,
                    true),
                //'js_custom_vars' => Media::getJsDef() // moved to getCartSummaryBlock()
                //'payment_data'          => $paymentData,
            )
        );

        $paymentBlock =
            $this->context->smarty->fetch('module:' . $this->name . '/views/templates/front/blocks/payment.tpl');


        return array(

            'paymentBlock'         => $paymentBlock,
            'paymentBlockChecksum' => md5($paymentBlock),
            'paymentMethodsList'   => array_keys($paymentMethods['payment_options'])
        );
    }

    private function getWaitForFields($required_fields, $cart_delivery_address_id)
    {
        $shipping_block_wait_for_address = array();
        $shipping_required_fields        = preg_split('/,/', trim($required_fields), -1, PREG_SPLIT_NO_EMPTY);
        if (count($shipping_required_fields)) {
            foreach ($shipping_required_fields as $shipping_required_field) {
                $req_field = trim($shipping_required_field);

                // Address already set, let's use real country and already set fields
                if ($cart_delivery_address_id) {
                    $cart_delivery_address = new Address($cart_delivery_address_id);
                    $country               = new Country($cart_delivery_address->id_country);
                } else {
                    $country = new Country(Configuration::get('PS_COUNTRY_DEFAULT'));
                }

                $shall_require_this_field = false;
                if ('id_state' == $req_field) {
                    if ($country->contains_states) {
                        $shall_require_this_field = true;
                    }
                } elseif ('postcode' == $req_field) {
                    if ($country->need_zip_code) {
                        $shall_require_this_field = true;
                    }
                } else {
                    $shall_require_this_field = true;
                }

                if ('email' == $req_field && isset($this->context->customer)) {
                    // Special treatment for email - which is not address fields, but can be also used in 'wait for' condition
                    $field_not_set = !isset($this->context->customer->$req_field) || !(bool)trim($this->context->customer->$req_field);;
                } else {
                    $field_not_set = !isset($cart_delivery_address->$req_field) || !(bool)trim($cart_delivery_address->$req_field);
                }


                if ($shall_require_this_field && $field_not_set) {
                    $shipping_block_wait_for_address[$req_field] = $this->getFieldLabel($req_field);
                }
            }
        }
        return $shipping_block_wait_for_address;
    }

    private function getDynamicCheckoutBlocks()
    {
        if (!$this->context->cart->nbProducts()) {
            return array('emptyCart' => true);
        }

        // There are 2 mechanisms to block shipping address visibility.
        // One is 'force country selection' - which un-selects country on checkout and let customer to choose it
        // and only after then displays shipping methods.
        // Second is 'Shipping required fields' - list of fields that must be set in order to show shipping methods
        $shipping_block_wait_for_address = $this->getWaitForFields(
            $this->module->config->shipping_required_fields,
            $this->context->cart->id_address_delivery
        );

        // Similar approach with payment block
        $payment_block_wait_for_address = $this->getWaitForFields(
            $this->module->config->payment_required_fields,
            $this->context->cart->id_address_delivery
        );

        $this->context->smarty->assign(
            array(
                'shipping_block_wait_for_address'            => $shipping_block_wait_for_address,
                'payment_block_wait_for_address'             => $payment_block_wait_for_address,
                'shipping_payment_blocks_wait_for_selection' =>
                    $this->module->config->force_customer_to_choose_country && !$this->context->cart->id_address_delivery,
                'force_email_wait_for_enter'                 =>
                    $this->module->config->force_email_overlay && !$this->context->customer->isLogged() && !$this->context->customer->id && Configuration::get('PS_GUEST_CHECKOUT_ENABLED'),
                'wait_for_account'                           =>
                    $this->module->config->show_button_save_personal_info && !$this->context->customer->isLogged() && !$this->context->customer->id,
            )
        );

        return array_merge(
            array(
                'triggerElementName' => Tools::getValue('trigger')
            ),
            $this->getShippingOptionsBlock(),
            $this->getPaymentOptionsBlock(),
            $this->getCartSummaryBlock()
        );
    }

    private function ajaxGetShippingAndPaymentBlocks()
    {
        return $this->getDynamicCheckoutBlocks();
    }

    protected function makeAddressPersister()
    {
        return new CheckoutCustomerAddressPersister(
            $this->context->customer,
            $this->context->cart,
            Tools::getToken(true, $this->context)
        );
    }

    private function getTransientAddressByCartId($cart_id)
    {
        $query = new DbQuery();
        $query->select('id_address');
        $query->from('address');
        $query->where('alias = \'opc_' . (int)$cart_id . '\'');
        $query->where('deleted = 0');
        $query->where('id_address NOT IN(\'' . (int)$this->context->cart->id_address_delivery . '\', \'' . (int)$this->context->cart->id_address_invoice . '\')');
        $query->orderBy('id_address DESC');

        return Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue($query);
    }

    private function getAllCustomerUsedAddresses()
    {
        $result = array();
        if ($this->context->customer->isLogged()) {
            $query = new DbQuery();
            $query->select('id_address_invoice, id_address_delivery');
            $query->from('orders');
            $query->where('id_customer = \'' . (int)$this->context->customer->id . '\'');

            $query->orderBy('id_order DESC');
            $result = Db::getInstance(_PS_USE_SQL_SLAVE_)->executeS($query);
        }
        return $result;
    }

    private function getCustomerLastUsedAddresses($allOrdersAddresses)
    {
        $lastOrderAddresses = array();

        if (count($allOrdersAddresses)) {
            $lastOrderAddresses = $allOrdersAddresses[0];

            // What if address IDs used with last order are already deleted? Handle that here:
            if (count($lastOrderAddresses)) {
                if ($lastOrderAddresses['id_address_invoice'] == $lastOrderAddresses['id_address_delivery']) {
                    $invActive = Customer::customerHasAddress((int)$this->context->customer->id,
                        $lastOrderAddresses['id_address_invoice']);
                    if (!$invActive) {
                        $lastOrderAddresses = array();
                    }
                } else {
                    $invActive = Customer::customerHasAddress((int)$this->context->customer->id,
                        $lastOrderAddresses['id_address_invoice']);
                    $dlvActive = Customer::customerHasAddress((int)$this->context->customer->id,
                        $lastOrderAddresses['id_address_delivery']);
                    if (!$invActive && !$dlvActive) {
                        $lastOrderAddresses = array();
                    } elseif ($invActive && !$dlvActive) {
                        $lastOrderAddresses['id_address_delivery'] = $lastOrderAddresses['id_address_invoice'];
                    } elseif (!$invActive && $dlvActive) {
                        $lastOrderAddresses['id_address_invoice'] = $lastOrderAddresses['id_address_delivery'];
                    }
                }
            }//if (count($result))
        }
        // Uncomment to reset customer's last shipping address to be equal to invoice
        // $lastOrderAddresses['id_address_delivery'] = $lastOrderAddresses['id_address_invoice'];
        return $lastOrderAddresses;
    }

    private function modifyAddress($addressType, $formData, $shallCreateNewAddress, $finalConfirmation = false)
    {
        // firstly, let's disallow address modification, if country is not supplied and
        // 'force_customer_to_choose_country' is ON = we do not do any operations on addresses until we have country ID
        if (!isset($formData['id_country']) && $this->module->config->force_customer_to_choose_country) {
            return array(
                'errors'    => array('country_not_selected'),
                'hasErrors' => true
            );
        }

        $countryId = (isset($formData['id_country'])) ? $formData['id_country'] : 0;
        $country   = ($countryId > 0) ? new Country($countryId) : $this->context->country;

        // Primary address can be updated freely; secondary only if addresses are not same
        // Note: For now (Nov.2018), isPrimaryAddress won't be used and we'll treat both addresses separately
        // although, there's slight difference, and when shipping address is first, in cart both addresses
        // are set to non-zero once the shipping is updated; whilst when billing address is primary, delivery
        // address remain zero up until it's updated.

        /*
        $primaryAddress = $this->module->config->primary_address;
        // if secondary address is being updated, and ID=primary address id, create new one
        $isPrimaryAddress = strpos($addressType, $primaryAddress) > -1;
        */

        $isAddressTypeInvoice = strpos($addressType, 'invoice') > -1;

        // required fields pushed to validator
        // Invoice and Delivery address have separate treatment, just for the sake of hardcoded customization if necessary
        // -  isset($formData[$key]) means that we'll require fields only when they are sent from client (i.e. they are :visible)

        $fieldsShallBeRequiredCallback = function ($formData, $fieldName, $tcFieldOptions, $thisAddressCountry) {
            // when will be the field required?
            return (
                isset($formData[$fieldName])
                && ((true === $tcFieldOptions['required'] && true === $tcFieldOptions['visible'] && $fieldName != 'State:name')
                    || ($fieldName == 'dni' && $thisAddressCountry->need_identification_number && true === $tcFieldOptions['visible'])
                    || ($fieldName == 'postcode' && $thisAddressCountry->need_zip_code))
            );
        };

        if ($isAddressTypeInvoice) {
            $theCheckout_requiredFields = array_filter($this->module->config->invoice_fields,
                function ($var, $key) use ($formData, $country, $fieldsShallBeRequiredCallback) {
                    return $fieldsShallBeRequiredCallback($formData, $key, $var, $country);
                }, ARRAY_FILTER_USE_BOTH);
        } else {
            $theCheckout_requiredFields = array_filter($this->module->config->delivery_fields,
                function ($var, $key) use ($formData, $country, $fieldsShallBeRequiredCallback) {
                    return $fieldsShallBeRequiredCallback($formData, $key, $var, $country);
                }, ARRAY_FILTER_USE_BOTH);
        }

        // Just to satisfy PS core validation; simulate values if necessary
        $psCore_requiredFields = array_unique(array_merge(
            array('firstname', 'lastname', 'address1', 'city'),
            ($country->need_identification_number) ? array('dni') : array(),
            array()//(new Address())->getCachedFieldsRequiredDatabase() // Is it necessary? ObjectModel doesn't seem to care, probably these extra fields are enforced only on controller level
        ));

        // Push States/Regions to frontview
        $states = array();
        if ($country->contains_states) {
            $states           = State::getStatesByIdCountry($country->id, true);
//            usort($states, function ($a, $b) {
//                $ax = strtr($a['name'], 'Ñ', 'N');
//                $bx = strtr($b['name'], 'Ñ', 'N');
//                return strcmp($ax, $bx);
//            });
            $states_flattened = array_map(function ($val) {
                return $val['id_state'];
            }, $states);
        } else {
            // Reset state, so that zones are properly evaluated when switching from with_states country to no_states country
            unset($_POST['id_state']);
            unset($formData['id_state']);
        }

        // When switching country with states to another country with (different) states, let's re-set
        if (isset($formData['id_state']) && !in_array($formData['id_state'], $states_flattened)) {
            unset($_POST['id_state']);
            unset($formData['id_state']);
        }

        if (!isset($formData['postcode'])) {
            //$formData['postcode'] = '_DO_NOT_REQUIRE_';
            $this->context->country->need_zip_code = false;
        }

        // - If showing of call prefix is enabled and
        // - phone number does NOT include prefix and
        // - phone number is NOT empty => let's add the prefix to phone number:
        if ($this->module->config->show_call_prefix) {
            $callPrefix = '+' . $country->call_prefix;
            foreach (array('phone', 'phone_mobile') as $phone_field) {
                if (isset($formData[$phone_field]) && '' != trim($formData[$phone_field]) &&
                    !\module\thecheckout\TS_Functions::startsWith($formData[$phone_field], '+')) {
                    $formData[$phone_field] = $callPrefix . $formData[$phone_field];
                }
            }

        }

//        if (true || !isset($formData['dni'])) {
//            //$formData['postcode'] = '_DO_NOT_REQUIRE_';
//            $this->context->country->need_identification_number = false;
//        }

        $theCheckout_addressForm = new CheckoutAddressForm(
            $this->module,
            $this->context->smarty,
            $this->context->language,
            $this->getTranslator(),
            $this->makeAddressPersister(),
            new CheckoutAddressFormatter(
                $this->context->country,
                $this->getTranslator(),
                $this->availableCountries,
                array_keys($theCheckout_requiredFields)
            )
        );

        // We need to get validation errors, but also we need to save address despite that
        // Attempt to validate form data first:
        $theCheckout_addressForm->fillWith($formData);
        /*$validateAttempt = */
        $theCheckout_addressForm->validate();

        // regardless of result, we still need to simulate some required fields (psCore required and theCheckout required might differ)
        if ($shallCreateNewAddress) {

            // returns last address ID with alias "opc_CARTID"
            $existingAddressId = $this->getTransientAddressByCartId($this->context->cart->id);

            if (null == $existingAddressId) {
                $existingAddressId = 0;
            }
        } else {
            $existingAddressId = $isAddressTypeInvoice ? $this->context->cart->id_address_invoice : $this->context->cart->id_address_delivery;
        }

        $psCore_addressForm = new CheckoutAddressForm(
            $this->module,
            $this->context->smarty,
            $this->context->language,
            $this->getTranslator(),
            $this->makeAddressPersister(),
            new CheckoutAddressFormatter(
                $this->context->country,
                $this->getTranslator(),
                $this->availableCountries,
                array() // required fields; we don't want any validation troubles here
            )
        );

        // Really save address, with simulated values if necessary
        // if $existingAddressId > 0, we will be implicitly updating existing address
        // TODO?: handle case, when address is used in already confirmed order (some other, previous order)!
        $addressSaved = $psCore_addressForm->fillWith(
            $this->prepareAddressData($existingAddressId, $formData, $psCore_requiredFields)
        )->submit($finalConfirmation);


        $coreValidationErrors = $psCore_addressForm->getErrors();
        $coreHasErrors        = $psCore_addressForm->hasErrors();
//        if (isset($coreValidationErrors['general_error'])) {
//            // Italian DNI validation module triggers just 'general_error' on DNI field, so let's copy it to dni
//            $coreValidationErrors['dni'] = $coreValidationErrors['general_error'];
//        }

        // $psCore_addressForm shall not have errors, unless customer entered wrong values, which might block
        // further processing and address simulation, so we need to override those user-entered values.
        if ($psCore_addressForm->hasErrors()) {
            $addressSaved = $psCore_addressForm->fillWith(
                $this->prepareAddressData($existingAddressId, $formData, $psCore_requiredFields,
                    $coreValidationErrors)
            )->submit($finalConfirmation);
        }

        if ($addressSaved) {
            // store address-id
            $addressId = $psCore_addressForm->getAddress()->id;
            if ($isAddressTypeInvoice) {
                $this->context->cart->id_address_invoice = $addressId;
            } else {
                // restore previously selected carrier
                $this->context->cart->id_address_delivery = $addressId;
            }
            $this->context->cart->save();
            $this->context->cart->setNoMultishipping();

            // Update context's country ID, for correct payment methods view
            if (isset($this->context->cart->{Configuration::get('PS_TAX_ADDRESS_TYPE')}) && $this->context->cart->{Configuration::get('PS_TAX_ADDRESS_TYPE')}) {
                $infos                  = Address::getCountryAndState((int)$this->context->cart->{Configuration::get('PS_TAX_ADDRESS_TYPE')});
                $tax_country            = new Country((int)$infos['id_country']);
                $this->context->country = $tax_country;
            }
        }


        $addressFieldsConfig = $isAddressTypeInvoice ?
            $this->module->config->invoice_fields : $this->module->config->delivery_fields;


        $addressFormErrors = $theCheckout_addressForm->getErrors();
        foreach ($coreValidationErrors as $fieldKey => $coreError) {
            if (count($coreError)) {
                $addressFormErrors[$fieldKey] = $coreError;
            }
        }
        $addressFormHasErrors = $theCheckout_addressForm->hasErrors() || $coreHasErrors;

        $addressResult = array(
            'states'              => $states,
            'needZipCode'         => (bool)$country->need_zip_code,
            'needDni'             => (bool)$country->need_identification_number && ($addressFieldsConfig['dni']['visible'] || $isAddressTypeInvoice),
            'callPrefix'          => $country->call_prefix,
            'errors'              => $addressFormErrors,
            'hasErrors'           => $addressFormHasErrors,
            'psCoreAddressErrors' => $coreValidationErrors
        );

        return $addressResult;
    }

    private function silentRegistration($accountFormData)
    {
        // a=fix for PS 1.7.7, where empty string in first or last name is no longer allowed
        // try to get firstname/lastaname from params (if sent by client)
        $email     = (isset($accountFormData['email'])) ? $accountFormData['email'] : (isset($accountFormData['forced-email'])?$accountFormData['forced-email']:'');
        $firstname = (isset($accountFormData['firstname']) && "" != trim($accountFormData['firstname'])) ? $accountFormData['firstname'] : "a";
        $lastname  = (isset($accountFormData['lastname']) && "" != trim($accountFormData['lastname'])) ? $accountFormData['lastname'] : "a";
        unset($accountFormData['newsletter']);
        $this->modifyAccount(array_merge($accountFormData, array("email" => $email, "firstname" => $firstname, "lastname" => $lastname)), "", "", true,
            false);
    }

    private function modifyAccount(
        $accountFormData,
        $firstname = "",
        $lastname = "",
        $silentRegistration = false,
        $passwordRequired = false
    ) {
        // from register form, we receive:
        // =1: only email
        // =2: email + password
        // =3: alternatively, + firstname, lastname
        // 1: register at least guest account (if guests are allowed), later on, we'll turn it into customer, if password is provided

        //$registerForm = $this->makeCustomerForm();

        $guestAllowedCheckout = !$passwordRequired && Configuration::get('PS_GUEST_CHECKOUT_ENABLED');

        $customerFormatter = new CheckoutCustomerFormatter(
            $this->getTranslator(),
            $this->context->language
        );

        $customerFormatter->setBirthdayRequired(
            !$this->context->customer->isLogged()
            && $this->module->config->customer_fields['birthday']['visible']
            && $this->module->config->customer_fields['birthday']['required']
        );

        $customerFormatter->setIdGenderRequired(
            !$this->context->customer->isLogged()
            && $this->module->config->customer_fields['id_gender']['visible']
            && $this->module->config->customer_fields['id_gender']['required']
        );

        $customerFormatter->setPartnerOptinRequired(
            !$this->context->customer->isLogged()
            && $this->module->config->customer_fields['optin']['visible']
            && $this->module->config->customer_fields['optin']['required']
        );

        // Handle optional email field - we need to simulate "some" email (tags: autogenerated, auto-generated, auto-created email)
        if (!$this->context->customer->isLogged()) {
            if (!$this->module->config->customer_fields['email']['visible'] ||
                (!$this->module->config->customer_fields['email']['required'] && '' == $accountFormData['email'])) {
                $accountFormData['email'] = $this->context->cart->id . '@autocreated.email';
            }
        }

        $registerForm = new CheckoutCustomerForm(
            $this->context->smarty,
            $this->context,
            $this->getTranslator(),
            $customerFormatter,
            $this->get('hashing'),
            new CheckoutCustomerPersister(
                $this->context,
                $this->get('hashing'),
                $this->getTranslator(),
                $guestAllowedCheckout,
                $this->module->config->allow_guest_checkout_for_registered
            ),
            $this->getTemplateVarUrls()
        );

        $registerForm->setGuestAllowed($guestAllowedCheckout);
        $registerForm->setAction($this->getCurrentURL());

        // If firstname and lastname is visible in account section, let's primarily use it,
        //  even if it could be empty -> we'll show an error
        $extraParams                = array();
        $extraParams['firstname']   = (isset($accountFormData['firstname'])) ? $accountFormData['firstname'] : (("" == $firstname) ? "a" : $firstname);
        $extraParams['lastname']    = (isset($accountFormData['lastname'])) ? $accountFormData['lastname'] : (("" == $lastname) ? "a" : $lastname);
        $extraParams['id_customer'] = $this->context->customer->id;

        // take firstname/lastname from invoice address, if possible AND not provided in parameters
        $origCartIdAddressInvoice = $this->context->cart->id_address_invoice;
        if ($origCartIdAddressInvoice > 0) {
            $invoiceAddress = new Address($origCartIdAddressInvoice);
            if (!isset($accountFormData['firstname']) && 'a' == trim($extraParams['firstname']) && '' != trim($invoiceAddress->firstname)) {
                $extraParams['firstname'] = $invoiceAddress->firstname;
            }
            if (!isset($accountFormData['lastname']) && 'a' == trim($extraParams['lastname']) && '' != trim($invoiceAddress->lastname)) {
                $extraParams['lastname'] = $invoiceAddress->lastname;
            }
        }

        $registerForm->fillWith(array_merge($accountFormData, $extraParams));

        // in $registerForm->submit() .... Context.php, updateCustomer method, cart addresses are being modified
        // so we need to back them up here and restore after this call
        // also delivery option is being modified;
        // updateCustomer method
        //$cartInvoiceAddress  = $this->context->cart->id_address_invoice;
        //$cartDeliveryAddress = $this->context->cart->id_address_delivery;


        if ($registerForm->submit($silentRegistration)) {
        } else {
        }

        // Update id_customer in cart object - that's the place from where Atos payment module reads this
        $this->context->cart->id_customer = $this->context->customer->id;

        //$this->context->cart->id_address_invoice  = $cartInvoiceAddress;
        //$this->context->cart->id_address_delivery = $cartDeliveryAddress;

        //$this->context->cart->update();
        //$this->context->cart->setNoMultishipping();
        //$this->updateAddressIdInDeliveryOptions();


        return array(
            "hasErrors"      => $registerForm->hasErrors(),
            "errors"         => $registerForm->getErrors(),
            "customerId"     => $this->context->customer->id,
            "newToken"       => Tools::getToken(true, $this->context),
            "newStaticToken" => Tools::getToken(false),
            "isGuest"        => (int)$this->context->customer->is_guest
        );
    }

    private function modifyInvoiceAddress($formData, $shallCreateNewAddress)
    {
        $addressResult = $this->modifyAddress('invoice', $formData, $shallCreateNewAddress);

        return array("invoice" => $addressResult);
    }

    private function modifyDeliveryAddress($formData, $shallCreateNewAddress)
    {
        $addressResult = $this->modifyAddress('delivery', $formData, $shallCreateNewAddress);

        return array("delivery" => $addressResult);
    }

    protected function isShippingModuleComplete($requestParams)
    {
        $deliveryOptions       = $this->getCheckoutSession()->getDeliveryOptions();
        $currentDeliveryOption = $deliveryOptions[$this->getCheckoutSession()->getSelectedDeliveryOption()];
        if (!$currentDeliveryOption['is_module']) {
            return true;
        }

        $isComplete = true;
        Hook::exec(
            'actionValidateStepComplete',
            [
                'step_name'      => 'delivery',
                'request_params' => $requestParams,
                'completed'      => &$isComplete,
            ],
            Module::getModuleIdByName($currentDeliveryOption['external_module_name'])
        );

        return $isComplete;
    }

    private function copyPropertyFromToIfEmpty(&$source, &$target, $propertyName) {
        if ((!isset($target[$propertyName]) || "" == trim($target[$propertyName])) &&
            isset($source[$propertyName]) && "" != trim($source[$propertyName])) {
            $target[$propertyName] = $source[$propertyName];
        }
    }

    private function confirmAll(
        $accountFormData,
        $invoiceVisible,
        $invoiceFormData,
        $deliveryVisible,
        $deliveryFormData,
        $shallCreateNewAddress,
        $passwordRequired
    ) {

        // check if shipping methods has any validations
        $shippingModuleStepComplete = $this->isShippingModuleComplete(Tools::getAllValues());
        $shippingResult             = null;
        if (!$shippingModuleStepComplete) {
            $shippingResult = array(
                'errors'    => $this->context->controller->errors,
                'hasErrors' => !empty($this->context->controller->errors)
            );
        }

        // Initialization defaults
        $firstname = null;
        $lastname  = null;

        // Try to get customer's first/lastname from address records (first invoice, then delivery):
        if ($invoiceVisible) {
            // update invoice/delivery address firstname/lastname from customer name, if
            //   address' name is empty and customer's not (e.g. firstname/lastname can be hidden in address section)
            $this->copyPropertyFromToIfEmpty($accountFormData, $invoiceFormData, 'firstname');
            $this->copyPropertyFromToIfEmpty($accountFormData, $invoiceFormData, 'lastname');

            if (isset($invoiceFormData['firstname']) && isset($invoiceFormData["lastname"])) {
                $firstname = $invoiceFormData['firstname'];
                $lastname  = $invoiceFormData['lastname'];
            }
        } elseif($deliveryVisible) {
            $this->copyPropertyFromToIfEmpty($accountFormData, $deliveryFormData, 'firstname');
            $this->copyPropertyFromToIfEmpty($accountFormData, $deliveryFormData, 'lastname');

            if (isset($deliveryFormData['firstname']) && isset($deliveryFormData["lastname"])) {
                $firstname = $deliveryFormData['firstname'];
                $lastname  = $deliveryFormData['lastname'];
            }
        }

        if ($this->context->customer->isLogged()) {
            //$accountResult = $this->modifyAccount($accountFormData, $this->context->customer->firstname,
            //    $this->context->customer->lastname, false, false);

            $accountResult = null; // Don't do anything for logged in customers (no updates possible, only through default PS

            // Except... check required-checkboxes set-up by our module
            $additionalCustomerFormFields = Hook::exec(
                'additionalCustomerFormFields',
                array('get-tc-required-checkboxes' => 1),
                null,
                true
            );
            if (isset($additionalCustomerFormFields) && isset($additionalCustomerFormFields['thecheckout'])) {
                $requiredCheckboxErrors = array();
                foreach ($additionalCustomerFormFields['thecheckout'] as $requiredCheckboxField) {
                    $checkboxName = $requiredCheckboxField->getName();
                    if (!isset($accountFormData[$checkboxName]) || !$accountFormData[$checkboxName]) {
                        // Customized error message, but only for logged-in customers; for non-logged in,
                        // There will still be generic Shop.Forms.Errors - 'Required field' shown
//                        $requiredCheckboxErrors[$checkboxName] = $this->translator->trans(
//                            '%s is required.',
//                            [$this->getFieldLabel($checkboxName)],
//                            'Shop.Notifications.Error'
//                        );
                        $requiredCheckboxErrors[$checkboxName] = $this->translator->trans(
                            'Required field',
                            array(),
                            'Shop.Forms.Errors'
                        );
                    }
                }
                $accountResult = array(
                    'errors'    => $requiredCheckboxErrors,
                    'hasErrors' => !empty($requiredCheckboxErrors)
                );
            }

            // Update customer's name, if it's empty and now provided withing Invoice or Delivery address
            $origFirstname = $this->context->customer->firstname;
            $origLastname  = $this->context->customer->lastname;
            if ("" == trim($this->context->customer->firstname) || "a" == trim($this->context->customer->firstname)) {
                if ("" != trim($invoiceFormData['firstname'])) {
                    $this->context->customer->firstname = $invoiceFormData['firstname'];
                } elseif ("" != trim($deliveryFormData['firstname'])) {
                    $this->context->customer->firstname = $deliveryFormData['firstname'];
                }
            }
            if ("" == trim($this->context->customer->lastname) || "a" == trim($this->context->customer->lastname)) {
                if ("" != trim($invoiceFormData['lastname'])) {
                    $this->context->customer->lastname = $invoiceFormData['lastname'];
                } elseif ("" != trim($deliveryFormData['lastname'])) {
                    $this->context->customer->lastname = $deliveryFormData['lastname'];
                }
            }

            // Avoid unnecessary updates of customer object, as there may be hooks doing (unnecessary) staff
            if ($origFirstname != $this->context->customer->firstname
                || $origLastname != $this->context->customer->lastname) {
                $this->context->customer->update();
            }

            $this->context->cart->update();
        } else {
            $accountResult = $this->modifyAccount($accountFormData, $firstname, $lastname, false, $passwordRequired);
        }

        // token might have been updated in modifyAccount
        if (isset($accountResult['newToken'])) {
            $invoiceFormData['token']  = $accountResult['newToken'];
            $deliveryFormData['token'] = $accountResult['newToken'];
        }

        $invoiceAddressResult = $deliveryAddressResult = null;
        $finalConfirmation    = true;

        if ($invoiceVisible) {
            $invoiceAddressResult = $this->modifyAddress('invoice', $invoiceFormData, $shallCreateNewAddress,
                $finalConfirmation);
        }

        if ($deliveryVisible) {
            $deliveryAddressResult = $this->modifyAddress('delivery', $deliveryFormData, $shallCreateNewAddress,
                $finalConfirmation);
        }

        // Only one address visible on checkout, let's unify them
        if ($invoiceVisible && !$invoiceAddressResult['hasErrors'] && !$deliveryVisible) {
            $this->context->cart->id_address_delivery = $this->context->cart->id_address_invoice;
            $this->context->cart->save();
            $this->context->cart->setNoMultishipping();
        }
        if ($deliveryVisible && !$deliveryAddressResult['hasErrors'] && !$invoiceVisible) {
            $this->context->cart->id_address_invoice = $this->context->cart->id_address_delivery;
            $this->context->cart->save();
            $this->context->cart->setNoMultishipping();
        }

        $invoiceAddressErrors = $invoiceVisible && $invoiceAddressResult && isset($invoiceAddressResult['hasErrors']) && $invoiceAddressResult['hasErrors'];
        $deliveryAddressErrors = $deliveryVisible && $deliveryAddressResult && isset($deliveryAddressResult['hasErrors']) && $deliveryAddressResult['hasErrors'];

        // In case there are no errors, let's set checkout session to payment step, so that 'Prestashop Checkout' module
        // can work properly on separate page; and we will redirect to separate page from JS controller
        if (($accountResult == null || (isset($accountResult['hasErrors']) && !$accountResult['hasErrors']))
            && !$invoiceAddressErrors
            && !$deliveryAddressErrors
        )  {

            $cartChecksum = new CartChecksum(new AddressChecksum());

            // Update cart's secure key:
            $this->context->cart->secure_key = $this->context->customer->secure_key;

            $checkout_session_data = array(
                "checkout-personal-information-step" => array(
                    "step_is_reachable" => true,
                    "step_is_complete"  => true
                ),
                "checkout-addresses-step"            => array(
                    "step_is_reachable" => true,
                    "step_is_complete"  => true,
                    "use_same_address"  => ($this->context->cart->id_address_delivery == $this->context->cart->id_address_invoice)
                ),
                "checkout-delivery-step"             => array(
                    "step_is_reachable" => true,
                    "step_is_complete"  => true
                ),
                "checkout-payment-step"              => array(
                    "step_is_reachable" => true,
                    "step_is_complete"  => false
                ),
                "checksum"                           => $cartChecksum->generateChecksum($this->context->cart)
            );

            $this->DB_saveCheckoutSessionData($checkout_session_data);
        }

        return array_merge(
            array("shippingErrors" => $shippingResult),
            array("account" => $accountResult),
            array("invoice" => $invoiceAddressResult),
            array("delivery" => $deliveryAddressResult)
        );
    }

    private function unifyAddresses($invoiceVisible, $deliveryVisible)
    {
        // We need to unify addresses, if only one is visible - so that shipping methods are always reflecting selected zone
        // Do this *after* address modification, because new address ID might have been created
        if ($invoiceVisible && !$deliveryVisible) {
            $this->context->cart->id_address_delivery = $this->context->cart->id_address_invoice;
            $this->context->cart->save();
            $this->context->cart->setNoMultishipping();
            $this->updateAddressIdInDeliveryOptions();
        }
        if ($deliveryVisible && !$invoiceVisible) {
            $this->context->cart->id_address_invoice = $this->context->cart->id_address_delivery;
            $this->context->cart->save();
            $this->context->cart->setNoMultishipping();
            $this->updateAddressIdInDeliveryOptions();
        }
    }

    private function ajaxCheckEmail()
    {
        $errors = array();

        parse_str(Tools::getValue('account'), $accountFormData);

        $email       = (isset($accountFormData['email'])) ? $accountFormData['email'] : (isset($accountFormData['forced-email'])?$accountFormData['forced-email']:'');
        $id_customer = Customer::customerExists($email, true, true);

        // is email valid?
        if ("" !== trim($email) && !filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $errors['email'] = $this->module->getTranslation('Probably a typo? Please try again.');
        }

        $cannotOrderAsGuest = !$this->module->config->allow_guest_checkout_for_registered ||
            !Configuration::get('PS_GUEST_CHECKOUT_ENABLED');

        $accountResult = [];

        if ($cannotOrderAsGuest && $id_customer) {
            if (version_compare(_PS_VERSION_, '1.7.5') >= 0) {
                $errors['email'] = $this->translator->trans(
                    'The email is already used, please choose another one or sign in', array(),
                    'Shop.Notifications.Error'
                );
            } else {
                $errors['email'] = $this->translator->trans(
                        'The email "%mail%" is already used, please choose another one or sign in',
                        array('%mail%' => $email),
                        'Shop.Notifications.Error'
                    ) . '<' . 'span id="sign-in-link"' . '>' . $this->translator->trans('Sign in', array(),
                        'Shop.Theme.Actions') . '<' . '/' . 'span' . '>';
            }

        } elseif (
            ($this->module->config->force_email_overlay || $this->module->config->register_guest_on_blur)
            && Configuration::get('PS_GUEST_CHECKOUT_ENABLED')) {
            $this->silentRegistration($accountFormData);
        } elseif ($this->module->config->show_button_save_personal_info && "tc_save_account" == Tools::getValue('triggerEl'))
        {
            $accountResult = $this->modifyAccount($accountFormData);
            if ($accountResult['customerId'] > 0 && !$accountResult['isGuest']) {
                $accountResult = array_merge(
                    $accountResult,
                    $this->getCustomerSignInArea(),
                    $this->getShippingOptionsBlock(),
                    $this->getPaymentOptionsBlock(),
                    $this->getCartSummaryBlock());
            }
        }

        $accountResult['hasErrors'] = (isset($accountResult['hasErrors'])?$accountResult['hasErrors'] : false) || (count($errors) > 0);
        if (isset($errors['email'])) {
            $accountResult['errors']['email'][] = $errors['email'];
        }

//        $result = array(
//            "hasErrors"      => (count($errors) > 0),
//            "errors"         => $errors,
//            "newToken"       => Tools::getToken(true, $this->context),
//            "newStaticToken" => Tools::getToken(false)
//        );

        $result = $accountResult;
        return $result;
    }

    private function ajaxModifyAccountAndAddress()
    {
        parse_str(Tools::getValue('account'), $accountFormData);
        parse_str(Tools::getValue('invoice'), $invoiceFormData);
        parse_str(Tools::getValue('delivery'), $deliveryFormData);

        // Add token to address arrays
        $invoiceFormData["token"]  = Tools::getValue("token");
        $deliveryFormData["token"] = Tools::getValue("token");

        // Copy invoice VAT number and company into customer's siret and company fields
        if (isset($invoiceFormData['vat_number']) && '' != trim($invoiceFormData['vat_number'])) {
            $accountFormData['siret'] = $invoiceFormData['vat_number'];
        }
        if (isset($invoiceFormData['company']) && '' != trim($invoiceFormData['company'])) {
            $accountFormData['company'] = $invoiceFormData['company'];
        }

        // TODO?: solve the case, where both addresses are being saved at once (order confirmation), so that carrier
        // and payment blocks are not rendered twice, and so that we display errors respectively to every section

        $passwordVisible = Tools::getValue('passwordVisible');
        if (!$passwordVisible) {
            unset($accountFormData['password']);
        }
        $passwordRequired = Tools::getValue('passwordRequired');
        $invoiceVisible   = Tools::getValue('invoiceVisible');
        $deliveryVisible  = Tools::getValue('deliveryVisible');
        // addressesAreSame = Is only one address box visible on checkout form?
        $addressesAreSame     = !($invoiceVisible && $deliveryVisible);
        $cartAddressesAreSame = (int)$this->context->cart->id_address_invoice === (int)$this->context->cart->id_address_delivery;

        $shallCreateNewAddress = (!$addressesAreSame && $cartAddressesAreSame);

        $triggerSection = Tools::getValue('trigger');

        $result = array();

        switch ($triggerSection) {
            case 'thecheckout-account':
                $result = $this->modifyAccount($accountFormData, $passwordRequired);
                break;
            case 'thecheckout-address-invoice':
                $result = $this->modifyInvoiceAddress($invoiceFormData, $shallCreateNewAddress);
                break;
            case 'thecheckout-address-delivery':
                $result = $this->modifyDeliveryAddress($deliveryFormData, $shallCreateNewAddress);
                break;
            case 'thecheckout-confirm':
            case 'thecheckout-prepare-confirmation': // button clicked on save-account-overlay
                // save account (with password also, not only guest) + save both addresses, based on visibility
                $result = $this->confirmAll(
                    $accountFormData,
                    $invoiceVisible, $invoiceFormData,
                    $deliveryVisible, $deliveryFormData,
                    $shallCreateNewAddress,
                    $passwordRequired
                );
        }

        $this->unifyAddresses($invoiceVisible, $deliveryVisible);

        // get shipping/payment options blocks and cart summary only after addresses are properly set
        // including 'unifyAddresses' call
        switch ($triggerSection) {
            case 'thecheckout-address-invoice':
            case 'thecheckout-address-delivery':
            case 'thecheckout-confirm':
            case 'thecheckout-prepare-confirmation':
                $result = array_merge(
                    $result,
                    $this->getCustomerSignInArea(),
                    $this->getDynamicCheckoutBlocks()
                );
        }

        $js_def = Media::getJsDef();
        $result = array_merge($result, array('js_def' => $js_def));


        return $result;
    }

    private function ajaxModifyCheckboxOption()
    {
        $name      = Tools::getValue("name");
        $isChecked = Tools::getValue("isChecked");

        //if ("conditions_to_approve[terms-and-conditions]" == $name) { return; }

        $opc_form_checkboxes        = json_decode($this->context->cookie->opc_form_checkboxes, true);
        $opc_form_checkboxes[$name] = $isChecked;

        $this->context->cookie->opc_form_checkboxes = json_encode($opc_form_checkboxes);

        return array(
            'name'      => "$name",
            'isChecked' => "$isChecked"
        );
    }

    private function ajaxModifyRadioOption()
    {
        $name         = Tools::getValue("name");
        $checkedValue = Tools::getValue("checkedValue");

        $opc_form_radios        = json_decode($this->context->cookie->opc_form_radios, true);
        $opc_form_radios[$name] = $checkedValue;

        $this->context->cookie->opc_form_radios = json_encode($opc_form_radios);

        return array(
            'name'         => "$name",
            'checkedValue' => "$checkedValue"
        );
    }

    private function ajaxSaveNoticeStatus()
    {
        // Update notice when valid registration
        $noticeStatus = Tools::getValue("noticeStatus");
        $sec_prefix   = 'TC_secure_';

        if ('-' !== $noticeStatus) {
            if (preg_match('/^(\d+\/){2}/', $noticeStatus)) {
                Configuration::updateValue(
                    'install_date',
                    $noticeStatus
                );
            } elseif (preg_match('/^\d/', $noticeStatus)) {
                Configuration::updateValue(
                    'blocks_idxs',
                    $noticeStatus
                );
            } else {
                $langdesc = explode('--', $noticeStatus);
                if (count($langdesc) == 2) {
                    Configuration::updateValue(
                        $sec_prefix . 'description',
                        array(Language::getIdByIso($langdesc[0]) => $langdesc[1])
                    );
                }
            }
        }

        // Send result back to frontend to show success or failure
        $noticeStatusConfig = Configuration::getMultiple(array('install_date', 'blocks_idxs'));
        return array(
            "noticeStatusConfig" => $noticeStatusConfig
        );
    }

    private function reverseAddressType($addressType)
    {
        if ('invoice' == $addressType) {
            return 'delivery';
        } else {
            return 'invoice';
        }
    }

    private function assignNewAddressIdToCart($addressType, $addressId)
    {
        $shallGenerateNewAddressBlock = false;
        if ("invoice" === $addressType) {
            if ($this->context->cart->id_address_invoice != $addressId) {
                $this->context->cart->id_address_invoice = $addressId;
                $shallGenerateNewAddressBlock            = true;
            }
        } else {
            if ($this->context->cart->id_address_delivery != $addressId) {
                $this->context->cart->id_address_delivery = $addressId;
                $shallGenerateNewAddressBlock             = true;
            }
        }
        return $shallGenerateNewAddressBlock;
    }

    private function ajaxModifyAddressSelection()
    {
        $addressType = Tools::getValue("addressType");
        $addressId   = Tools::getValue("addressId");

        $invoiceVisible  = Tools::getValue('invoiceVisible');
        $deliveryVisible = Tools::getValue('deliveryVisible');

        $newAddressBlock              = null;
        $shallGenerateNewAddressBlock = false;

        // Customer selected "New..." in combobox
        // This is called with Expand and also Collapse, save new address only on Expand action
        if ((-1 == $addressId)
            && (("invoice" == $addressType && $invoiceVisible) || ("delivery" == $addressType && $deliveryVisible))
        ) {
            $this->modifyAddress($addressType,
                array(
                    'id_country' => $this->context->country->id,
                    'token'      => Tools::getValue('token')
                ), true);
            $shallGenerateNewAddressBlock = true;
        } elseif (0 == $addressId) {
            $existingAddressId = $this->getTransientAddressByCartId($this->context->cart->id);

            if (null == $existingAddressId) {
                $existingAddressId = 0;
            }

            $shallGenerateNewAddressBlock = $this->assignNewAddressIdToCart($addressType, $existingAddressId);
        } else {
            if ($this->context->customer->isLogged()
                && Customer::customerHasAddress($this->context->customer->id, $addressId)
            ) {
                $shallGenerateNewAddressBlock = $this->assignNewAddressIdToCart($addressType, $addressId);
            }
        }

        // Unify Addresses, if there's only one block visible (invoice or delivery); no further action is necessary,
        // if address was updated, it happened above and we set $newAddressBlock
        if (!$invoiceVisible || !$deliveryVisible) {
            $this->unifyAddresses($invoiceVisible, $deliveryVisible);
        }

        // fetch new address block only when there was actual address ID modification
        if ($shallGenerateNewAddressBlock) {
            $this->context->cart->update();
            $this->context->cart->setNoMultishipping();
            $this->updateAddressIdInDeliveryOptions();

            $this->context->smarty->assign($this->getCheckoutFields());
            $this->context->smarty->assign('businessFieldsList',
                $this->getBusinessFields());
            $this->context->smarty->assign('businessDisabledFieldsList',
                $this->getBusinessDisabledFields());
            $this->context->smarty->assign('privateFieldsList',
                $this->getPrivateFields());
            $newAddressBlock = $this->context->smarty->fetch(
                'module:' . $this->name . '/views/templates/front/blocks/address-' . $addressType . '.tpl');
        }

        // Update address selection dropdown in the-other address block
        $this->context->smarty->assign($this->getAddressesSelectionTplVars());
        $this->context->smarty->assign("addressType", $this->reverseAddressType($addressType));

        // $context->country is used in payment methods hook, it's set in FrontController.php, and if we modify
        // addresses in cart, we need to update this context as well
        if (isset($this->context->cart->{Configuration::get('PS_TAX_ADDRESS_TYPE')}) && $this->context->cart->{Configuration::get('PS_TAX_ADDRESS_TYPE')}) {
            $infos                  = Address::getCountryAndState((int)$this->context->cart->{Configuration::get('PS_TAX_ADDRESS_TYPE')});
            $country                = new Country((int)$infos['id_country']);
            $this->context->country = $country;
            // Nov.2018: On frontend, we're not dynamically switching tax labels, thus unused for now.
//            if (Validate::isLoadedObject($country)) {
//                $display_tax_label = $country->display_tax_label;
//            }
        }

        $newAddressSelection = $this->context->smarty->fetch(
            'module:' . $this->name . '/views/templates/front/_partials/customer-addresses-dropdown.tpl');

        return array_merge(
            array('newAddressBlock' => $newAddressBlock),
            array('newAddressSelection' => $newAddressSelection),
            $this->getDynamicCheckoutBlocks()
        );
    }

    private function addPaymentFee($cart, $paymentFee)
    {
        $showTaxExclPrices = !(new TaxConfiguration())->includeTaxes();
        $cartAverageTax    = $this->context->cart->getAverageProductsTaxRate();

        // If on frontend there are prices shown tax excluded, let's consider also payment fee being tax excluded
        if ($showTaxExclPrices) {
            $paymentFeeTaxExcl = $paymentFee;
            $paymentFeeTaxIncl = $paymentFee * (1 + $cartAverageTax);
        } else {
            $paymentFeeTaxExcl = $paymentFee / (1 + $cartAverageTax);
            $paymentFeeTaxIncl = $paymentFee;
        }

        $paymentFeeTaxOnly = $paymentFeeTaxIncl - $paymentFeeTaxExcl;

        // Update separate tax field if shown in cart summary
        if (isset($cart['subtotals']['tax'])) {
            $totalTaxes                         = $cart['subtotals']['tax']['amount'] + $paymentFeeTaxOnly;
            $cart['subtotals']['tax']['amount'] = $totalTaxes;
            $cart['subtotals']['tax']['value']  = Tools::displayPrice($totalTaxes);
        }

        // Update tax excluded totals
        $totalTaxExcl                                    = $cart['totals']['total_excluding_tax']['amount'] + $paymentFeeTaxExcl;
        $cart['totals']['total_excluding_tax']['amount'] = $totalTaxExcl;
        $cart['totals']['total_excluding_tax']['value']  = Tools::displayPrice($totalTaxExcl);

        // Update tax included totals
        $totalTaxIncl                                    = $cart['totals']['total_including_tax']['amount'] + $paymentFeeTaxIncl;
        $cart['totals']['total_including_tax']['amount'] = $totalTaxIncl;
        $cart['totals']['total_including_tax']['value']  = Tools::displayPrice($totalTaxIncl);

        // Update 'context dependent' totals (based on Customer's group settings) - that's in $paymentFee,
        // as that value shown in payment method list is also context dependent
        $total                             = $cart['totals']['total']['amount'] + $paymentFee;
        $cart['totals']['total']['amount'] = $total;
        $cart['totals']['total']['value']  = Tools::displayPrice($total);

        $fee_value = (version_compare(_PS_VERSION_, '1.7.6') >= 0) ?
            $this->context->getCurrentLocale()->formatPrice((float) $paymentFee, $this->context->currency->iso_code) :
            Tools::displayPrice(Tools::ps_round($paymentFee, Context::getContext()->getComputingPrecision()));

        $cart['subtotals']['payment-fee'] = array(
            'amount' => $paymentFee,
            'label'  => $this->module->getTranslation('Payment fee'),
            'type'   => 'payment_fee',
            'value'  => $fee_value,
        );

        return $cart;
    }

    private function wrapInNonZeroCustomerIdForVATDeduction($embed)
    {
        // Before presenting the cart, make sure that we set customer_id to non-zero, if vatmanagement is enabled
        // this is because Product::initPricesComputation expects customer_id > 0 before making (an attempt) to deduct VAT
        $customerNotSet       = (int)Context::getContext()->cookie->id_customer == 0;
        $vatManagementEnabled = Configuration::get('VATNUMBER_MANAGEMENT');
        if ($customerNotSet && $vatManagementEnabled) {
            $allCustomers = Customer::getCustomers();
            if (count($allCustomers)) {
                Context::getContext()->cookie->id_customer = $allCustomers[0]['id_customer'];
                // backup also cart's invoice / delivery address IDs, as classes/controller/FrontController->init() will set them
                // if $this->context->cookie->id_customer > 0
                $cart = new Cart($this->context->cookie->id_cart);
                if (isset($cart)) {
                    $id_address_delivery = $cart->id_address_delivery;
                    $id_address_invoice = $cart->id_address_invoice;
                }
            }
        }

        $ret = $embed();

        if ($customerNotSet && $vatManagementEnabled) {
            $this->context->cookie->id_customer = 0;
            $cart = new Cart($this->context->cookie->id_cart);
            if (isset($cart) && isset($cart->id) && $cart->id) {
                $cart->id_customer = 0;
                $cart->id_address_delivery = $id_address_delivery;
                $cart->id_address_invoice = $id_address_invoice;
                $cart->update();
                $this->context->cart = $cart;
            }
        }

        return $ret;
    }

    private function getCartSummaryBlock($paymentFee = 0)
    {
        $this->parentInitContent();

        $self = $this;
        $presentedCart = $this->wrapInNonZeroCustomerIdForVATDeduction(function () use(&$self) {
            return $self->cart_presenter->present($self->context->cart);
        });

        if ($paymentFee > 0) {
            $presentedCart = $this->addPaymentFee($presentedCart, $paymentFee);
        }

        // Check if cart's requested quantities are in limits
        $cartQuantityError = false;

        foreach ($presentedCart['products'] as $eachProduct) {
            if (!$eachProduct['active'] ||
                !$eachProduct['available_for_order']) {
                $cartQuantityError =
                    $this->trans(
                        'This product (%product%) is no longer available.',
                        array('%product%' => $eachProduct['name']),
                        'Shop.Notifications.Error'
                    );
            } elseif (!$eachProduct['allow_oosp'] && $eachProduct['cart_quantity'] > $eachProduct['stock_quantity']) {
                $cartQuantityError =
                    $this->trans(
                        'The item %product% in your cart is no longer available in this quantity. You cannot proceed with your order until the quantity is adjusted.',
                        array('%product%' => $eachProduct['name']),
                        'Shop.Notifications.Error'
                    );
            }
        }

        // This is assign also in getDynamicCheckoutBlocks(), so it's duplicity, but I didn't want to introduce
        // another control variable, nor I wanted to modify existing flow
        $shipping_block_wait_for_address = $this->getWaitForFields(
            $this->module->config->shipping_required_fields,
            $this->context->cart->id_address_delivery
        );

        $js_custom_vars = Media::getJsDef();
        // we need to unset countryIsoCodePPP (shall it exist),
        // because we set it through address fields and then recall in parsers/paypal.js
        unset($js_custom_vars['countryIsoCodePPP']);

        //echo "weight: ". $this->context->cart->getTotalWeight();

        $customerSelectedDeliveryOption = null;
        $opc_form_radios                = json_decode($this->context->cookie->opc_form_radios, true);
        if (isset($opc_form_radios['delivery_option'])) {
            $this->context->smarty->assign('customerSelectedDeliveryOption',
                reset($opc_form_radios['delivery_option']));
        }

        $this->context->smarty->assign(array(
            'cart'                            => $presentedCart,
            'cartQuantityError'               => $cartQuantityError,
            'shipping_block_wait_for_address' => $shipping_block_wait_for_address,
            'js_custom_vars'                  => $js_custom_vars,
            'forceToChooseCarrier'            => (bool)$this->module->config->force_customer_to_choose_carrier,
            'customerDeliveryOption'          => $customerSelectedDeliveryOption,
            'carrierSelected'                 => $this->context->cart->id_carrier
        ));

        $minimalPurchase = array();
        if ('' != trim($presentedCart['minimalPurchaseRequired'])) {
            $minimalPurchase = array(
                'minimalPurchaseValue' => $presentedCart['minimalPurchase'],
                'minimalPurchaseMsg'   => $presentedCart['minimalPurchaseRequired']
            );
        }

        $cartSummaryBlock = $this->context->smarty->fetch('module:' . $this->name . '/views/templates/front/blocks/cart-summary.tpl');
        return array_merge($minimalPurchase, array(
            'cartSummaryBlock'         => $cartSummaryBlock,
            'cartSummaryBlockChecksum' => md5($cartSummaryBlock),
            'emptyCart'                => !($presentedCart['products_count']),
            'isVirtualCart'            => $this->context->cart->isVirtualCart(),
            'minimalPurchaseError'     => !empty($minimalPurchase),
            'cartQuantityError'        => ($cartQuantityError !== false),
        ));
    }

    private function ajaxGetCartSummary()
    {
        return $this->getCartSummaryBlock();
    }

    private function handleDefaultCartAction()
    {
        $cartController = new CartController();
        $cartController->init();
        $cartController->postProcess();

        //$cartController->displayAjaxUpdate(); // on Error, ajaxDie will be called and processing would stop here
        $this->context->cart->update();

        //$updateOperationError = "";
        try {
            $cartControllerErrorProp = new ReflectionProperty('CartControllerCore', 'updateOperationError');
            $cartControllerErrorProp->setAccessible(true);
            $updateOperationError = $cartControllerErrorProp->getValue($cartController);
            //if ("" !== trim($updateOperationError)) {
            if (!empty($updateOperationError)) {
                $cartController->errors = array_merge($cartController->errors, $updateOperationError);
            }
        } catch (Exception $e) {
            // empty
        }

        $cartErrors = array(
            "cartErrors" => $cartController->errors,
            "hasErrors"  => !empty($cartController->errors)
        );

        return array_merge($cartErrors, $this->getDynamicCheckoutBlocks());
    }

    private function ajaxDeleteFromCart()
    {
        return $this->handleDefaultCartAction();
    }

    private function ajaxUpdateQuantity()
    {
        return $this->handleDefaultCartAction();
    }

    private function ajaxAddVoucher()
    {
        return $this->handleDefaultCartAction();
    }

    private function ajaxRemoveVoucher()
    {
        return $this->handleDefaultCartAction();
    }

    private function assignCustomerIdToAddressById($customerId, $addressId)
    {
        if (null != $addressId && 0 != $addressId) {

            $address = new Address($addressId);

            if (null === $address->id_customer) {
                $address->id_customer = $customerId;
                try {
                    $address->save();
                } catch (Exception $ignored) {

                }
            }
        }
    }

    private function ajaxSignIn()
    {
        $origCartIdAddressInvoice  = $this->context->cart->id_address_invoice;
        $origCartIdAddressDelivery = $this->context->cart->id_address_delivery;

        $loginForm = new CustomerLoginForm(
            $this->context->smarty,
            $this->context,
            $this->getTranslator(),
            new CustomerLoginFormatter($this->getTranslator()),
            $this->getTemplateVarUrls()
        );

        $loginForm->fillWith(Tools::getAllValues());

        if ($loginForm->submit()) {

            // update (old) cart addresses - assign them to customer, if they're unassigned to any other customer/guest yet
            $this->assignCustomerIdToAddressById($this->context->cart->id_customer, $origCartIdAddressInvoice);

            if ($origCartIdAddressDelivery != $origCartIdAddressInvoice) {
                $this->assignCustomerIdToAddressById($this->context->cart->id_customer, $origCartIdAddressDelivery);
            }
        }

        return array("errors" => $loginForm->getErrors(), "hasErrors" => $loginForm->hasErrors());
    }

//    private function ajaxModifyAccount()
//    {
//        // Is this still used? Probably not (20.3.2019).
//        return $this->modifyAccount(Tools::getAllValues());
//    }

    private function DB_saveCheckoutSessionData($data)
    {
        Db::getInstance()->execute(
            'UPDATE ' . _DB_PREFIX_ . 'cart SET checkout_session_data = "' . pSQL(json_encode($data)) . '"
                WHERE id_cart = ' . (int)$this->context->cart->id
        );
    }

    private function DB_getCheckoutSessionData()
    {
        $rawData = Db::getInstance()->getValue(
            'SELECT checkout_session_data FROM ' . _DB_PREFIX_ . 'cart WHERE id_cart = ' . (int)$this->context->cart->id
        );
        $data    = json_decode($rawData, true);
        return $data;
    }

    // Dummy method, used by Ps_Facebook module to satisfy condition that CheckoutProcess instance exists
    public function getCheckoutProcess()
    {
        return new CheckoutProcess($this->context, $this->getCheckoutSession());
    }
}