<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Requests\StoreDeceasedRequest;
use App\Http\Requests\UpdateDeceasedRequest;
use App\Http\Resources\Deceased\DeceasedResource;
use App\Http\Resources\Deceased\DeceasedCollection;
use App\Models\Deceased;
use App\Repositories\DeceasedRepositoryInterface;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Symfony\Component\HttpFoundation\Response;

class DeceasedController extends Controller
{
    /**
     * @var DeceasedRepositoryInterface
     */
    protected $deceasedRepository;

    /**
     * DeceasedController constructor.
     *
     * @param DeceasedRepositoryInterface $deceasedRepository
     */
    public function __construct(DeceasedRepositoryInterface $deceasedRepository)
    {
        $this->deceasedRepository = $deceasedRepository;
    }

    /**
     * Display a listing of the resource.
     */
    public function index(Request $request): JsonResponse
    {
        try {
            $filters = $request->only([
                'search',
                'start_date',
                'end_date',
                'sort_by',
                'sort_order'
            ]);

            $perPage = $request->input('per_page', 15);

            $deceased = $this->deceasedRepository->getAllPaginated($filters, $perPage);

            return response()->json(new DeceasedCollection($deceased));
        } catch (\Exception $e) {
            Log::error('Error fetching deceased list: ' . $e->getMessage());

            return response()->json([
                'message' => 'Une erreur est survenue lors de la récupération des défunts.',
                'error' => $e->getMessage()
            ], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(StoreDeceasedRequest $request): JsonResponse
    {
        try {
            $validated = $request->validated();

            $deceased = $this->deceasedRepository->create($validated);

            return response()->json(new DeceasedResource($deceased), Response::HTTP_CREATED);
        } catch (\Exception $e) {
            Log::error('Error creating deceased: ' . $e->getMessage());

            return response()->json([
                'message' => 'Une erreur est survenue lors de la création du défunt.',
                'error' => $e->getMessage()
            ], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * Display the specified resource.
     */
    public function show(int $id): JsonResponse
    {
        try {
            $deceased = $this->deceasedRepository->findById($id);

            return response()->json(new DeceasedResource($deceased));
        } catch (\Exception $e) {
            Log::error('Error fetching deceased details: ' . $e->getMessage());

            return response()->json([
                'message' => 'Défunt non trouvé ou une erreur est survenue.',
                'error' => $e->getMessage()
            ], Response::HTTP_NOT_FOUND);
        }
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(UpdateDeceasedRequest $request, int $id): JsonResponse
    {
        try {
            $deceased = $this->deceasedRepository->findById($id);

            $validated = $request->validated();

            $updatedDeceased = $this->deceasedRepository->update($deceased, $validated);

            return response()->json(new DeceasedResource($updatedDeceased));
        } catch (\Exception $e) {
            Log::error('Error updating deceased: ' . $e->getMessage());

            return response()->json([
                'message' => 'Une erreur est survenue lors de la mise à jour du défunt.',
                'error' => $e->getMessage()
            ], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(int $id): JsonResponse
    {
        try {
            $deceased = $this->deceasedRepository->findById($id);

            $this->deceasedRepository->delete($deceased);

            return response()->json(null, Response::HTTP_NO_CONTENT);
        } catch (\Exception $e) {
            Log::error('Error deleting deceased: ' . $e->getMessage());

            return response()->json([
                'message' => 'Une erreur est survenue lors de la suppression du défunt.',
                'error' => $e->getMessage()
            ], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }
    /**
     * Search deceased by name or other criteria.
     */
    public function searchBy(Request $request): JsonResponse
    {
        try {
            $search = $request->get('search', '');

            if (empty($search)) {
                return response()->json([
                    'message' => 'Le paramètre "search" est requis.',
                ], 400);
            }

            $deceased = $this->deceasedRepository->searchByName($search);

            return response()->json([
                'data' => $deceased,
                'count' => $deceased->count(),
                'message' => $deceased->count() > 0
                    ? 'Défunts trouvés avec succès.'
                    : 'Aucun défunt trouvé.',
            ], 200);

        } catch (\Exception $e) {
            Log::error('Error searching deceased by name: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'search_term' => $search ?? '',
            ]);

            return response()->json([
                'message' => 'Une erreur est survenue lors de la recherche des défunts.',
                'error' => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    }
}