store/app/Services/Master/ProductService.php

<?php

namespace App\Services\Master;

use App\Enums\Permission;
use App\Enums\ProductPendingAction;
use App\Enums\ProductStatus;
use App\Models\Category;
use App\Models\Product;
use App\Models\ProductVariant;
use App\Models\User;
use App\Services\Manage\CuttingResultPriceResolver;
use App\Services\Media\MediaService;
use App\Services\System\PushNotificationService;
use App\Support\Media\MediaPresenter;
use Carbon\Carbon;
use Illuminate\Contracts\Pagination\LengthAwarePaginator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;

class ProductService
{
    private const MAX_VARIANT_IMAGES = 5;

    public function __construct(
        private readonly MediaService $mediaService,
        private readonly CuttingResultPriceResolver $cuttingResultPriceResolver,
        private readonly PushNotificationService $pushNotificationService,
    ) {}

    /**
     * @return list<array{
     *     id: int,
     *     name: string,
     *     edit_url: string,
     *     variants: list<array{
     *         id: int,
     *         name: string,
     *         stock_formatted: string,
     *         images: list<array<string, mixed>>,
     *     }>,
     * }>
     */
    public function outOfStockGroups(): array
    {
        return $this->inventoryAlertGroups(
            fn (ProductVariant $variant): bool => $variant->stock <= 0,
        );
    }

    /**
     * @return list<array{
     *     id: int,
     *     name: string,
     *     edit_url: string,
     *     variants: list<array{
     *         id: int,
     *         name: string,
     *         stock_formatted: string,
     *         images: list<array<string, mixed>>,
     *     }>,
     * }>
     */
    public function stockWarningGroups(): array
    {
        return $this->inventoryAlertGroups(function (ProductVariant $variant): bool {
            if ($variant->stock <= 0) {
                return false;
            }

            return $variant->stock < ProductVariant::minStock();
        });
    }

    /**
     * @return list<array{
     *     id: int,
     *     name: string,
     *     edit_url: string,
     *     variants: list<array{
     *         id: int,
     *         name: string,
     *         stock_formatted: string,
     *         images: list<array<string, mixed>>,
     *     }>,
     * }>
     */
    private function inventoryAlertGroups(callable $filter): array
    {
        return ProductVariant::query()
            ->with(['product', 'media'])
            ->whereHas('product', fn (Builder $query) => $query
                ->where('is_active', true)
                ->where('status', ProductStatus::APPROVED))
            ->get()
            ->filter($filter)
            ->sortBy([
                fn (ProductVariant $variant) => $variant->product->name,
                fn (ProductVariant $variant) => $variant->name,
            ])
            ->groupBy('product_id')
            ->map(function ($variants, $productId) {
                $product = $variants->first()->product;

                return [
                    'id' => (int) $productId,
                    'name' => $product->name,
                    'edit_url' => route('admin.master.products.edit', $productId),
                    'variants' => $variants->map(function (ProductVariant $variant): array {
                        return [
                            'id' => $variant->id,
                            'name' => $variant->name,
                            'stock_formatted' => number_format($variant->stock, 0, ',', '.').' pcs',
                            'images' => MediaPresenter::collection($variant, 'images'),
                        ];
                    })->values()->all(),
                ];
            })
            ->values()
            ->all();
    }

    /**
     * @param  array{search: string, sort: string, direction: 'asc'|'desc'}  $tableQuery
     */
    public function paginateForIndex(array $tableQuery, string $isActive, string $categoryId = '', string $status = ''): LengthAwarePaginator
    {
        $query = Product::query()
            ->with([
                'categories',
                'rejection',
                'variants' => fn ($query) => $query
                    ->with('media')
                    ->orderBy('created_at'),
            ])
            ->when($tableQuery['search'] !== '', function (Builder $query) use ($tableQuery): void {
                $search = $tableQuery['search'];
                $query->where(function (Builder $query) use ($search) {
                    $query->where('name', 'like', "%{$search}%")
                        ->orWhere('slug', 'like', "%{$search}%")
                        ->orWhere('description', 'like', "%{$search}%")
                        ->orWhereHas('categories', fn (Builder $query) => $query->where('name', 'like', "%{$search}%"))
                        ->orWhereHas('variants', fn (Builder $query) => $query->where('name', 'like', "%{$search}%"))
                        ->orWhereHas('rejection', fn (Builder $query) => $query->where('reason', 'like', "%{$search}%"));
                });
            })
            ->when(
                $isActive !== '',
                fn (Builder $query) => $query->where('is_active', $isActive === '1')
            )
            ->when(
                $status !== '',
                fn (Builder $query) => $query->where('status', $status)
            )
            ->when(
                $categoryId !== '',
                fn (Builder $query) => $query->whereHas('categories', fn (Builder $query) => $query->where('categories.id', $categoryId))
            );

        $this->applySorting($query, $tableQuery['sort'], $tableQuery['direction']);

        return $query
            ->paginate(10)
            ->withQueryString()
            ->through(function (Product $product) {
                $product->variants->each(function (ProductVariant $variant): void {
                    $variant->setAttribute(
                        'images',
                        MediaPresenter::collection($variant, 'images'),
                    );
                    $variant->setAttribute(
                        'prices',
                        $this->presentVariantPrices($variant->id),
                    );
                });

                return $product;
            });
    }

    /**
     * @return list<array{value: int, label: string}>
     */
    public function categoryOptions(): array
    {
        return Category::query()
            ->orderBy('name')
            ->get(['id', 'name'])
            ->map(fn (Category $category) => [
                'value' => $category->id,
                'label' => $category->name,
            ])
            ->all();
    }

    /**
     * @param  array<string, mixed>  $validated
     */
    public function create(array $validated, User $user): void
    {
        DB::transaction(function () use ($validated, $user): void {
            $autoApprove = $this->userCanAutoApprove($user);

            $product = Product::create([
                'name' => $validated['name'],
                'description' => $validated['description'] ?? null,
                'is_active' => $autoApprove,
                'status' => $autoApprove ? ProductStatus::APPROVED : ProductStatus::PENDING,
                'was_ever_approved' => $autoApprove,
                'submitted_by_id' => $autoApprove ? null : $user->id,
                'verified_at' => $autoApprove ? Carbon::now() : null,
                'verified_by_id' => $autoApprove ? $user->id : null,
            ]);

            $product->categories()->sync($validated['category_ids']);

            foreach ($validated['variants'] as $index => $variantData) {
                $this->createVariant($product, $variantData, $index);
            }

            if (! $autoApprove) {
                $this->notifyOwnersOfPendingProduct($product, 'baru');
            }
        });
    }

    /**
     * @param  array<string, mixed>  $validated
     */
    public function update(Product $product, array $validated, User $user): void
    {
        $this->ensureEditable($product, 'Produk hanya dapat diubah saat status menunggu atau ditolak.');

        DB::transaction(function () use ($validated, $product, $user): void {
            $autoApprove = $this->userCanAutoApprove($user);

            $product->name = $validated['name'];
            $product->description = $validated['description'] ?? null;

            if ($autoApprove) {
                $product->status = ProductStatus::APPROVED;
                $product->pending_action = null;
                $product->was_ever_approved = true;
                $product->verified_at = Carbon::now();
                $product->verified_by_id = $user->id;
                $product->submitted_by_id = null;
            } else {
                $product->status = ProductStatus::PENDING;
                $product->pending_action = null;
                $product->verified_at = null;
                $product->verified_by_id = null;
                $product->submitted_by_id = $user->id;
                $product->is_active = false;
                $product->rejection()?->delete();
            }

            $product->save();

            $product->categories()->sync($validated['category_ids']);

            $submittedVariantIds = collect($validated['variants'])
                ->pluck('id')
                ->filter()
                ->map(fn ($id) => (int) $id)
                ->all();

            $product->variants()
                ->whereNotIn('id', $submittedVariantIds)
                ->get()
                ->each(function (ProductVariant $variant): void {
                    $variant->clearMediaCollection('images');
                    $variant->delete();
                });

            foreach ($validated['variants'] as $index => $variantData) {
                if (! empty($variantData['id'])) {
                    $variant = $product->variants()->findOrFail($variantData['id']);
                    $variant->name = $variantData['name'];
                    $variant->stock = $variantData['stock'];
                    $variant->save();
                    $this->syncVariantImages($variant, $variantData, $index);

                    continue;
                }

                $this->createVariant($product, $variantData, $index);
            }

            if (! $autoApprove) {
                $this->notifyOwnersOfPendingProduct($product, 'diperbarui');
            }
        });
    }

    public function toggleStatus(Product $product, bool $isActive, User $user): void
    {
        if (! $this->userCanAutoApprove($user)) {
            throw ValidationException::withMessages([
                'is_active' => 'Perubahan status produk memerlukan persetujuan owner.',
            ]);
        }

        $this->ensureApproved($product, 'Status produk hanya dapat diubah setelah disetujui.');

        $product->is_active = $isActive;
        $product->save();
    }

    public function delete(Product $product, User $user): void
    {
        if ($this->userCanAutoApprove($user)) {
            $this->performDelete($product);

            return;
        }

        if ($product->status === ProductStatus::PENDING && $product->pending_action === null) {
            $this->performDelete($product);

            return;
        }

        if ($product->status === ProductStatus::REJECTED && $product->pending_action === null) {
            $this->performDelete($product);

            return;
        }

        $this->ensureApproved($product, 'Pengajuan penghapusan hanya dapat dilakukan untuk produk yang sudah disetujui.');

        DB::transaction(function () use ($product, $user): void {
            $product->status = ProductStatus::PENDING;
            $product->pending_action = ProductPendingAction::DELETE;
            $product->is_active = false;
            $product->submitted_by_id = $user->id;
            $product->verified_at = null;
            $product->verified_by_id = null;
            $product->rejection()?->delete();
            $product->save();

            $this->notifyOwnersOfPendingProduct($product, 'dihapus');
        });
    }

    public function approve(Product $product, User $user): void
    {
        $this->ensurePending($product, 'Produk ini sudah diverifikasi.');

        if ($product->pending_action === ProductPendingAction::DELETE) {
            $submittedById = $product->submitted_by_id;
            $productName = $product->name;

            DB::transaction(function () use ($product): void {
                $this->performDelete($product);
            });

            if ($submittedById) {
                $this->pushNotificationService->sendToUser(
                    '✅ Penghapusan Produk Disetujui',
                    "Pengajuan penghapusan produk {$productName} telah disetujui.",
                    $submittedById,
                    '/admin/master/products',
                );
            }

            return;
        }

        DB::transaction(function () use ($product, $user): void {
            $product->status = ProductStatus::APPROVED;
            $product->pending_action = null;
            $product->is_active = true;
            $product->was_ever_approved = true;
            $product->verified_at = Carbon::now();
            $product->verified_by_id = $user->id;
            $product->save();

            $product->rejection()?->delete();
        });

        $product->loadMissing('submittedBy');
        if ($product->submitted_by_id) {
            $this->pushNotificationService->sendToUser(
                '✅ Produk Disetujui',
                "Produk {$product->name} telah disetujui dan aktif.",
                $product->submitted_by_id,
                '/admin/master/products',
            );
        }
    }

    public function reject(Product $product, string $reason, User $user): void
    {
        $this->ensurePending($product, 'Produk ini sudah diverifikasi.');

        if ($product->pending_action === ProductPendingAction::DELETE) {
            DB::transaction(function () use ($product, $user, $reason): void {
                $product->status = ProductStatus::APPROVED;
                $product->pending_action = null;
                $product->is_active = true;
                $product->verified_at = Carbon::now();
                $product->verified_by_id = $user->id;
                $product->save();

                $product->rejection()->create([
                    'reason' => $reason,
                    'rejected_by_id' => $user->id,
                ]);
            });

            $product->loadMissing('submittedBy');
            if ($product->submitted_by_id) {
                $this->pushNotificationService->sendToUser(
                    '❌ Penghapusan Produk Ditolak',
                    "Pengajuan penghapusan produk {$product->name} ditolak dengan alasan: '{$reason}'.",
                    $product->submitted_by_id,
                    '/admin/master/products',
                );
            }

            return;
        }

        DB::transaction(function () use ($product, $user, $reason): void {
            $submittedById = $product->submitted_by_id;
            $productName = $product->name;

            if (! $product->was_ever_approved) {
                $this->performDelete($product);

                if ($submittedById) {
                    $this->pushNotificationService->sendToUser(
                        '❌ Produk Ditolak',
                        "Pengajuan produk {$productName} ditolak dengan alasan: '{$reason}'.",
                        $submittedById,
                        '/admin/master/products',
                    );
                }

                return;
            }

            $product->status = ProductStatus::REJECTED;
            $product->pending_action = null;
            $product->is_active = false;
            $product->verified_at = Carbon::now();
            $product->verified_by_id = $user->id;
            $product->save();

            $product->rejection()->create([
                'reason' => $reason,
                'rejected_by_id' => $user->id,
            ]);

            if ($submittedById) {
                $this->pushNotificationService->sendToUser(
                    '❌ Produk Ditolak',
                    "Pengajuan produk {$productName} ditolak dengan alasan: '{$reason}'.",
                    $submittedById,
                    '/admin/master/products',
                );
            }
        });
    }

    private function performDelete(Product $product): void
    {
        DB::transaction(function () use ($product): void {
            $product->variants()->each(function (ProductVariant $variant): void {
                $variant->clearMediaCollection('images');
            });
            $product->variants()->delete();
            $product->categories()->detach();
            $product->rejection()?->delete();
            $product->delete();
        });
    }

    private function notifyOwnersOfPendingProduct(Product $product, string $actionLabel): void
    {
        $this->pushNotificationService->sendToRoles(
            '📦 Pengajuan Produk Baru',
            "Produk {$product->name} {$actionLabel} dan menunggu persetujuan owner.",
            ['owner', 'developer'],
            '/admin/master/products',
        );
    }

    private function userCanAutoApprove(User $user): bool
    {
        return $user->can(Permission::PRODUCTS_VERIFY->value);
    }

    private function ensurePending(Product $product, string $message): void
    {
        if ($product->status !== ProductStatus::PENDING) {
            throw ValidationException::withMessages([
                'product' => $message,
            ]);
        }
    }

    private function ensureApproved(Product $product, string $message): void
    {
        if ($product->status !== ProductStatus::APPROVED) {
            throw ValidationException::withMessages([
                'product' => $message,
            ]);
        }
    }

    private function ensureEditable(Product $product, string $message): void
    {
        if (! in_array($product->status, [ProductStatus::PENDING, ProductStatus::REJECTED], true)) {
            throw ValidationException::withMessages([
                'product' => $message,
            ]);
        }
    }

    private function applySorting(Builder $query, string $sort, string $direction): void
    {
        if (in_array($sort, ['name', 'slug', 'is_active', 'status'], true)) {
            $query->orderBy($sort, $direction);

            return;
        }

        $query->latest();
    }

    /**
     * @param  array<string, mixed>  $variantData
     */
    private function createVariant(Product $product, array $variantData, int $index): ProductVariant
    {
        $variant = $product->variants()->create([
            'name' => $variantData['name'],
            'stock' => $variantData['stock'],
        ]);

        $this->syncVariantImages($variant, $variantData, $index);

        return $variant;
    }

    /**
     * @param  array<string, mixed>  $variantData
     */
    private function syncVariantImages(ProductVariant $variant, array $variantData, int $index): void
    {
        $this->mediaService->syncCollection(
            $variant,
            'images',
            $variantData['images'] ?? null,
            $variantData['remove_media_ids'] ?? null,
            self::MAX_VARIANT_IMAGES,
            required: true,
            errorKey: "variants.{$index}.images",
        );
    }

    /**
     * @return list<array{
     *     type: string,
     *     type_label: string,
     *     price: int,
     *     price_formatted: string,
     *     price_input: string,
     *     cost_per_unit: int,
     *     cost_per_unit_formatted: string,
     * }>
     */
    private function presentVariantPrices(int $variantId): array
    {
        return collect($this->cuttingResultPriceResolver->latestPricesForVariant($variantId))
            ->map(fn ($price) => [
                'type' => $price->price_type->value,
                'type_label' => $price->price_type->label(),
                'price' => (int) $price->price,
                'price_formatted' => $price->price_formatted,
                'price_input' => (string) $price->price,
                'cost_per_unit' => (int) $price->cost_per_unit,
                'cost_per_unit_formatted' => $price->cost_per_unit_formatted,
            ])
            ->values()
            ->all();
    }
}