store/app/Services/Master/ProductService.php

<?php

namespace App\Services\Master;

use App\Models\Product;
use App\Models\ProductVariant;
use App\Services\Media\MediaService;
use App\Support\Media\MediaPresenter;
use Illuminate\Contracts\Pagination\LengthAwarePaginator;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;

class ProductService
{
    private const MAX_VARIANT_IMAGES = 5;

    public function __construct(
        private readonly MediaService $mediaService,
    ) {}

    /**
     * @param  array{search: string, sort: string, direction: 'asc'|'desc'}  $tableQuery
     */
    public function paginateForIndex(array $tableQuery, string $isActive, string $categoryId = '', string $stockStatus = ''): LengthAwarePaginator
    {
        $query = Product::query()
            ->with([
                'categories',
                'variants' => fn ($query) => $query
                    ->with(['media', 'prices' => fn ($query) => $query->orderBy('type')])
                    ->orderBy('created_at'),
            ])
            ->when($tableQuery['search'] !== '', function (Builder $query) use ($tableQuery): void {
                $search = $tableQuery['search'];
                $query->where(function (Builder $query) use ($search): void {
                    $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}%"));
                });
            })
            ->when($isActive !== '', fn (Builder $query) => $query->where('is_active', $isActive === '1'))
            ->when($categoryId !== '', function (Builder $query) use ($categoryId): void {
                $query->whereHas('categories', fn (Builder $query) => $query->where('categories.id', $categoryId));
            })
            ->when($stockStatus === 'out_of_stock', function (Builder $query): void {
                $query->whereHas('variants', fn (Builder $q) => $q->where('stock', '<=', 0));
            })
            ->when($stockStatus === 'low_stock', function (Builder $query): void {
                $query->whereHas('variants', fn (Builder $q) => $q->where('stock', '>', 0)->where('stock', '<', ProductVariant::minStock()));
            });

        $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'),
                    );
                });

                return $product;
            });
    }

    /**
     * @param  array<string, mixed>  $validated
     */
    public function create(array $validated): void
    {
        DB::transaction(function () use ($validated): void {
            $product = Product::create([
                'name' => $validated['name'],
                'description' => $validated['description'] ?? null,
                'is_active' => true,
            ]);

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

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

    /**
     * @param  array<string, mixed>  $validated
     */
    public function update(Product $product, array $validated): void
    {
        DB::transaction(function () use ($validated, $product): void {
            $product->update([
                'name' => $validated['name'],
                'description' => $validated['description'] ?? null,
            ]);

            $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->update([
                        'name' => $variantData['name'],
                        'stock' => $variantData['stock'],
                    ]);
                    $this->syncVariantImages($variant, $variantData, $index);

                    continue;
                }

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

    public function toggleStatus(Product $product, array $validated): void
    {
        $product->update([
            'is_active' => $validated['is_active'],
        ]);
    }

    public function delete(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->delete();
        });
    }

    private function applySorting(Builder $query, string $sort, string $direction): void
    {
        if (in_array($sort, ['name', 'slug', 'is_active'], 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",
        );
    }
}