<?php

/**
 * SOTESHOP/stDelivery
 *
 * Ten plik należy do aplikacji stDelivery opartej na licencji (Professional License SOTE).
 * Nie zmieniaj tego pliku, jeśli chcesz korzystać z automatycznych aktualizacji oprogramowania.
 * Jeśli chcesz wprowadzać swoje modyfikacje do programu, zapoznaj się z dokumentacją, jak zmieniać
 * oprogramowanie bez zmiany kodu bazowego http://www.sote.pl/modifications
 *
 * @package     stDelivery
 * @subpackage  libs
 * @copyright   SOTE (www.sote.pl)
 * @license     http://www.sote.pl/license/sote (Professional License SOTE)
 * @version     $Id: stDeliveryFrontend.class.php 7534 2010-08-11 13:48:48Z marcin $
 * @author      Marcin Butlak <marcin.butlak@sote.pl>
 */

/**
 * Klasa zarządzająca dostawami w sklepie
 *
 * @author Marcin Butlak <marcin.butlak@sote.pl>
 *
 * @package     stDelivery
 * @subpackage  libs
 */
class stDeliveryFrontend
{
    const SESSION_NAMESPACE = 'soteshop/stDeliveryFrontend';
    const SESSION_WEEKEND_DELIVERY_NAME = 'weekend_delivery';
    const SESSION_EXPRESS_DELIVERY_NAME = 'express_delivery';
    const SESSION_DELIVERY_COUNTRY_NAME = 'delivery_country';

    /**
     * Singleton
     *
     * @var stDeliveryFrontend
     */
    protected static $instance = null;

    protected
        $minOrderAmount = null,
        $minOrderQuantity = null,
        $minOrderWeight = null,
        $maxOrderAmount = null,
        $maxOrderQuantity = null,
        $maxOrderWeight = null;

    /**
     * 
     * @var stDeliveryProductInfoAbstract
     */
    protected $productInfo = null;

    /**
     * Koszyk
     *
     * @var stBasket
     */
    protected $basket;

    /**
     * Dyspozytor zdarzeń
     *
     * @var stEventDispatcher
     */
    protected $dispatcher = null;

    /**
     * Dostawa
     *
     * @var Delivery
     */
    protected $delivery = null;

    /**
     * Kraj dostawy
     *
     * @var Countries
     */
    protected $deliveryCountry = null;

    /**
     * Lista Dostaw
     *
     * @var Delivery[]
     */
    protected $deliveries = null;

    /**
     * Lista krajów dostawy
     *
     * @var Countries[]
     */
    protected $deliveryCountries = null;

    /**
     * Konfiguracja dostaw
     *
     * @var stConfig
     */
    protected $config;

    /**
     * Incjalizacja klasy stDelivery
     *
     * @param stBasket $basket
     */
    public function initialize(stBasket $basket)
    {
        $this->basket = $basket;

        $this->dispatcher = stEventDispatcher::getInstance();

        $this->config = stConfig::getInstance('stDeliveryBackend');
    }

    public function clearBasketTotals()
    {
        $this->getProductInfo()->refresh();
    }

    /**
     * Zwraca instancje obiektu
     *
     * @param stBasket $basket
     * @return   stDeliveryFrontend
     */
    public static function getInstance(stBasket $basket)
    {
        if (!isset(self::$instance))
        {
            $class = __CLASS__;

            self::$instance = new $class();

            self::$instance->initialize($basket);
        }

        return self::$instance;
    }

    /**
     * Usuwa z sesji domyślna dostawę oraz domyślną płatność
     */
    public function clearSession()
    {
        $this->getUser()->getAttributeHolder()->remove('delivery', self::SESSION_NAMESPACE);

        $this->getUser()->getAttributeHolder()->remove('delivery_payment', self::SESSION_NAMESPACE);
    }

    /**
     *
     * @return stUser
     */
    public function getUser()
    {
        return $this->basket->getUser();
    }

    /**
     * Koszyk
     *
     * @return stBasket
     */
    public function getBasket()
    {
        return $this->basket;
    }

    /**
     * Ustawia domyslna dostawe
     *
     * @param Delivery|int $delivery
     */
    public function setDefaultDelivery($delivery)
    {
        if ($delivery)
        {
            if (!is_object($delivery))
            {
                $this->delivery = $this->getDeliveryById($delivery);
            }
            else
            {
                $this->delivery = $delivery;
            }

            $this->getUser()->setAttribute('delivery', $this->delivery ? $this->delivery->getId() : null, self::SESSION_NAMESPACE);
        }
    }

    /**
     * Ustawia domyślny kraj dostawy 
     *
     * @param Countries|int $delivery_country
     * @return void 
     * @throws PropelException 
     * @throws SQLException 
     */
    public function setDefaultDeliveryCountry($deliveryCountry)
    {
        if ($deliveryCountry)
        {
            if (!is_object($deliveryCountry))
            {
                $this->deliveryCountry = $this->getCountryById($deliveryCountry);
            }
            else
            {
                $this->deliveryCountry = $deliveryCountry instanceof Countries ? $this->deliveryCountryCallback($deliveryCountry) : $deliveryCountry;
            }

            $this->getUser()->setAttribute(self::SESSION_DELIVERY_COUNTRY_NAME, $this->deliveryCountry ? $this->deliveryCountry->getId() : null, self::SESSION_NAMESPACE);
            $this->deliveries = null;
            $this->delivery = null;
            $this->getProductInfo()->refresh();
        }
    }

    public function setWeekendDelivery($weekendDelivery)
    {
        $this->getUser()->setAttribute(self::SESSION_WEEKEND_DELIVERY_NAME, $weekendDelivery, self::SESSION_NAMESPACE);
    }

    public function setExpressDelivery($expressDelivery)
    {
        $this->getUser()->setAttribute(self::SESSION_EXPRESS_DELIVERY_NAME, $expressDelivery, self::SESSION_NAMESPACE);
    }

    public function getWeekendDelivery()
    {
        return $this->getUser()->getAttribute(self::SESSION_WEEKEND_DELIVERY_NAME, false, self::SESSION_NAMESPACE);
    }

    public function getExpressDelivery()
    {
        return $this->getUser()->getAttribute(self::SESSION_EXPRESS_DELIVERY_NAME, false, self::SESSION_NAMESPACE);
    }

    public function getIsWeekendDelivery()
    {
        return $this->getWeekendDelivery() && $this->getDefaultDelivery() && $this->getDefaultDelivery()->isWeekendDeliveryAvailable();
    }

    public function getIsExpressDelivery()
    {
        return $this->getExpressDelivery() && $this->getDefaultDelivery() && $this->getDefaultDelivery()->getIsExpressDelivery();
    }

    /**
     * Pobiera listę aktywnych dostaw
     *
     * @return stDeliveryFrontendContainer[]
     */
    public function getDeliveries()
    {
        if (is_null($this->deliveries))
        {
            $this->deliveries = $this->doSelectDeliveries();
        }

        return $this->deliveries;
    }

    /**
     *
     * Metoda pomocniczna pobierająca listę aktywnych dostaw
     *
     * @param Criteria $c Dodatkowe kryteria filtrujace liste dostaw
     * @return stDeliveryFrontendContainer[]
     */
    public function doSelectDeliveries(Criteria $c = null)
    {
        if (is_null($c))
        {
            $c = new Criteria();
        }
        else
        {
            $c = clone $c;
        }

        $deliveries = array();

        if (null === $this->getProductInfo()->getAllowedDeliveries())
        {
            $deliveries = array();
        }
        else
        {
            $this->setBaseFilterCriteria($c);

            $this->setCountriesFilterCriteria($c);

            $this->setMaxFilterCriteria($c);

            $c->addAscendingOrderByColumn(DeliveryPeer::POSITION);

            $deliveries = DeliveryPeer::doSelect($c);
        }

        return array_map(array($this, 'deliveryCallback'), $deliveries);
    }

    /**
     * Zwraca kraje dostawy
     *
     * @param boolean $without_max_restrictions
     * @return stDeliveryCountryFrontendContainer[]
     */
    public function getDeliveryCountries($without_max_restrictions = false)
    {
        if (is_null($this->deliveryCountries))
        {
            $c = new Criteria();

            $c->addSelectColumn(CountriesPeer::ID);

            $c->addJoin(CountriesAreaHasCountriesPeer::COUNTRIES_ID, CountriesPeer::ID);

            $c->addJoin(CountriesAreaHasCountriesPeer::COUNTRIES_AREA_ID, CountriesAreaPeer::ID);

            $c->addJoin(CountriesAreaPeer::ID, DeliveryPeer::COUNTRIES_AREA_ID);

            $c->add(CountriesAreaPeer::IS_ACTIVE, true);

            $this->setBaseFilterCriteria($c);

            if (!$without_max_restrictions)
            {
                $this->setMaxFilterCriteria($c);
            }

            $c->addGroupByColumn(CountriesPeer::ID);

            $rs = CountriesPeer::doSelectRS($c);

            $ids = array();

            while ($rs->next())
            {
                list($id) = $rs->getRow();
                $ids[$id] = $id;
            }

            $countries = array();

            foreach (CountriesPeer::doSelectActiveCached() as $country)
            {
                if (isset($ids[$country->getId()]))
                {
                    $countries[] = $this->deliveryCountryCallback($country);
                }
            }

            $this->deliveryCountries = $countries;
        }

        return $this->deliveryCountries;
    }

    /**
     *
     * Jest dostawa domyślna?
     *
     * @return bool
     */
    public function hasDefaultDelivery()
    {
        return (bool) $this->getDefaultDelivery();
    }

    /**
     *
     * Są dostawy?
     *
     * @return bool
     */
    public function hasDeliveries()
    {
        $deliveries = $this->getDeliveries();

        return !empty($deliveries);
    }

    /**
     * Sprawdza czy dostawy nie wykluczają się wzajemnie
     *
     * @return boolean
     */
    public function hasValidAllowCriteria()
    {
        $this->getDeliveries();

        $allowedDeliveries = $this->getProductInfo()->getAllowedDeliveries();

        return !empty($allowedDeliveries);
    }

    /**
     *
     * Zwraca łączny koszt dostawy
     *
     * @return float
     */
    public function getTotalDeliveryCost($with_tax = false, $with_currency = false)
    {
        $totalAmount = 0.00;

        $delivery = $this->getDefaultDelivery();

        if ($delivery)
        {
            $totalAmount += $delivery->getTotalCost($with_tax, $with_currency, true);

            $payment = $delivery->getDefaultPayment();

            if ($payment && !$payment->isFree())
            {
                $totalAmount += $payment->getCost($with_tax, $with_currency);
            }

            if ($this->getIsWeekendDelivery())
            {
                $totalAmount += $delivery->getWeekendDeliveryCost($with_tax, $with_currency);
            }

            if ($this->getIsExpressDelivery())
            {
                $totalAmount += $delivery->getExpressDeliveryCost($with_tax, $with_currency);
            }
        }

        return $totalAmount > 0 ? $totalAmount : 0.00;
    }

    /**
     * Pobiera domyslna dostawe
     *
     * @return stDeliveryFrontendContainer
     */
    public function getDefaultDelivery()
    {
        if (null === $this->delivery)
        {
            $deliveries = $this->getDeliveries();

            $default = $this->getUser()->getAttribute('delivery', null, self::SESSION_NAMESPACE);

            $defaultDelivery = null;

            foreach ($deliveries as $delivery)
            {
                if (null === $defaultDelivery && $delivery->getDelivery()->getIsDefault())
                {
                    $defaultDelivery = $delivery;
                }

                if ($default)
                {
                    if ($default == $delivery->getId())
                    {
                        $this->setDefaultDelivery($delivery);
                        break;
                    }
                }
                elseif ($delivery->getDelivery()->getIsDefault())
                {
                    $this->setDefaultDelivery($delivery);
                    break;
                }
            }

            if (null === $this->delivery && !empty($deliveries))
            {
                $this->setDefaultDelivery($defaultDelivery ? $defaultDelivery : current($deliveries));
            }
        }

        return $this->delivery;
    }

    /**
     * Pobiera domyslny kraj dostawy
     *
     * @return stDeliveryCountryFrontendContainer
     */
    public function getDefaultDeliveryCountry()
    {
        if (is_null($this->deliveryCountry))
        {
            $countries = $this->getDeliveryCountries();

            $default = $this->getUser()->getAttribute(self::SESSION_DELIVERY_COUNTRY_NAME, null, self::SESSION_NAMESPACE);

            foreach ($countries as $country)
            {
                if ($default)
                {
                    if ($default == $country->getId())
                    {
                        $this->setDefaultDeliveryCountry($country);

                        break;
                    }
                }
                else
                {
                    if ($country->getDeliveryCountry()->getIsDefault())
                    {
                        $this->setDefaultDeliveryCountry($country);

                        break;
                    }
                }
            }

            if (is_null($this->deliveryCountry) && !empty($countries))
            {
                $this->setDefaultDeliveryCountry(current($countries));
            }
        }

        return $this->deliveryCountry;
    }

    /**
     *
     * Ustawia kryteria filtrowania dla dostaw - podstawowe kryteria filtrowania
     *
     * @param Criteria $c
     */
    protected function setBaseFilterCriteria($c)
    {
        $c->add(DeliveryPeer::ACTIVE, true);

        $this->dispatcher->notify(new sfEvent($this, 'stDeliveryFrontend.postSetBaseFilterCriteria', array('criteria' => $c)));
    }

    /**
     * Ustawia kryteria filtrowania dla dostaw - krytuje filtrowania wedlug domyslnego kraju
     */
    protected function setCountriesFilterCriteria($c)
    {
        if ($this->getDefaultDeliveryCountry())
        {
            $ca = new Criteria();
            $ca->addSelectColumn(CountriesAreaPeer::ID);
            $ca->addJoin(CountriesAreaHasCountriesPeer::COUNTRIES_AREA_ID, CountriesAreaPeer::ID);
            $ca->add(CountriesAreaHasCountriesPeer::COUNTRIES_ID, $this->getDefaultDeliveryCountry()->getId());
            $ca->add(CountriesAreaPeer::IS_ACTIVE, true);
            $rs = CountriesAreaPeer::doSelectRS($ca);

            while ($rs->next())
            {
                $row = $rs->getRow();
                $ids[] = $row[0];
            }

            $c->add(DeliveryPeer::COUNTRIES_AREA_ID, $ids, Criteria::IN);
        }
    }

    /**
     *
     * Ustawia kryteria filtrowania dla dostaw - maksymalne wartości zamówienia
     *
     * @param Criteria $c
     */
    public function setMaxFilterCriteria($c)
    {
        if (!$this->basket->isEmpty())
        {
            DeliveryPeer::addMaxFilterCriteria($c, $this->getProductInfo());
        }
    }

    /**
     *
     * Pobiera maksymalną dozwoloną kwotę zamówienia
     *
     * @return float
     */
    public function getMaxOrderAmount()
    {
        if (is_null($this->maxOrderAmount))
        {
            $this->maxOrderAmount = $this->getValueByColumn(DeliveryPeer::MAX_ORDER_AMOUNT);
        }

        return $this->maxOrderAmount;
    }

    public function getMinOrderAmount()
    {
        if (is_null($this->minOrderAmount))
        {
            $this->minOrderAmount = $this->getValueByColumn(DeliveryPeer::MIN_ORDER_AMOUNT, false);
        }

        return $this->minOrderAmount;
    }

    /**
     *
     * Pobiera maksymalną dozwoloną wagę zamówienia
     *
     * @return float
     */
    public function getMaxOrderWeight()
    {
        if (is_null($this->maxOrderWeight))
        {
            $this->maxOrderWeight = $this->getValueByColumn(DeliveryPeer::MAX_ORDER_WEIGHT);
        }

        return $this->maxOrderWeight;
    }

    public function getMinOrderWeight()
    {
        if (is_null($this->minOrderWeight))
        {
            $this->minOrderWeight = $this->getValueByColumn(DeliveryPeer::MIN_ORDER_WEIGHT, false);
        }

        return $this->minOrderWeight;
    }

    /**
     *
     * Pobiera maksymlaną dozwoloną ilość sztuk w zamówieniu
     *
     * @return integer
     */
    public function getMaxOrderQuantity()
    {
        if (is_null($this->maxOrderQuantity))
        {
            $this->maxOrderQuantity = $this->getValueByColumn(DeliveryPeer::MAX_ORDER_QUANTITY);
        }

        return $this->maxOrderQuantity;
    }

    public function getMinOrderQuantity()
    {
        if (is_null($this->minOrderQuantity))
        {
            $this->minOrderQuantity = $this->getValueByColumn(DeliveryPeer::MIN_ORDER_QUANTITY, false);
        }

        return $this->minOrderQuantity;
    }

    protected function getValueByColumn($column, $max = true)
    {
        $con = Propel::getConnection();

        $c = new Criteria();

        if ($max)
        {
            $c->addAsColumn('max_value', sprintf('MAX(%s)', $column));
        }
        else
        {
            $c->addAsColumn('max_value', sprintf('MIN(%s)', $column));
        }

        $this->setBaseFilterCriteria($c);

        $this->setCountriesFilterCriteria($c);

        $rs = BasePeer::doSelect($c, $con);

        return $rs->next() ? $rs->get(1) : 0;
    }

    public function getProductInfo(): stDeliveryProductInfoAbstract
    {
        if (null === $this->productInfo)
        {
            $this->productInfo = new stDeliveryBasketProductInfo($this->basket, stCurrency::getInstance(sfContext::getInstance())->get());
        }
           
        return $this->productInfo;
    }

    /**
     *
     * Metoda pomocnicza - Zwraca rozszerzony obiekt Delivery
     *
     * @param DeliveryHasPaymentType $delivery_payment
     * @return stDeliveryFrontendContainer Obiekt rozszerzony
     */
    protected function deliveryCallback($delivery)
    {
        $delivery = new stDeliveryFrontendContainer($this, $delivery);

        return $delivery;
    }

    protected function deliveryCountryCallback($delivery_country)
    {
        $delivery_country = new stDeliveryCountryFrontendContainer($this, $delivery_country);

        return $delivery_country;
    }

    /**
     *
     * Pobiera rozszerzoną dostawę na podstawie id
     *
     * @param integer $id Id dostawy
     * @return stDeliveryFrontendContainer Rozszerzona dostawa
     */
    protected function getDeliveryById($id)
    {
        $deliveries = $this->getDeliveries();

        foreach ($deliveries as $delivery)
        {
            if ($delivery->getId() == $id)
            {
                return $delivery;
            }
        }

        return null;
    }

    /**
     *
     * Pobiera kraj dostawy na podstawie id
     *
     * @param integer $id Id dostawy
     * @return stDeliveryCountryFrontendContainer Kraj dostawy
     */
    protected function getCountryById($id)
    {
        $delivery_countries = $this->getDeliveryCountries();

        foreach ($delivery_countries as $delivery_country)
        {
            if ($delivery_country->getId() == $id)
            {
                return $delivery_country;
            }
        }

        return null;
    }
}

/**
 * Kontener rozszerzający funkcjonalność modelu Delivery
 *
 * @see Delivery
 */
class stDeliveryFrontendContainer
{
    /**
     * @var Delivery
     */
    protected $delivery = null;
    protected $deliveryPayments = null;
    protected $deliveryPayment = null;
    /**
     *
     * @var stDeliveryFrontend
     */
    protected $deliveryFrontend = null;
    protected $additionalCost = null;

    /**
     * Zwraca orginalny obiekt dostawy
     *
     * @return Delivery
     */
    public function getDelivery()
    {
        return $this->delivery;
    }

    public function __construct(stDeliveryFrontend $delivery_frontend, Delivery $delivery)
    {
        $this->delivery = $delivery;
        $this->deliveryFrontend = $delivery_frontend;

        $tax = $delivery_frontend->getProductInfo()->getMaxTax();
        $this->delivery->setTax($tax);
        $this->delivery->resetModified();
    }

    public function getAdditionalCost(bool $withTax = false, bool $withCurrency = false)
    {
        return $this->delivery->getAdditionaCost($this->deliveryFrontend->getProductInfo(), $withTax, $withCurrency);
    }

    public function getService(): ?stDeliveryTypeInterface
    {
        return $this->delivery->getService();
    }

    /**
     *
     * Zwraca aktualnego użytkownika
     *
     * @return stUser
     */
    public function getUser()
    {
        return $this->deliveryFrontend->getUser();
    }

    public function getDefaultCost(bool $withTax = false, bool $withCurrency = false)
    {
        if ($this->isFree())
        {
            return '0.00';
        }

        if ($withTax)
        {
            $cost = $this->delivery->getCostBrutto($withCurrency);
        }
        else
        {
            $cost = $this->delivery->getCostNetto($withCurrency);
        }

        return $cost;
    }

    public function getExpressDeliveryOrderTimeLimit()
    {
        $expressDeliveryTimeLimit = stConfig::getInstance('stDeliveryBackend')->get('express_delivery_order_time_limit');

        return $this->delivery->getExpressDeliveryOrderTimeLimit() ? $this->delivery->getExpressDeliveryOrderTimeLimit() : $expressDeliveryTimeLimit;
    }

    public function getWeekendDeliveryCost(bool $withTax = false, bool $withCurrency = false)
    {
        return $this->delivery->getWeekendDeliveryCost($this->deliveryFrontend->getProductInfo(), $withTax, $withCurrency);
    }

    public function getExpressDeliveryCost(bool $withTax = false, bool $withCurrency = false)
    {
        return $this->delivery->getExpressDeliveryCost($this->deliveryFrontend->getProductInfo(), $withTax, $withCurrency);
    }

    public function getTotalCost(bool $withTax = false, bool $withCurrency = false)
    {
        if ($this->isFree())
        {
            return 0;
        }
    
        return $this->delivery->getTotalCost($this->deliveryFrontend->getProductInfo(), $withTax, $withCurrency);
    }

    /**
     *
     * Jest darmowa?
     *
     * @return bool
     */
    public function isFree()
    {
        return $this->delivery->isFree($this->deliveryFrontend->getProductInfo());
    }

    /**
     *
     * Jest domyślna?
     *
     * @return bool
     */
    public function getIsDefault()
    {
        $delivery = $this->deliveryFrontend->getDefaultDelivery();

        if ($delivery)
        {
            return $delivery->getId() == $this->delivery->getId();
        }

        return $this->delivery->getIsDefault();
    }

    /**
     *
     * Zwraca listę płatności dostawy
     *
     * @return stDeliveryPaymentFrontendContainer[]
     */
    public function getDeliveryPayments()
    {
        if (is_null($this->deliveryPayments))
        {
            $c = new Criteria();

            $this->setFilterCriteria($c);

            $deliveryPayments = [];

            $defaultPayment = $this->getUser()->getAttribute('delivery_payment', null, stDeliveryFrontend::SESSION_NAMESPACE);

            $deliveryHasPayments = DeliveryHasPaymentTypePeer::doSelect($c);

            /**
             * @todo Dostosować przelewy24 do interfejsu stPaymentTypeInterface
             */
            $api = new stPrzelewy24();
            
            if ($api->checkPaymentConfiguration() && $api->hasChannels())
            {
                $additionalPaymentTypes = $api->getBasketPaymentTypes();

                foreach ($additionalPaymentTypes as $paymentType)
                {
                    if ($paymentType->getActive())
                    {
                        $additionalDeliveryPayment = new DeliveryHasPaymentType();
                        $additionalDeliveryPayment->setPaymentType($paymentType);
                        $additionalDeliveryPayment->setDelivery($this);
                        $additionalDeliveryPayment->resetModified();
                        $deliveryHasPayments[] = $additionalDeliveryPayment;
                    }
                }
            }
            
            foreach ($deliveryHasPayments as $deliveryPayment)
            {
                $payment = $deliveryPayment->getPayment();

                if ($payment && $payment->getActive() && $payment->checkPaymentConfiguration() && (!$payment->getHideForWholesale() || $payment->getHideForWholesale() && !stWholesalePluginListener::getWholesaleType()))
                {
                    $currentDeliveryPayment = stDeliveryPaymentFrontendContainer::create($this->deliveryFrontend, $deliveryPayment);
                
                    if ($defaultPayment == $currentDeliveryPayment->getId())
                    {
                        $this->setDefaultPayment($currentDeliveryPayment);
                    }

                    if (null === $defaultPayment && $deliveryPayment->getIsDefault())
                    {
                        $this->setDefaultPayment($currentDeliveryPayment);
                    }

                    $deliveryPayments[] = $currentDeliveryPayment;
                }
            }

            if (null === $this->deliveryPayment && !empty($deliveryPayments))
            {
                $this->setDefaultPayment(current($deliveryPayments));
            }

            $totalAmount = $this->deliveryFrontend->getProductInfo()->getTotalAmount(true) + $this->getTotalCost(true, true); 

            if (!empty($deliveryPayments) && !$this->deliveryPayment->getPayment()->checkPaymentConfiguration($totalAmount))
            {
                $this->setDefaultPayment(current($deliveryPayments));
            }

            foreach ($deliveryPayments as $index => $deliveryPayment)
            {
                if (!$deliveryPayment->getPayment()->checkPaymentConfiguration($totalAmount))
                {
                    unset($deliveryPayments[$index]);
                }
            }

            $this->deliveryPayments = $deliveryPayments;
        }

        return $this->deliveryPayments;
    }

    /**
     *
     * Ustawia kryteria filtrowania dla płatności
     *
     * @param Criteria $c
     */
    protected function setFilterCriteria($c)
    {
        $c->add(DeliveryHasPaymentTypePeer::DELIVERY_ID, $this->getId());

        $c->add(DeliveryHasPaymentTypePeer::IS_ACTIVE, true);

        $c->addAscendingOrderByColumn(DeliveryHasPaymentTypePeer::ID);
    }

    /**
     *
     * Są płatności?
     *
     * @return bool
     */
    public function hasDeliveryPayments()
    {
        $delivery_payments = $this->getDeliveryPayments();

        return !empty($delivery_payments);
    }

    /**
     *
     * @return stDeliveryPaymentFrontendContainer
     */
    public function getDefaultPayment()
    {
        if (null === $this->deliveryPayment)
        {
            $this->getDeliveryPayments();
        }

        return $this->deliveryPayment;
    }

    /**
     *
     * Ustawia domyślną płatność
     *
     * @param int|stDeliveryPaymentFrontendContainer|DeliveryHasPaymentType $deliveryPayment Id lub instancja modelu płatności w zamówieniu
     */
    public function setDefaultPayment($deliveryPayment, $saveToSession = true)
    {
        if ($deliveryPayment)
        {
            if (!is_object($deliveryPayment))
            {
                $this->deliveryPayment = $this->getPaymentById($deliveryPayment);
            }
            else
            {
                $this->deliveryPayment = get_class($deliveryPayment) != 'stDeliveryPaymentFrontendContainer' ? stDeliveryPaymentFrontendContainer::create($this->deliveryFrontend, $deliveryPayment) : $deliveryPayment;
            }

            if ($saveToSession)
            {
                $this->getUser()->setAttribute('delivery_payment', $this->deliveryPayment ? $this->deliveryPayment->getId() : null, stDeliveryFrontend::SESSION_NAMESPACE);
            }
        }
    }

    /**
     *
     * Wykonuje metody obiektu Delivery nie występujące w stDeliveryFrontendContainer
     *
     * @param string $name Nazwa metody
     * @param array $arguments Argumenty metody
     * @return mixed
     */
    public function __call($name, $arguments)
    {
        return call_user_func_array(array($this->delivery, $name), $arguments);
    }

    /**
     *
     * Pobiera rozszerzony obiekt stDeliveryPaymentFrontendContainer na podstawie id
     *
     * @param integer $id
     * @return stDeliveryPaymentFrontendContainer
     */
    protected function getPaymentById($id)
    {
        $payments = $this->getDeliveryPayments();

        foreach ($payments as $payment)
        {
            if ($payment->getId() == $id)
            {
                return $payment;
            }
        }

        return null;
    }
}

/**
 * Kontener rozszerzający funkcjonalność modelu DeliveryHasPaymentType
 *
 * @see DeliveryHasPaymentType
 */
class stDeliveryPaymentFrontendContainer
{

    /**
     * 
     * @var DeliveryHasPaymentType
     */
    protected $deliveryPayment = null;

    protected $deliveryFrontend = null;

   /**
    *
    * Metoda pomocnicza - Zwraca rozszerzony obiekt DeliveryHasPaymentType
    *
    * @param DeliveryHasPaymentType $delivery_payment
    * @return stDeliveryPaymentFrontendContainer Obiekt rozszerzony
    */
   public static function create(stDeliveryFrontend $deliveryFrontend, DeliveryHasPaymentType $deliveryHasPaymentType)
   {
       $proxy = new stDeliveryPaymentFrontendContainer($deliveryFrontend, $deliveryHasPaymentType);

       $proxy->setDelivery($deliveryFrontend->getDefaultDelivery());

       return $proxy;
   }

    public function __construct(stDeliveryFrontend $deliveryFrontend, DeliveryHasPaymentType $deliveryHasPaymentType)
    {
        $this->deliveryFrontend = $deliveryFrontend;
        $this->deliveryPayment = $deliveryHasPaymentType;
    }

    /**
     * Zwraca orginalny obiekt platnosci dostawt
     *
     * @return DeliveryHasPaymentType
     */
    public function getDeliveryPayment()
    {
        return $this->deliveryPayment;
    }

    /**
     * Zwraca klase obslugi typu platnosci
     * 
     * @return stPaymentTypeInterface|null 
     * @throws sfCacheException 
     */
    public function getPaymentTypeApi()
    {
        return $this->deliveryPayment->getPaymentType()->getApiInstance();
    }

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

    public function getSocketName()
    {
        return $this->getPayment() ? 'stPayment_show_' . $this->getPayment()->getModuleName() . '_info' : null;
    }

    public function getSocketNameExists($type = 'component')
    {
        return (bool) array_key_exists($this->getSocketName(), sfConfig::get('st_socket_' . $type));
    }

    public function getName()
    {
        return $this->getPayment() ? $this->getPayment()->getName() : '';
    }

    public function getDescription()
    {
        $description = null;

        if ($this->deliveryPayment->getPayment()->hasChannels())
        {
            $channels = [];

            $totalAmount = $this->deliveryFrontend->getProductInfo()->getTotalAmount() + $this->getCost();

            foreach ($this->deliveryPayment->getPayment()->getChannels($totalAmount) as $channel)
            {
                if ($channel['highlighted'])
                {
                    $description .= '<div class="highlighted-payment"><span class="payment-logo"><img src="'.$channel['logo'].'" alt="'.$channel['name'].'"></span><span class="payment-name">'.$channel['description'].'</span></div>';
                }
                else
                {
                    $channels[] = $channel['name'];
                }
            }
            
            if (!empty($channels))
            {
                $description .= '<div class="text-left">'.implode(', ', $channels).'</div>';
            }
        }

        if (null === $description)
        {
            $description = $this->getPayment() ? $this->getPayment()->getDescription() : '';
        }

        return $description;
    }

    public function getCost(bool $withTax = false, bool $withCurrency = false)
    {
        if ($this->isFree())
        {
            return '0.00';
        }

        if ($this->deliveryPayment->getCostType() == '%')
        {
            $totalAmount = $this->deliveryFrontend->getDefaultDelivery()->getTotalCost($withTax) + $this->deliveryFrontend->getProductInfo()->getTotalAmount();

            $cost = stPrice::percentValue($totalAmount, $this->deliveryPayment->getCost());

            if ($withCurrency)
            {
                $cost = stCurrency::exchange($cost);
            }
        }
        elseif ($withTax)
        {
            $cost = $this->deliveryPayment->getCostBrutto($withCurrency);
        }
        else
        {
            $cost = $this->deliveryPayment->getCostNetto($withCurrency);
        }

        return $cost;
    }

    public function isFree()
    {
        $freeFrom = $this->deliveryPayment->getFreeFrom();

        $totalAmount = $this->deliveryFrontend->getBasket()->getTotalAmount(true);

        return $freeFrom > 0 && $totalAmount >= $freeFrom;
    }

    public function getIsDefault()
    {
        $deliveryPayment = $this->deliveryFrontend->getDefaultDelivery()->getDefaultPayment();

        if ($deliveryPayment)
        {
            return $deliveryPayment->getId() == $this->getId();
        }

        return $this->deliveryPayment->getIsDefault();
    }

    public function hasPaymentLogo(): bool
    {
        return $this->getPaymentTypeApi() instanceof stPaymentTypeInterface;
    }

    public function getPaymentLogo(): ?string
    {
        if ($this->getPaymentTypeApi() instanceof stPaymentTypeInterface)
        {
            return $this->getPaymentTypeApi()->getLogoPath();
        }

        return null;        
    }

    public function __call($name, $arguments)
    {
        return call_user_func_array(array($this->deliveryPayment, $name), $arguments);
    }
}

/**
 * Kontener rozszerzający funkcjonalność modelu Countries
 *
 * @mixin Countries
 */
class stDeliveryCountryFrontendContainer
{

    protected
        $deliveryCountry = null,
        $deliveryFrontend = null;

    public function __construct($delivery_frontend, $delivery_country)
    {
        $this->deliveryCountry = $delivery_country;

        $this->deliveryFrontend = $delivery_frontend;
    }

    /**
     * Zwraca orginalny obiekt kraju dostawy
     *
     * @return Countires
     */
    public function getDeliveryCountry()
    {
        return $this->deliveryCountry;
    }

    public function getIsDefault()
    {
        $delivery_country = $this->deliveryFrontend->getDefaultDeliveryCountry();

        if ($delivery_country)
        {
            return $delivery_country->getId() == $this->deliveryCountry->getId();
        }

        return $this->deliveryCountry->getIsDefault();
    }

    public function __call($name, $arguments)
    {
        return call_user_func_array(array($this->deliveryCountry, $name), $arguments);
    }
}