<?php

namespace App\Main\Repositories;

use App\Main\Attrs\Fillable\ItemAttr;
use App\Main\Attrs\FilterAllAttr;
use App\Main\Attrs\ItemSelect2PaginateAttr;
use App\Main\Attrs\PaginateBuilderAttr;
use App\Main\Attrs\PaginateCollectionAttr;
use App\Main\Builders\PaginateCollectionAttrBuilder;
use App\Main\Contracts\ItemRepositoryInterface;
use App\Main\PaginateSchema\CompositeItem;
use App\Main\PaginateSchema\Item as PaginateSchemaItem;
use App\Models\Item;

class ItemRepository implements ItemRepositoryInterface
{
    public function findByName($name)
    {
        return Item::where('name', $name)->first();
    }

    public function findByNameAndCategoryId($name, $categoryId)
    {
        return Item::where([
            ['name', $name],
            ['item_category_id', $categoryId]
        ])->first();
    }

    public function all(FilterAllAttr $filterAllAttr)
    {
        $item = Item::with('warehouses', 'relatedItems');

        if ($fromDate = $filterAllAttr->getFromDate() and $toDate = $filterAllAttr->getToDate()) {
            $item = $item->whereBetween('created_at', [formatDate($fromDate), formatDate($toDate)]);
        }

        return $item->get();
    }

    public function select2PaginateHasWarehouseAndPriceList($warehouseId, $priceListId, $priceListType, ?string $search): PaginateCollectionAttr
    {
        if (!in_array($priceListType, ["sales", "purchase"])) {
            abort('422');
        }

        $item = Item::selectRaw('id, name as text');

        $item = $item->whereHas('warehouses', function ($q) use ($warehouseId) {
            return $q->where('id', $warehouseId);
        });

        $item = $item->whereHas('priceLists', function ($q) use ($priceListId, $priceListType) {
            return $q->where('id', $priceListId);
        })->with(['priceLists' => function ($q) use ($priceListId, $priceListType) {
            return $q->where('id', $priceListId);
        }]);

        $builder =  (new PaginateCollectionAttrBuilder)
            ->build(
                $item,
                (new PaginateBuilderAttr)
                    ->setSearchKeyword($search),
                new PaginateSchemaItem
            );

        $newCollections = $builder->getCollections()->map(function ($item) {
            $item['price_list_rate'] = $item->priceLists()->first()->pivot->price;

            return $item;
        });

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

    public function select2PaginateHasWarehouses(array $warehouseIds = [], ?string $search = ""): PaginateCollectionAttr
    {
        $item = Item::selectRaw('id, name as text');

        $item = $item->whereHas('warehouses', function ($q) use ($warehouseIds) {
            return $q->whereIn('id', $warehouseIds);
        })->with(['warehouses' => function ($q) use ($warehouseIds) {
            return $q->whereIn('id', $warehouseIds);
        }]);

        return  (new PaginateCollectionAttrBuilder)
            ->build(
                $item,
                (new PaginateBuilderAttr)
                    ->setSearchKeyword($search),
                new PaginateSchemaItem
            );
    }

    public function select2PaginateHasWarehouse($warehouseId, ?string $search): PaginateCollectionAttr
    {
        $item = Item::selectRaw('id, name as text');

        $item = $item->whereHas('warehouses', function ($q) use ($warehouseId) {
            return $q->where('id', $warehouseId);
        })->with(['warehouses' => function ($q) use ($warehouseId) {
            return $q->where('id', $warehouseId);
        }]);

        $builder =  (new PaginateCollectionAttrBuilder)
            ->build(
                $item,
                (new PaginateBuilderAttr)
                    ->setSearchKeyword($search),
                new PaginateSchemaItem
            );

        $newCollections = $builder->getCollections()->map(function ($item) {
            $item['stock_left'] = $item->warehouses()->first()->pivot->stockLeft ?? 0;

            return $item;
        });

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

    public function paginateCompositeItems(PaginateBuilderAttr $paginateBuilderAttr): PaginateCollectionAttr
    {
        $item = Item::isComposite()->with('relatedItems', 'warehouses');

        return (new PaginateCollectionAttrBuilder)
            ->build(
                $item,
                $paginateBuilderAttr,
                new CompositeItem
            );
    }

    public function getRandomIdInWarehouse($warehouseId, $limit = 10)
    {
        $item = Item::whereHas('warehouses', function ($q) use ($warehouseId) {
            return $q->where('id', $warehouseId);
        })->limit($limit)->inRandomOrder();

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

    public function getRandomIdAsRelatedItem($itemId, $limit = 10)
    {
        $item = Item::whereHas('parentItems', function ($q) use ($itemId) {
            return $q->where('id', $itemId);
        })->limit($limit)->inRandomOrder();

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

    public function getRandomId($isComposite = false, $limit = 10)
    {
        $item = Item::limit($limit)->inRandomOrder();

        if ($isComposite) {
            $item = $item->isComposite();
        }

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

    public function select2Paginate(ItemSelect2PaginateAttr $itemSelect2PaginateAttr): PaginateCollectionAttr
    {
        $item = Item::selectRaw('id, name as text');
        /** costum hasil query */
        $customCollection = false;
        
        // hanya item composite yang ditampilkan
        if ($itemSelect2PaginateAttr->getOnlyComposite()) {
            $item = $item->isComposite()->with('warehouses', 'relatedItems.warehouses');
        }

        // hanya item yang memiliki gudang sesuai nilai dari attribute
        if ($warehouseId = $itemSelect2PaginateAttr->getHasWarehouse()) {
            $customCollection = true;
            
            $item = $item->whereHas('warehouses', function ($q) use ($warehouseId) {
                return $q->where('id', $warehouseId);
            });
            // ->with(['warehouses' => function ($q) use ($warehouseId) {
            //     return $q->where('id', $warehouseId);
            // }]);
        } 
        
        // hanya item yang memiliki gudang sesuai nilai "array" dari attribute
        elseif ($warehouseIds = $itemSelect2PaginateAttr->getHasWarehouses()) {
            $item = $item->whereHas('warehouses', function ($q) use ($warehouseIds) {
                return $q->whereIn('id', $warehouseIds);
            })->with(['warehouses' => function ($q) use ($warehouseIds) {
                return $q->whereIn('id', $warehouseIds);
            }]);
        }

        // menambahkan relasi harga pada item sesuai nilai dari attribute
        if ($priceListId = $itemSelect2PaginateAttr->getWithPriceList()
                and $priceListType = $itemSelect2PaginateAttr->getPriceListType()) {
            $customCollection = true;
            
            $item = $item->with(['priceLists' => function ($q) use ($priceListId, $priceListType) {
                return $q->where('id', $priceListId)->where('type', $priceListType);
            }]);
        }

        $builder = (new PaginateCollectionAttrBuilder)
            ->build(
                $item,
                $itemSelect2PaginateAttr,
                new PaginateSchemaItem
            );

        if ($customCollection) {
            $newCollections = $builder->getCollections()->map(function ($item) {
                // $item['stock_left'] = $item->warehouses()->first()->pivot->stockLeft ?? 0;
                $item['price_list_rate'] = $item->priceLists()->first()->pivot->price ?? null;
    
                return $item;
            });

            $builder->setCollections($newCollections);
        }

        return $builder;
    }

    public function fetch($id)
    {
        return Item::with('warehouses', 'relatedItems.warehouses')->findOrFail($id);
    }

    public function create(ItemAttr $itemAttr)
    {
        $item = Item::create([
            'import_id' => $itemAttr->getImportId(),
            'item_category_id' => $itemAttr->getItemCategoryId(),
            'name' => $itemAttr->getName(),
            'sku' => $itemAttr->getSku(),
            'unit' => $itemAttr->getUnit(),
        ]);

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

    public function update(ItemAttr $itemAttr, $id)
    {
        $item = $this->fetch($id);

        $item->update([
            'item_category_id' => $itemAttr->getItemCategoryId(),
            'name' => $itemAttr->getName(),
            'sku' => $itemAttr->getSku(),
            'unit' => $itemAttr->getUnit(),
        ]);

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

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

        return $item->delete();
    }

    public function syncWarehouses($id, $warehouseItemAttrs)
    {
        $item = $this->fetch($id);

        $pivots = [];

        foreach ($warehouseItemAttrs as $warehouseItemAttr) {
            $pivots[$warehouseItemAttr->getWarehouseId()] = [
                'initial_stock' => $warehouseItemAttr->getInitialStock()
            ];
        }

        $item->warehouses()->sync($pivots);

        return Item::with('warehouses')->find($id);
    }

    public function syncRelatedItems($id, $relatedItemAttrs)
    {
        $item = $this->fetch($id);

        $pivots = [];

        foreach ($relatedItemAttrs as $relatedItemAttr) {
            $pivots[$relatedItemAttr->getRelatedItemId()] = [
                'qty' => $relatedItemAttr->getQty()
            ];
        }

        $item->relatedItems()->sync($pivots);

        return Item::with('relatedItems')->find($id);
    }
}