sfp_api_laravel_serprati/app/Http/Controllers/AppointmentController.php

<?php

namespace App\Http\Controllers;

use App\Http\Requests\AppointmentApproveRequest;
use App\Http\Requests\AppointmentRequest;
use App\Http\Resources\AppointmentResource;
use App\Models\Appointment;
use App\Services\AppointmentGuideService;
use App\Services\AppointmentService;
use App\Enums\AppointmentStatusEnum;
use App\Enums\UserStatusEnum;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Auth;

class AppointmentController extends Controller
{
    public function __construct(
        protected AppointmentService $service,
        protected AppointmentGuideService $guideService,
    ) {}

    public function index(): JsonResponse
    {
        $items = $this->service->getAll();
        return $this->successResponse(payload: AppointmentResource::collection($items));
    }

    public function myAppointments(): JsonResponse
    {
        $items = $this->service->getAllByUser(Auth::id());
        return $this->successResponse(payload: AppointmentResource::collection($items));
    }

    public function partnerAppointments(): JsonResponse
    {
        $items = $this->service->getAllByPartnerUser(Auth::id());
        return $this->successResponse(payload: AppointmentResource::collection($items));
    }

    public function getByUser(int $id): JsonResponse
    {
        $items = $this->service->getAllByUser($id);
        return $this->successResponse(payload: AppointmentResource::collection($items));
    }

    public function store(AppointmentRequest $request): JsonResponse
    {
        $data = $request->validated();
        $authUser = Auth::user();
        $creatingForOther = isset($data['user_id']) && (int) $data['user_id'] !== $authUser->id;

        if ($creatingForOther) {
            $data['status'] = AppointmentStatusEnum::CONFIRMADO;
            $data['auto_approved'] = true;
        } elseif ($authUser->status === UserStatusEnum::ACTIVE) {
            $data['status'] = AppointmentStatusEnum::CONFIRMADO;
            $data['auto_approved'] = true;
        }

        $item = $this->service->create($data);

        if ($creatingForOther) {
            $this->service->notifyCreation($item);
        }

        return $this->successResponse(
            payload: new AppointmentResource($item),
            message: __('messages.created'),
            code: 201,
        );
    }

    public function show(int $id): JsonResponse
    {
        $item = $this->service->findById($id);
        return $this->successResponse(payload: new AppointmentResource($item));
    }

    public function update(AppointmentRequest $request, int $id): JsonResponse
    {
        $item = $this->service->update($id, $request->validated(), Auth::id());
        return $this->successResponse(
            payload: new AppointmentResource($item),
            message: __('messages.updated'),
        );
    }

    public function destroy(int $id): JsonResponse
    {
        $this->service->delete($id);
        return $this->successResponse(message: __('messages.deleted'), code: 204);
    }

    public function getAdminCounters(): JsonResponse
    {
        return $this->successResponse(payload: $this->service->getAdminCounters());
    }

    public function getAdminAppointmentsPaginated(Request $request): JsonResponse
    {
        $filters = $request->only(['status', 'search']);
        $perPage = (int) $request->input('per_page', 10);
        $paginator = $this->service->getAllPaginated($filters, $perPage);

        $items = collect($paginator->items())->map(fn($a) => [
            'id'                      => $a->id,
            'order_number'            => $a->order_number,
            'registration'            => $a->user?->registration,
            'user_name'               => $a->user?->name,
            'dependent_name'          => $a->userDependent?->name,
            'is_for_dependent'        => $a->user_dependent_id !== null,
            'partner_name'            => $a->partnerAgreement?->company_name,
            'service_name'            => $a->partnerAgreementService?->name,
            'requested_at'            => $a->requested_at?->format('d/m/Y'),
            'status'                  => $a->status?->value,
            'can_issue_guide'         => $this->guideService->canIssue($a),
        ]);

        return $this->successResponse(payload: [
            'data'         => $items,
            'total'        => $paginator->total(),
            'per_page'     => $paginator->perPage(),
            'current_page' => $paginator->currentPage(),
            'from'         => $paginator->firstItem(),
            'to'           => $paginator->lastItem(),
        ]);
    }

    public function approve(AppointmentApproveRequest $request, int $id): JsonResponse
    {
        $item = $this->service->approve($id, $request->date, $request->time, Auth::id());
        return $this->successResponse(payload: new AppointmentResource($item), message: __('messages.updated'));
    }

    public function reject(int $id): JsonResponse
    {
        $item = $this->service->reject($id);
        return $this->successResponse(payload: new AppointmentResource($item), message: __('messages.updated'));
    }

    public function approveByPartner(AppointmentApproveRequest $request, int $id): JsonResponse
    {
        $item = $this->service->approveByPartner($id, Auth::id(), $request->date, $request->time);
        if (!$item) return $this->errorResponse(message: __('messages.not_found'), code: 404);
        return $this->successResponse(payload: new AppointmentResource($item), message: __('messages.updated'));
    }

    public function rejectByPartner(int $id): JsonResponse
    {
        $item = $this->service->rejectByPartner($id, Auth::id());
        if (!$item) return $this->errorResponse(message: __('messages.not_found'), code: 404);
        return $this->successResponse(payload: new AppointmentResource($item), message: __('messages.updated'));
    }

    public function guide(int $id): Response|JsonResponse
    {
        return $this->buildGuide($this->service->findById($id));
    }

    public function myGuide(int $id): Response|JsonResponse
    {
        $item = $this->service->findById($id);

        if ($item && $item->user_id !== Auth::id()) {
            return $this->errorResponse(message: __('messages.unauthorized'), code: 403);
        }

        return $this->buildGuide($item);
    }

    public function partnerGuide(int $id): Response|JsonResponse
    {
        $item = $this->service->findByIdForPartnerUser($id, Auth::id());

        return $this->buildGuide($item);
    }

    private function buildGuide(?Appointment $appointment): Response|JsonResponse
    {
        if (!$appointment) {
            return $this->errorResponse(message: __('messages.not_found'), code: 404);
        }

        if (!$this->guideService->canIssue($appointment)) {
            return $this->errorResponse(message: __('messages.guide_unavailable'), code: 422);
        }

        return $this->guideService
            ->pdf($appointment, Auth::id())
            ->download($this->guideService->fileName($appointment));
    }
}