szkp-map-service/app/Http/Controllers/Api/ActivityBookingController.php

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Concerns\AuthorizesActivitySubmitter;
use App\Http\Controllers\Controller;
use App\Models\Activity;
use App\Models\ActivityDay;
use Carbon\Carbon;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Validation\ValidationException;

class ActivityBookingController extends Controller
{
    use AuthorizesActivitySubmitter;

    private const BOOKING_MODE_INDIVIDUAL = 'individual';

    private const BOOKING_MODE_GROUP = 'group';

    private const BOOKING_MODE_BOTH = 'both';

    public function show(Request $request, Activity $activity): JsonResponse
    {
        $this->authorizeActivityCollaboratorView($request, $activity);

        return response()->json($this->formatBookingPayload($activity->load('venue:id,appointment_type')));
    }

    public function update(Request $request, Activity $activity): JsonResponse
    {
        $this->ensureVenueOrCreatorPermission($request, $activity);
        $this->authorizeActivityFullEdit($request, $activity);

        $t = trim((string) ($activity->reservation_type ?? Activity::RESERVATION_TYPE_ONLINE));
        if ($t === '') {
            $t = Activity::RESERVATION_TYPE_ONLINE;
        }
        $allowSessionKinds = [
            Activity::RESERVATION_TYPE_ONLINE,
            Activity::RESERVATION_TYPE_NONE,
            Activity::RESERVATION_TYPE_PAID_STUDY,
        ];
        if (! in_array($t, $allowSessionKinds, true)) {
            throw ValidationException::withMessages([
                'reservation_type' => ['当前活动性质不可配置场次'],
            ]);
        }

        $isOnlineBooking = $t === Activity::RESERVATION_TYPE_ONLINE;
        /** 无需平台预约公益性科普、收费研学：场次列表可为空（不在此强制至少一场） */
        $allowEmptySessionList = in_array($t, [
            Activity::RESERVATION_TYPE_NONE,
            Activity::RESERVATION_TYPE_PAID_STUDY,
        ], true);
        $dayQuotaRules = $isOnlineBooking ? ['required', 'integer', 'min:1'] : ['sometimes', 'nullable', 'integer', 'min:0'];

        $dayListRules = ['required', 'array'];
        if (! $allowEmptySessionList) {
            $dayListRules[] = 'min:1';
        }

        $data = $request->validate([
            'booking_audience' => ['required', 'in:individual,group,both'],
            'min_people_per_order' => ['nullable', 'integer', 'min:1'],
            'max_people_per_order' => ['nullable', 'integer', 'min:1'],
            'days' => $dayListRules,
            'days.*.id' => ['nullable', 'integer', 'min:1'],
            'days.*.session_name' => ['required', 'string', 'max:200'],
            'days.*.session_start_at' => ['required', 'date'],
            'days.*.session_end_at' => ['required', 'date'],
            'days.*.booking_deadline_at' => ['nullable', 'date'],
            'days.*.booking_opens_at' => ['nullable', 'date'],
            'days.*.day_quota' => $dayQuotaRules,
            'days.*.quota_note' => ['nullable', 'string', 'max:500'],
        ]);
        foreach ($data['days'] as $i => $dayRow) {
            $deadlineRaw = $dayRow['booking_deadline_at'] ?? null;
            $hasDeadline = $deadlineRaw !== null && trim((string) $deadlineRaw) !== '';
            if ($isOnlineBooking && ! $hasDeadline) {
                throw ValidationException::withMessages([
                    "days.{$i}.booking_deadline_at" => ['公益性需预约活动的场次须填写预约截止时间'],
                ]);
            }
        }

        if ($isOnlineBooking) {
            foreach ($data['days'] as $i => $dayRow) {
                $opensRaw = $dayRow['booking_opens_at'] ?? null;
                $hasOpens = $opensRaw !== null && trim((string) $opensRaw) !== '';
                if (! $hasOpens) {
                    throw ValidationException::withMessages([
                        "days.{$i}.booking_opens_at" => ['公益性需预约活动的场次须填写预约开始时间'],
                    ]);
                }
            }
        }

        if (! $isOnlineBooking) {
            foreach ($data['days'] as &$dayRow) {
                if (($dayRow['booking_deadline_at'] ?? null) === null || trim((string) ($dayRow['booking_deadline_at'] ?? '')) === '') {
                    $dayRow['booking_deadline_at'] = $dayRow['session_start_at'];
                }
                $dayRow['booking_opens_at'] = null;
            }
            unset($dayRow);
        }

        $mode = $data['booking_audience'];

        $minPeople = (int) ($data['min_people_per_order'] ?? 1);
        $maxPeople = (int) ($data['max_people_per_order'] ?? 1);
        if ($mode === self::BOOKING_MODE_INDIVIDUAL) {
            $minPeople = 1;
            $maxPeople = 1;
        } else {
            $minPeople = max(1, $minPeople);
            $maxPeople = max(1, $maxPeople);
            if ($maxPeople < $minPeople) {
                throw ValidationException::withMessages([
                    'max_people_per_order' => ['每单最多人数不能小于每单最少人数'],
                ]);
            }
            if ($maxPeople === 1) {
                throw ValidationException::withMessages([
                    'max_people_per_order' => ['团体或个人+团体模式下，每单最多人数须大于等于每单最少人数，且不可为 1（请至少设为 2）'],
                ]);
            }
        }

        $this->validateSessionRows($activity, $data['days']);

        DB::transaction(function () use ($activity, $data, $minPeople, $maxPeople, $isOnlineBooking) {
            $activity->booking_audience = $data['booking_audience'];
            $activity->min_people_per_order = $minPeople;
            $activity->max_people_per_order = $maxPeople;

            $incomingIds = [];
            $sumDay = 0;
            foreach ($data['days'] as $row) {
                $id = isset($row['id']) ? (int) $row['id'] : 0;
                $sessionStart = Carbon::parse($row['session_start_at']);
                $sessionEnd = Carbon::parse($row['session_end_at']);
                $deadline = Carbon::parse($row['booking_deadline_at']);
                $bookingOpens = $isOnlineBooking ? Carbon::parse($row['booking_opens_at']) : null;
                $quotaNote = trim((string) ($row['quota_note'] ?? ''));
                $name = trim((string) $row['session_name']);
                $dqRaw = $row['day_quota'] ?? null;
                $quotaUnset = ! $isOnlineBooking
                    && (($dqRaw === null || $dqRaw === '') || (is_string($dqRaw) && trim((string) $dqRaw) === ''));

                if ($id > 0) {
                    $day = ActivityDay::query()
                        ->where('activity_id', $activity->id)
                        ->where('id', $id)
                        ->first();
                    if (! $day) {
                        throw ValidationException::withMessages(['days' => ['存在无效的场次 id']]);
                    }
                    /** @phpstan-ignore-next-line */
                    $bookedFloor = (int) $day->booked_count;
                    $dayQuota = $isOnlineBooking
                        ? (int) $dqRaw
                        : ($quotaUnset ? max(0, $bookedFloor) : max(0, (int) $dqRaw));
                    if ($day->booked_count > $dayQuota) {
                        throw ValidationException::withMessages([
                            'days' => ['「'.$name.'」已占用 '.(int) $day->booked_count.' 人，总名额不能小于该值'],
                        ]);
                    }

                    $sumDay += $dayQuota;

                    $day->session_name = $name;
                    $day->session_start_at = $sessionStart;
                    $day->session_end_at = $sessionEnd;
                    $day->booking_deadline_at = $deadline;
                    $day->booking_opens_at = $bookingOpens;
                    $day->day_quota = $dayQuota;
                    $day->quota_note = $quotaNote !== '' ? $quotaNote : null;
                    $this->fillLegacyOpenClose($activity, $day, $sessionStart, $sessionEnd, $deadline);
                    $day->save();
                    $incomingIds[] = (int) $day->id;
                } else {
                    $dayQuota = $isOnlineBooking
                        ? (int) $dqRaw
                        : ($quotaUnset ? 0 : max(0, (int) $dqRaw));
                    $sumDay += $dayQuota;

                    $d = new ActivityDay([
                        'activity_id' => $activity->id,
                        'session_name' => $name,
                        'day_quota' => $dayQuota,
                        'quota_note' => $quotaNote !== '' ? $quotaNote : null,
                        'booked_count' => 0,
                        'session_start_at' => $sessionStart,
                        'session_end_at' => $sessionEnd,
                        'booking_deadline_at' => $deadline,
                        'booking_opens_at' => $bookingOpens,
                    ]);
                    $this->fillLegacyOpenClose($activity, $d, $sessionStart, $sessionEnd, $deadline);
                    $d->save();
                    $incomingIds[] = (int) $d->id;
                }
            }

            $activity->total_quota = $sumDay;
            $activity->save();

            $toDelete = ActivityDay::query()
                ->where('activity_id', $activity->id)
                ->whereNotIn('id', $incomingIds)
                ->get();
            foreach ($toDelete as $d) {
                if ((int) $d->booked_count > 0) {
                    throw ValidationException::withMessages(['days' => ['已有预约占用，不能删除该场次']]);
                }
                $d->delete();
            }
        });

        $activity->load('activityDays');
        $activity->forceFill(['schedule_status' => Activity::computeScheduleStatusForDisplay($activity)])->saveQuietly();

        if (! $request->user()?->isSuperAdmin()) {
            $activity->forceFill([
                'audit_status' => Activity::AUDIT_PENDING,
                'audit_remark' => null,
            ])->save();
        }

        return response()->json(array_merge(
            ['message' => '保存成功'],
            $this->formatBookingPayload($activity->fresh()->load('venue:id,appointment_type'))
        ));
    }

    /**
     * 部分旧逻辑仍读 opens_at/closes_at，写入合理近似值以兼容；H5/前台以场次、预约截止为准。
     */
    private function fillLegacyOpenClose(
        Activity $activity,
        ActivityDay $day,
        Carbon $sessionStart,
        Carbon $sessionEnd,
        Carbon $deadline,
    ): void {
        $open = $activity->start_at?->copy()->startOfDay() ?? $sessionStart->copy()->subDays(30);
        if ($open->gt($sessionStart)) {
            $open = $sessionStart->copy()->subDays(1);
        }
        $day->opens_at = $open;
        $day->closes_at = $deadline;
    }

    /**
     * @param  array<int, array<string, mixed>>  $days
     */
    private function validateSessionRows(Activity $activity, array $days): void
    {
        $tz = (string) config('app.timezone');
        $actStartD = $activity->start_at?->copy()->timezone($tz)->format('Y-m-d');
        $actEndD = $activity->end_at?->copy()->timezone($tz)->format('Y-m-d');
        $kind = trim((string) ($activity->reservation_type ?? Activity::RESERVATION_TYPE_ONLINE));
        if ($kind === '') {
            $kind = Activity::RESERVATION_TYPE_ONLINE;
        }
        $isOnlineBooking = $kind === Activity::RESERVATION_TYPE_ONLINE;
        /** 无需平台预约公益性科普、收费科普研学：场次开始与结束允许跨自然日 */
        $sessionAllowsCrossDay = in_array($kind, [
            Activity::RESERVATION_TYPE_NONE,
            Activity::RESERVATION_TYPE_PAID_STUDY,
        ], true);

        foreach ($days as $row) {
            $name = (string) ($row['session_name'] ?? '');
            $sessionStart = Carbon::parse($row['session_start_at'])->timezone($tz);
            $sessionEnd = Carbon::parse($row['session_end_at'])->timezone($tz);
            if (! $sessionAllowsCrossDay && ! $sessionStart->isSameDay($sessionEnd)) {
                throw ValidationException::withMessages([
                    'days' => ['每场次的开始时间与结束时间须为同一天内'],
                ]);
            }
            if ($sessionEnd->lte($sessionStart)) {
                throw ValidationException::withMessages([
                    'days' => ['「'.$name.'」场次结束时间须晚于开始时间'],
                ]);
            }
            if ($actStartD || $actEndD) {
                $startDStr = $sessionStart->format('Y-m-d');
                $endDStr = $sessionEnd->format('Y-m-d');
                if ($actStartD && $startDStr < $actStartD) {
                    throw ValidationException::withMessages([
                        'days' => ['「'.$name.'」场次开始日期不能早于活动开始日期'],
                    ]);
                }
                if ($actEndD && $startDStr > $actEndD) {
                    throw ValidationException::withMessages([
                        'days' => ['「'.$name.'」场次开始日期不能晚于活动结束日期'],
                    ]);
                }
                if ($actStartD && $endDStr < $actStartD) {
                    throw ValidationException::withMessages([
                        'days' => ['「'.$name.'」场次结束日期不能早于活动开始日期'],
                    ]);
                }
                if ($actEndD && $endDStr > $actEndD) {
                    throw ValidationException::withMessages([
                        'days' => ['「'.$name.'」场次结束日期不能晚于活动结束日期'],
                    ]);
                }
            }

            if (! $isOnlineBooking) {
                continue;
            }

            $deadline = Carbon::parse($row['booking_deadline_at'])->timezone($tz);
            $bookingOpens = Carbon::parse($row['booking_opens_at'])->timezone($tz);
            if ($bookingOpens->gt($deadline)) {
                throw ValidationException::withMessages([
                    'days' => ['「'.$name.'」预约开始时间不能晚于预约截止时间'],
                ]);
            }
            if ($deadline->gte($sessionStart)) {
                throw ValidationException::withMessages([
                    'days' => ['「'.$name.'」预约截止时间须早于场次开始时间'],
                ]);
            }
        }
    }

    /**
     * @return array{booking_audience: string|null, total_quota: int, days: array<int, array<string, mixed>>}
     */
    private function formatBookingPayload(Activity $activity): array
    {
        $days = $activity->activityDays()->get()->map(function (ActivityDay $d) {
            $deadline = $d->booking_deadline_at ?? $d->closes_at;

            return [
                'id' => $d->id,
                'session_name' => (string) ($d->session_name ?? ''),
                'session_start_at' => $d->session_start_at?->format('Y-m-d H:i:s'),
                'session_end_at' => $d->session_end_at?->format('Y-m-d H:i:s'),
                'booking_deadline_at' => $d->booking_deadline_at?->format('Y-m-d H:i:s'),
                'booking_opens_at' => $d->booking_opens_at?->format('Y-m-d H:i:s'),
                'activity_date' => $d->activity_date?->format('Y-m-d'),
                'day_quota' => $d->day_quota,
                'quota_note' => $d->quota_note,
                'booked_count' => $d->booked_count,
                'opens_at' => $d->opens_at?->format('Y-m-d H:i:s'),
                'closes_at' => $deadline?->format('Y-m-d H:i:s') ?? $d->opens_at?->format('Y-m-d H:i:s'),
            ];
        })->values()->all();

        $audience = $activity->booking_audience ?: self::BOOKING_MODE_BOTH;
        $venue = $activity->relationLoaded('venue') ? $activity->venue : $activity->venue()->first(['id', 'appointment_type']);
        $minP = 1;
        $maxP = 1;
        if ($audience === self::BOOKING_MODE_GROUP || $audience === self::BOOKING_MODE_BOTH) {
            $minP = max(1, (int) ($activity->min_people_per_order ?? 1));
            $maxP = max($minP, (int) ($activity->max_people_per_order ?? $minP));
        }

        return [
            'booking_audience' => $audience,
            'total_quota' => (int) ($activity->total_quota ?? 0),
            'min_people_per_order' => $minP,
            'max_people_per_order' => $maxP,
            'venue_appointment_type' => $venue?->appointment_type,
            'days' => $days,
        ];
    }
}