Starseed/src/Module/Commercial/Infrastructure/Doctrine/DoctrineClientRepository.php

<?php

declare(strict_types=1);

namespace App\Module\Commercial\Infrastructure\Doctrine;

use App\Module\Commercial\Domain\Entity\Client;
use App\Module\Commercial\Domain\Repository\ClientRepositoryInterface;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\ORM\QueryBuilder;
use Doctrine\Persistence\ManagerRegistry;

/**
 * @extends ServiceEntityRepository<Client>
 */
class DoctrineClientRepository extends ServiceEntityRepository implements ClientRepositoryInterface
{
    public function __construct(ManagerRegistry $registry)
    {
        parent::__construct($registry, Client::class);
    }

    public function findById(int $id): ?Client
    {
        return $this->find($id);
    }

    public function save(Client $client): void
    {
        $this->getEntityManager()->persist($client);
        $this->getEntityManager()->flush();
    }

    public function createListQueryBuilder(
        bool $includeArchived = false,
        ?string $search = null,
        array $categoryCodes = [],
        array $siteIds = [],
        bool $archivedOnly = false,
    ): QueryBuilder {
        $qb = $this->createQueryBuilder('c')
            // Jointures + addSelect pour hydrater en une seule requete les
            // collections affichees par le Repertoire (colonnes Catégories /
            // Site(s)) : sans cela, la serialisation declenche un N+1 (une
            // requete par client, puis par adresse). Le Paginator ORM
            // (fetchJoinCollection: true, cf. ClientProvider) gere le COUNT
            // malgre ces jointures to-many.
            ->leftJoin('c.categories', 'cat')->addSelect('cat')
            ->leftJoin('c.addresses', 'addr')->addSelect('addr')
            ->leftJoin('addr.sites', 'site')->addSelect('site')
            ->andWhere('c.deletedAt IS NULL')
            ->orderBy('c.companyName', 'ASC')
        ;

        // Perimetre d'archivage : archivedOnly prioritaire sur includeArchived.
        if ($archivedOnly) {
            $qb->andWhere('c.isArchived = true');
        } elseif (!$includeArchived) {
            $qb->andWhere('c.isArchived = false');
        }

        $this->applySearch($qb, $search);
        $this->applyCategoryCodes($qb, $categoryCodes);
        $this->applySiteIds($qb, $siteIds);

        return $qb;
    }

    /**
     * Recherche fuzzy insensible a la casse sur companyName + lastName + email.
     * Les metacaracteres LIKE (%, _, \) saisis sont echappes pour rester
     * litteraux.
     */
    private function applySearch(QueryBuilder $qb, ?string $search): void
    {
        if (null === $search || '' === trim($search)) {
            return;
        }

        $escaped = str_replace(['\\', '%', '_'], ['\\\\', '\%', '\_'], trim($search));
        $pattern = '%'.mb_strtolower($escaped, 'UTF-8').'%';

        $qb->andWhere(
            'LOWER(c.companyName) LIKE :search '
            .'OR LOWER(c.lastName) LIKE :search '
            .'OR LOWER(c.email) LIKE :search',
        )->setParameter('search', $pattern);
    }

    /**
     * Restreint aux clients possedant au moins une categorie dont le code figure
     * dans la liste (OR — ERP-78). Alimente le filtre « Catégories » du drawer
     * (multi) ainsi que les selects « distributeur »/« courtier » (un seul code,
     * RG-1.03). Sous-requete IN (plutot qu'un JOIN sur la collection M2M) pour ne
     * pas perturber le DISTINCT / ORDER BY principal.
     *
     * @param list<string> $categoryCodes
     */
    private function applyCategoryCodes(QueryBuilder $qb, array $categoryCodes): void
    {
        $codes = $this->normalizeStringList($categoryCodes);
        if ([] === $codes) {
            return;
        }

        $sub = $this->getEntityManager()->createQueryBuilder()
            ->select('c2.id')
            ->from(Client::class, 'c2')
            ->join('c2.categories', 'cat2')
            ->where('cat2.code IN (:categoryCodes)')
        ;

        $qb->andWhere($qb->expr()->in('c.id', $sub->getDQL()))
            ->setParameter('categoryCodes', $codes)
        ;
    }

    /**
     * Restreint aux clients ayant au moins une adresse rattachee a l'un des
     * sites donnes (OR — RG-1.10 : les sites vivent sur les adresses, pas sur le
     * client). Sous-requete IN pour ne pas perturber le tri/pagination principal.
     *
     * @param list<int> $siteIds
     */
    private function applySiteIds(QueryBuilder $qb, array $siteIds): void
    {
        $ids = $this->normalizeIntList($siteIds);
        if ([] === $ids) {
            return;
        }

        $sub = $this->getEntityManager()->createQueryBuilder()
            ->select('c3.id')
            ->from(Client::class, 'c3')
            ->join('c3.addresses', 'addr3')
            ->join('addr3.sites', 'site3')
            ->where('site3.id IN (:siteIds)')
        ;

        $qb->andWhere($qb->expr()->in('c.id', $sub->getDQL()))
            ->setParameter('siteIds', $ids)
        ;
    }

    /**
     * Nettoie une liste de chaines : trim, retrait des vides, reindexation.
     *
     * @param list<string> $values
     *
     * @return list<string>
     */
    private function normalizeStringList(array $values): array
    {
        $cleaned = array_filter(
            array_map(static fn (string $v): string => trim($v), $values),
            static fn (string $v): bool => '' !== $v,
        );

        return array_values($cleaned);
    }

    /**
     * Nettoie une liste d'identifiants : cast int, retrait des <= 0, reindexation.
     *
     * @param list<int> $values
     *
     * @return list<int>
     */
    private function normalizeIntList(array $values): array
    {
        return array_values(array_filter($values, static fn (int $v): bool => $v > 0));
    }
}