shopit-back/app/Domains/Catalog/Services/VariantReplacementService.php

<?php

namespace App\Domains\Catalog\Services;

use App\Domains\Catalog\Models\BundleComponent;
use App\Domains\Catalog\Models\Variant;
use App\Domains\Event\Models\EventDate;
use Illuminate\Support\Collection;

class VariantReplacementService
{
    /** @return Collection<int, Variant> */
    public function replaceEventDate(EventDate $source, EventDate $destination): Collection
    {
        $variants = Variant::query()
            ->whereNull('sales_disabled_at')
            ->whereNull('replaced_by_variant_id')
            ->where(function ($query) use ($source): void {
                $query->where('event_date_id', $source->getKey())
                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
                        ->where('event_dates.id', $source->getKey()));
            })
            ->with(['eventDates', 'eventDate', 'definitions', 'allAttachments'])
            ->orderBy('id')
            ->lockForUpdate()
            ->get();

        return $variants->map(function (Variant $variant) use ($source, $destination): Variant {
            $destinationDateIds = $variant->selectedEventDates()
                ->pluck('id')
                ->map(fn ($id): int => (int) $id === (int) $source->getKey()
                    ? (int) $destination->getKey()
                    : (int) $id)
                ->unique()
                ->sort()
                ->values();

            $replacement = $this->findEquivalent($variant, $destinationDateIds)
                ?? $this->cloneWithDates($variant, $destinationDateIds);

            $variant->update([
                'replaced_by_variant_id' => $replacement->getKey(),
                'sales_disabled_at' => now(),
            ]);

            BundleComponent::query()
                ->where('component_variant_id', $variant->getKey())
                ->update(['component_variant_id' => $replacement->getKey()]);

            return $replacement;
        })->values();
    }

    public function disableForSuspension(EventDate $eventDate): void
    {
        Variant::query()
            ->whereNull('sales_disabled_at')
            ->whereNull('replaced_by_variant_id')
            ->where(function ($query) use ($eventDate): void {
                $query->where('event_date_id', $eventDate->getKey())
                    ->orWhereHas('eventDates', fn ($eventDates) => $eventDates
                        ->where('event_dates.id', $eventDate->getKey()));
            })
            ->update(['sales_disabled_at' => now()]);
    }

    /** @param Collection<int, int> $eventDateIds */
    private function findEquivalent(Variant $source, Collection $eventDateIds): ?Variant
    {
        $definitionSignature = $this->definitionSignature($source);
        $dateSignature = $eventDateIds->map(fn ($id): int => (int) $id)->sort()->values()->all();

        return Variant::query()
            ->where('catalog_item_id', $source->catalog_item_id)
            ->whereKeyNot($source->getKey())
            ->whereNull('sales_disabled_at')
            ->whereNull('replaced_by_variant_id')
            ->with(['eventDates', 'eventDate', 'definitions'])
            ->orderBy('id')
            ->lockForUpdate()
            ->get()
            ->first(fn (Variant $candidate): bool => $this->definitionSignature($candidate) === $definitionSignature
                && $candidate->selectedEventDates()
                    ->pluck('id')
                    ->map(fn ($id): int => (int) $id)
                    ->sort()
                    ->values()
                    ->all() === $dateSignature
            );
    }

    /** @param Collection<int, int> $eventDateIds */
    private function cloneWithDates(Variant $source, Collection $eventDateIds): Variant
    {
        $replacement = $source->replicate([
            'event_date_id',
            'replaced_by_variant_id',
            'sales_disabled_at',
        ]);
        $replacement->event_date_id = $eventDateIds->count() === 1
            ? $eventDateIds->first()
            : null;
        $replacement->save();
        $replacement->eventDates()->sync($eventDateIds->all());

        $replacement->definitions()->createMany(
            $source->definitions
                ->map(fn ($definition): array => [
                    'item_attribute_id' => $definition->item_attribute_id,
                    'value' => $definition->value,
                ])
                ->all(),
        );

        $attachments = $source->allAttachments
            ->mapWithKeys(fn ($attachment): array => [
                $attachment->getKey() => [
                    'orden' => $attachment->pivot->orden,
                    'is_enabled' => $attachment->pivot->is_enabled,
                ],
            ])
            ->all();
        $replacement->allAttachments()->sync($attachments);

        return $replacement->load(['eventDates', 'eventDate', 'definitions', 'allAttachments']);
    }

    /** @return list<string> */
    private function definitionSignature(Variant $variant): array
    {
        return $variant->definitions
            ->map(fn ($definition): string => $definition->item_attribute_id.'\0'.$definition->value)
            ->sort()
            ->values()
            ->all();
    }
}