<?php

class stAllegroOrderImportTask extends stTask
{
    /**
     * Allegro config instance
     *
     * @var stConfig
     */
    protected $config = null;

    /**
     * Allegro API instance
     *
     * @var stAllegroApi
     */
    protected $api = null;

    /**
     * Default Tax instance
     *
     * @var Tax
     */
    protected $tax = null;

    /**
     * Default OrderStatus instance
     *
     * @var OrderStatus
     */
    protected $orderStatus = null;

    protected $allegroPaymentType = null;

    /**
     * @var stEventDispatcher
     */
    protected $dispatcher;

    /**
     * Domyślny status dla nowego zamówienia
     * 
     * @var OrderStatus
     */
    protected $defaultOrderStatus;

    protected static $userGroup = null;

    public function count(): int
    {        
        $count = 0;

        if (!stConfig::getInstance('stAllegroBackend')->get('access_token'))
        {
            return 0;
        }

        try
        {
            $fromDate = gmdate('Y-m-d\TH:i:s\Z', time() - 60*60*24 * stConfig::getInstance('stAllegroBackend')->get('import_offset'));
            $api = stAllegroApi::getInstance();
            $forms = $api->getOrderCheckoutForms(null, $fromDate);
            $count = $forms->totalCount;
            $this->setParameter('from_date', $fromDate);
        }
        catch (stAllegroException $e)
        {
            $errors = stAllegroApi::getLastErrors();

            if ($errors)
            {
                foreach ($errors as $error)
                {
                    $this->getLogger()->error($error->message);
                }
            }
            else
            {
                $this->getLogger()->exception($e);
            }
        }

        return $count;
    }

    public function finished()
    {
        $this->clearCache();
    }

    public function execute(int $offset): int
    {
        sfLoader::loadHelpers(array('Helper', 'I18N', 'stUrl', 'stOrder', 'stDate'));

        $response = $this->getApi()->getOrderCheckoutForms($offset, $this->getParameter('from_date'));

        foreach ($response->checkoutForms as $form)
        {
            $order = $this->getOrder($form);

            if (null === $order)
            {
                $order = new Order();
                $order->setClientCulture('pl_PL');
                $order->setOptAllegroCheckoutFormId($form->id);
                $order->setOptAllegroNick($form->buyer->login);
                $order->setOptClientEmail($form->buyer->email);
                $order->setOrderCurrency($this->getOrderCurrency());
                $order->setOrderStatus($this->getDefaultOrderStatus());
                $this->addProducts($order, $form->lineItems);
                $this->addOrderUserDataBilling($order, $form);
                $this->addOrderUserDataDelivery($order, $form);
                $this->addOrderDelivery($order, $form->delivery);
            }

            if ($form->messageToSeller)
            {
                $order->setDescription($this->replace4Bytes($form->messageToSeller));
            }

            $isNew = $order->isNew();

            if (!$isNew && !trim($order->getOrderUserDataDelivery()->getFullName()))
            {
                $address = $form->delivery->address;
                $order->getOrderUserDataDelivery()->setFullName($address->firstName . ' ' . $address->lastName);
                $order->getOrderUserDataDelivery()->save();
            }

            if ($order->isModified())
            {
                $order->save();
            }

            if ($isNew)
            {
                $order->setNumber(OrderPeer::updateOrderNumber($order->getId(), $order->getCreatedAt()));
                $this->addOrderPayment($order, $form->payment);
                $this->addOrderInvoice($order, $form->invoice);
                $this->updateStock($order);

                $this->logImportedOrder($order, $form);
            }

            usleep(100000);

            stNewProductOptions::clearStaticPool();

            $offset++;
        }


        return $offset;
    }

    protected function replace4Bytes($string) 
    {
	    return preg_replace('%(?:
	          \xF0[\x90-\xBF][\x80-\xBF]{2}      # planes 1-3
	        | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
	        | \xF4[\x80-\x8F][\x80-\xBF]{2}      # plane 16
	    )%xs', '', $string);    
	}

    protected function addOrderDelivery(Order $order, $delivery)
    {
        $orderDelivery = new OrderDelivery();

        $orderDelivery->setName('Dostawa Allegro - ' . $delivery->method->name);
        $orderDelivery->setTax($this->getDefaultProductTax());
        $orderDelivery->setCostBrutto($delivery->cost->amount);
        $orderDelivery->setOptAllegroDeliveryMethodId($delivery->method->id);
        $orderDelivery->setOptAllegroDeliverySmart($delivery->smart);

        if (isset($delivery->pickupPoint) && !empty($delivery->pickupPoint))
        {
            $orderDelivery->setPickupPoint($delivery->pickupPoint->id);
        }

        $order->setOrderDelivery($orderDelivery);
    }

    protected function updateStock(Order $order)
    {
        $config = stConfig::getInstance('stProduct');

        if ($config->get('depository_enabled') && $config->get('get_depository') == 'order')
        {
            $c = new Criteria();

            $items = $order->getOrderProducts($c);

            stDepositoryPluginListener::decreaseAll($items);
        }
    }

    protected function addOrderInvoice(Order $order, $invoice)
    {
        if ($invoice->required && $invoice->address) {

            $userData = $order->getOrderUserDataBilling();

            if (isset($invoice->address->naturalPerson) && $invoice->address->naturalPerson) {
                $userData->setFullName($invoice->address->naturalPerson->firstName . ' ' . $invoice->address->naturalPerson->lastName);
            } else {
                $userData->setFullName('');
            }

            $userData->setAddress($invoice->address->street);
            $userData->setTown($invoice->address->city);
            $country = CountriesPeer::retrieveByIsoA2($invoice->address->countryCode);
            $userData->setCountries($country);

            if (isset($invoice->address->company) && $invoice->address->company) {
                if ($invoice->address->company->name)
                {
                    $userData->setCompany($invoice->address->company->name);
                }

                if ($invoice->address->company->taxId)
                {
                    $userData->setVatNumber($invoice->address->company->taxId);
                }
            }

            $userData->setCode($invoice->address->zipCode);

            $userData->save();
        }

        $proforma = stInvoice::createInvoiceProforma($order);

        if ($invoice->required) {
            stInvoice::createInvoiceRequest($order, $proforma);
        }
    }

    protected function addOrderPayment(Order $order, $payment)
    {
        $c = new Criteria();
        $c->add(PaymentTypePeer::MODULE_NAME, 'stAllegro');
        $c->add(PaymentTypePeer::HIDE_MODULE, 1);
        $paymentType = PaymentTypePeer::doSelectOne($c);

        if (null === $paymentType) {
            $paymentType = new PaymentType();
            $paymentType->setHideModule(true);
            $paymentType->setModuleName('stAllegro');
            $paymentType->setActive(false);
            $paymentType->setCulture('pl_PL');
            $paymentType->setName("Płatność w serwisie Allegro");
            $paymentType->save();
        }

        $paymentInstance = stPayment::newPaymentInstance($paymentType->getId(), $order->getOptTotalAmount());

        if ($payment->type == "ONLINE") {
            $paymentInstance->setAllegroPaymentType(strtolower($payment->provider));
        } else {
            $paymentInstance->setAllegroPaymentType(strtolower($payment->type));
        }

        $paymentInstance->setTransactionId($payment->id);

        $ohp = new OrderHasPayment();
        $ohp->setOrder($order);
        $ohp->setPayment($paymentInstance);
        $ohp->save();

        $order->setOrderPayment($paymentInstance);

        if (null !== $payment->paidAmount && $payment->type == "ONLINE") {
            $paymentInstance->setStatus(true);
            $paymentInstance->setPayedAt(strtotime($payment->finishedAt));
        }

        $paymentInstance->save();
    }

    protected function addOrderUserDataBilling(Order $order, $form)
    {
        $userData = new OrderUserDataBilling();

        if ($form->buyer->guest) {
            $address = $form->delivery->address;
            $userData->setFullName($address->firstName . ' ' . $address->lastName);
            $userData->setAddress($address->street);
            $userData->setTown($address->city);
            $country = CountriesPeer::retrieveByIsoA2($address->countryCode);
            $userData->setCountries($country);
            $userData->setCompany($address->companyName);
            $userData->setPhone($address->phoneNumber);
            $userData->setCode($address->zipCode);
        } else {
            $userData->setFullName($form->buyer->firstName . ' ' . $form->buyer->lastName);
            $userData->setAddress($form->buyer->address->street);
            $userData->setTown($form->buyer->address->city);
            $country = CountriesPeer::retrieveByIsoA2($form->buyer->address->countryCode);
            $userData->setCountries($country);
            $userData->setCompany($form->buyer->companyName);
            $userData->setPhone($form->buyer->phoneNumber);
            $userData->setCode($form->buyer->address->postCode);
        }

        $this->getEventDispatcher()->notify(new sfEvent($this, 'stAllegroOrderBar.addOrderUserDataBilling', array('order_user_data_billing' => $userData, 'order' => $order, 'allegro_form' => $form)));

        $order->setOrderUserDataBilling($userData);
    }

    protected function addOrderUserDataDelivery(Order $order, $form)
    {           
        $userData = new OrderUserDataDelivery();

        $address = $form->delivery->address;

        if (isset($form->delivery->pickupPoint) && $form->delivery->pickupPoint)
        {
            $pickupPoint = $form->delivery->pickupPoint;           

            $userData->setFullName($address->firstName . ' ' . $address->lastName);
            $userData->setAddress($pickupPoint->address->street);
            $userData->setTown($pickupPoint->address->city);
            $country = CountriesPeer::retrieveByIsoA2('PL');
            $userData->setCountries($country);
            $userData->setCompany($pickupPoint->name);
            $userData->setPhone($form->delivery->address->phoneNumber);
            $userData->setCode($pickupPoint->address->zipCode);            
        }
        else
        {
            $userData->setFullName($address->firstName . ' ' . $address->lastName);
            $userData->setAddress($address->street);
            $userData->setTown($address->city);
            $country = CountriesPeer::retrieveByIsoA2($address->countryCode);
            $userData->setCountries($country);
            $userData->setCompany($address->companyName);
            $userData->setPhone($address->phoneNumber);
            $userData->setCode($address->zipCode);
        }

        $this->getEventDispatcher()->notify(new sfEvent($this, 'stAllegroOrderBar.addOrderUserDataDelivery', array('order_user_data_delivery' => $userData, 'order' => $order, 'allegro_form' => $form)));

        $order->setOrderUserDataDelivery($userData);
    }

    protected function addProducts(Order $order, $items)
    {
        $offerIds = array();

        $createdAt = 0;

        foreach ($items as $item) {
            $offerIds[] = $item->offer->id;
        }

        $offers = AllegroAuctionPeer::doSelectByAuctionIds($offerIds);

        foreach ($items as $item) {
            $offer = isset($offers[$item->offer->id]) ? $offers[$item->offer->id] : null;

            $product = null;

            if ($offer) {
                $product = $offer->getProduct();
            }

            $orderProduct = new OrderProduct();

            $orderProduct->setVersion(2);

            if ($product) {
                $orderProduct->setProduct($product);

                $offer->getProductOptionsArray();

                $priceModifiers = $product->getPriceModifiers();

                /**
                 * @see BasketProduct::setPriceModifiers()
                 **/
                foreach ($priceModifiers as $index => $value) {
                    if (isset($value['custom']['label'])) {
                        $label = $value['custom']['label'];

                        unset($value['custom']['label']);

                        $value['label'] = $label;

                        $priceModifiers[$index] = $value;
                    }
                }

                $orderProduct->setPriceModifiers($priceModifiers);
            }

            $orderProduct->setQuantity($item->quantity);

            $orderProduct->setCode($product ? $product->getCode() : $item->offer->id);

            $orderProduct->setName($this->getConfig()->get('import_product_name', 'offer') == 'offer' || !$product ? $item->offer->name : $product->getName());

            $orderProduct->setPriceNetto(null);

            $orderProduct->setAllegroAuctionId($item->offer->id);

            $orderProduct->setPriceBrutto($item->price->amount);

            if ($product) {
                $orderProduct->setImage($product->getOptImage());
            }

            $orderProduct->setTax($product ? $product->getTax() : $this->getDefaultProductTax());

            $this->getEventDispatcher()->notify(new sfEvent($this, 'stAllegroOrderBar.addProducts', array('order_product' => $orderProduct, 'order' => $order, 'auction' => $offer, 'allegro_item' => $item)));

            $order->addOrderProduct($orderProduct);

            $time = strtotime($item->boughtAt);

            if ($createdAt < $time) {
                $createdAt = $time;
            }
        }

        $order->setCreatedAt($time);
    }

    public function logImportedOrder(Order $order, $form)
    {
        $offers = array();

        foreach ($form->lineItems as $item) {
            $offers[] = $item->offer->id;
        }

        $this->getLogger()->info('Nowe zamówienie %order% (oferty: %offers%) złożone %created_at% na kwotę %amount%', array(
            '%order%' => sprintf('[%s](%s)', $order->getNumber(), st_url_for('@stOrder?action=edit&id=' . $order->getId())),
            '%offers%' => implode(', ', $offers), 
            '%created_at%' => st_format_date($order->getCreatedAt()),
            '%amount%' => st_order_price($order->getOptTotalAmount(), $order->getOrderCurrency()),
        ));
    }

    /**
     * Pobiera zamówienia na podstawie formularza pozakupowego Allegro
     *
     * @param stdClass $form
     * @return Order
     */
    protected function getOrder($form)
    {
        $c = new Criteria();
        $c->add(OrderPeer::OPT_ALLEGRO_CHECKOUT_FORM_ID, $form->id);
        return OrderPeer::doSelectOne($c);
    }

    public function getOrderCurrency()
    {
        $orderCurrency = new OrderCurrency();
        $orderCurrency->setName('Polski złoty');
        $orderCurrency->setShortcut('PLN');
        $orderCurrency->setExchange(1);
        $orderCurrency->setFrontSymbol(null);
        $orderCurrency->setBackSymbol('zł');
        $orderCurrency->save();
        return $orderCurrency;
    }

    protected static function getUserGroup()
    {
        if (null === self::$userGroup) {
            $c = new Criteria();
            $c->add(sfGuardGroupPeer::NAME, 'user');
            self::$userGroup = sfGuardGroupPeer::doSelectOne($c);
        }

        return self::$userGroup;
    }

    protected function getAllegroPaymentType()
    {
        if (null === $this->allegroPaymentType) {
            $c = new Criteria();
            $c->add(PaymentTypePeer::MODULE_NAME, 'stAllegro');
            $c->add(PaymentTypePeer::HIDE_MODULE, 1);
            $paymentType = PaymentTypePeer::doSelectOne($c);

            if (null === $paymentType) {
                $paymentType = new PaymentType();
                $paymentType->setHideModule(true);
                $paymentType->setModuleName('stAllegro');
                $paymentType->setActive(false);
                $paymentType->setCulture('pl_PL');
                $paymentType->setName("Płatność w serwisie Allegro");
                $paymentType->save();
            }

            $this->allegroPaymentType = $paymentType;
        }

        return $this->allegroPaymentType;
    }

    protected function getApi(): stAllegroApi
    {
        return stAllegroApi::getInstance();
    }

    public function getConfig(): stConfig
    {
        return stConfig::getInstance('stAllegroBackend');
    }

    public function getDefaultOrderStatus(): OrderStatus
    {
        if (null === $this->defaultOrderStatus)
        {
            $this->defaultOrderStatus = OrderStatusPeer::retrieveDefaultPendingStatus();
        }

        return $this->defaultOrderStatus;
    }

    public function getDefaultProductTax(): Tax
    {
        return TaxPeer::retrieveByTax(23);
    }

    public function getEventDispatcher(): stEventDispatcher
    {
        return stEventDispatcher::getInstance();
    }
}