<?php

namespace App\Main\Repositories;

use App\Http\Resources\PaginateCollection;
use App\Main\Attrs\Fillable\PurchaseOrderAttr;
use App\Main\Attrs\Fillable\ReportCoaFilterAttr;
use App\Main\Attrs\PaginateBuilderAttr;
use App\Main\Attrs\PaginateCollectionAttr;
use App\Main\Attrs\PurchaseOrderSelect2PaginateAttr;
use App\Main\Attrs\FilterAllAttr;
use App\Main\Builders\PaginateCollectionAttrBuilder;
use App\Main\Contracts\PurchaseOrderRepositoryInterface;
use App\Main\PaginateSchema\PurchaseOrder as PaginateSchemaPurchaseOrder;
use App\Models\PurchaseOrder;
use App\Models\PurchaseOrderMaterial;
use App\Models\PurchaseOrderVendor;
use App\Models\PurchaseOrderManual;
use App\Models\PurchaseRequestMachineDetail;
use App\Models\PurchaseRequestMachineManualDetail;
use App\Models\PurchaseRequestMaterial;
use App\Models\PurchaseRequestVendor;
use App\Models\PurchaseRequestManual;
use App\Models\PurchaseRequestManualDetail;
use App\Models\PurchaseRequestMaterialDetail;
use App\Models\PurchaseRequestOtherCostDetail;
use App\Models\PurchaseRequestOtherCostManualDetail;
use App\Models\PurchaseRequestVendorDetail;
use App\Models\PurchaseRequestVendorManualDetail;
use Illuminate\Support\Facades\DB;
use PDO;

class PurchaseOrderRepository implements PurchaseOrderRepositoryInterface
{
    public function all(FilterAllAttr $transactionAllAttr)
    {
        $purchaseOrder = PurchaseOrder::with('items', 'supplier', 'warehouse', 'priceList', 'chartOfAccount');

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

        return $purchaseOrder->get();
    }

    public function paginatePayable(PaginateBuilderAttr $paginateBuilderAttr, ReportCoaFilterAttr $reportCoaFilterAttr): PaginateCollectionAttr
    {
        $purchaseOrder = lessAndBetweenDateQuery(
            PurchaseOrder::unpaid()->with('supplier'),
            $reportCoaFilterAttr->getLessDate(),
            $reportCoaFilterAttr->getBetweenTwoDates(),
            'transaction_date'
        );

        return (new PaginateCollectionAttrBuilder)
            ->build(
                $purchaseOrder,
                $paginateBuilderAttr,
                new PaginateSchemaPurchaseOrder
            );
    }

    public function sumItemTax(ReportCoaFilterAttr $reportCoaFilterAttr)
    {
        $purchaseOrder = lessAndBetweenDateQuery(
            PurchaseOrder::query(),
            $reportCoaFilterAttr->getLessDate(),
            $reportCoaFilterAttr->getBetweenTwoDates(),
            'transaction_date'
        );

        return $purchaseOrder->sumItemTax($reportCoaFilterAttr)->first()->item_tax ?? 0;
    }

    public function sumTotalAmountDue(?ReportCoaFilterAttr $reportCoaFilterAttr)
    {
        $purchaseOrder = lessAndBetweenDateQuery(
            PurchaseOrder::query(),
            $reportCoaFilterAttr ? $reportCoaFilterAttr->getLessDate() : null,
            $reportCoaFilterAttr ? $reportCoaFilterAttr->getBetweenTwoDates() : null,
            'transaction_date'
        );

        return $purchaseOrder->unpaid()->sumTotalAmountDue($reportCoaFilterAttr)->first()->total_amount_due ?? 0;
    }

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

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

    public function getRandomId($limit = 10)
    {
        $purchaseOrder = PurchaseOrder::limit($limit)->inRandomOrder();

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

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

    public function updateStatus($id, $status)
    {
        $purchaseOrder = PurchaseOrder::with('purchaseOrderMaterials', 'purchaseOrderVendors')->where('id', $id)->first();

        if ($purchaseOrder->approved === '0') {
            return "harus di setujui oleh General Manager atau Director";
        }

        $purchaseOrderMaterial = PurchaseOrderMaterial::where('purchase_order_id', $id)
            ->where('ref_pr', $purchaseOrder->purchase_request_id)
            ->get();

        $purchaseOrderVendor = PurchaseOrderVendor::where('purchase_order_id', $id)
            ->where('ref_pr', $purchaseOrder->purchase_request_id)
            ->get();

        $purchaseOrderManual = PurchaseOrderManual::where('purchase_order_id', $id)
            ->where('ref_pr', $purchaseOrder->purchase_request_id)
            ->get();

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

        if ($status == 'received') {
            foreach ($purchaseOrder->purchaseOrderMaterials as $material) {
                $purchaseOrderMaterial = PurchaseOrderMaterial::where('purchase_order_id', $id)
                    ->where('material_id', $material->material_id)
                    ->where('ref_pr', $purchaseOrder->purchase_request_id)
                    ->get();

                foreach ($purchaseOrderMaterial as $detail) {
                    $poUsedQty = $detail->temporary_used_qty;
                    $purchaseRequest = PurchaseRequestMaterial::where([
                        ['purchase_request_id', '=', $material->ref_pr],
                        ['material_id', '=', $material->material_id]
                    ])->first();

                    if ((int) $purchaseRequest->used_qty > (int) $poUsedQty) {
                        return "Qty Telah Melebihi Batas";
                    } else {
                        $purchaseRequest->update([
                            "used_qty" =>  (int)$poUsedQty
                        ]);
                    }
                }
            }

            foreach ($purchaseOrder->purchaseOrderVendors as $vendor) {
                $purchaseOrderVendor = PurchaseOrderVendor::where('purchase_order_id', $id)
                    ->where('vendor_product_id', $vendor->vendor_product_id)
                    ->where('ref_pr', $purchaseOrder->purchase_request_id)
                    ->get();

                foreach ($purchaseOrderVendor as $detailVendor) {
                    $poUsedQtyVendor = $detailVendor->temporary_used_qty;
                    $purchaseRequestVendor = PurchaseRequestVendor::where([
                        ['purchase_request_id', '=', $vendor->ref_pr],
                        ['vendor_product_id', '=', $vendor->vendor_product_id]
                    ])->first();

                    if ((int) $purchaseRequestVendor->used_qty > (int) $poUsedQtyVendor) {
                        return "Qty Telah Melebihi Batas";
                    } else {
                        $purchaseRequestVendor->update([
                            "used_qty" =>  (int)$poUsedQtyVendor
                        ]);
                    }
                }
            }

            foreach ($purchaseOrder->purchaseOrderManuals as $manual) {
                $purchaseOrderManual = PurchaseOrderManual::where([
                    ['ref_pr', '=', $purchaseOrder->purchase_request_id],
                    ['manual_id', '=', $manual->manual_id],
                    ['purchase_order_id', '=', $id]
                ])->get();

                foreach ($purchaseOrderManual as $detailManual) {
                    $poUsedQtyManual = $detailManual->temporary_used_qty;

                    $purchaseRequestManual = PurchaseRequestManual::where([
                        ['purchase_request_id', '=', $manual->ref_pr],
                        ['material_id', '=', $manual->manual_id]
                    ])->orWhere([
                        ['purchase_request_id', '=', $manual->ref_pr],
                        ['id', '=', $manual->manual_id]
                    ])->first();

                    if ((int) $purchaseRequestManual->used_qty > (int) $poUsedQtyManual) {
                        return "Qty Telah Melebihi Batas";
                    } else {
                        $purchaseRequestManual->update([
                            "used_qty" => (int) $poUsedQtyManual
                        ]);
                    }
                }
            }
        }

        return $purchaseOrder;
    }

    public function select2Paginate(PurchaseOrderSelect2PaginateAttr $purchaseOrderSelect2PaginateAttr): PaginateCollectionAttr
    {
        // $purchaseOrder = PurchaseOrder::selectRaw('id, no_po as text')->with('purchaseOrderMaterials', 'purchaseOrderVendors', 'purchaseOrderManuals');

        // testing pake yg ini
        // $purchaseOrder = PurchaseOrder::selectRaw('no_po as text, *')
        $purchaseOrder = PurchaseOrder::select('*', 'no_po as text')->with(
            'purchaseOrderMaterials',
            'purchaseOrderVendors',
            'purchaseOrderMachines',
            'purchaseOrderOtherCosts',
            'project',
            'purchaseOrderManuals',
            'purchaseOrderVendorManuals',
            'purchaseOrderMachineManuals',
            'purchaseOrderOtherCostManuals',
            'purchaseRequest',
            'supplier',
            'additionalCosts'
        );

        if ($supplierId = $purchaseOrderSelect2PaginateAttr->getHasSupplier()) {
            $purchaseOrder = $purchaseOrder->where('supplier_id', $supplierId);
        }

        if ($projectId = $purchaseOrderSelect2PaginateAttr->getHasProject()) {
            $purchaseOrder = $purchaseOrder->where('project_id', $projectId);
        }

        // $check = 0;
        if ($purchaseOrderSelect2PaginateAttr->getUnpaidOnly()) {
            // Old
            if ($purchaseOrderSelect2PaginateAttr->getReferences() != 'project') { //gua gatau ini kenapa kondisinya begini, tapi ini penyebabnya
                // if ($purchaseOrderSelect2PaginateAttr->getReferences()) { //gua hilangin kondisinya sebagai fix sementara sampe tau flownya.
                $purchaseOrder = $purchaseOrder->unpaid(
                    $purchaseOrderSelect2PaginateAttr->getExceptPaymentId()
                );
            } else {
                // $check = 1;
                $purchaseOrder = $purchaseOrder->unpaidForProject(
                    $purchaseOrderSelect2PaginateAttr->getExceptPaymentId()
                );
            }
        }

        if ($purchaseOrderSelect2PaginateAttr->getNotHaveBill()) {
            if ($exceptBillId = $purchaseOrderSelect2PaginateAttr->getExceptBillId()) {
                $purchaseOrder = $purchaseOrder->whereDoesntHave('bill', function ($q) use ($exceptBillId) {
                    return $q->where('id', '<>', $exceptBillId);
                });
            } else {
                $purchaseOrder = $purchaseOrder->whereDoesntHave('bill');
            }
        }

        return (new PaginateCollectionAttrBuilder)
            ->build(
                $purchaseOrder,
                $purchaseOrderSelect2PaginateAttr,
                new PaginateSchemaPurchaseOrder
            );

        // $builder = (new PaginateCollectionAttrBuilder)
        //     ->build(
        //         $purchaseOrder,
        //         $purchaseOrderSelect2PaginateAttr,
        //         new PaginateSchemaPurchaseOrder
        //     );

        // kondisi untuk eliminasi yg sudah lunas
        // if ($check == 1) {
        //     $newCollections = $builder->getCollections()->filter(function ($po) {
        //         // Asumsikan 'amount_project' dan 'payment_amount' adalah atribut model
        //         return $po->amount_project != $po->payment_amount;
        //     });
        // } else {
        // $newCollections = $builder->getCollections();
        // }

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

    public function paginate(PaginateBuilderAttr $paginateBuilderAttr): PaginateCollectionAttr
    {
        $check = PurchaseOrder::with(['project.deal', 'supplier', 'additionalCosts', 'purchaseOrderMaterials' => function ($query) {
            $query->with(['supplier' => function ($query) {
                $query->selectRaw('id, name, phone_number, email, address, type');
            }]);
            $query->with(['purchaseOrderMaterialDetails' => function ($query) {
                $query->with(['unitPrice' => function ($query) {
                    $query->with(['materials']);
                }]);
            }]);
            $query->with(['material' => function ($query) {
                $query->selectRaw('id, name, unit, price');
                $query->with(['suppliers' => function ($query) {
                    $query->selectRaw('id, name, phone_number, email, address, type');
                    $query->whereHas('purchaseOrderMaterials');
                }]);
            }]);
        }, 'purchaseOrderVendors' => function ($query) {
            $query->with(['supplier' => function ($query) {
                $query->selectRaw('id, name, phone_number, email, address, type');
            }]);
            $query->with(['vendorProduct' => function ($query) {
                $query->selectRaw('id, name, dimensional_spesification, unit, price');
                $query->with(['suppliers' => function ($query) {
                    $query->selectRaw('id, name, phone_number, email, address, type');
                    $query->whereHas('purchaseOrderVendors');
                }]);
            }]);
        }, 'purchaseOrderVendorManuals' => function ($query) {
            $query->with('vendor', 'purchaseOrderVendorManualDetails.unitPrice');
        }, 'purchaseOrderManuals' => function ($query) {
            $query->with('purchaseOrderManualDetails.unitPrice');
        }, 'purchaseOrderOtherCosts' => function ($query) {
            $query->with('otherCost', 'purchaseOrderOtherCostDetails.unitPrice');
        }, 'purchaseOrderOtherCostManuals' => function ($query) {
            $query->with('otherCost', 'purchaseOrderOtherCostManualDetails.unitPrice');
        }, 'purchaseOrderMachines' => function ($query) {
            $query->with('asset', 'purchaseOrderMachineDetails.unitPrice');
        }, 'purchaseOrderMachineManuals' => function ($query) {
            $query->with('asset', 'purchaseOrderMachineManualDetails.unitPrice');
        }, 'purchaseRequest']);

        if (isset(request()->tab)) {
            $check->where('reference', request()->tab);
        }

        return (new PaginateCollectionAttrBuilder)
            ->build(
                $check,
                $paginateBuilderAttr,
                new PaginateSchemaPurchaseOrder
            );
    }

    public function fetch($id)
    {
        $purchaseOrder = PurchaseOrder::with(['purchaseOrderMaterials' => function ($query) {
            $query->with(['supplier' => function ($query) {
                $query->selectRaw('id, name, phone_number, email, address, type');
            }]);
            $query->with(['purchaseOrderMaterialDetails' => function ($query) {
                $query->with(['unitPrice' => function ($query) {
                    $query->with(['materials']);
                }]);
            }]);
            $query->with(['material' => function ($query) {
                $query->selectRaw('id, name, unit, price');
                $query->with(['suppliers' => function ($query) {
                    $query->selectRaw('id, name, phone_number, email, address, type');
                    $query->whereHas('purchaseOrderMaterials');
                }]);
            }]);
        }, 'purchaseOrderVendors' => function ($query) {
            $query->with(['supplier' => function ($query) {
                $query->selectRaw('id, name, phone_number, email, address, type');
            }]);
            $query->with(['vendorProduct' => function ($query) {
                $query->selectRaw('id, name, dimensional_spesification, unit, price');
                $query->with(['suppliers' => function ($query) {
                    $query->selectRaw('id, name, phone_number, email, address, type');
                    $query->whereHas('purchaseOrderVendors');
                }]);
            }]);
        }, 'purchaseOrderVendorManuals' => function ($query) {
            $query->with(['purchaseOrderVendorManualDetails' => function ($query) {
                $query->select('id', 'purchase_order_vendor_manual_id', 'unit_price_id', 'qty');
                $query->with(['unitPrice']);
            }]);
            $query->with(['vendor' => function ($query) {
                $query->selectRaw('id, name, dimensional_spesification, unit, price');
            }]);
        }, 'purchaseOrderManuals', 'purchaseRequest', 'project.deal.budgetPlan.order', 'chartOfAccount', 'priceList', 'warehouse', 'items', 'supplier', 'additionalCosts'])->findOrFail($id);


        $skkNumber = $purchaseOrder->project->deal->skk_number ?? null;
        $customerName = $purchaseOrder->project->deal->customer_name ?? null;
        $customerPhone = $purchaseOrder->project->deal->budgetPlan->order->customer_phone ?? null;

        $array = [];
        foreach ($purchaseOrder->project->deal->budgetPlan->order->orderServices ?? [] as $orderService) {
            $array[] = $orderService->service->title ?? null;
        }

        $serviceName = join(", ", $array);

        $purchaseOrder['project_name'] = $skkNumber . ' | ' . $customerName . ' | ' . $customerPhone . ' | ' . $serviceName;

        return $purchaseOrder;
    }

    public function create(PurchaseOrderAttr $purchaseOrderAttr, $noPo)
    {
        $purchaseOrder = PurchaseOrder::create([
            'no_po' => $noPo,
            'reference' => $purchaseOrderAttr->getReference(),
            'transaction_date' => formatDate($purchaseOrderAttr->getTransactionDate()),
            'delivery_date' => formatDate($purchaseOrderAttr->getDeliveryDate()),
            'tempo' => $purchaseOrderAttr->getTempo(),
            'chart_of_account_id' => $purchaseOrderAttr->getChartOfAccountId(),
            'warehouse_id' => $purchaseOrderAttr->getWarehouseId(),
            'supplier_id' => $purchaseOrderAttr->getSupplierId(),
            'price_list_id' => $purchaseOrderAttr->getPriceListId(),
            'status' => $purchaseOrderAttr->getStatus() ?? 'draft',
            'project_id' => $purchaseOrderAttr->getProjectId(),
            'purchase_request_id' => $purchaseOrderAttr->getPurchaseRequestId(),
            'po_product' => $purchaseOrderAttr->getPoProduct(),
            'payment_system' => $purchaseOrderAttr->getPaymentSystem(),
            'note_payment' => $purchaseOrderAttr->getNotePayment(),
            'po_date' => $purchaseOrderAttr->getPoDate()
        ]);

        return $this->checkReference($purchaseOrder->id);
    }

    public function update(PurchaseOrderAttr $purchaseOrderAttr, $id)
    {
        $purchaseOrder = $this->checkReference($id);
        $update = PurchaseOrder::findOrFail($purchaseOrder->id);

        if ($update->approved == 2 || $update->approved == 3) {
            return (object)[
                "success" => false,
                "message" => "has been approved by the GM/Director"
            ];
        }

        $update->update([
            'reference' => $purchaseOrderAttr->getReference(),
            'transaction_date' => formatDate($purchaseOrderAttr->getTransactionDate()),
            'delivery_date' => formatDate($purchaseOrderAttr->getDeliveryDate()),
            'chart_of_account_id' => $purchaseOrderAttr->getChartOfAccountId(),
            'warehouse_id' => $purchaseOrderAttr->getWarehouseId(),
            'supplier_id' => $purchaseOrderAttr->getSupplierId(),
            'price_list_id' => $purchaseOrderAttr->getPriceListId(),
            'project_id' => $purchaseOrderAttr->getProjectId(),
            'purchase_request_id' => $purchaseOrderAttr->getPurchaseRequestId(),
            'po_product' => $purchaseOrderAttr->getPoProduct(),
            'payment_system' => $purchaseOrderAttr->getPaymentSystem(),
            'note_payment' => $purchaseOrderAttr->getNotePayment(),
            'po_date' => $purchaseOrderAttr->getPoDate(),
            'approved' => null
        ]);

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

    public function delete($id)
    {
        $purchaseOrder = $this->updateUsedQtyWhileDelete($id);
        $purchaseOrder->delete();

        return $purchaseOrder;
    }

    public function updateUsedQtyWhileDelete($id)
    {
        $purchaseOrder = DB::transaction(function () use ($id) {
            $purchaseOrder = PurchaseOrder::with([
                'purchaseOrderMaterials',
                'purchaseOrderManuals',
                'purchaseOrderVendors',
                'purchaseOrderVendorManuals',
                'purchaseOrderOtherCosts',
                'purchaseOrderOtherCostManuals',
                'purchaseOrderMachines',
                'purchaseOrderMachineManuals'
            ])
                ->where('id', $id)
                ->first();

            // DELETE PURCHASE REQUEST MATERIALS
            foreach ($purchaseOrder->purchaseOrderMaterials ?? [] as $purchaseOrderMaterial) {
                foreach ($purchaseOrderMaterial->purchaseOrderMaterialDetails ?? [] as $purchaseOrderMaterialDetail) {
                    $updt = PurchaseRequestMaterialDetail::whereHas('purchaseRequestMaterial', function ($q) use ($purchaseOrderMaterial) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderMaterial->ref_pr],
                            ['material_id', '=', $purchaseOrderMaterial->material_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderMaterialDetail->unit_price_id)->first();

                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderMaterialDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST MANUALS
            foreach ($purchaseOrder->purchaseOrderManuals ?? [] as $purchaseOrderManual) {
                foreach ($purchaseOrderManual->purchaseOrderManualDetails ?? [] as $purchaseOrderManualDetail) {
                    $updt = PurchaseRequestManualDetail::whereHas('purchaseRequestManual', function ($q) use ($purchaseOrderManual) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderManual->ref_pr],
                            ['material_id', '=', $purchaseOrderManual->manual_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderManualDetail->unit_price_id)->first();

                    $updt->update([
                        "used_qty" =>  $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderManualDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST VENDOR
            foreach ($purchaseOrder->purchaseOrderVendors ?? [] as $purchaseOrderVendor) {
                foreach ($purchaseOrderVendor->purchaseOrderVendorDetails ?? [] as $purchaseOrderVendorDetail) {
                    $updt = PurchaseRequestVendorDetail::whereHas('purchaseRequestVendor', function ($q) use ($purchaseOrderVendor) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderVendor->ref_pr],
                            ['vendor_product_id', '=', $purchaseOrderVendor->vendor_product_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderVendorDetail->unit_price_id)->first();

                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderVendorDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST VENDOR MANUAL
            foreach ($purchaseOrder->purchaseOrderVendorManuals ?? [] as $purchaseOrderVendorManual) {
                foreach ($purchaseOrderVendorManual->purchaseOrderVendorManualDetails ?? [] as $purchaseOrderVendorManualDetail) {
                    $updt = PurchaseRequestVendorManualDetail::whereHas('purchaseRequestVendorManual', function ($q) use ($purchaseOrderVendorManual) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderVendorManual->ref_pr],
                            ['vendor_product_id', '=', $purchaseOrderVendorManual->vendor_product_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderVendorManualDetail->unit_price_id)->first();

                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderVendorManualDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST OTHER COST
            foreach ($purchaseOrder->purchaseOrderOtherCosts ?? [] as $purchaseOrderOtherCost) {
                foreach ($purchaseOrderOtherCost->purchaseOrderOtherCostDetails ?? [] as $purchaseOrderOtherCostDetail) {
                    $updt = PurchaseRequestOtherCostDetail::whereHas('purchaseRequestOtherCost', function ($q) use ($purchaseOrderOtherCost) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderOtherCost->ref_pr],
                            ['other_cost_id', '=', $purchaseOrderOtherCost->other_cost_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderOtherCostDetail->unit_price_id)->first();

                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderOtherCostDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST OTHER COST MANUAL
            foreach ($purchaseOrder->purchaseOrderOtherCostManuals ?? [] as $purchaseOrderOtherCostManual) {
                foreach ($purchaseOrderOtherCostManual->purchaseOrderOtherCostManualDetails ?? [] as $purchaseOrderOtherCostManualDetail) {
                    $updt = PurchaseRequestOtherCostManualDetail::whereHas('purchaseRequestOtherCostManual', function ($q) use ($purchaseOrderOtherCostManual) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderOtherCostManual->ref_pr],
                            ['other_cost_id', '=', $purchaseOrderOtherCostManual->other_cost_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderOtherCostManualDetail->unit_price_id)->first();

                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderOtherCostManualDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST MACHINE
            foreach ($purchaseOrder->purchaseOrderMachines ?? [] as $purchaseOrderMachine) {
                foreach ($purchaseOrderMachine->purchaseOrderMachineDetails ?? [] as $purchaseOrderMachineDetail) {
                    $updt = PurchaseRequestMachineDetail::whereHas('purchaseRequestMachine', function ($q) use ($purchaseOrderMachine) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderMachine->ref_pr],
                            ['asset_id', '=', $purchaseOrderMachine->asset_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderMachineDetail->unit_price_id)->first();


                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderMachineDetail->qty : 0
                    ]);
                }
            }

            // DELETE PURCHASE REQUEST MACHINE MANUAL
            foreach ($purchaseOrder->purchaseOrderMachineManuals ?? [] as $purchaseOrderMachineManual) {
                foreach ($purchaseOrderMachineManual->purchaseOrderMachineManualDetails ?? [] as $purchaseOrderMachineManualDetail) {
                    $updt = PurchaseRequestMachineManualDetail::whereHas('purchaseRequestMachineManual', function ($q) use ($purchaseOrderMachineManual) {
                        $q->where([
                            ['purchase_request_id', '=', $purchaseOrderMachineManual->ref_pr],
                            ['asset_id', '=', $purchaseOrderMachineManual->asset_id]
                        ]);
                    })->where('unit_price_id', $purchaseOrderMachineManualDetail->unit_price_id)->first();
                    $updt->update([
                        "used_qty" => $updt->used_qty > 0 ? (float)$updt->used_qty - (float)$purchaseOrderMachineManualDetail->qty : 0
                    ]);
                }
            }

            return $purchaseOrder;
        });

        return $purchaseOrder;
    }

    public function syncItems($id, array $itemPurchaseOrderAttrs)
    {
        // Bisa jadi clue
        $purchaseOrder = $this->fetch($id);

        $pivots = [];

        foreach ($itemPurchaseOrderAttrs as $itemPurchaseOrderAttr) {
            $pivots[$itemPurchaseOrderAttr->getItemId()] = [
                'rate' => allowMinusSubtotal($itemPurchaseOrderAttr->getRate()),
                'qty' => qtyFormat($itemPurchaseOrderAttr->getQty()),
                'tax_id' => $itemPurchaseOrderAttr->getTaxId(),
                'tax_rate' => numberOnly($itemPurchaseOrderAttr->getTaxRate()),
                'subtotal' => allowMinusSubtotal($itemPurchaseOrderAttr->getSubtotal()),
                'description' => $itemPurchaseOrderAttr->getDescription()
            ];
        }

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

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

    public function syncAdditionalCosts($id, $additionalCostPrices)
    {
        // Bisa jadi clue
        $purchaseOrder = $this->fetch($id);

        $pivots = [];

        foreach ($additionalCostPrices as $additionalCostPrice) {
            $pivots[$additionalCostPrice['additional_cost_id']] = [
                'price' => $additionalCostPrice['price'] ?? 0
            ];
        }

        $purchaseOrder->additionalCosts()->sync($pivots);

        return PurchaseOrder::with('additionalCosts')->find($id);
    }

    private function checkReference($id)
    {
        $purchaseOrderByProduct = $this->fetch($id);
        $check = $purchaseOrderByProduct->reference;

        if ($check == 'po_product' || $check == null) {
            return $purchaseOrderByProduct;
        }

        $purchaseOrderByProject = $this->fetchByRefProject($id);
        return $purchaseOrderByProject;
    }

    private function checkMaterialSupplierId($id)
    {
        $checkSupplierIdMaterial = PurchaseOrder::with('purchaseOrderMaterials')->find($id);

        foreach ($checkSupplierIdMaterial->purchaseOrderMaterials ?? [] as $material) {
            return $material->supplier_id;
        }
    }

    private function checkVendorSupplierId($id)
    {
        $checkSupplierIdVendor = PurchaseOrder::with('purchaseOrderVendors')->find($id);

        foreach ($checkSupplierIdVendor->purchaseOrderVendors ?? [] as $vendor) {
            return $vendor->supplier_id;
        }
    }

    public function fetchByRefProject($id)
    {
        $supplierIdMat = $this->checkMaterialSupplierId($id);
        $supplierIdVen = $this->checkVendorSupplierId($id);

        $query = PurchaseOrder::with([
            'purchaseOrderMaterials' => function ($query) use ($supplierIdMat) {
                //check supplier_id di purchase_order_material
                $query->with(['purchaseOrderMaterialDetails.unitPrice' => function ($un) {
                    $un->selectRaw('id, name');
                }]);
                $query->with(['material' => function ($query) use ($supplierIdMat) {
                    $query->selectRaw('id, name, price, unit, price');
                    $query->with(['suppliers' => function ($query) use ($supplierIdMat) {
                        $query->selectRaw('id, name, phone_number, email, address, type');
                        $query->where('id', $supplierIdMat);
                    }]);
                }]);
            },
            'purchaseOrderVendors' => function ($query) use ($supplierIdVen) {
                //check supplier_id di purchase_order_vendor
                // $query->selectRaw('id, purchase_order_id, supplier_id, vendor_product_id, qty, price');
                $query->with(['purchaseOrderVendorDetails.unitPrice', 'vendorProduct' => function ($query) use ($supplierIdVen) {
                    $query->selectRaw('id, name, dimensional_spesification, unit, price');
                    $query->with(['suppliers' => function ($query) use ($supplierIdVen) {
                        $query->selectRaw('id, name, phone_number, email, address, type');
                        $query->where('id', $supplierIdVen);
                    }]);
                }]);
            },
            'purchaseOrderManuals' => function ($query) {
                $query->with(['purchaseOrderManualDetails.unitPrice' => function ($un) {
                    $un->selectRaw('id, name');
                }]);
            },
            'purchaseOrderMachines' => function ($query) {
                $query->with(['asset', 'purchaseOrderMachineDetails.unitPrice' => function ($un) {
                    $un->selectRaw('id, name');
                }]);
            },
            'project' => function ($query) {
                $query->with('deal.budgetPlan.order');
                $query->selectRaw('id, deal_id, project_manager_id, start_date, end_date, site_project_id');
                $query->whereHas('deal.budgetPlan.order');
            },
            'purchaseOrderOtherCosts' => function ($query) {
                $query->with('otherCost', 'purchaseOrderOtherCostDetails.unitPrice');
            },
            'purchaseOrderVendorManuals' => function ($query) {
                $query->with(['vendor' => function ($query) {
                    $query->selectRaw('id, name, dimensional_spesification, unit, price');
                }]);
                $query->with(['purchaseOrderVendorManualDetails' => function ($query) {
                    $query->select('id', 'purchase_order_vendor_manual_id', 'unit_price_id', 'qty');
                    $query->with(['unitPrice']);
                }]);
            },
            'purchaseOrderOtherCostManuals' => function ($query) {
                $query->with(['otherCost' => function ($query) {
                    $query->select('id', 'other_cost_category_id', 'item', 'unit', 'price', 'qty');
                }]);
                $query->with(['purchaseOrderOtherCostManualDetails' => function ($query) {
                    $query->with(['unitPrice']);
                }]);
            },
            'purchaseOrderMachines' => function ($query) {
                $query->with(['asset']);
                $query->with(['purchaseOrderMachineDetails' => function ($query) {
                    $query->select('purchase_order_machine_id', 'unit_price_id', 'qty');
                    $query->with(['unitPrice']);
                }]);
            },
            'purchaseOrderMachineManuals' => function ($query) {
                $query->with(['asset']);
                $query->with(['purchaseOrderMachineManualDetails' => function ($query) {
                    $query->with(['unitPrice']);
                }]);
            },
            'purchaseRequest',
            'supplier',
            'additionalCosts'
        ])->findOrFail($id);

        $skkNumber = $query->project->deal->skk_number ?? null;
        $customerName = $query->project->deal->customer_name ?? null;
        $customerPhone = $query->project->deal->budgetPlan->order->customer_phone ?? null;

        $array = [];
        foreach ($query->project->deal->budgetPlan->order->orderServices ?? [] as $orderService) {
            $array[] = $orderService->service->title ?? null;
        }

        $serviceName = join(", ", $array);

        $query['project_name'] = $skkNumber . ' | ' . $customerName . ' | ' . $customerPhone . ' | ' . $serviceName;

        return $query;
    }

    public function approved($id, $over = null)
    {
        //jika over tidak samadengan null / ada
        $fetch = PurchaseOrder::findOrFail($id);
        if ($over && $fetch->approve == null) {
            $fetch->approved = "0";
            $fetch->save();
            return $fetch;
        }

        if (getAuthRoleName() == 'general manager' || getAuthRoleName() == 'director') {
            if ($fetch->approved === '0' && getAuthRoleName() == 'general manager') {
                $num = 1;
            } elseif ($fetch->approved === '0' && getAuthRoleName() == 'director') {
                $num = 2;
            } else {
                $authName = getAuthRolename();
                return (object)[
                    "success" => false,
                    "message" => "already approved (status : $fetch->approved | role : $authName)"
                ];
            }

            $fetch->approved  = $num;
            $fetch->save();
            $fetch->approved_aliases = $this->approveAliases($fetch->approved) ?? null;
            return $fetch;
        } else {
            $authName = getAuthRolename();
            return (object)[
                "success" => false,
                "message" => "role check (status : $fetch->approved | role : $authName)"
            ];
        }
    }

    public function approveAliases($number)
    {
        $director = getDirector()->name ?? "Director";
        $gm = getGeneralManager()->name ?? "GM";

        if ($number === '1') {
            $result = "Disetujui oleh $gm";
        } elseif ($number === '2') {
            $result = "Disetujui oleh $director";
        } elseif ($number === '0') {
            $result = "Butuh Persetujuan";
        } else {
            $result = "";
        }
        return $result;
    }
}