<?php

use KupShop\AdminBundle\Util\ActivityLog;
use KupShop\KupShopBundle\Config;
use KupShop\KupShopBundle\Context\CurrencyContext;
use KupShop\KupShopBundle\Context\DomainContext;
use KupShop\KupShopBundle\Context\LanguageContext;
use KupShop\KupShopBundle\Util\Compat\ServiceContainer;
use KupShop\KupShopBundle\Util\Contexts;
use KupShop\KupShopBundle\Util\Delivery\RestrictionParams;
use KupShop\KupShopBundle\Util\Delivery\RestrictionUtils;
use KupShop\OrderingBundle\Entity\Purchase\PurchaseState;
use KupShop\OrderingBundle\Exception\PaymentException;
use KupShop\OrderingBundle\Util\Order\OrderInfo;
use Psr\Log\LoggerInterface;
use Symfony\Component\DependencyInjection\Container;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

#[AllowDynamicProperties]
class Payment implements ArrayAccess
{
    use DatabaseCommunication;

    // Payment statuses
    public const STATUS_UNKNOWN = -1;
    public const STATUS_CREATED = 1;
    public const STATUS_PENDING = 2;
    public const STATUS_STORNO = 3;
    public const STATUS_FINISHED = 0;

    /** @var \Symfony\Component\HttpFoundation\Request */
    protected $request;

    // Payment class info
    public static $name = 'NoName';

    public static bool $canAutoReturn = false;

    public $class = 'NoClass';

    protected $databaseName;

    // Shop Settings
    public $config;

    public $step = 0;
    public $template = 'payment.tpl';
    protected $templateCart;
    protected $templateDescription;
    protected $templateOrderView = 'payment.orderView.tpl';
    protected $templateInit;

    protected ?string $defaultIcon = null;

    /** Order of payment.
     * @var Order
     */
    public $order;
    public $orderId;

    public $status = self::STATUS_UNKNOWN;
    public ?int $paymentId = null;
    protected $id;
    protected $custom_data;

    /**
     * @var \KupShop\OrderingBundle\Exception\PaymentException
     */
    public $exception;

    protected $pay_method;

    public const METHOD_CASH = 1;
    public const METHOD_CARD = 2;
    public const METHOD_INVOICE = 3;
    public const METHOD_TRANSFER = 6;
    public const METHOD_COD = 7;
    public const METHOD_ONLINE = 8;

    public const METHOD_CASH_INSERTION = 4;
    public const METHOD_CASH_SELECTION = 5;
    public const METHOD_COMPENSATION = 9;

    // Používá se pro slovenské EET - úhrada faktury (101 - hotově, 102 - kartou)
    public const METHOD_EET_INVOICE_CASH = 101;
    public const METHOD_EET_INVOICE_CARD = 102;

    public const METHOD_UNKNOWN = 10;
    public const METHOD_INSTALLMENTS = 11;

    protected $isNotification = false;

    /** @var RestrictionUtils */
    protected $restrictionUtils;

    /** @var RestrictionParams */
    protected $restrictionParams;

    /** @var LoggerInterface */
    protected $kibanaLogger;

    public static function getSettingsConfiguration(): array
    {
        return [];
    }

    public static function getCanAutoReturn(): bool
    {
        return static::$canAutoReturn;
    }

    public static function includeClass($name)
    {
        global $cfg;

        $name = preg_replace('/[^a-zA-Z0-9-]/', '', $name);
        $class = "payments/class.{$name}.php";

        if (file_exists($cfg['Path']['web_root'].$class) && !isFunctionalTests()) {
            require_once $cfg['Path']['web_root'].$class;

            return;
        }

        if (!file_exists($cfg['Path']['shared_class'].$class)) {
            throw new NotFoundHttpException('Platební modul '.$name.' neexistuje');
        }

        require_once $cfg['Path']['shared_class'].$class;
    }

    /** Factory function for Payment clases.
     * @param string $className Payment class name
     *
     * @return Payment
     */
    public static function getClass($className)
    {
        self::includeClass($className);

        if ($paymentClass = ServiceContainer::getService('kupshop.payment.'.strtolower($className), Container::NULL_ON_INVALID_REFERENCE)) {
            return $paymentClass;
        }

        if (!$className::isEnabled($className)) {
            return null;
        }

        return new $className();
    }

    /** List all Payment implementations.
     */
    public static function listClasses()
    {
        global $cfg;

        $classDir = $cfg['Path']['shared_class'].'payments/';

        $shopClassDir = $cfg['Path']['web_root'].'payments/';
        $classesDir = array_merge(glob($classDir.'class.*.php'), glob($shopClassDir.'class.*.php'));
        $classes = [];

        foreach ($classesDir as $class) {
            $class = basename($class);
            preg_match('/class.([a-zA-Z0-9-]+).php/', $class, $matches);
            $class = $matches[1];

            self::includeClass($class);

            if (!$class::isEnabled($class)) {
                continue;
            }

            $classes[$class] = $class::$name;
        }

        return $classes;
    }

    public function getId(): ?int
    {
        return $this->id ? (int) $this->id : null;
    }

    public function setIsNotification(bool $isNotification): Payment
    {
        $this->isNotification = $isNotification;

        return $this;
    }

    public function setDatabaseName($databaseName)
    {
        $this->databaseName = $databaseName;
    }

    public function hasCartTitle()
    {
        return (bool) $this->templateCart;
    }

    public function hasCartTemplate()
    {
        return (bool) $this->templateCart;
    }

    public function getGenericPaymentUrl(int $step = 1, array $params = []): string
    {
        return path('kupshop_ordering_payment_payment', array_merge([
            'IDo' => $this->order->id,
            'cf' => $this->order->getSecurityCode(),
            'step' => $step,
            'class' => $this->class,
        ], $params), \Symfony\Component\Routing\Router::ABSOLUTE_URL);
    }

    /** @deprecated Use getGenericPaymentUrl() instead. */
    public function getPaymentUrl()
    {
        return $this->getGenericPaymentUrl();
    }

    /** Get row in cart with payment title.
     * @param Smarty $smarty
     *
     * @return string|null
     *
     * @internal param array $context
     */
    public function getCartTitle($smarty)
    {
        if ($this->templateCart) {
            $params = [
                'object' => $this,
            ];

            $_smarty_tpl_vars = $smarty->tpl_vars;

            $ret = $smarty->_subTemplateRender($this->templateCart, $smarty->cache_id, $smarty->compile_id, 0, null, $params, 0, false);

            $smarty->tpl_vars = $_smarty_tpl_vars;

            return $ret;
        }

        return null;
    }

    public function getInitTemplate($smarty)
    {
        if ($this->templateInit) {
            $params = [
                'object' => $this,
            ];

            $_smarty_tpl_vars = $smarty->tpl_vars;

            $ret = $smarty->_subTemplateRender($this->templateInit, $smarty->cache_id, $smarty->compile_id, 0, null, $params, 0, false);

            $smarty->tpl_vars = $_smarty_tpl_vars;

            return $ret;
        }

        return null;
    }

    /** Get payment HTML when payment selected.
     */
    public function getCartDescription()
    {
        if ($this->templateDescription) {
            $smarty = createSmarty();
            $smarty->assign([
                'object' => $this,
            ]);

            return $smarty->fetch($this->templateDescription);
        }

        return null;
    }

    /** Get payment HTML on completed order.
     */
    public function getOrderViewDescription($smarty = null)
    {
        $params = [
            'payment' => $this,
            'order' => $this->order,
        ];

        if ($smarty) {
            return $smarty->_subTemplateRender($this->templateOrderView, $smarty->cache_id, $smarty->compile_id, 0, null, $params, 0, false);
        } else {
            $smarty = createSmarty(false, true);
            $smarty->assign($params);

            return $smarty->fetch($this->templateOrderView);
        }
    }

    public static function isEnabled($className)
    {
        return true;
    }

    /** Get payment icon url and name.
     * @return array|null
     */
    public function getIcon()
    {
        return null;
    }

    protected function getRestrictionUtils()
    {
        if (!isset($this->restrictionUtils)) {
            $this->restrictionUtils = ServiceContainer::getService(RestrictionUtils::class);
        }

        return $this->restrictionUtils->setType('payment');
    }

    public function accept($totalPrice, $freeDelivery)
    {
        return $this->getRestrictionUtils()->checkHardRequirements($this);
    }

    public function check(CartBase $cart)
    {
        $this->checkRestrictions($cart->getPurchaseState());

        ServiceContainer::getService('event_dispatcher')->dispatch(
            new \KupShop\OrderingBundle\Event\PaymentCheckEvent($this, $cart)
        );
    }

    public function checkRestrictions(PurchaseState $purchaseState)
    {
        $customData = $this->getCustomData();
        if ($restrictions = $customData['restrictions'] ?? false) {
            if (!isset($this->restrictionParams)) {
                $this->restrictionParams = $this->getRestrictionUtils()
                    ->createParamsFromConfig($this->config ?? [], $customData['restrictions'] ?? []);
            }
            $this->getRestrictionUtils()->checkSoftRequirements(
                $purchaseState->getDeliveryRestrictionParams(),
                $this->restrictionParams
            );

            if ($productsFilter = $restrictions['productsFilter'] ?? null) {
                $this->getRestrictionUtils()->checkProductsFilter($productsFilter, $purchaseState->getProductList());
            }
        }
    }

    public function setException(Exception $exception)
    {
        $this->exception = $exception;
    }

    public function getName()
    {
        return empty($this->databaseName) ? static::$name : $this->databaseName;
    }

    public function __construct()
    {
        $this->loadConfig();

        $this->kibanaLogger = ServiceContainer::getService('logger');
    }

    public function __toString()
    {
        return static::class;
    }

    public function setOrder($order)
    {
        if (is_object($order)) {
            $this->orderId = $order->id;
            $this->order = $order;
        } else {
            $this->orderId = $order;
            $this->order = new Order();

            if (!$this->order->createFromDB($this->orderId)) {
                $this->error(replacePlaceholders(translate('errorOrderNotFound', 'payment'), ['ID' => $this->orderId]));
            }
        }

        return $this->order;
    }

    public function getOrderNumber(): string
    {
        return $this->order->order_no;
    }

    public function loadConfig(?string $language = null)
    {
        $cfg = Config::get();
        // pokud je poslana $language, tak naloaduju settingy pro ten danej jazyk
        // napr. v administraci getDefault vzdycky naloaduje default jazyk, ale v nekterych pripadech
        // chci settingy pro jiny jazyk (napr. kdyz vracim platbu)
        $dbcfg = $language ? Settings::getFromCache($language) : Settings::getDefault();

        $dbConfig = $this->loadPaymentDbConfig($dbcfg);

        if (isset($dbcfg->payment_config['order_status_new']) && !isset($dbConfig['order_status_new'])) {
            $dbConfig['order_status_new'] = $dbcfg->payment_config['order_status_new'];
        }
        if (isset($dbcfg->payment_config['order_status_finished'])) {
            $dbConfig['order_status_finished'] = $dbcfg->payment_config['order_status_finished'] !== 'keep' ? $dbcfg->payment_config['order_status_finished'] : null;
        }

        $config = $cfg['Modules']['payments'][$this->class] ?? false;

        if (!is_array($config)) {
            $config = [];
        }

        // Do not load database configuration in development - use one from config_db.php
        if (isLocalDevelopment()) {
            $dbConfig = [];
        }

        $this->config = array_merge($config, $dbConfig);

        // neni pouzity isset kvuli tomu ze hodnota muze bejt null !!
        if (!array_key_exists('order_status_finished', $this->config)) {
            $this->config['order_status_finished'] = 1;
            $languageContext = Contexts::get(LanguageContext::class);
            if ($languageContext->translationActive()) {
                // hotfix, zahranicni platby menily stav objednavek
                $defaultDbcfg = Settings::getFromCache($languageContext->getDefaultId());
                if (isset($defaultDbcfg->payment_config['order_status_finished'])) {
                    $this->config['order_status_finished'] = $defaultDbcfg->payment_config['order_status_finished'] !== 'keep' ? $defaultDbcfg->payment_config['order_status_finished'] : null;
                }
            }
        }

        // load domain config
        if (array_key_exists('domain_config', $this->config)) {
            $domainContext = ServiceContainer::getService(DomainContext::class);
            $domain = $domainContext->getActiveId();
            if (array_key_exists($domain, $this->config['domain_config'])) {
                $domain_config = $this->config['domain_config'][$domain];
                $this->config = array_merge($this->config, $domain_config);
            }
        }
    }

    protected function loadPaymentDbConfig($dbcfg): array
    {
        return array_filter($dbcfg->payments[$this->class] ?? []);
    }

    public function getOrderId($session)
    {
        $session = sqlFormatInput($session);
        $orderId = returnSQLResult('SELECT id_order FROM '.getTableName('order_payments')." WHERE payment_data LIKE '%\"{$session}\"%'");

        /*
        if (empty($orderId))
           logError(__FILE__, __LINE__, "Payment: getOrderId: Cannot get order id of session: {$session}, POST:".print_r($_POST, true));
        */

        return $orderId;
    }

    public function getStatus($session = null)
    {
        $SQL = sqlQuery('SELECT id, status, payment_data FROM '.getTableName('order_payments')." WHERE id_order={$this->orderId} FOR UPDATE");

        if (empty($session) && sqlNumRows($SQL) > 1) {
            logError(__FILE__, __LINE__, 'Payment: getStatus: empty session but multiple payments!');
        }

        while (($payment = sqlFetchAssoc($SQL)) !== false) {
            if (!empty($payment['payment_data'])) {
                $payment_data = json_decode($payment['payment_data'], true);

                if (empty($session) || (isset($payment_data['session']) && $payment_data['session'] == $session)) {
                    $this->status = $payment['status'];
                    $this->paymentId = $payment['id'];

                    return true;
                }
            }
        }

        return false;
    }

    public function createPayment($session, $price = null, $data = [])
    {
        $fields = [
            'id_order' => $this->orderId,
            'price' => $price,
            'note' => "Platba modulu {$this->class}",
            'status' => self::STATUS_CREATED,
            'payment_data' => json_encode(array_merge($data, ['session' => $session])),
            'date' => date('Y-m-d H:i:s'),
            'method' => $this->pay_method ?? self::METHOD_ONLINE,
            'admin' => getAdminID(null),
        ];

        $this->insertSQL('order_payments', $fields);

        $this->status = self::STATUS_CREATED;
        $this->paymentId = sqlInsertId();

        $this->order->updatePayments();

        return true;
    }

    public function setStatus($status, $session = null)
    {
        $change = false;
        // Použiju transakci, abych zajistil že zjištění stavu transakce a její následná změna jsou atomický a nevběhne tam mezitím jiný thread
        sqlGetConnection()->transactional(function () use ($status, $session, &$change) {
            if (!$this->getStatus($session)) {
                logError(__FILE__, __LINE__, 'Payment::setStatus: get status failed!');
                $this->error('Payment::setStatus: get status failed!');
            }

            if ($this->status != $status) {
                if ($this->status == self::STATUS_FINISHED) {
                    return;
                }

                $change = true;

                sqlQuery('UPDATE '.getTableName('order_payments')." SET status={$status}, date=NOW() WHERE id={$this->paymentId}");
            }
        });

        // Tohle mám mimo transakci, protože to může trvat dlouho (odesílá se email o zaplacení).
        // Hlavní je, že se tdvakrát nezavolá změna stavu zaplacení platby
        if ($change) {
            $this->order->updatePayments();

            $forceEmail = null;
            $this->changeOrderStatus($status, $forceEmail);
        }

        return true;
    }

    public function changeOrderStatus($paymentStatus, $forceEmail)
    {
        switch ($paymentStatus) {
            case self::STATUS_FINISHED:
                if ($this->order->isActive() && !$this->order->isPaid()) {
                    break;
                }

                $status = $this->config['order_status_finished'] ?? null;
                if (is_null($status)) {
                    $status = $this->order->status;
                }

                $this->order->changeStatus($status, translate('msgStatusFinished', 'payment'), false);

                if (($forceEmail !== false) && ($this->order->source != OrderInfo::ORDER_SOURCE_POS)) {
                    // Send Payment email
                    $this->order->sendPaymentReceipt($this->paymentId);
                }
                break;
        }

        $this->status = $paymentStatus;
    }

    private function getPayment()
    {
        return sqlQueryBuilder()->select('*')
            ->from('order_payments', 'op')
            ->where(\Query\Operator::equals(['op.id' => $this->paymentId]))->execute()->fetch();
    }

    public function checkOrderIsActiveAndNotPaid()
    {
        if (!$this->order->isActive()) {
            $this->error(replacePlaceholders(translate('errorOrderCanceled', 'payment'), ['ID' => $this->order->order_no]));
        }

        if ($this->order->isPaid(true)) {
            $this->error(replacePlaceholders(translate('errorOrderAlreadyPaid', 'payment'), ['ID' => $this->order->order_no]));
        }
    }

    public function startPayment()
    {
        $this->step(1, translate('msgStartPayment', 'payment'));
    }

    public function processStep($index)
    {
        try {
            if ($index == 1) {
                $this->checkOrderIsActiveAndNotPaid();
            }
            if ($index >= 0) {
                $reflectionMethod = new ReflectionMethod($this, 'processStep_'.intval($index));

                return $reflectionMethod->invoke($this);
            }
        } catch (\KupShop\KupShopBundle\Exception\RedirectException $e) {
            throw $e;
        } catch (Exception $e) {
            addActivityLog(ActivityLog::SEVERITY_ERROR, ActivityLog::TYPE_COMMUNICATION, 'Payment error: '.$this->getName().': '.$e->getMessage());

            return $this->error($e->getMessage());
        }
    }

    public function step($index, $message, $data = [])
    {
        // logError(__FILE__, __LINE__, "Payment::Step: $index, $message, {$this->orderId}");
        if ($this->isNotification) {
            $this->sendNotificationResponse(500, $message);
        }

        $redirect = [
            'URL' => 'launch.php',
            's' => 'payment',
            'IDo' => $this->orderId,
            'class' => $this->class,
            'step' => $index,
            'cf' => $this->order ? $this->order->getSecurityCode() : '',
            'message' => $message,
        ];
        $redirect = array_merge($redirect, $data);

        redirection(createScriptURL($redirect));
    }

    public function getStepUrl(int $step): string
    {
        return createScriptURL([
            's' => 'payment',
            'IDo' => $this->order->id,
            'cf' => $this->order->getSecurityCode(),
            'step' => $step,
            'class' => $this->class,
            'absolute' => true,
        ]);
    }

    public function error($message)
    {
        if ($this->isNotification) {
            $this->sendNotificationResponse(500, $message);
        }
        if ($this->order) {
            addUserMessage($message, 'danger');

            redirection($this->order->getUrl());
        }

        if (getVal('step') != -1) {
            $this->step(-1, $message);
        }

        return false;
    }

    public function success($message)
    {
        if ($this->isNotification) {
            $this->sendNotificationResponse(200, 'OK');
        }
        if ($this->order) {
            addUserMessage($message, 'success');

            redirection($this->order->getDetailUrl(1));
        }

        $this->step(-2, $message);
    }

    public function info($message)
    {
        if ($this->isNotification) {
            $this->sendNotificationResponse(200, $message);
        }
        addUserMessage($message, 'info');
        redirection($this->order->getUrl());
    }

    public function checkAuth()
    {
        $cf = getVal('cf');

        if ($this->order->getSecurityCode() != $cf) {
            throw new NotFoundHttpException(translate('errorSecurityCode', 'payment'));
        }
    }

    public function storePaymentInfo()
    {
        return [];
    }

    public function loadPaymentInfo($data)
    {
        foreach ($data as $key => $value) {
            $this->$key = $value;
        }
    }

    public function requiresEET()
    {
        return false;
    }

    public function hasOnlinePayment()
    {
        return false;
    }

    public function hasPaymentDescription()
    {
        return $this->hasOnlinePayment();
    }

    public function getPayMethod()
    {
        if (!$this->pay_method) {
            throw new RuntimeException('Missing pay_method in Payment class '.$this->getName());
        } else {
            return $this->pay_method;
        }
    }

    /**
     * Implements ArrayAccess interface.
     */
    public function offsetSet($offset, $value): void
    {
        $this->{$offset} = $value;
    }

    public function offsetExists($offset): bool
    {
        return isset($this->{$offset});
    }

    public function offsetUnset($offset): void
    {
        unset($this->{$offset});
    }

    public function offsetGet($offset): mixed
    {
        return isset($this->{$offset}) ? $this->{$offset} : null;
    }

    /**
     * @return false|array $payment (with decoded json payment_data as decoded_data)
     */
    public function getPendingPayment()
    {
        $payments = $this->order->getPaymentsArray();
        foreach ($payments as $payment) {
            $paymentData = json_decode($payment['payment_data']);
            if (($payment['status'] == self::STATUS_CREATED || $payment['status'] == self::STATUS_PENDING)
                and isset($paymentData->paymentClass)
                and $paymentData->paymentClass === static::class
            ) {
                $payment['decoded_data'] = $paymentData;

                return $payment;
            }
        }

        return false;
    }

    public function setRequest(Symfony\Component\HttpFoundation\Request $request): Payment
    {
        $this->request = $request;

        return $this;
    }

    public function orderCreatedPostProcess(Order $order)
    {
        if (($this->hasOnlinePayment() || (findModule(\Modules::BANK_AUTO_PAYMENTS) && $this->getPayMethod() === self::METHOD_TRANSFER))
            && !empty($this->config['order_status_new'])
            && $order->status !== $this->config['order_status_new']
        ) {
            $order->changeStatus($this->config['order_status_new'], null, false);
        }
    }

    public function deletePayment()
    {
        return sqlQueryBuilder()->delete('order_payments')->where(\Query\Operator::equals(['id' => $this->paymentId]))->execute();
    }

    public function processAdminWindowData($data)
    {
        return $data;
    }

    public function getCustomData()
    {
        if (isset($this->custom_data)) {
            return $this->custom_data;
        }

        if ($this->id !== null) {
            $this->custom_data = json_decode(sqlQueryBuilder()->select('data')
                ->from('delivery_type_payment')
                ->where(\Query\Operator::equals(['id' => $this->id]))
                ->execute()
                ->fetchColumn(), true);
        }

        return $this->custom_data;
    }

    /**
     * @param int|null $id
     */
    public function setID($id = null)
    {
        $this->id = $id;
    }

    /**
     * @param null $custom_data
     */
    public function setCustomData($custom_data): void
    {
        $this->custom_data = $custom_data;
    }

    private function isPaymentInstanceOfClass($payment)
    {
        $data = (is_array($payment['payment_data'])) ? $payment['payment_data'] : json_decode($payment['payment_data'], true);

        return ($data['paymentClass'] ?? '') === static::class;
    }

    protected function updateReturnPayment($payment, $returnId, $full)
    {
        if ($returnId) {
            $title = 'Vrácení částky: objednávka '.$this->order->order_no.', číslo platby: '.$payment['id'];
            $data = ['return_from_payment' => $payment['id'], 'paymentClass' => $this->class];
            $this->updateSQL('order_payments', ['note' => $title, 'payment_data' => json_encode($data)], ['id' => $returnId]);
        }
    }

    public function getPaymentForReturn($amount, ?int $paymentId = null)
    {
        if ($paymentId) {
            $this->paymentId = $paymentId;
            $payment = $this->getPayment();
            if ($this->isPaymentInstanceOfClass($payment)) {
                $payment['payment_data'] = json_decode($payment['payment_data'], true);

                return $payment;
            }
        }

        $paymentsArray = $this->order->getPaymentsArray();
        $payment = false;
        foreach ($paymentsArray as $paytmp) {
            if ((int) $paytmp['status'] === Payment::STATUS_FINISHED && $paytmp['price'] >= ($amount * -1)) {
                $paytmp['payment_data'] = json_decode($paytmp['payment_data'], true);
                if (isset($paytmp['payment_data']['session']) && $this->isPaymentInstanceOfClass($paytmp)) {
                    $payment = $paytmp;
                }
            }
        }

        if (!$payment) {
            throw new PaymentException('Platba nemohla být automaticky vrácena, protože neexistuje validní platba.');
        }

        return $payment;
    }

    public function enabledReturnPayment(): bool
    {
        $dbcfg = \Settings::getDefault();

        return (($dbcfg->payment_config['return_payment_auto_gate'] ?? null) !== 'N') && static::$canAutoReturn;
    }

    /**
     * @throws PaymentException
     */
    public function doReturnPayment(array $payment, float $amount)
    {
        return false;
    }

    /**
     * @throws PaymentException
     */
    public function returnPayment($amount, ?int $paymentId = null, ?int $returnId = null)
    {
        // TODO: zabránit znovuvrácení platby, když už se z ní vracelo - vracet pouze zbytek
        // TODO: zakázat editaci vrácené platby, pokud byla vrácena automatem
        if ($this->enabledReturnPayment()) {
            $payment = $this->getPaymentForReturn($amount, $paymentId);
            $this->updateReturnPayment($payment, $returnId, ($payment['price'] + $amount) == 0);
            if ($result = $this->doReturnPayment($payment, $amount)) {
                return $result;
            }
        }
        $currencyContext = Contexts::get(CurrencyContext::class);
        $currency = $currencyContext->getActive();
        // Automatic return not implemented
        throw new PaymentException('Vrácení nelze pro tento způsob platby automatizovat. Vraťte zákazníkovi '.$amount * (-1).' '.$currency->getSymbol().' manuálně.');
    }

    protected function sendNotificationResponse(int $httpResponseCode, $message)
    {
        http_response_code($httpResponseCode);
        echo $message;
        exit;
    }

    public function getPhoto(?string $photo, ?string $date_updated = null): ?array
    {
        $icon = $this->getPhotoPath($photo);

        if ($icon === null) {
            return null;
        }

        return getImage($this->id, basename($icon), dirname($icon), 8, $this::$name, strtotime($date_updated));
    }

    public function getPhotoPath(?string $photo): ?string
    {
        return empty($photo) ? $this->defaultIcon : '../payment/'.$photo;
    }

    public function getClassName(): string
    {
        return $this->class;
    }

    /**
     * Pro platebni brany - vrati platebni metody.
     *
     * @return array|null
     */
    public function getAvailableMethods()
    {
        return null;
    }

    public function getSelectedMethodId(): ?string
    {
        return $this->method ?? null;
    }

    public function getSelectedMethod(): ?array
    {
        if (empty($this->method)) {
            return null;
        }

        $methods = $this->getAvailableMethods();

        return $methods[$this->method] ?? null;
    }
}