New-Thanasoft/thanasoft-back/app/Http/Controllers/Api/ClientGroupController.php

<?php

declare(strict_types=1);

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Requests\AssignClientsToGroupRequest;
use App\Http\Requests\StoreClientGroupRequest;
use App\Http\Requests\UpdateClientGroupRequest;
use App\Http\Resources\Client\ClientGroupResource;
use App\Models\Client;
use App\Repositories\ClientGroupRepositoryInterface;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\DB;

class ClientGroupController extends Controller
{
    public function __construct(
        private readonly ClientGroupRepositoryInterface $clientGroupRepository
    ) {
    }

    /**
     * Display a listing of client groups.
     */
    public function index(Request $request): AnonymousResourceCollection|JsonResponse
    {
        try {
            $perPage = (int) $request->get('per_page', 5);
            $filters = array_filter([
                'search' => $request->get('search'),
                'sort_by' => $request->get('sort_by', 'created_at'),
                'sort_direction' => $request->get('sort_direction', 'desc'),
            ], static fn ($value) => $value !== null && $value !== '');

            $clientGroups = $this->clientGroupRepository->paginate($perPage, $filters);

            return ClientGroupResource::collection($clientGroups);
        } catch (\Exception $e) {
            Log::error('Error fetching client groups: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
            ]);

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

    /**
     * Store a newly created client group.
     */
    public function store(StoreClientGroupRequest $request): ClientGroupResource|JsonResponse
    {
        try {
            $validated = $request->validated();

            $clientGroup = DB::transaction(function () use ($validated) {
                $clientIds = Arr::get($validated, 'client_ids', []);

                $clientGroup = $this->clientGroupRepository->create(Arr::except($validated, ['client_ids']));

                if (!empty($clientIds)) {
                    Client::query()
                        ->whereIn('id', $clientIds)
                        ->update(['group_id' => $clientGroup->id]);
                }

                return $clientGroup->load(['clients'])->loadCount('clients');
            });

            return new ClientGroupResource($clientGroup);
        } catch (\Exception $e) {
            Log::error('Error creating client group: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'data' => $request->validated(),
            ]);

            return response()->json([
                'message' => 'Une erreur est survenue lors de la création du groupe de clients.',
                'error' => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    }

    /**
     * Display the specified client group.
     */
    public function show(string $id): ClientGroupResource|JsonResponse
    {
        try {
            $clientGroup = $this->clientGroupRepository->find($id);

            if (!$clientGroup) {
                return response()->json([
                    'message' => 'Groupe de clients non trouvé.',
                ], 404);
            }

            $clientGroup->load(['clients'])->loadCount('clients');

            return new ClientGroupResource($clientGroup);
        } catch (\Exception $e) {
            Log::error('Error fetching client group: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'client_group_id' => $id,
            ]);

            return response()->json([
                'message' => 'Une erreur est survenue lors de la récupération du groupe de clients.',
                'error' => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    }

    /**
     * Update the specified client group.
     */
    public function update(UpdateClientGroupRequest $request, string $id): ClientGroupResource|JsonResponse
    {
        try {
            $validated = $request->validated();

            $updated = DB::transaction(function () use ($id, $validated) {
                $updated = $this->clientGroupRepository->update($id, Arr::except($validated, ['client_ids']));

                if (!$updated) {
                    return false;
                }

                if (array_key_exists('client_ids', $validated)) {
                    $clientIds = $validated['client_ids'] ?? [];

                    Client::query()
                        ->where('group_id', (int) $id)
                        ->whereNotIn('id', $clientIds)
                        ->update(['group_id' => null]);

                    if (!empty($clientIds)) {
                        Client::query()
                            ->whereIn('id', $clientIds)
                            ->update(['group_id' => (int) $id]);
                    }
                }

                return true;
            });

            if (!$updated) {
                return response()->json([
                    'message' => 'Groupe de clients non trouvé ou échec de la mise à jour.',
                ], 404);
            }

            $clientGroup = $this->clientGroupRepository->find($id);
            $clientGroup?->load(['clients'])->loadCount('clients');

            return new ClientGroupResource($clientGroup);
        } catch (\Exception $e) {
            Log::error('Error updating client group: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'client_group_id' => $id,
                'data' => $request->validated(),
            ]);

            return response()->json([
                'message' => 'Une erreur est survenue lors de la mise à jour du groupe de clients.',
                'error' => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    }

    /**
     * Remove the specified client group.
     */
    public function destroy(string $id): JsonResponse
    {
        try {
            $deleted = $this->clientGroupRepository->delete($id);

            if (!$deleted) {
                return response()->json([
                    'message' => 'Groupe de clients non trouvé ou échec de la suppression.',
                ], 404);
            }

            return response()->json([
                'message' => 'Groupe de clients supprimé avec succès.',
            ], 200);
        } catch (\Exception $e) {
            Log::error('Error deleting client group: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'client_group_id' => $id,
            ]);

            return response()->json([
                'message' => 'Une erreur est survenue lors de la suppression du groupe de clients.',
                'error' => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    }

    /**
     * Assign many clients to one client group.
     */
    public function assignClients(AssignClientsToGroupRequest $request, string $id): JsonResponse
    {
        try {
            $clientGroup = $this->clientGroupRepository->find($id);

            if (!$clientGroup) {
                return response()->json([
                    'message' => 'Groupe de clients non trouvé.',
                ], 404);
            }

            $clientIds = $request->validated('client_ids');

            $updatedCount = DB::transaction(function () use ($clientIds, $clientGroup) {
                return Client::query()
                    ->whereIn('id', $clientIds)
                    ->update(['group_id' => $clientGroup->id]);
            });

            $clientGroup->load(['clients'])->loadCount('clients');

            return response()->json([
                'message' => 'Clients assignés au groupe avec succès.',
                'assigned_count' => $updatedCount,
                'group' => new ClientGroupResource($clientGroup),
            ]);
        } catch (\Exception $e) {
            Log::error('Error assigning clients to group: ' . $e->getMessage(), [
                'exception' => $e,
                'trace' => $e->getTraceAsString(),
                'client_group_id' => $id,
                'data' => $request->validated(),
            ]);

            return response()->json([
                'message' => 'Une erreur est survenue lors de l’assignation des clients au groupe.',
                'error' => config('app.debug') ? $e->getMessage() : null,
            ], 500);
        }
    }
}