<?php

namespace App\Main\Repositories;

use App\Main\Attrs\Fillable\ReportCoaFilterAttr;
use App\Main\Attrs\Fillable\SaleOrderAttr;
use App\Main\Attrs\PaginateBuilderAttr;
use App\Main\Attrs\PaginateCollectionAttr;
use App\Main\Attrs\SaleOrderSelect2PaginateAttr;
use App\Main\Attrs\FilterAllAttr;
use App\Main\Builders\PaginateCollectionAttrBuilder;
use App\Main\Contracts\SaleOrderRepositoryInterface;
use App\Main\PaginateSchema\SaleOrder as PaginateSchemaSaleOrder;
use App\Models\SaleOrder;

class SaleOrderRepository implements SaleOrderRepositoryInterface
{
    public function all(FilterAllAttr $transactionAllAttr)
    {
        $saleOrder = SaleOrder::with('items', 'customer', 'warehouse', 'priceList', 'chartOfAccount');

        if ($fromDate = $transactionAllAttr->getFromDate() and $toDate = $transactionAllAttr->getToDate()) {
            $saleOrder = $saleOrder->whereBetween('transaction_date', [formatDate($fromDate), formatDate($toDate)]);
        }

        return $saleOrder->get();
    }

    public function paginateReceivable(PaginateBuilderAttr $paginateBuilderAttr, ReportCoaFilterAttr $reportCoaFilterAttr): PaginateCollectionAttr
    {
        $saleOrder = lessAndBetweenDateQuery(
            SaleOrder::unpaid()->with('customer'),
            $reportCoaFilterAttr->getLessDate(),
            $reportCoaFilterAttr->getBetweenTwoDates(),
            'transaction_date'
        );

        return (new PaginateCollectionAttrBuilder)
        ->build(
            $saleOrder,
            $paginateBuilderAttr,
            new PaginateSchemaSaleOrder
        );
    }

    public function sumItemTax(ReportCoaFilterAttr $reportCoaFilterAttr)
    {
        $saleOrder = lessAndBetweenDateQuery(
            SaleOrder::query(),
            $reportCoaFilterAttr->getLessDate(),
            $reportCoaFilterAttr->getBetweenTwoDates(),
            'transaction_date'
        );
        return $saleOrder->sumItemTax($reportCoaFilterAttr)->first()->item_tax ?? 0;
    }

    public function sumTotalAmountDue(?ReportCoaFilterAttr $reportCoaFilterAttr)
    {
        $saleOrder = lessAndBetweenDateQuery(
            SaleOrder::unpaid(),
            $reportCoaFilterAttr ? $reportCoaFilterAttr->getLessDate() : null,
            $reportCoaFilterAttr ? $reportCoaFilterAttr->getBetweenTwoDates() : null,
            'transaction_date'
        );
        
        return $saleOrder->sumTotalAmountDue($reportCoaFilterAttr)->first()->total_amount_due ?? 0;
    }

    public function getRandomIds($limit = 10)
    {
        $saleOrder = SaleOrder::select('id')->limit($limit)->inRandomOrder();

        return array_keys($saleOrder->get()->toArray(), 'id') ?? null;
    }

    public function getRandomId($limit = 10)
    {
        $saleOrder = SaleOrder::limit($limit)->inRandomOrder();

        return $saleOrder->first()->id ?? null;
    }

    public function getLastRow()
    {
        return SaleOrder::orderBy('id', 'desc')->first();
    }

    public function updateStatus($id, $status)
    {
        $saleOrder = $this->fetch($id);

        $saleOrder->update([
            'status' => $status
        ]);

        return $this->fetch($id);
    }

    public function select2Paginate(SaleOrderSelect2PaginateAttr $saleOrderSelect2PaginateAttr): PaginateCollectionAttr
    {
        $saleOrder = SaleOrder::selectRaw('id, no_so as text, discount, postal_fee_price');

        if ($customerId = $saleOrderSelect2PaginateAttr->getHasCustomer()) {
            $saleOrder = $saleOrder->where('customer_id', $customerId);
        }

        if ($saleOrderSelect2PaginateAttr->getUnpaidOnly()) {
            $saleOrder = $saleOrder->unpaid(
                $saleOrderSelect2PaginateAttr->getExceptPaymentId()
            );
        }

        if ($saleOrderSelect2PaginateAttr->getNotHaveInvoice()) {
            if ($exceptInvoiceId = $saleOrderSelect2PaginateAttr->getExceptInvoiceId()) {
                $saleOrder = $saleOrder->whereDoesntHave('invoice', function ($q) use ($exceptInvoiceId) {
                    return $q->where('id', '<>', $exceptInvoiceId);
                });
            } else {
                $saleOrder = $saleOrder->whereDoesntHave('invoice');
            }
        }

        return (new PaginateCollectionAttrBuilder)
            ->build(
                $saleOrder,
                $saleOrderSelect2PaginateAttr,
                new PaginateSchemaSaleOrder
            );
    }

    public function paginate(PaginateBuilderAttr $paginateBuilderAttr): PaginateCollectionAttr
    {
        return (new PaginateCollectionAttrBuilder)
            ->build(
                SaleOrder::with('customer'),
                $paginateBuilderAttr,
                new PaginateSchemaSaleOrder
            );

        // $newCollections = $builder->getCollections()->map(function ($query) {
        //     $subtotal = 0;
        //     foreach ($query->items ?? [] as $item) {
        //         $explode = explode("-", $item->pivot->subtotal);
        //         if (count($explode) > 1) {
        //             $subtotal = $subtotal - numberOnly($explode[1]);
        //         } else {
        //             $subtotal = $subtotal + numberOnly($explode[0]);
        //         }
        //     }

        //     $total = (int) $subtotal - (int) $query->discount + (int) $query->postal_fee_price;

        //     $query['testing'] = (int) $total;

        //     return $query;
        // });

        // return $builder->setCollections($newCollections);
    }

    public function fetch($id)
    {
        $res = SaleOrder::with('items', 'customer', 'warehouse', 'priceList', 'chartOfAccount', 'discountAccount', 'postalFeeAccount', 'customerAddress')->findOrFail($id);

        // $subtotal = 0;
        // foreach ($res->items ?? [] as $item) {
            // $explode = explode("-", $item->pivot->subtotal);
            // if (count($explode) > 1) {
            //     $subtotal = $subtotal - numberOnly($explode[1]);
            // } else {
            //     $subtotal = $subtotal + numberOnly($explode[0]);
            // }
        // }

        // $total = (int) $subtotal - (int) $res->discount + (int) $res->postal_fee_price;

        // $res->amount = (int) $total;

        return $res;
    }

    public function create(SaleOrderAttr $saleOrderAttr, $noPo)
    {
        $saleOrder = SaleOrder::create([
            'no_so' => $noPo,
            'customer_id' => $saleOrderAttr->getCustomerId(),
            'customer_address_id' => $saleOrderAttr->getCustomerAddressId(),
            'transaction_date' => formatDate($saleOrderAttr->getTransactionDate()),
            'delivery_date' => formatDate($saleOrderAttr->getDeliveryDate()),
            'chart_of_account_id' => $saleOrderAttr->getChartOfAccountId(),
            'warehouse_id' => $saleOrderAttr->getWarehouseId(),
            'price_list_id' => $saleOrderAttr->getPriceListId(),
            'postal_fee_account_id' => $saleOrderAttr->getPostalFeeAccountId(),
            'postal_fee_price' => numberOnly($saleOrderAttr->getPostalFeePrice()),
            'discount_account_id' => $saleOrderAttr->getDiscountAccountId(),
            'discount' => numberOnly($saleOrderAttr->getDiscount()),
            'status' => $saleOrderAttr->getStatus() ?? 'draft'
        ]);

        return $this->fetch($saleOrder->id);
    }

    public function update(SaleOrderAttr $saleOrderAttr, $id)
    {
        $saleOrder = SaleOrder::find($id);

        $saleOrder->update([
            'customer_id' => $saleOrderAttr->getCustomerId(),
            'customer_address_id' => $saleOrderAttr->getCustomerAddressId(),
            'transaction_date' => formatDate($saleOrderAttr->getTransactionDate()),
            'delivery_date' => formatDate($saleOrderAttr->getDeliveryDate()),
            'chart_of_account_id' => $saleOrderAttr->getChartOfAccountId(),
            'warehouse_id' => $saleOrderAttr->getWarehouseId(),
            'price_list_id' => $saleOrderAttr->getPriceListId(),
            'postal_fee_account_id' => $saleOrderAttr->getPostalFeeAccountId(),
            'postal_fee_price' => numberOnly($saleOrderAttr->getPostalFeePrice()),
            'discount_account_id' => $saleOrderAttr->getDiscountAccountId(),
            'discount' => numberOnly($saleOrderAttr->getDiscount()),
        ]);

        return $this->fetch($id);
    }

    public function delete($id)
    {
        $saleOrder = $this->fetch($id);

        $saleOrder->delete();

        return $saleOrder;
    }

    public function syncItems($id, array $itemSaleOrderAttrs)
    {
        $saleOrder = $this->fetch($id);

        $pivots = [];

        foreach ($itemSaleOrderAttrs as $itemSaleOrderAttr) {
            $pivots[$itemSaleOrderAttr->getItemId()] = [
                // 'warehouse_id' => $itemSaleOrderAttr->getWarehouseId(),
                'rate' => numberOnly($itemSaleOrderAttr->getRate()),
                'qty' => qtyFormat($itemSaleOrderAttr->getQty()),
                'tax_id' => $itemSaleOrderAttr->getTaxId(),
                'tax_rate' => numberOnly($itemSaleOrderAttr->getTaxRate()),
                'subtotal' => numberOnly($itemSaleOrderAttr->getSubtotal()),
                'description' => $itemSaleOrderAttr->getDescription(),
                'sign' => $itemSaleOrderAttr->getSign(),
                'tax_value' => numberOnly($itemSaleOrderAttr->getTaxValue())
            ];
        }

        $saleOrder->items()->sync($pivots);

        return SaleOrder::with('items')->find($id);
    }

    public function fetchWithInvoice($id)
    {
        return SaleOrder::with('invoice')->find($id);
    }
}