src/Services/GestionEngagementService.php line 69

Open in your IDE?
  1. <?php
  3. namespace App\Services;
  5. use App\Entity\Engagement\EngagementBudget;
  6. use App\Entity\Engagement\EngagementBudgetEngage;
  7. use App\Entity\Engagement\EngagementBudgetEngageComment;
  8. use App\Entity\Engagement\EngagementBudgetEngageDetail;
  9. use App\Entity\Engagement\EngagementBudgetPrevisionel;
  10. use App\Entity\Engagement\EngagementJalon;
  11. use App\Entity\Engagement\EngagementProjet;
  12. use App\Entity\Engagement\EngagementVersion;
  13. use App\Entity\Engagement\EngagementVersionLog;
  14. use App\Entity\Engagement\TypeDepense;
  15. use App\Entity\Engagement\TypeDepenseStatutAdministatif;
  16. use App\Entity\BonDeCommande;
  17. use App\Entity\DocUpload;
  18. use App\Entity\Etaps;
  19. use App\Entity\EtapsCategory;
  20. use App\Entity\FactureFinance;
  21. use App\Entity\Fournisseur;
  22. use App\Entity\Project;
  23. use App\Entity\Spv;
  24. use App\Repository\EngagementBudgetEngageRepository;
  25. use App\Repository\EngagementBudgetRepository;
  26. use App\Repository\EngagementProjetRepository;
  27. use App\Repository\EngagementVersionRepository;
  28. use Doctrine\ORM\EntityManagerInterface;
  29. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  30. use Symfony\Component\Routing\RouterInterface;
  31. use Symfony\Component\Security\Core\Security;
  32. use Twig\Environment;
  34. class GestionEngagementService
  35. {
  36.     private $em;
  37.     private $router;
  38.     private $security;
  39.     private $twig;
  40.     private $params;
  42.     /** Cache local du facturé par engagé : "bonDeCommandeId|classifErpi" => montant. */
  43.     private $factureEngageCache = [];
  45.     /** @var EngagementProjetRepository */
  46.     private $engagementProjetRepo;
  47.     /** @var EngagementVersionRepository */
  48.     private $engagementVersionRepo;
  49.     /** @var EngagementBudgetRepository */
  50.     private $engagementBudgetRepo;
  51.     /** @var EngagementBudgetEngageRepository */
  52.     private $engagementBudgetEngageRepo;
  53.     /** @var \App\Repository\ProjectRepository */
  54.     private $projectRepo;
  56.     public function __construct(
  57.         EntityManagerInterface $em,
  58.         RouterInterface $router,
  59.         Security $security,
  60.         Environment $twig,
  61.         ParameterBagInterface $params
  62.     ) {
  63.         $this->em       = $em;
  64.         $this->router   = $router;
  65.         $this->security = $security;
  66.         $this->twig     = $twig;
  67.         $this->params   = $params;
  69.         $this->engagementProjetRepo      = $em->getRepository(EngagementProjet::class);
  70.         $this->engagementVersionRepo     = $em->getRepository(EngagementVersion::class);
  71.         $this->engagementBudgetRepo      = $em->getRepository(EngagementBudget::class);
  72.         $this->engagementBudgetEngageRepo = $em->getRepository(EngagementBudgetEngage::class);
  73.         $this->projectRepo                = $em->getRepository(Project::class);
  74.     }
  76.     // ─── PAGINATION LISTE ─────────────────────────────────────────────────────
  78.     public function paginateProjets(array $params): array
  79.     {
  80.         $filters = [
  81.             'search'              => $params['search']['value'] ?? '',
  82.             'spvId'               => $params['spv'] ?? null,
  83.             'statutAdministratif' => $params['statutAdministratif'] ?? null,
  84.         ];
  86.         $start  = (int) ($params['start'] ?? 0);
  87.         $length = (int) ($params['length'] ?? 20);
  88.         $draw   = (int) ($params['draw'] ?? 1);
  90.         // La liste est désormais basée sur les projets (et non sur EngagementProjet) :
  91.         // les projets sans engagement apparaissent aussi.
  92.         $total   = $this->projectRepo->countForEngagementPagination($filters);
  93.         $projets = $this->projectRepo->findForEngagementPagination($filters, $start, $length);
  95.         $data = [];
  96.         foreach ($projets as $projet) {
  97.             $data[] = $this->buildProjetRow($projet);
  98.         }
  100.         return [
  101.             'draw'            => $draw,
  102.             'recordsTotal'    => $total,
  103.             'recordsFiltered' => $total,
  104.             'data'            => $data,
  105.         ];
  106.     }
  108.     private function buildProjetRow(Project $projet): array
  109.     {
  110.         // Données issues de la DERNIÈRE version d'engagement du projet (si elle existe)
  111.         $ep         = $this->engagementProjetRepo->findOneBy(['projet' => $projet]);
  112.         $version    = $ep ? $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId()) : null;
  113.         $hasVersion = $version !== null;
  115.         $totaux = ['totalPrevisionnel' => 0, 'totalEngage' => 0, 'totalFacture' => 0];
  116.         if ($version) {
  117.             $totaux = $this->engagementBudgetRepo->getTotauxByVersion($version->getId());
  118.         }
  120.         $previsionnel = (float) ($totaux['totalPrevisionnel'] ?? 0);
  121.         $engage       = (float) ($totaux['totalEngage'] ?? 0);
  123.         // Budget facturé : calculé par classification (factures payées du projet),
  124.         // comme dans l'arbre de la page détail.
  125.         $facture = 0;
  126.         if ($version) {
  127.             $factureMap = $this->buildFactureMapByClassification($projet);
  128.             if (!empty($factureMap)) {
  129.                 foreach ($this->engagementBudgetRepo->findByVersionWithRelations($version->getId()) as $eb) {
  130.                     $classif = $eb->getTypeDepense() ? $eb->getTypeDepense()->getClassificationDepenseErpi() : null;
  131.                     if ($classif && isset($factureMap[$classif])) {
  132.                         $facture += (float) $factureMap[$classif];
  133.                     }
  134.                 }
  135.             }
  136.         }
  138.         // Budget consommé = (Budget engagé / Budget prévisionnel) * 100
  139.         $consomme     = $previsionnel > 0 ? (int) round(($engage / $previsionnel) * 100) : 0;
  141.         // Liens basés sur le projet (l'EngagementProjet est créé à la volée si nécessaire)
  142.         $showUrl   = $this->router->generate('admin_gestion_engagement_open_by_project', ['projectId' => $projet->getId()]);
  143.         $engageUrl = $this->router->generate('admin_gestion_engagement_engage_by_project', ['projectId' => $projet->getId()]);
  144.         $budgetUrl = $this->router->generate('admin_gestion_engagement_budget_by_project', ['projectId' => $projet->getId()]);
  145.         $statut    = $this->formatStatutAdministratif($projet->getStatusAdministratif());
  146.         $spvName   = $projet->getSpv() ? $projet->getSpv()->getName() : '-';
  148.         $tpl = 'admin/gestion_engagement/default/';
  150.         return [
  151.             'inputCheckbox'       => $this->twig->render($tpl . 'row-checkbox.html.twig', ['id' => $projet->getId()]),
  152.             'name'                => $this->twig->render($tpl . 'projet-link.html.twig', ['url' => $showUrl, 'nom' => $this->formatProjetNom($projet), 'hasVersion' => $hasVersion]),
  153.             'spv'                 => $spvName,
  154.             'statutAdministratif' => $this->twig->render($tpl . 'statut-badge.html.twig', ['statut' => $statut]),
  155.             'previsionnel'        => number_format($previsionnel, 0, ',', ' '),
  156.             'engage'              => number_format($engage, 0, ',', ' '),
  157.             'facture'             => number_format($facture, 0, ',', ' '),
  158.             'consomme'            => $this->twig->render($tpl . 'progress-budget.html.twig', ['pct' => $consomme]),
  159.             'action'              => $this->twig->render($tpl . 'action-menu.html.twig', ['showUrl' => $showUrl, 'engageUrl' => $engageUrl, 'budgetUrl' => $budgetUrl]),
  160.         ];
  161.     }
  163.     // ─── DÉTAIL PROJET (ARBRE) ────────────────────────────────────────────────
  165.     public function getBudgetTree(EngagementProjet $ep, ?int $versionId): array
  166.     {
  167.         $version = $versionId
  168.             ? $this->engagementVersionRepo->findWithLogsByVersion($versionId)
  169.             : $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  171.         if (!$version) {
  172.             return ['rows' => [], 'version' => null, 'jalon' => null, 'totaux' => $this->emptyTotaux(), 'seuils' => [], 'ratios' => ['ebeCapex' => null, 'equity' => null, 'dette' => null]];
  173.         }
  175.         $budgets = $this->engagementBudgetRepo->findByVersionWithRelations($version->getId());
  176.         $totaux  = $this->engagementBudgetRepo->getTotauxByVersion($version->getId());
  178.         // Budget facturé : niveau 1 + total = mapping par classification (inchangé) ;
  179.         // niveaux 2 et 3 = roll-up des sous-lignes (facturé par engagé), géré dans buildTree.
  180.         $factureMap   = $this->buildFactureMapByClassification($ep->getProjet());
  181.         $factureTotal = 0;
  182.         foreach ($budgets as $eb) {
  183.             $classif = $eb->getTypeDepense() ? $eb->getTypeDepense()->getClassificationDepenseErpi() : null;
  184.             if ($classif && isset($factureMap[$classif])) {
  185.                 $factureTotal += (float) $factureMap[$classif];
  186.             }
  187.         }
  189.         $tree = $this->buildTree($budgets, $ep->getId(), $factureMap, $version->getId());
  191.         return [
  192.             'rows'   => $tree,
  193.             'jalon'  => $version->getEngagementJalon() ? $version->getEngagementJalon()->getName() : null,
  194.             'totaux' => [
  195.                 'previsionnel' => number_format((float) ($totaux['totalPrevisionnel'] ?? 0), 0, ',', ' '),
  196.                 'engage'       => number_format((float) ($totaux['totalEngage'] ?? 0), 0, ',', ' '),
  197.                 'facture'      => number_format($factureTotal, 0, ',', ' '),
  198.             ],
  199.             'seuils'  => $this->buildSeuilsMax($version, $budgets),
  200.             // Ratios financiers issus de la fiche transfert (dernier tableau)
  201.             'ratios'  => [
  202.                 'ebeCapex' => $version->getEbeCapex(),
  203.                 'equity'   => $version->getEquity(),
  204.                 'dette'    => $version->getDette(),
  205.             ],
  206.             'version' => [
  207.                 'id'        => $version->getId(),
  208.                 'createdAt' => $version->getCreatedAt() ? $version->getCreatedAt()->format('d/m/Y') : null,
  209.             ],
  210.         ];
  211.     }
  213.     /**
  214.      * Bloc « Seuils max » : pour chaque catégorie (statut administratif), calcule le total engagé
  215.      * et le pourcentage par rapport au seuil configuré sur la version.
  216.      *
  217.      * - Catégorie d'une ligne = statut administratif lié à son TypeDepense (typeDepenseStatutAdministatif),
  218.      *   en remontant la hiérarchie si nécessaire.
  219.      * - Pourcentage = montant total engagé de la catégorie / seuil configuré × 100.
  220.      * - Montant affiché sur chaque barre = montant total engagé de la catégorie.
  221.      *
  222.      * @param EngagementBudget[] $budgets
  223.      */
  224.     private function buildSeuilsMax(EngagementVersion $version, array $budgets): array
  225.     {
  226.         // Seuils configurés par catégorie
  227.         $seuils = [
  228.             EngagementVersion::CAT_Prospection           => (float) $version->getProspectionMontant(),
  229.             EngagementVersion::CAT_Montage_Administratif => (float) $version->getMontageAdministratifMontant(),
  230.             EngagementVersion::CAT_Developpement         => (float) $version->getDeveloppementMontant(),
  231.             EngagementVersion::CAT_Construction          => (float) $version->getConstructionMontant(),
  232.         ];
  234.         // Montant total engagé cumulé par catégorie
  235.         $engages = array_fill_keys(array_keys($seuils), 0.0);
  236.         foreach ($budgets as $eb) {
  237.             $montant = 0.0;
  238.             foreach ($this->ebEngageDetails($eb) as $detail) {
  239.                 $montant += (float) ($detail->getEngageMontant() ?? 0);
  240.             }
  241.             if ($montant === 0.0) {
  242.                 continue;
  243.             }
  244.             $cat = $this->resolveStatutAdministratif($eb->getTypeDepense());
  245.             if ($cat !== null && isset($engages[$cat])) {
  246.                 $engages[$cat] += $montant;
  247.             }
  248.         }
  250.         $result = [];
  251.         foreach ($this->getStatutsAdministratifs() as $cat => $label) {
  252.             $seuil  = $seuils[$cat];
  253.             $engage = $engages[$cat];
  254.             $pct    = $seuil > 0 ? ($engage / $seuil) * 100 : 0;
  255.             $result[] = [
  256.                 'cat'         => $cat,
  257.                 'label'       => $label,
  258.                 'seuil'       => $seuil,
  259.                 'engage'      => $engage,
  260.                 'pourcentage' => $pct,
  261.                 'depasse'     => $pct > 100,
  262.             ];
  263.         }
  265.         return $result;
  266.     }
  268.     // ─── DÉPASSEMENTS BUDGÉTAIRES (alertes / notifications) ────────────────────
  270.     /**
  271.      * Type comptable racine (niveau 1) d'une ligne : DEVEX | CAPEX | OPEX (ou null),
  272.      * lu depuis le champ `type` du TypeDepense de niveau 1 (racine de la hiérarchie).
  273.      */
  274.     private function rootType(?TypeDepense $type): ?string
  275.     {
  276.         if ($type === null) {
  277.             return null;
  278.         }
  279.         $node = $type;
  280.         while ($node->getParent() !== null) {
  281.             $node = $node->getParent();
  282.         }
  283.         $t = $node->getType();
  285.         return $t !== null ? strtoupper(trim($t)) : null;
  286.     }
  288.     /**
  289.      * Prévisionnel / engagé par type comptable (DEVEX, CAPEX) et global (DEVEX + CAPEX) d'une version.
  290.      * DEVEX / CAPEX déterminés via le champ `type` de TypeDepense (racine de niveau 1).
  291.      *
  292.      * @return array{devex:array,capex:array,global:array}
  293.      *   chaque sous-tableau : {prev:float, eng:float, depasse:bool, depassement:float}
  294.      */
  295.     public function computeDevexCapexGlobal(EngagementVersion $version): array
  296.     {
  297.         $budgets = $this->engagementBudgetRepo->findByVersionWithRelations($version->getId());
  299.         $prev = ['DEVEX' => 0.0, 'CAPEX' => 0.0];
  300.         $eng  = ['DEVEX' => 0.0, 'CAPEX' => 0.0];
  302.         foreach ($budgets as $eb) {
  303.             $root = $this->rootType($eb->getTypeDepense());
  304.             if ($root !== 'DEVEX' && $root !== 'CAPEX') {
  305.                 continue;
  306.             }
  307.             // Prévisionnel : porté par les lignes de niveau « code budget » (comme buildTree)
  308.             if ($eb->getTypeDepense() && (int) $eb->getTypeDepense()->getNiveau() === TypeDepense::NIVEAU_CODE_BUDGET) {
  309.                 $ebP = $eb->getEngagementBudgetPrevisionel();
  310.                 $prev[$root] += $ebP ? (float) ($ebP->getMontant() ?? 0) : 0.0;
  311.             }
  312.             // Engagé : somme des détails d'engagé de la ligne
  313.             $m = 0.0;
  314.             foreach ($this->ebEngageDetails($eb) as $d) {
  315.                 $m += (float) ($d->getEngageMontant() ?? 0);
  316.             }
  317.             $eng[$root] += $m;
  318.         }
  320.         $mk = function (float $p, float $e): array {
  321.             return [
  322.                 'prev'        => $p,
  323.                 'eng'         => $e,
  324.                 // Dépassement actif seulement si le prévisionnel est défini (> 0)
  325.                 'depasse'     => $p > 0 && $e > $p,
  326.                 'depassement' => max(0.0, $e - $p),
  327.             ];
  328.         };
  330.         return [
  331.             'devex'  => $mk($prev['DEVEX'], $eng['DEVEX']),
  332.             'capex'  => $mk($prev['CAPEX'], $eng['CAPEX']),
  333.             'global' => $mk($prev['DEVEX'] + $prev['CAPEX'], $eng['DEVEX'] + $eng['CAPEX']),
  334.         ];
  335.     }
  337.     /**
  338.      * Seuils (catégories) d'une version avec l'engagé cumulé et le drapeau de dépassement
  339.      * (Prospection / Montage administratif / Développement / Construction) — utilisés pour le
  340.      * blocage du bouton « Ajouter un engagé » et l'autorisation de dépassement.
  341.      *
  342.      * @return array<int, array{cat:int,label:string,seuil:float,engage:float,pourcentage:float,depasse:bool}>
  343.      */
  344.     public function getSeuilsForVersion(EngagementVersion $version): array
  345.     {
  346.         $budgets = $this->engagementBudgetRepo->findByVersionWithRelations($version->getId());
  348.         return $this->buildSeuilsMax($version, $budgets);
  349.     }
  351.     /**
  352.      * Vrai si au moins une catégorie est en dépassement → bloque l'ajout d'un engagé (Action 6).
  353.      */
  354.     public function isEngageBloque(?EngagementVersion $version): bool
  355.     {
  356.         if (!$version) {
  357.             return false;
  358.         }
  359.         foreach ($this->getSeuilsForVersion($version) as $s) {
  360.             if (!empty($s['depasse'])) {
  361.                 return true;
  362.             }
  363.         }
  365.         return false;
  366.     }
  368.     /**
  369.      * Dépassement d'une SPV (N4) : par projet, prévisionnel/engagé global = DEVEX + CAPEX ;
  370.      * on somme sur tous les projets de la SPV. Renvoie le détail par projet pour l'email admin.
  371.      */
  372.     public function computeSpvDepassement(Spv $spv): array
  373.     {
  374.         $totalPrev = 0.0;
  375.         $totalEng  = 0.0;
  376.         $lignes    = [];
  378.         foreach ($this->projectRepo->findBy(['spv' => $spv]) as $projet) {
  379.             $ep = $this->engagementProjetRepo->findOneBy(['projet' => $projet]);
  380.             if (!$ep) {
  381.                 continue;
  382.             }
  383.             $version = $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  384.             if (!$version) {
  385.                 continue;
  386.             }
  387.             $g = $this->computeDevexCapexGlobal($version)['global'];
  388.             $p = (float) $g['prev'];
  389.             $e = (float) $g['eng'];
  390.             $totalPrev += $p;
  391.             $totalEng  += $e;
  392.             $lignes[]   = [
  393.                 'projet'       => $projet->getName(),
  394.                 'previsionnel' => $p,
  395.                 'engage'       => $e,
  396.                 'depassement'  => max(0.0, $e - $p),
  397.             ];
  398.         }
  400.         return [
  401.             'previsionnel' => $totalPrev,
  402.             'engage'       => $totalEng,
  403.             'depasse'      => $totalPrev > 0 && $totalEng > $totalPrev,
  404.             'depassement'  => max(0.0, $totalEng - $totalPrev),
  405.             'projets'      => $lignes,
  406.         ];
  407.     }
  409.     /**
  410.      * Statut administratif (catégorie) associé à un TypeDepense, en remontant la hiérarchie
  411.      * jusqu'à trouver un statut configuré. Retourne la valeur entière (1..4) ou null.
  412.      */
  413.     private function resolveStatutAdministratif(?TypeDepense $type): ?int
  414.     {
  415.         while ($type !== null) {
  416.             foreach ($type->getTypeDepenseStatutAdministatif() as $s) {
  417.                 $val = $s->getStatutAdministratif();
  418.                 if ($val !== null && trim((string) $val) !== '') {
  419.                     return (int) $val;
  420.                 }
  421.             }
  422.             $type = $type->getParent();
  423.         }
  425.         return null;
  426.     }
  428.     /**
  429.      * Getter/setter du montant seuil de chaque catégorie sur la version.
  430.      *
  431.      * @return array<int, array{0:string,1:string}>
  432.      */
  433.     private function seuilAccessors(): array
  434.     {
  435.         return [
  436.             EngagementVersion::CAT_Prospection           => ['getProspectionMontant', 'setProspectionMontant'],
  437.             EngagementVersion::CAT_Montage_Administratif => ['getMontageAdministratifMontant', 'setMontageAdministratifMontant'],
  438.             EngagementVersion::CAT_Developpement         => ['getDeveloppementMontant', 'setDeveloppementMontant'],
  439.             EngagementVersion::CAT_Construction          => ['getConstructionMontant', 'setConstructionMontant'],
  440.         ];
  441.     }
  443.     /**
  444.      * Cibles autorisables : seuils par catégorie (clé numérique = valeur CAT_* :
  445.      * Prospection / Montage administratif / Développement / Construction).
  446.      *
  447.      * @return array<string, array{0:string,1:string,2:string}>  [getter, setter, libellé]
  448.      */
  449.     private function depassementAccessors(): array
  450.     {
  451.         $labels = $this->getStatutsAdministratifs();
  452.         $map    = [];
  453.         foreach ($this->seuilAccessors() as $cat => $acc) {
  454.             $map[(string) $cat] = [$acc[0], $acc[1], $labels[$cat] ?? ('Seuil ' . $cat)];
  455.         }
  457.         return $map;
  458.     }
  460.     /**
  461.      * Autorise un dépassement (Action 8) : remplace le seuil de la catégorie sur la version et
  462.      * journalise l'ancienne → la nouvelle valeur dans EngagementVersionLog.
  463.      *
  464.      * @param string|int $cible          '1'..'4' (catégorie de seuil)
  465.      * @param mixed      $nouveauMontant
  466.      */
  467.     public function autoriserDepassement(EngagementProjet $ep, ?int $versionId, $cible, $nouveauMontant, ?object $user): array
  468.     {
  469.         $version = $versionId
  470.             ? $this->engagementVersionRepo->find($versionId)
  471.             : $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  473.         if (!$version || ($version->getEngagementProjet() && $version->getEngagementProjet()->getId() !== $ep->getId())) {
  474.             return ['success' => false, 'message' => 'Version introuvable.'];
  475.         }
  477.         $accessors = $this->depassementAccessors();
  478.         $cible     = (string) $cible;
  479.         if (!isset($accessors[$cible])) {
  480.             return ['success' => false, 'message' => 'Cible de dépassement invalide.'];
  481.         }
  483.         $newMontant = $this->toFloat($nouveauMontant);
  484.         if ($newMontant === null || $newMontant < 0) {
  485.             return ['success' => false, 'message' => 'Le montant autorisé est invalide.'];
  486.         }
  488.         [$getter, $setter, $label] = $accessors[$cible];
  489.         $oldMontant = (float) $version->{$getter}();
  491.         $version->{$setter}($newMontant);
  493.         $oldStr = number_format($oldMontant, 0, ',', ' ') . ' €';
  494.         $newStr = number_format($newMontant, 0, ',', ' ') . ' €';
  495.         $action = 'Autorisation de dépassement — ' . $label . $this->formatOldNew($oldStr, $newStr);
  496.         $this->logAction($version, $action, $user);
  498.         $this->em->flush();
  500.         return ['success' => true, 'message' => 'Le dépassement « ' . $label . ' » a été autorisé.'];
  501.     }
  503.     /**
  504.      * Détails d'engagé d'une ligne budget (un par engagé rattaché). Utilise la collection
  505.      * engagementBudgetEngageDetails ; repli sur l'ancien lien unique pour les données non migrées.
  506.      *
  507.      * @return EngagementBudgetEngageDetail[]
  508.      */
  509.     private function ebEngageDetails(EngagementBudget $eb): array
  510.     {
  511.         $details = $eb->getEngagementBudgetEngageDetails()->toArray();
  512.         if (empty($details) && $eb->getEngagementBudgetEngageDetail()) {
  513.             $details = [$eb->getEngagementBudgetEngageDetail()];
  514.         }
  515.         return $details;
  516.     }
  518.     /** Détail d'une ligne budget correspondant à un engagé donné (ou null). */
  519.     private function ebDetailForEngage(EngagementBudget $eb, int $engageId): ?EngagementBudgetEngageDetail
  520.     {
  521.         foreach ($this->ebEngageDetails($eb) as $d) {
  522.             $e = $d->getEngagementBudgetEngage();
  523.             if ($e && $e->getId() === $engageId) {
  524.                 return $d;
  525.             }
  526.         }
  527.         return null;
  528.     }
  530.     private function buildTree(array $budgets, int $epId, array $factureMap = [], ?int $versionId = null): array
  531.     {
  532.         $grouped = [];
  534.         // URL du modal détails, basée sur le type de dépense (toujours disponible, même sans engagé)
  535.         $detailsUrl = function (?int $typeId) use ($epId, $versionId) {
  536.             if (!$typeId) {
  537.                 return null;
  538.             }
  539.             $params = ['id' => $epId, 'typeId' => $typeId];
  540.             if ($versionId) {
  541.                 $params['version'] = $versionId;
  542.             }
  543.             return $this->router->generate('admin_gestion_engagement_details', $params);
  544.         };
  546.         foreach ($budgets as $eb) {
  547.             // Hiérarchie reconstruite à partir du TypeDepense de la ligne :
  548.             // chaîne racine → feuille suivant le niveau (parent).
  549.             $chain = [];
  550.             $node  = $eb->getTypeDepense();
  551.             while ($node !== null) {
  552.                 array_unshift($chain, $node);
  553.                 $node = $node->getParent();
  554.             }
  556.             $n1     = $chain[0] ?? null;             // niveau 1
  557.             $n2     = $chain[1] ?? null;             // niveau 2
  558.             $leaf   = $eb->getTypeDepense();         // TypeDepense porté par la ligne
  559.             $niveau = $leaf ? (int) $leaf->getNiveau() : 0;
  560.             // Classification ERPI de la ligne (sert au facturé par classification — niveaux n1/n2/n3).
  561.             $classifErpi = $leaf ? $leaf->getClassificationDepenseErpi() : null;
  562.             // Classification ERPI du NIVEAU 1 : base du filtre facturé par engagé (niveau 4).
  563.             $classifErpiN1 = $n1 ? $n1->getClassificationDepenseErpi() : null;
  565.             $fournisseur  = '-';
  566.             $engageId     = null;
  568.             // Budget engagé : une ligne peut porter PLUSIEURS engagés (un détail par engagé).
  569.             // On construit la liste des engagés + la somme des montants propres à la ligne.
  570.             $engagesList = [];
  571.             $engage      = 0.0;
  572.             foreach ($this->ebEngageDetails($eb) as $d) {
  573.                 $dEbe = $d->getEngagementBudgetEngage();
  574.                 $m    = (float) ($d->getEngageMontant() ?? 0);
  575.                 $engage += $m;
  576.                 // Libellé de l'engagé : n° de devis du bon de commande si présent, sinon l'id de l'engagé.
  577.                 $bdc         = $dEbe ? $dEbe->getBonDeCommande() : null;
  578.                 $numeroDevis = $bdc ? trim((string) $bdc->getNumeroDevis()) : '';
  579.                 $fournisseurBonDeCommande = '-';
  580.                 if ($bdc && $bdc->getFournisseur()) {
  581.                     $fournisseurBonDeCommande = trim((string) $bdc->getFournisseur());
  582.                 } elseif ($dEbe && $dEbe->getFournisseur()) {
  583.                     $fournisseurBonDeCommande = $dEbe->getFournisseur()->getName();
  584.                 }
  585.                 $engagesList[] = [
  586.                     'engageId'    => $dEbe ? $dEbe->getId() : null,
  587.                     'fournisseur' => $fournisseurBonDeCommande,
  588.                     'montantRaw'  => $m,
  589.                     // Facturé de l'engagé : factures payées correspondant à son bon de commande
  590.                     // (classification = celle du NIVEAU 1).
  591.                     'factureRaw'  => $dEbe ? $this->factureMontantForEngage($dEbe, $classifErpiN1) : 0.0,
  592.                     'label'       => $numeroDevis !== '' ? $numeroDevis : ($dEbe ? (string) $dEbe->getId() : '-'),
  593.                 ];
  594.             }
  595.             // rétro-compat : premier engagé (fournisseur / lien unique des niveaux agrégés)
  596.             if (!empty($engagesList)) {
  597.                 $fournisseur = $engagesList[0]['fournisseur'];
  598.                 $engageId    = $engagesList[0]['engageId'];
  599.             }
  601.             // Budget prévisionnel : porté par EngagementBudgetPrevisionel->montant
  602.             $ebP          = $eb->getEngagementBudgetPrevisionel();
  603.             $previsionnel = $ebP ? (float) ($ebP->getMontant() ?? 0) : 0;
  605.             // Budget facturé — niveau 1 : mapping par classification (ancienne version, inchangé).
  606.             $factureClassif = ($classifErpi && isset($factureMap[$classifErpi])) ? (float) $factureMap[$classifErpi] : 0;
  607.             // Budget facturé — niveaux 2 et 3 : somme des sous-lignes (facturé par engagé), en roll-up.
  608.             $factureEngage = 0.0;
  609.             foreach ($engagesList as $e) {
  610.                 $factureEngage += (float) ($e['factureRaw'] ?? 0);
  611.             }
  613.             // ── Groupe Niveau 1 ──
  614.             $n1Key   = $n1 ? $n1->getId() : 0;
  615.             if (!isset($grouped[$n1Key])) {
  616.                 $grouped[$n1Key] = [
  617.                     'typeId'       => $n1 ? $n1->getId() : null,
  618.                     'classif'      => $n1 ? $n1->getClassificationDepenseErpi() : null,
  619.                     'label'        => $n1 ? $n1->getLibelle() : 'Autre',
  620.                     'previsionnel' => 0,
  621.                     'engage'       => 0,
  622.                     'facture'      => 0,
  623.                     'fournisseur'  => '-',
  624.                     'engageId'     => null,
  625.                     'detailsUrl'   => $detailsUrl($n1 ? $n1->getId() : null),
  626.                     'children'     => [],
  627.                 ];
  628.             }
  629.             // Le prévisionnel est porté par la ligne de SON propre niveau (pas de cumul
  630.             // depuis les niveaux enfants → évite le double comptage). L'engagé est porté
  631.             // par les lignes de dépense (niveau 3) et remonte vers la catégorie / code budget.
  632.             if ($niveau === TypeDepense::NIVEAU_CODE_BUDGET) {
  633.                 $grouped[$n1Key]['previsionnel'] += $previsionnel;
  634.             }
  635.             $grouped[$n1Key]['engage']  += $engage;
  636.             $grouped[$n1Key]['facture'] += $factureClassif;
  638.             // Engagé porté directement par le code budget (niveau 1) → utilisé par l'onglet Engagé
  639.             if ($niveau === TypeDepense::NIVEAU_CODE_BUDGET && $engageId) {
  640.                 $grouped[$n1Key]['engageId']    = $engageId;
  641.                 $grouped[$n1Key]['fournisseur'] = $fournisseur;
  642.             }
  644.             // ── Groupe Niveau 2 (uniquement s'il existe) ──
  645.             if ($n2) {
  646.                 $n2Key = $n2->getId();
  647.                 if (!isset($grouped[$n1Key]['children'][$n2Key])) {
  648.                     $grouped[$n1Key]['children'][$n2Key] = [
  649.                         'typeId'       => $n2->getId(),
  650.                         'label'        => $n2->getLibelle(),
  651.                         'previsionnel' => 0,
  652.                         'engage'       => 0,
  653.                         'facture'      => 0,
  654.                         'fournisseur'  => '-',
  655.                         'engageId'     => null,
  656.                         'detailsUrl'   => $detailsUrl($n2->getId()),
  657.                         'children'     => [],
  658.                     ];
  659.                 }
  660.                 if ($niveau === TypeDepense::NIVEAU_CATEGORIE) {
  661.                     $grouped[$n1Key]['children'][$n2Key]['previsionnel'] += $previsionnel;
  662.                 }
  663.                 $grouped[$n1Key]['children'][$n2Key]['engage']  += $engage;
  664.                 $grouped[$n1Key]['children'][$n2Key]['facture'] += $factureEngage;
  666.                 // Engagé porté directement par la catégorie (niveau 2) → utilisé par l'onglet Engagé
  667.                 if ($niveau === TypeDepense::NIVEAU_CATEGORIE && $engageId) {
  668.                     $grouped[$n1Key]['children'][$n2Key]['engageId']    = $engageId;
  669.                     $grouped[$n1Key]['children'][$n2Key]['fournisseur'] = $fournisseur;
  670.                 }
  672.                 // ── Feuille : uniquement les vraies lignes de dépense (niveau 3) ──
  673.                 if ($niveau === TypeDepense::NIVEAU_LIGNE) {
  674.                     $grouped[$n1Key]['children'][$n2Key]['children'][] = [
  675.                         'id'          => $eb->getId(),
  676.                         'typeId'      => $leaf->getId(),
  677.                         'label'       => $leaf->getLibelle(),
  678.                         'fournisseur' => $fournisseur,
  679.                         'previsionnel'=> $previsionnel,
  680.                         'engage'      => $engage,
  681.                         'facture'     => $factureEngage,
  682.                         'engageId'    => $engageId,
  683.                         'engages'     => $engagesList, // un élément par engagé (montantRaw à formater)
  684.                         'detailsUrl'  => $detailsUrl($leaf->getId()),
  685.                     ];
  686.                 }
  687.             }
  688.         }
  690.         // Montant nul → « - » (dans les 4 tableaux : tous / prévisionnel / engagé / facturé)
  691.         $fmt = function (float $v): string {
  692.             $s = number_format($v, 0, ',', ' ');
  693.             return $s === '0' ? '-' : $s;
  694.         };
  696.         $result = [];
  697.         foreach ($grouped as $typeGroup) {
  698.             $cats = [];
  699.             foreach ($typeGroup['children'] as $cat) {
  700.                 foreach ($cat['children'] as &$leaf) {
  701.                     $leaf['previsionnel'] = $fmt($leaf['previsionnel']);
  702.                     $leaf['engage']       = $fmt($leaf['engage']);
  703.                     $leaf['facture']      = $fmt($leaf['facture']);
  704.                     foreach ($leaf['engages'] as &$eng) {
  705.                         $eng['montant'] = $fmt((float) ($eng['montantRaw'] ?? 0));
  706.                         $eng['facture'] = $fmt((float) ($eng['factureRaw'] ?? 0));
  707.                     }
  708.                     unset($eng);
  709.                 }
  710.                 $cats[] = [
  711.                     'typeId'       => $cat['typeId'] ?? null,
  712.                     'label'        => $cat['label'],
  713.                     'previsionnel' => $fmt($cat['previsionnel']),
  714.                     'engage'       => $fmt($cat['engage']),
  715.                     'facture'      => $fmt($cat['facture']),
  716.                     'fournisseur'  => $cat['fournisseur'] ?? '-',
  717.                     'engageId'     => $cat['engageId'] ?? null,
  718.                     'detailsUrl'   => $cat['detailsUrl'] ?? null,
  719.                     'children'     => array_values($cat['children']),
  720.                 ];
  721.             }
  722.             $result[] = [
  723.                 'typeId'       => $typeGroup['typeId'] ?? null,
  724.                 'classif'      => $typeGroup['classif'] ?? null,
  725.                 'label'        => $typeGroup['label'],
  726.                 'previsionnel' => $fmt($typeGroup['previsionnel']),
  727.                 'engage'       => $fmt($typeGroup['engage']),
  728.                 'facture'      => $fmt($typeGroup['facture']),
  729.                 'factureRaw'   => $typeGroup['facture'],
  730.                 'fournisseur'  => $typeGroup['fournisseur'] ?? '-',
  731.                 'engageId'     => $typeGroup['engageId'] ?? null,
  732.                 'detailsUrl'   => $typeGroup['detailsUrl'] ?? null,
  733.                 'children'     => $cats,
  734.             ];
  735.         }
  737.         return $result;
  738.     }
  740.     /**
  741.      * Construit la table [classification => montant facturé] pour un projet.
  742.      *
  743.      * Pour chaque FactureFinance liée au projet (via ProjectFactureFinance) :
  744.      *  - tauxTva ≠ « Autre » (≠ 0) : on ajoute FactureFinance.monatantTtc sur sa classification ;
  745.      *  - tauxTva = « Autre » (= 0) : on ajoute, pour chaque ligne TVA (FactureFinanceMontantTva),
  746.      *    son montantTtc sur la classification de la ligne.
  747.      *
  748.      * @return array<string,float>
  749.      */
  750.     /**
  751.      * Montant facturé d'un engagé : somme des factures PAYÉES correspondant à son bon de commande,
  752.      * filtrées par fournisseur + SPV + projet (intersection des collections) + classification ERPI
  753.      * de la ligne. Retourne 0 si l'engagé n'a pas de bon de commande.
  754.      */
  755.     private function factureMontantForEngage(EngagementBudgetEngage $ebe, ?string $classifErpi): float
  756.     {
  757.         $bdc = $ebe->getBonDeCommande();
  758.         if (!$bdc || !$classifErpi) {
  759.             return 0.0;
  760.         }
  762.         $cacheKey = $bdc->getId() . '|' . $classifErpi;
  763.         if (isset($this->factureEngageCache[$cacheKey])) {
  764.             return $this->factureEngageCache[$cacheKey];
  765.         }
  767.         // Projets du bon de commande + fournisseur (obligatoires pour un rapprochement)
  768.         $projetIds = [];
  769.         foreach ($bdc->getProjectBonCommande() as $pbc) {
  770.             if ($pbc->getProject()) {
  771.                 $projetIds[] = $pbc->getProject()->getId();
  772.             }
  773.         }
  774.         $fournisseur = $bdc->getFournisseur();
  775.         if (empty($projetIds) || !$fournisseur) {
  776.             return $this->factureEngageCache[$cacheKey] = 0.0;
  777.         }
  779.         $statutsPayes = [
  780.             FactureFinance::STATUS_PAYER,
  781.             FactureFinance::STATUS_PAYER_NEW,
  782.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER,
  783.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER_NEW,
  784.         ];
  786.         $factures = $this->em->getRepository(FactureFinance::class)->findPayeesByFournisseurSpvClassification(
  787.             $fournisseur->getId(),
  788.             $bdc->getSpv() ? $bdc->getSpv()->getId() : null,
  789.             $classifErpi,
  790.             $projetIds,
  791.             $statutsPayes
  792.         );
  794.         // Somme : classification au niveau facture ET/OU au niveau des lignes TVA.
  795.         $total = 0.0;
  796.         $seen  = [];
  797.         foreach ($factures as $facture) {
  798.             if (isset($seen[$facture->getId()])) {
  799.                 continue;
  800.             }
  801.             $seen[$facture->getId()] = true;
  802.             if ($facture->getClassification() === $classifErpi) {
  803.                 $total += (float) $this->toFloat($facture->getMonatantTtc());
  804.             }
  805.             foreach ($facture->getTvaFactureFinance() as $ligneTva) {
  806.                 if ($ligneTva->getClassification() === $classifErpi) {
  807.                     $total += (float) $this->toFloat($ligneTva->getMontantTtc());
  808.                 }
  809.             }
  810.         }
  812.         return $this->factureEngageCache[$cacheKey] = $total;
  813.     }
  815.     /**
  816.      * Factures d'un engagé (niveau 4, onglet Facturé) : mêmes critères que le montant facturé —
  817.      * bon de commande de l'engagé (fournisseur + SPV + projets) et classification du NIVEAU 1
  818.      * (déduite du typeId de niveau 1 passé en paramètre).
  819.      *
  820.      * @return array{classif: ?string, factures: array<int,array<string,mixed>>}
  821.      */
  822.     public function getFacturesByEngage(int $engageId, int $n1TypeId, EngagementProjet $ep): array
  823.     {
  824.         return $this->getFacturesByEngages([$engageId], $n1TypeId, $ep);
  825.     }
  827.     /**
  828.      * Union des factures de plusieurs engagés (niveaux 2 et 3 de l'onglet Facturé) :
  829.      * pour chaque engagé, mêmes critères que le montant facturé (bon de commande : fournisseur +
  830.      * SPV + projets) et classification du NIVEAU 1 (typeId). Dédoublonnage par facture.
  831.      *
  832.      * @param int[] $engageIds
  833.      * @return array{classif: ?string, factures: array<int,array<string,mixed>>}
  834.      */
  835.     public function getFacturesByEngages(array $engageIds, int $n1TypeId, EngagementProjet $ep): array
  836.     {
  837.         $n1Type  = $this->em->getRepository(TypeDepense::class)->find($n1TypeId);
  838.         $classif = $n1Type ? $n1Type->getClassificationDepenseErpi() : null;
  840.         if (!$classif || empty($engageIds)) {
  841.             return ['classif' => $classif, 'factures' => []];
  842.         }
  844.         $statutsPayes = [
  845.             FactureFinance::STATUS_PAYER,
  846.             FactureFinance::STATUS_PAYER_NEW,
  847.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER,
  848.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER_NEW,
  849.         ];
  851.         $rows = [];
  852.         $seen = [];
  853.         foreach (array_unique(array_map('intval', $engageIds)) as $engageId) {
  854.             $ebe = $this->engagementBudgetEngageRepo->find($engageId);
  855.             if (!$ebe) {
  856.                 continue;
  857.             }
  858.             $bdc = $ebe->getBonDeCommande();
  859.             if (!$bdc) {
  860.                 continue;
  861.             }
  863.             $projetIds = [];
  864.             foreach ($bdc->getProjectBonCommande() as $pbc) {
  865.                 if ($pbc->getProject()) {
  866.                     $projetIds[] = $pbc->getProject()->getId();
  867.                 }
  868.             }
  869.             $fournisseur = $bdc->getFournisseur();
  870.             if (empty($projetIds) || !$fournisseur) {
  871.                 continue;
  872.             }
  874.             $factures = $this->em->getRepository(FactureFinance::class)->findPayeesByFournisseurSpvClassification(
  875.                 $fournisseur->getId(),
  876.                 $bdc->getSpv() ? $bdc->getSpv()->getId() : null,
  877.                 $classif,
  878.                 $projetIds,
  879.                 $statutsPayes
  880.             );
  882.             foreach ($factures as $facture) {
  883.                 if (isset($seen[$facture->getId()])) {
  884.                     continue;
  885.                 }
  886.                 $seen[$facture->getId()] = true;
  888.                 $montant = 0.0;
  889.                 if ($facture->getClassification() === $classif) {
  890.                     $montant += (float) $this->toFloat($facture->getMonatantTtc());
  891.                 }
  892.                 foreach ($facture->getTvaFactureFinance() as $ligneTva) {
  893.                     if ($ligneTva->getClassification() === $classif) {
  894.                         $montant += (float) $this->toFloat($ligneTva->getMontantTtc());
  895.                     }
  896.                 }
  898.                 $rows[] = [
  899.                     'numero'      => $facture->getNumeroFacture(),
  900.                     'fournisseur' => $facture->getFournisseur() ? $facture->getFournisseur()->getName() : '-',
  901.                     'spv'         => $facture->getSpv() ? $facture->getSpv()->getName() : '-',
  902.                     'montantTtc'  => $montant,
  903.                     'statut'      => $facture->getStatusString(),
  904.                     'token'       => $facture->getToken(),
  905.                 ];
  906.             }
  907.         }
  909.         return ['classif' => $classif, 'factures' => $rows];
  910.     }
  912.     private function buildFactureMapByClassification(?Project $project): array
  913.     {
  914.         $map = [];
  915.         if (!$project) {
  916.             return $map;
  917.         }
  919.         // On ne retient que les factures payées
  920.         $statutsPayes = [
  921.             FactureFinance::STATUS_PAYER,
  922.             FactureFinance::STATUS_PAYER_NEW,
  923.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER,
  924.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER_NEW,
  925.         ];
  927.         $factures = $this->em->getRepository(FactureFinance::class)
  928.             ->findPayeesByProjet($project->getId(), $statutsPayes);
  930.         // Sans condition sur le tauxTva : on additionne les montants correspondant à la
  931.         // classification, à la fois au niveau facture ET au niveau des lignes TVA.
  932.         $seen = [];
  933.         foreach ($factures as $facture) {
  934.             if (isset($seen[$facture->getId()])) {
  935.                 continue;
  936.             }
  937.             $seen[$facture->getId()] = true;
  939.             // Niveau facture
  940.             $classif = $facture->getClassification();
  941.             $montant = $this->toFloat($facture->getMonatantTtc());
  942.             if ($classif && $montant !== null) {
  943.                 $map[$classif] = ($map[$classif] ?? 0) + $montant;
  944.             }
  946.             // Niveau lignes TVA
  947.             foreach ($facture->getTvaFactureFinance() as $ligneTva) {
  948.                 $c = $ligneTva->getClassification();
  949.                 $m = $this->toFloat($ligneTva->getMontantTtc());
  950.                 if ($c && $m !== null) {
  951.                     $map[$c] = ($map[$c] ?? 0) + $m;
  952.                 }
  953.             }
  954.         }
  956.         return $map;
  957.     }
  959.     // ─── MODAL DÉTAILS ────────────────────────────────────────────────────────
  961.     public function getDetailsEngage(int $engageId, int $epId): array
  962.     {
  963.         $ebe     = $this->engagementBudgetEngageRepo->findWithRelations($engageId);
  964.         $budgets = $this->engagementBudgetRepo->findByEngage($engageId);
  966.         $previsionnel        = 0;
  967.         $classificationLabel = '-';
  968.         $classifs            = [];
  970.         foreach ($budgets as $eb) {
  971.             $ebP           = $eb->getEngagementBudgetPrevisionel();
  972.             $previsionnel += $ebP ? (float) ($ebP->getMontant() ?? 0) : 0;
  973.             if ($classificationLabel === '-') {
  974.                 $cat = $eb->getCategorie() ? $eb->getCategorie() . '-' : '';
  975.                 $classificationLabel = $cat . ($eb->getClassificationBudget() ?? '-');
  976.             }
  977.             if ($eb->getTypeDepense() && $eb->getTypeDepense()->getClassificationDepenseErpi()) {
  978.                 $classifs[] = $eb->getTypeDepense()->getClassificationDepenseErpi();
  979.             }
  980.         }
  982.         // Factures liées à l'engagé (via les classifications de ses lignes)
  983.         $ep       = $this->engagementProjetRepo->find($epId);
  984.         $factures = $this->matchFacturesByClassifs($ep ? $ep->getProjet() : null, $classifs);
  986.         $fournisseurs = [];
  987.         $numeros      = [];
  988.         $factureTotal = 0;
  989.         foreach ($factures as $f) {
  990.             $factureTotal += (float) $f['montantTtc'];
  991.             if ($f['fournisseur'] && $f['fournisseur'] !== '-') {
  992.                 $fournisseurs[$f['fournisseur']] = true;
  993.             }
  994.             if ($f['numero']) {
  995.                 $numeros[] = $f['numero'];
  996.             }
  997.         }
  999.         $engage  = $ebe ? (float) ($ebe->getEngageMontant() ?? 0) : 0;
  1000.         $depasse = $previsionnel > 0 && $engage > $previsionnel;
  1002.         return [
  1003.             'ebe'                 => $ebe,
  1004.             'classificationLabel' => $classificationLabel,
  1005.             'budgetEngage'        => $engage,
  1006.             'budgetFacture'       => $factureTotal,
  1007.             'budgetPrevisionnel'  => $previsionnel,
  1008.             'depasse'             => $depasse,
  1009.             'factures'            => $factures,
  1010.             'factureFournisseurs' => array_keys($fournisseurs),
  1011.             'factureNumeros'      => $numeros,
  1012.         ];
  1013.     }
  1015.     /**
  1016.      * Détails d'une LIGNE (type de dépense) pour le modal, indépendamment de l'existence
  1017.      * d'un engagé : prévisionnel, engagé (s'il y en a un), et factures liées par classification.
  1018.      */
  1019.     public function getDetailsByType(int $typeId, EngagementProjet $ep, ?int $versionId): array
  1020.     {
  1021.         $type    = $this->em->getRepository(TypeDepense::class)->find($typeId);
  1022.         $version = $versionId
  1023.             ? $this->engagementVersionRepo->findWithLogsByVersion($versionId)
  1024.             : $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  1026.         $eb = ($type && $version)
  1027.             ? $this->engagementBudgetRepo->findOneBy(['engagementVersion' => $version, 'typeDepense' => $type])
  1028.             : null;
  1030.         $previsionnel        = 0;
  1031.         $engage              = 0;
  1032.         $ebe                 = null;
  1033.         $classificationLabel = $type ? $type->getLibelle() : '-';
  1035.         if ($eb) {
  1036.             $ebP          = $eb->getEngagementBudgetPrevisionel();
  1037.             $previsionnel = $ebP ? (float) ($ebP->getMontant() ?? 0) : 0;
  1039.             $ebe      = $eb->getEngagementBudgetEngage();
  1040.             $ebDetail = $eb->getEngagementBudgetEngageDetail();
  1041.             $engage   = $ebDetail ? (float) ($ebDetail->getEngageMontant() ?? 0) : 0;
  1043.             $cat                 = $eb->getCategorie() ? $eb->getCategorie() . '-' : '';
  1044.             $classificationLabel = $cat . ($eb->getClassificationBudget() ?? $classificationLabel);
  1045.         }
  1047.         // Factures liées par la classification ERPI du type
  1048.         $classif  = $type ? $type->getClassificationDepenseErpi() : null;
  1049.         $factures = $this->matchFacturesByClassifs($ep->getProjet(), $classif ? [$classif] : []);
  1051.         $fournisseurs = [];
  1052.         $numeros      = [];
  1053.         $factureTotal = 0;
  1054.         foreach ($factures as $f) {
  1055.             $factureTotal += (float) $f['montantTtc'];
  1056.             if ($f['fournisseur'] && $f['fournisseur'] !== '-') {
  1057.                 $fournisseurs[$f['fournisseur']] = true;
  1058.             }
  1059.             if ($f['numero']) {
  1060.                 $numeros[] = $f['numero'];
  1061.             }
  1062.         }
  1064.         $depasse = $previsionnel > 0 && $engage > $previsionnel;
  1066.         return [
  1067.             'ebe'                 => $ebe,
  1068.             'classificationLabel' => $classificationLabel,
  1069.             'budgetEngage'        => $engage,
  1070.             'budgetFacture'       => $factureTotal,
  1071.             'budgetPrevisionnel'  => $previsionnel,
  1072.             'depasse'             => $depasse,
  1073.             'factures'            => $factures,
  1074.             'factureFournisseurs' => array_keys($fournisseurs),
  1075.             'factureNumeros'      => $numeros,
  1076.         ];
  1077.     }
  1079.     /**
  1080.      * Factures (payées) d'un projet correspondant à une liste de classifications
  1081.      * (au niveau facture OU ligne TVA). Inclut le document fileFacture pour l'affichage.
  1082.      *
  1083.      * @param string[] $classifs
  1084.      */
  1085.     private function matchFacturesByClassifs(?Project $project, array $classifs): array
  1086.     {
  1087.         $classifs = array_values(array_unique(array_filter($classifs)));
  1088.         if (!$project || empty($classifs)) {
  1089.             return [];
  1090.         }
  1092.         $statutsPayes = [
  1093.             FactureFinance::STATUS_PAYER,
  1094.             FactureFinance::STATUS_PAYER_NEW,
  1095.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER,
  1096.             FactureFinance::STATUS_DATE_PAIEMENT_PAYER_NEW,
  1097.         ];
  1099.         $rows = [];
  1100.         foreach ($this->em->getRepository(FactureFinance::class)->findPayeesByProjet($project->getId(), $statutsPayes) as $facture) {
  1101.             $montant = 0;
  1102.             $matched = false;
  1104.             if (in_array($facture->getClassification(), $classifs, true)) {
  1105.                 $montant += (float) $this->toFloat($facture->getMonatantTtc());
  1106.                 $matched = true;
  1107.             }
  1108.             foreach ($facture->getTvaFactureFinance() as $ligneTva) {
  1109.                 if (in_array($ligneTva->getClassification(), $classifs, true)) {
  1110.                     $montant += (float) $this->toFloat($ligneTva->getMontantTtc());
  1111.                     $matched = true;
  1112.                 }
  1113.             }
  1114.             if (!$matched) {
  1115.                 continue;
  1116.             }
  1118.             $doc = $facture->getFileFacture();
  1119.             $rows[] = [
  1120.                 'numero'      => $facture->getNumeroFacture(),
  1121.                 'fournisseur' => $facture->getFournisseur() ? $facture->getFournisseur()->getName() : '-',
  1122.                 'spv'         => $facture->getSpv() ? $facture->getSpv()->getName() : '-',
  1123.                 'montantTtc'  => $montant,
  1124.                 'statut'      => $facture->getStatusString(),
  1125.                 'token'       => $facture->getToken(),
  1126.                 'file'        => $doc ? [
  1127.                     'name'         => $doc->getNomenclature() ?: $doc->getName(),
  1128.                     'user'         => $doc->getUserCreated() ? $doc->getUserCreated()->getName() : null,
  1129.                     'date'         => $doc->getCreatedAt(),
  1130.                     'token'        => $doc->getToken(),
  1131.                 ] : null,
  1132.             ];
  1133.         }
  1135.         return $rows;
  1136.     }
  1138.     // ─── PAGE DÉTAIL D'UN ENGAGÉ ──────────────────────────────────────────────
  1140.     /**
  1141.      * Données de la page « Détails » d'un engagé : informations, lignes de classification,
  1142.      * note interne (commentaires) et historique (logs de la version).
  1143.      */
  1144.     public function getEngageDetailData(int $engageId, EngagementProjet $ep): array
  1145.     {
  1146.         $ebe     = $this->engagementBudgetEngageRepo->findWithRelations($engageId);
  1147.         $budgets = $this->engagementBudgetRepo->findByEngage($engageId);
  1149.         $lignes  = [];
  1150.         $statut  = null;
  1151.         $version = null;
  1152.         foreach ($budgets as $eb) {
  1153.             $version = $version ?: $eb->getEngagementVersion();
  1155.             $detail   = $this->ebDetailForEngage($eb, $engageId);
  1156.             $lignes[] = [
  1157.                 'label'   => $eb->getClassificationBudget(),
  1158.                 'montant' => $detail ? $this->toFloat($detail->getEngageMontant()) : null,
  1159.                 'projet'  => ($detail && $detail->getProjet()) ? $detail->getProjet()->getName() : null,
  1160.             ];
  1162.             // Statut administratif : première phase configurée sur le type de dépense
  1163.             if ($statut === null && $eb->getTypeDepense()) {
  1164.                 foreach ($eb->getTypeDepense()->getTypeDepenseStatutAdministatif() as $s) {
  1165.                     $statut = $this->statutLabel($s->getStatutAdministratif());
  1166.                     break;
  1167.                 }
  1168.             }
  1169.         }
  1171.         // Historique propre à CET engagé
  1172.         $logs = $this->em->getRepository(EngagementVersionLog::class)
  1173.             ->findByEngagementBudgetEngage($engageId);
  1175.         return [
  1176.             'engagementProjet' => $ep,
  1177.             'projet'           => $ep->getProjet(),
  1178.             'ebe'              => $ebe,
  1179.             'engageId'         => $engageId,
  1180.             'lignes'           => $lignes,
  1181.             'statut'           => $statut,
  1182.             'comments'         => $ebe ? $ebe->getComment() : [],
  1183.             'logs'             => $logs,
  1184.         ];
  1185.     }
  1187.     /** Ajoute un commentaire (note interne) à un engagé, éventuellement en réponse à un autre. */
  1188.     public function addEngageComment(int $engageId, ?string $comment, ?object $user, ?int $parentId = null): bool
  1189.     {
  1190.         $comment = trim((string) $comment);
  1191.         $ebe     = $this->engagementBudgetEngageRepo->find($engageId);
  1192.         if (!$ebe || $comment === '') {
  1193.             return false;
  1194.         }
  1196.         $c = new EngagementBudgetEngageComment();
  1197.         $c->setComment($comment);
  1198.         if ($user) {
  1199.             $c->setUser($user);
  1200.         }
  1201.         $c->setEngagementBudgetEngage($ebe);
  1203.         if ($parentId) {
  1204.             $parent = $this->em->getRepository(EngagementBudgetEngageComment::class)->find($parentId);
  1205.             // On ne rattache la réponse que si le parent appartient bien à cet engagé
  1206.             if ($parent && $parent->getEngagementBudgetEngage() === $ebe) {
  1207.                 $c->setParent($parent);
  1208.                 $parent->addChild($c);
  1209.             }
  1210.         }
  1212.         $this->em->persist($c);
  1213.         $ebe->addComment($c);
  1214.         $this->em->flush();
  1216.         return true;
  1217.     }
  1219.     /** Supprime un commentaire (et ses réponses) d'un engagé. */
  1220.     public function deleteEngageComment(int $commentId, int $engageId): bool
  1221.     {
  1222.         $c = $this->em->getRepository(EngagementBudgetEngageComment::class)->find($commentId);
  1223.         if (!$c || !$c->getEngagementBudgetEngage() || $c->getEngagementBudgetEngage()->getId() !== $engageId) {
  1224.             return false;
  1225.         }
  1227.         $this->removeCommentTree($c);
  1228.         $this->em->flush();
  1230.         return true;
  1231.     }
  1233.     private function removeCommentTree(EngagementBudgetEngageComment $c): void
  1234.     {
  1235.         foreach ($c->getChildren()->toArray() as $child) {
  1236.             $this->removeCommentTree($child);
  1237.         }
  1238.         $this->em->remove($c);
  1239.     }
  1241.     // ─── MODAL FACTURES D'UNE LIGNE ───────────────────────────────────────────
  1243.     /**
  1244.      * Factures (payées) du projet liées à un type de dépense via sa classification ERPI.
  1245.      * Retourne la liste pour le modal : numéro, fournisseur, montant TTC (part de la
  1246.      * classification), statut.
  1247.      */
  1248.     public function getFacturesByType(int $typeId, EngagementProjet $ep): array
  1249.     {
  1250.         $type    = $this->em->getRepository(TypeDepense::class)->find($typeId);
  1251.         $classif = $type ? $type->getClassificationDepenseErpi() : null;
  1253.         if (!$classif) {
  1254.             return ['classif' => $classif, 'factures' => []];
  1255.         }
  1257.         return [
  1258.             'classif'  => $classif,
  1259.             'factures' => $this->matchFacturesByClassifs($ep->getProjet(), [$classif]),
  1260.         ];
  1261.     }
  1263.     /** Libellé d'une phase (statut administratif) à partir de sa valeur. */
  1264.     private function statutLabel(?string $value): ?string
  1265.     {
  1266.         if ($value === null || trim($value) === '') {
  1267.             return null;
  1268.         }
  1269.         $map = $this->getStatutsAdministratifs();
  1271.         return $map[(int) $value] ?? $value;
  1272.     }
  1274.     // ─── AJOUT D'UN ENGAGÉ ────────────────────────────────────────────────────
  1276.     public function createEngage(EngagementProjet $ep, array $data, ?object $user): void
  1277.     {
  1278.         $version = $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  1279.         if (!$version) {
  1280.             $version = new EngagementVersion();
  1281.             $version->setEngagementProjet($ep);
  1282.             $version->setIsVersion(false);
  1283.             $this->em->persist($version);
  1284.         }
  1286.         // Garantir une ligne EngagementBudget par TypeDepense (suivi) AVANT l'ajout de l'engagé
  1287.         $this->ensureBudgetLinesForAllTypes($version);
  1289.         $ebe = new EngagementBudgetEngage();
  1290.         $ebe->setEngageMontant((float) ($data['montantTotalEngage'] ?? 0));
  1292.         if (!empty($data['fournisseurId'])) {
  1293.             $fournisseur = $this->em->getRepository(Fournisseur::class)->find($data['fournisseurId']);
  1294.             if ($fournisseur) {
  1295.                 $ebe->setFournisseur($fournisseur);
  1296.             }
  1297.         }
  1299.         // Devis (DocUpload référencé par token)
  1300.         if (!empty($data['fileDevis'])) {
  1301.             $doc = $this->em->getRepository(DocUpload::class)->findOneBy(['token' => $data['fileDevis']]);
  1302.             if ($doc) {
  1303.                 $ebe->setDevis($doc);
  1304.             }
  1305.         }
  1307.         // Bon de commande (généré via la modale « Générer un bon de commande »)
  1308.         if (!empty($data['bonDeCommandeId'])) {
  1309.             $bdc = $this->em->getRepository(BonDeCommande::class)->find($data['bonDeCommandeId']);
  1310.             if ($bdc) {
  1311.                 $ebe->setBonDeCommande($bdc);
  1312.             }
  1313.         }
  1315.         $this->em->persist($ebe);
  1317.         // Détail du log : type de dépense + montant pour chaque classification engagée
  1318.         $logParts = [];
  1320.         foreach ($data['classifications'] ?? [] as $classifData) {
  1321.             // La valeur "classification" correspond à l'id d'un TypeDepense du référentiel.
  1322.             $typeDepense = !empty($classifData['classification'])
  1323.                 ? $this->em->getRepository(TypeDepense::class)->find($classifData['classification'])
  1324.                 : null;
  1326.             $classificationLibelle = $typeDepense ? $typeDepense->getLibelle() : ($classifData['classification'] ?? null);
  1328.             if ($classificationLibelle) {
  1329.                 $montantLigne = (float) ($classifData['montant'] ?? 0);
  1330.                 $logParts[]   = $classificationLibelle . ' : ' . number_format($montantLigne, 0, ',', ' ') . ' €';
  1331.             }
  1332.             $categorieLibelle       = ($typeDepense && $typeDepense->getParent())
  1333.                 ? $typeDepense->getParent()->getLibelle()
  1334.                 : ($classifData['categorie'] ?? null);
  1336.             // Réutiliser la ligne existante du TypeDepense (garantie par ensureBudgetLinesForAllTypes),
  1337.             // sinon la créer (cas d'un type hors suivi).
  1338.             $eb = $typeDepense ? $this->findBudgetLineByType($version, $typeDepense) : null;
  1339.             if (!$eb) {
  1340.                 $eb = new EngagementBudget();
  1341.                 $eb->setEngagementVersion($version);
  1342.                 $eb->setTypeDepense($typeDepense);
  1343.                 $eb->setClassificationBudget($classificationLibelle);
  1344.                 $eb->setCategorie($categorieLibelle);
  1345.                 $this->em->persist($eb);
  1346.                 $version->addEngagementBudget($eb);
  1347.             }
  1349.             $eb->setEngagementBudgetEngage($ebe);
  1351.             // Montant PROPRE de la dépense (et non la somme) : porté par le détail de chaque ligne,
  1352.             // désormais rattaché à l'engagé (EngagementBudgetEngage 1—N EngagementBudgetEngageDetail).
  1353.             $detail = new EngagementBudgetEngageDetail();
  1354.             $detail->setClassificationBudget($classificationLibelle);
  1355.             $detail->setEngageMontant((float) ($classifData['montant'] ?? 0));
  1356.             $detail->setEngagementBudgetEngage($ebe);
  1357.             if (!empty($classifData['projetId'])) {
  1358.                 $projetLie = $this->em->getRepository(Project::class)->find($classifData['projetId']);
  1359.                 if ($projetLie) {
  1360.                     $detail->setProjet($projetLie);
  1361.                 }
  1362.             }
  1363.             $this->em->persist($detail);
  1364.             $ebe->addEngagementBudgetEngageDetail($detail);
  1365.             $eb->setEngagementBudgetEngageDetail($detail);
  1366.             $eb->addEngagementBudgetEngageDetail($detail); // rattachement à la ligne (plusieurs engagés possibles)
  1367.         }
  1369.         // Note interne : enregistrée directement sur l'engagé (distincte des commentaires)
  1370.         if (isset($data['commentaire'])) {
  1371.             $note = trim((string) $data['commentaire']);
  1372.             $ebe->setNoteInterne($note !== '' ? $note : null);
  1373.         }
  1375.         $action = 'Ajout d\'un engagé';
  1376.         if (!empty($logParts)) {
  1377.             $action .= ' — ' . implode(', ', $logParts);
  1378.         }
  1379.         $this->logAction($version, $action, $user, $ebe);
  1381.         $this->em->flush();
  1382.     }
  1384.     /**
  1385.      * Crée un engagé associé à plusieurs projets (page « Ajout d'un engagé »).
  1386.      *
  1387.      * Structure attendue dans $data :
  1388.      *   - montantTotalEngage, fileDevis, commentaire (note interne)
  1389.      *   - projets[] : [projetId, timeline (EtapsCategory id), etape (Etaps id),
  1390.      *                  classifications[] => [classification (TypeDepense id), montant]]
  1391.      *
  1392.      * Un seul EngagementBudgetEngage est créé et partagé : chaque ligne de classification
  1393.      * devient un EngagementBudgetEngageDetail (projet / timeline / étape / montant) et est
  1394.      * rattachée à la version d'engagement du projet correspondant.
  1395.      *
  1396.      * @return EngagementProjet|null Projet d'engagement du premier projet (pour redirection).
  1397.      */
  1398.     public function createEngageMultiProjet(array $data, ?object $user): ?EngagementProjet
  1399.     {
  1400.         $projets = $data['projets'] ?? [];
  1401.         if (empty($projets)) {
  1402.             return null;
  1403.         }
  1405.         // Engagé partagé par tous les projets associés
  1406.         $ebe = new EngagementBudgetEngage();
  1407.         $ebe->setEngageMontant((float) ($data['montantTotalEngage'] ?? 0));
  1409.         if (!empty($data['fileDevis'])) {
  1410.             $doc = $this->em->getRepository(DocUpload::class)->findOneBy(['token' => $data['fileDevis']]);
  1411.             if ($doc) {
  1412.                 $ebe->setDevis($doc);
  1413.             }
  1414.         }
  1415.         if (!empty($data['commentaire'])) {
  1416.             $ebe->setNoteInterne(trim((string) $data['commentaire']));
  1417.         }
  1418.         // Bon de commande (généré via la modale « Générer un bon de commande »)
  1419.         if (!empty($data['bonDeCommandeId'])) {
  1420.             $bdc = $this->em->getRepository(BonDeCommande::class)->find($data['bonDeCommandeId']);
  1421.             if ($bdc) {
  1422.                 $ebe->setBonDeCommande($bdc);
  1423.             }
  1424.         }
  1425.         $this->em->persist($ebe);
  1427.         $firstEp     = null;
  1428.         $totalEngage = 0.0;
  1429.         $hasLine     = false;
  1431.         foreach ($projets as $projData) {
  1432.             if (empty($projData['projetId'])) {
  1433.                 continue;
  1434.             }
  1435.             $projet = $this->em->getRepository(Project::class)->find($projData['projetId']);
  1436.             if (!$projet) {
  1437.                 continue;
  1438.             }
  1440.             $ep      = $this->getOrCreateByProject($projet);
  1441.             $firstEp = $firstEp ?: $ep;
  1443.             $version = $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  1444.             if (!$version) {
  1445.                 $version = new EngagementVersion();
  1446.                 $version->setEngagementProjet($ep);
  1447.                 $version->setIsVersion(false);
  1448.                 $this->em->persist($version);
  1449.             }
  1450.             $this->ensureBudgetLinesForAllTypes($version);
  1452.             $timeline = !empty($projData['timeline'])
  1453.                 ? $this->em->getRepository(EtapsCategory::class)->find($projData['timeline'])
  1454.                 : null;
  1455.             $etape = !empty($projData['etape'])
  1456.                 ? $this->em->getRepository(Etaps::class)->find($projData['etape'])
  1457.                 : null;
  1459.             $logParts = [];
  1460.             foreach ($projData['classifications'] ?? [] as $classifData) {
  1461.                 $typeDepense = !empty($classifData['classification'])
  1462.                     ? $this->em->getRepository(TypeDepense::class)->find($classifData['classification'])
  1463.                     : null;
  1464.                 $classificationLibelle = $typeDepense ? $typeDepense->getLibelle() : ($classifData['classification'] ?? null);
  1465.                 if (!$classificationLibelle) {
  1466.                     continue;
  1467.                 }
  1469.                 $hasLine      = true;
  1470.                 $montantLigne = (float) ($classifData['montant'] ?? 0);
  1471.                 $totalEngage += $montantLigne;
  1472.                 $logParts[]   = $classificationLibelle . ' : ' . number_format($montantLigne, 0, ',', ' ') . ' €';
  1474.                 $categorieLibelle = ($typeDepense && $typeDepense->getParent())
  1475.                     ? $typeDepense->getParent()->getLibelle()
  1476.                     : ($classifData['categorie'] ?? null);
  1478.                 $eb = $typeDepense ? $this->findBudgetLineByType($version, $typeDepense) : null;
  1479.                 if (!$eb) {
  1480.                     $eb = new EngagementBudget();
  1481.                     $eb->setEngagementVersion($version);
  1482.                     $eb->setTypeDepense($typeDepense);
  1483.                     $eb->setClassificationBudget($classificationLibelle);
  1484.                     $eb->setCategorie($categorieLibelle);
  1485.                     $this->em->persist($eb);
  1486.                     $version->addEngagementBudget($eb);
  1487.                 }
  1488.                 $eb->setEngagementBudgetEngage($ebe);
  1490.                 $detail = new EngagementBudgetEngageDetail();
  1491.                 $detail->setClassificationBudget($classificationLibelle);
  1492.                 $detail->setEngageMontant($montantLigne);
  1493.                 $detail->setEngagementBudgetEngage($ebe);
  1494.                 $detail->setProjet($projet);
  1495.                 $detail->setTimeline($timeline);
  1496.                 $detail->setEtape($etape);
  1497.                 $this->em->persist($detail);
  1498.                 $ebe->addEngagementBudgetEngageDetail($detail);
  1499.                 $eb->setEngagementBudgetEngageDetail($detail);
  1500.                 $eb->addEngagementBudgetEngageDetail($detail); // rattachement à la ligne (plusieurs engagés possibles)
  1501.             }
  1503.             $action = 'Ajout d\'un engagé — ' . $this->formatProjetNom($projet);
  1504.             if (!empty($logParts)) {
  1505.                 $action .= ' (' . implode(', ', $logParts) . ')';
  1506.             }
  1507.             $this->logAction($version, $action, $user, $ebe);
  1508.         }
  1510.         if (!$firstEp || !$hasLine) {
  1511.             return null;
  1512.         }
  1514.         // Montant total : déduit de la somme des lignes s'il n'a pas été fourni
  1515.         if (empty($data['montantTotalEngage'])) {
  1516.             $ebe->setEngageMontant($totalEngage);
  1517.         }
  1519.         $this->em->flush();
  1521.         return $firstEp;
  1522.     }
  1524.     // ─── ÉDITION D'UN ENGAGÉ ──────────────────────────────────────────────────
  1526.     /**
  1527.      * Données de pré-remplissage du formulaire d'édition d'un engagé.
  1528.      * Structure identique à l'ajout (« new ») : les lignes sont regroupées par projet
  1529.      * pour alimenter les blocs « Projets associés » (projets[][classifications][]).
  1530.      */
  1531.     public function getEngageEditData(int $engageId, EngagementProjet $ep): ?array
  1532.     {
  1533.         $ebe = $this->engagementBudgetEngageRepo->find($engageId);
  1534.         if (!$ebe) {
  1535.             return null;
  1536.         }
  1538.         $projets = [];
  1539.         $version = null;
  1540.         foreach ($this->engagementBudgetRepo->findByEngage($engageId) as $eb) {
  1541.             $version = $version ?: $eb->getEngagementVersion();
  1542.             $detail  = $this->ebDetailForEngage($eb, $engageId);
  1543.             $type    = $eb->getTypeDepense();
  1544.             // Projet du détail ; repli sur le projet de l'engagement (données sans projet sur le détail)
  1545.             $projet  = ($detail && $detail->getProjet()) ? $detail->getProjet() : $ep->getProjet();
  1546.             $pid     = $projet ? $projet->getId() : 0;
  1548.             if (!isset($projets[$pid])) {
  1549.                 $projets[$pid] = [
  1550.                     'projetId'        => $projet ? $projet->getId() : null,
  1551.                     'projetName'      => $projet ? $projet->getName() : null,
  1552.                     'timeline'        => $detail && $detail->getTimeline() ? $detail->getTimeline()->getId() : null,
  1553.                     'etape'           => $detail && $detail->getEtape() ? $detail->getEtape()->getId() : null,
  1554.                     'classifications' => [],
  1555.                 ];
  1556.             }
  1557.             $projets[$pid]['classifications'][] = [
  1558.                 'classification'      => $type ? $type->getId() : null,
  1559.                 'classificationLabel' => $type ? $type->getCheminComplet() : null,
  1560.                 'montant'             => $detail ? $detail->getEngageMontant() : null,
  1561.             ];
  1562.         }
  1564.         return ['ebe' => $ebe, 'projets' => array_values($projets), 'version' => $version];
  1565.     }
  1567.     /**
  1568.      * Ids des TypeDepense déjà engagés dans une version (pour désactiver ces classifications
  1569.      * dans le formulaire d'ajout/édition d'un engagé).
  1570.      *
  1571.      * @return int[]
  1572.      */
  1573.     public function getEngagedTypeIdsForVersion(?EngagementVersion $version, ?int $excludeEngageId = null): array
  1574.     {
  1575.         if (!$version) {
  1576.             return [];
  1577.         }
  1579.         return $this->engagementBudgetRepo->findEngagedTypeIdsByVersion($version->getId(), $excludeEngageId);
  1580.     }
  1582.     /**
  1583.      * Met à jour un engagé. Accepte le même payload multi-projet que l'ajout
  1584.      * (« new » : projets[][projetId], projets[][classifications][], bonDeCommandeId,
  1585.      * montantTotalEngage, fileDevis, commentaire). Rétro-compatible avec l'ancien
  1586.      * format plat (classifications[]). Les détails de CET engagé sont remplacés.
  1587.      */
  1588.     public function updateEngage(int $engageId, array $data, ?object $user): bool
  1589.     {
  1590.         $ebe = $this->engagementBudgetEngageRepo->find($engageId);
  1591.         if (!$ebe) {
  1592.             return false;
  1593.         }
  1595.         // État AVANT modification (pour journaliser chaque champ modifié : ancienne → nouvelle valeur)
  1596.         $oldValues = [
  1597.             'engageMontant' => $ebe->getEngageMontant(),
  1598.             'devis'         => $ebe->getDevis() ? ($ebe->getDevis()->getNomenclature() ?: $ebe->getDevis()->getName()) : null,
  1599.             'noteInterne'   => $ebe->getNoteInterne(),
  1600.         ];
  1602.         $ebe->setEngageMontant((float) ($data['montantTotalEngage'] ?? 0));
  1604.         // Fournisseur : uniquement si le champ est fourni (le formulaire « new » n'en a pas)
  1605.         if (array_key_exists('fournisseurId', $data)) {
  1606.             $fournisseur = !empty($data['fournisseurId'])
  1607.                 ? $this->em->getRepository(Fournisseur::class)->find($data['fournisseurId'])
  1608.                 : null;
  1609.             $ebe->setFournisseur($fournisseur ?: null);
  1610.         }
  1612.         // Devis (DocUpload référencé par token)
  1613.         if (!empty($data['fileDevis'])) {
  1614.             $doc = $this->em->getRepository(DocUpload::class)->findOneBy(['token' => $data['fileDevis']]);
  1615.             if ($doc) {
  1616.                 $ebe->setDevis($doc);
  1617.             }
  1618.         }
  1620.         // Bon de commande (généré via la modale « Générer un bon de commande »)
  1621.         if (array_key_exists('bonDeCommandeId', $data)) {
  1622.             $bdc = !empty($data['bonDeCommandeId'])
  1623.                 ? $this->em->getRepository(BonDeCommande::class)->find($data['bonDeCommandeId'])
  1624.                 : null;
  1625.             $ebe->setBonDeCommande($bdc ?: null);
  1626.         }
  1628.         // Détacher UNIQUEMENT les détails de CET engagé (les autres engagés de la même ligne restent)
  1629.         $primaryVersion = null;
  1630.         $oldLignes      = [];
  1631.         foreach ($this->engagementBudgetRepo->findByEngage($engageId) as $eb) {
  1632.             $primaryVersion = $primaryVersion ?: $eb->getEngagementVersion();
  1633.             foreach ($this->ebEngageDetails($eb) as $detail) {
  1634.                 $dEbe = $detail->getEngagementBudgetEngage();
  1635.                 if (!$dEbe || $dEbe->getId() !== $engageId) {
  1636.                     continue;
  1637.                 }
  1638.                 $oldLignes[$eb->getClassificationBudget()] = $this->toFloat($detail->getEngageMontant());
  1639.                 if ($eb->getEngagementBudgetEngageDetail() === $detail) {
  1640.                     $eb->setEngagementBudgetEngageDetail(null);
  1641.                 }
  1642.                 $eb->removeEngagementBudgetEngageDetail($detail);
  1643.                 $this->em->remove($detail);
  1644.             }
  1645.             if ($eb->getEngagementBudgetEngage() === $ebe) {
  1646.                 $eb->setEngagementBudgetEngage(null);
  1647.             }
  1648.         }
  1650.         // Payload : format multi-projet (« new ») ou repli sur l'ancien format plat.
  1651.         $projets = $data['projets'] ?? null;
  1652.         if ($projets === null) {
  1653.             $projets = [['projetId' => null, 'classifications' => $data['classifications'] ?? []]];
  1654.         }
  1656.         // Recréer les lignes à partir des projets / classifications soumis
  1657.         $newLignes = [];
  1658.         $version   = $primaryVersion;
  1659.         $totalSum  = 0.0;
  1660.         foreach ($projets as $projData) {
  1661.             $projet = !empty($projData['projetId'])
  1662.                 ? $this->em->getRepository(Project::class)->find($projData['projetId'])
  1663.                 : null;
  1665.             // Version du projet ciblé (sinon version primaire de l'engagé)
  1666.             if ($projet) {
  1667.                 $ep      = $this->getOrCreateByProject($projet);
  1668.                 $pVersion = $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  1669.                 if (!$pVersion) {
  1670.                     $pVersion = new EngagementVersion();
  1671.                     $pVersion->setEngagementProjet($ep);
  1672.                     $pVersion->setIsVersion(false);
  1673.                     $this->em->persist($pVersion);
  1674.                 }
  1675.                 $this->ensureBudgetLinesForAllTypes($pVersion);
  1676.             } else {
  1677.                 $pVersion = $primaryVersion;
  1678.             }
  1679.             if (!$pVersion) {
  1680.                 continue;
  1681.             }
  1682.             $version = $pVersion;
  1684.             $timeline = !empty($projData['timeline'])
  1685.                 ? $this->em->getRepository(EtapsCategory::class)->find($projData['timeline'])
  1686.                 : null;
  1687.             $etape = !empty($projData['etape'])
  1688.                 ? $this->em->getRepository(Etaps::class)->find($projData['etape'])
  1689.                 : null;
  1691.             foreach ($projData['classifications'] ?? [] as $classifData) {
  1692.                 $typeDepense = !empty($classifData['classification'])
  1693.                     ? $this->em->getRepository(TypeDepense::class)->find($classifData['classification'])
  1694.                     : null;
  1696.                 $classificationLibelle = $typeDepense ? $typeDepense->getLibelle() : ($classifData['classification'] ?? null);
  1697.                 if (!$classificationLibelle) {
  1698.                     continue;
  1699.                 }
  1701.                 $montantLigne = (float) ($classifData['montant'] ?? 0);
  1702.                 $newLignes[$classificationLibelle] = $montantLigne;
  1703.                 $totalSum += $montantLigne;
  1705.                 $categorieLibelle = ($typeDepense && $typeDepense->getParent())
  1706.                     ? $typeDepense->getParent()->getLibelle()
  1707.                     : ($classifData['categorie'] ?? null);
  1709.                 $eb = $typeDepense ? $this->findBudgetLineByType($pVersion, $typeDepense) : null;
  1710.                 if (!$eb) {
  1711.                     $eb = new EngagementBudget();
  1712.                     $eb->setEngagementVersion($pVersion);
  1713.                     $eb->setTypeDepense($typeDepense);
  1714.                     $eb->setClassificationBudget($classificationLibelle);
  1715.                     $eb->setCategorie($categorieLibelle);
  1716.                     $this->em->persist($eb);
  1717.                     $pVersion->addEngagementBudget($eb);
  1718.                 }
  1720.                 $eb->setEngagementBudgetEngage($ebe);
  1722.                 $detail = new EngagementBudgetEngageDetail();
  1723.                 $detail->setClassificationBudget($classificationLibelle);
  1724.                 $detail->setEngageMontant($montantLigne);
  1725.                 $detail->setEngagementBudgetEngage($ebe);
  1726.                 if ($projet) {
  1727.                     $detail->setProjet($projet);
  1728.                 }
  1729.                 if ($timeline) {
  1730.                     $detail->setTimeline($timeline);
  1731.                 }
  1732.                 if ($etape) {
  1733.                     $detail->setEtape($etape);
  1734.                 }
  1735.                 $this->em->persist($detail);
  1736.                 $ebe->addEngagementBudgetEngageDetail($detail);
  1737.                 $eb->setEngagementBudgetEngageDetail($detail);
  1738.                 $eb->addEngagementBudgetEngageDetail($detail); // rattachement à la ligne (plusieurs engagés possibles)
  1739.             }
  1740.         }
  1742.         if (!$version) {
  1743.             return false;
  1744.         }
  1746.         // Montant total : déduit de la somme des lignes s'il n'a pas été fourni
  1747.         if (empty($data['montantTotalEngage'])) {
  1748.             $ebe->setEngageMontant($totalSum);
  1749.         }
  1751.         // Note interne : enregistrée directement sur l'engagé (distincte des commentaires)
  1752.         if (isset($data['commentaire'])) {
  1753.             $note = trim((string) $data['commentaire']);
  1754.             $ebe->setNoteInterne($note !== '' ? $note : null);
  1755.         }
  1757.         // ── Journalisation : un log par champ modifié, avec ancienne et nouvelle valeur ──
  1758.         $newValues = [
  1759.             'engageMontant' => $ebe->getEngageMontant(),
  1760.             'devis'         => $ebe->getDevis() ? ($ebe->getDevis()->getNomenclature() ?: $ebe->getDevis()->getName()) : null,
  1761.             'noteInterne'   => $ebe->getNoteInterne(),
  1762.         ];
  1764.         $changes = [];
  1766.         // Champs simples
  1767.         foreach ($newValues as $field => $newVal) {
  1768.             $oldVal = $oldValues[$field];
  1769.             if ($field === 'engageMontant') {
  1770.                 if ((float) $oldVal === (float) $newVal) {
  1771.                     continue;
  1772.                 }
  1773.                 $oldStr = $oldVal !== null ? number_format((float) $oldVal, 0, ',', ' ') . ' €' : null;
  1774.                 $newStr = $newVal !== null ? number_format((float) $newVal, 0, ',', ' ') . ' €' : null;
  1775.             } else {
  1776.                 if ((string) $oldVal === (string) $newVal) {
  1777.                     continue;
  1778.                 }
  1779.                 $oldStr = $oldVal;
  1780.                 $newStr = $newVal;
  1781.             }
  1782.             $label     = $this->getEngageFieldLabel($field) ?: $field;
  1783.             $changes[] = 'Modification : ' . $label . $this->formatOldNew($oldStr, $newStr);
  1784.         }
  1786.         // Lignes de classification (ajout / suppression / modification de montant)
  1787.         foreach (array_keys($oldLignes + $newLignes) as $label) {
  1788.             $o = $oldLignes[$label] ?? null;
  1789.             $n = $newLignes[$label] ?? null;
  1790.             if ((float) $o === (float) $n && array_key_exists($label, $oldLignes) === array_key_exists($label, $newLignes)) {
  1791.                 continue;
  1792.             }
  1793.             $oStr = $o !== null ? number_format((float) $o, 0, ',', ' ') . ' €' : null;
  1794.             $nStr = $n !== null ? number_format((float) $n, 0, ',', ' ') . ' €' : null;
  1795.             if (!array_key_exists($label, $newLignes)) {
  1796.                 $changes[] = 'Suppression classification « ' . $label . ' » ( `' . $oStr . '` )';
  1797.             } elseif (!array_key_exists($label, $oldLignes)) {
  1798.                 $changes[] = 'Ajout classification « ' . $label . ' » ( `' . $nStr . '` )';
  1799.             } else {
  1800.                 $changes[] = 'Modification classification « ' . $label . ' »' . $this->formatOldNew($oStr, $nStr);
  1801.             }
  1802.         }
  1804.         if (empty($changes)) {
  1805.             $this->logAction($version, 'Modification d\'un engagé (aucun changement)', $user, $ebe);
  1806.         } else {
  1807.             foreach ($changes as $change) {
  1808.                 $this->logAction($version, $change, $user, $ebe);
  1809.             }
  1810.         }
  1812.         $this->em->flush();
  1814.         return true;
  1815.     }
  1817.     /**
  1818.      * Construit le suffixe de log « ( de `ancien` à `nouveau` ) » (ou « ( `nouveau` ) » si pas d'ancienne valeur),
  1819.      * dans le même esprit que DetectUpdateListener::postUpdate.
  1820.      */
  1821.     private function formatOldNew($old, $new): string
  1822.     {
  1823.         $old = ($old === null || $old === '') ? null : $old;
  1824.         $new = ($new === null || $new === '') ? null : $new;
  1826.         if ($old !== null) {
  1827.             return ' ( de `' . $old . '` à `' . ($new ?? '—') . '` )';
  1828.         }
  1830.         return ' ( `' . ($new ?? '—') . '` )';
  1831.     }
  1833.     /** Libellé lisible d'un champ de l'engagé, lu depuis l'annotation @CustomAnnotation (comme les listeners). */
  1834.     private function getEngageFieldLabel(string $field): ?string
  1835.     {
  1836.         try {
  1837.             $reflector = new \ReflectionClass(EngagementBudgetEngage::class);
  1838.             if (!$reflector->hasProperty($field)) {
  1839.                 return null;
  1840.             }
  1841.             $doc = (string) $reflector->getProperty($field)->getDocComment();
  1842.             if (preg_match('/@CustomAnnotation\((.*?)\)/', $doc, $m)) {
  1843.                 return trim($m[1], '"');
  1844.             }
  1845.         } catch (\ReflectionException $e) {
  1846.             // ignore
  1847.         }
  1849.         return null;
  1850.     }
  1852.     // ─── SUPPRESSION D'UN ENGAGÉ ──────────────────────────────────────────────
  1854.     public function deleteEngage(int $engageId, ?object $user): bool
  1855.     {
  1856.         $ebe = $this->engagementBudgetEngageRepo->find($engageId);
  1857.         if (!$ebe) {
  1858.             return false;
  1859.         }
  1861.         $budgets = $this->engagementBudgetRepo->findByEngage($engageId);
  1862.         $version = null;
  1863.         foreach ($budgets as $eb) {
  1864.             $version = $eb->getEngagementVersion();
  1865.             // détacher les détails de CET engagé (la ligne subsiste si d'autres engagés y restent)
  1866.             foreach ($this->ebEngageDetails($eb) as $detail) {
  1867.                 $dEbe = $detail->getEngagementBudgetEngage();
  1868.                 if ($dEbe && $dEbe->getId() === $engageId) {
  1869.                     if ($eb->getEngagementBudgetEngageDetail() === $detail) {
  1870.                         $eb->setEngagementBudgetEngageDetail(null);
  1871.                     }
  1872.                     $eb->removeEngagementBudgetEngageDetail($detail);
  1873.                 }
  1874.             }
  1875.             if ($eb->getEngagementBudgetEngage() === $ebe) {
  1876.                 $eb->setEngagementBudgetEngage(null);
  1877.             }
  1878.         }
  1880.         if ($version) {
  1881.             $this->logAction($version, 'Suppression d\'un engagé', $user);
  1882.         }
  1884.         $this->em->remove($ebe); // les détails restants sont supprimés en cascade (FK onDelete=CASCADE)
  1885.         $this->em->flush();
  1887.         return true;
  1888.     }
  1890.     // ─── CRÉATION / RÉCUPÉRATION ──────────────────────────────────────────────
  1892.     public function getOrCreateByProject(Project $project): EngagementProjet
  1893.     {
  1894.         $ep = $this->engagementProjetRepo->findOneBy(['projet' => $project]);
  1895.         if (!$ep) {
  1896.             $ep = new EngagementProjet();
  1897.             $ep->setProjet($project);
  1898.             $this->em->persist($ep);
  1899.             $this->em->flush();
  1900.         }
  1902.         return $ep;
  1903.     }
  1905.     // ─── VERSIONS ─────────────────────────────────────────────────────────────
  1907.     public function getAllVersions(EngagementProjet $ep): array
  1908.     {
  1909.         return $this->engagementVersionRepo->findAllByEngagementProjet($ep->getId());
  1910.     }
  1912.     public function getLatestVersion(EngagementProjet $ep): ?EngagementVersion
  1913.     {
  1914.         return $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  1915.     }
  1917.     /**
  1918.      * Logs d'un projet d'engagement (toutes versions confondues) + libellés de version.
  1919.      * Retourne :
  1920.      *   - 'logs'          : EngagementVersionLog[] (du plus récent au plus ancien)
  1921.      *   - 'versionLabels' : map [versionId => ['num' => int, 'jalon' => ?string]]
  1922.      */
  1923.     public function getLogsData(EngagementProjet $ep): array
  1924.     {
  1925.         $logs = $this->em->getRepository(EngagementVersionLog::class)
  1926.             ->findByEngagementProjet($ep->getId());
  1928.         // Numérotation des versions identique à l'écran (la plus ancienne = Version 1)
  1929.         $versions = $this->getAllVersions($ep); // triées DESC par createdAt
  1930.         $total    = count($versions);
  1931.         $labels   = [];
  1932.         foreach ($versions as $i => $v) {
  1933.             $labels[$v->getId()] = [
  1934.                 'num'   => $total - $i,
  1935.                 'jalon' => $v->getEngagementJalon() ? $v->getEngagementJalon()->getName() : null,
  1936.             ];
  1937.         }
  1939.         return ['logs' => $logs, 'versionLabels' => $labels];
  1940.     }
  1942.     /** @return EngagementJalon[] */
  1943.     public function getAllJalons(): array
  1944.     {
  1945.         return $this->em->getRepository(EngagementJalon::class)->findBy([], ['name' => 'ASC']);
  1946.     }
  1948.     // ─── IMPORT D'UN BUDGET (CSV "Fiche transfert") ──────────────────────────
  1950.     public function importBudget(EngagementProjet $ep, array $data, ?object $user): array
  1951.     {
  1952.         // 1. Récupération du fichier téléversé (DocUpload via token)
  1953.         $token = $data['fileBudget'] ?? null;
  1954.         if (!$token) {
  1955.             return ['success' => false, 'message' => "Aucun document budget n'a été téléversé."];
  1956.         }
  1958.         $doc = $this->em->getRepository(DocUpload::class)->findOneBy(['token' => $token]);
  1959.         if (!$doc) {
  1960.             return ['success' => false, 'message' => "Document introuvable."];
  1961.         }
  1963.         $path = rtrim($this->params->get('uploads_directory'), '/\\') . '/' . $doc->getPath();
  1964.         if (!is_file($path)) {
  1965.             return ['success' => false, 'message' => "Le fichier est introuvable sur le serveur."];
  1966.         }
  1968.         // 2. Lecture + validation du fichier "Fiche transfert"
  1969.         $rows = $this->parseCsvFile($path);
  1970.         if (count($rows) < 3) {
  1971.             return ['success' => false, 'message' => "Le fichier ne correspond pas au modèle attendu (Fiche transfert)."];
  1972.         }
  1974.         // Entête : ligne 1 (NIVEAU 1 / NIVEAU 2) et ligne 2 (CODE BUDGET / Montant / CATÉGORIE DE DÉPENSE / Montant)
  1975.         $l1 = array_map([$this, 'norm'], $rows[0]);
  1976.         $l2 = array_map([$this, 'norm'], $rows[1]);
  1977.         $headerOk = in_array('NIVEAU 1', $l1, true)
  1978.             && in_array('NIVEAU 2', $l1, true)
  1979.             && ($l2[0] ?? '') === 'CODE BUDGET'
  1980.             && ($l2[2] ?? '') === 'CATEGORIE DE DEPENSE';
  1982.         if (!$headerOk) {
  1983.             return ['success' => false, 'message' => "L'entête du fichier ne correspond pas au modèle Fiche transfert."];
  1984.         }
  1986.         // 3. Référentiel TypeDepense indexé par libellé normalisé
  1987.         $mapN1 = $this->indexTypeDepenseByLibelle(TypeDepense::NIVEAU_CODE_BUDGET);
  1988.         $mapN2 = $this->indexTypeDepenseByLibelle(TypeDepense::NIVEAU_CATEGORIE);
  1990.         // 4. Lignes de données → (TypeDepense, montant)
  1991.         $lignes = [];
  1992.         for ($i = 2; $i < count($rows); $i++) {
  1993.             $row = $rows[$i];
  1995.             $codeBudget = $this->norm($row[0] ?? '');
  1996.             if ($codeBudget !== '' && isset($mapN1[$codeBudget])) {
  1997.                 $lignes[] = ['type' => $mapN1[$codeBudget], 'montant' => $this->toFloat($row[1] ?? null)];
  1998.             }
  2000.             $categorie = $this->norm($row[2] ?? '');
  2001.             if ($categorie !== '' && isset($mapN2[$categorie])) {
  2002.                 $lignes[] = ['type' => $mapN2[$categorie], 'montant' => $this->toFloat($row[3] ?? null)];
  2003.             }
  2004.         }
  2006.         if (empty($lignes)) {
  2007.             return ['success' => false, 'message' => "Aucune ligne du fichier ne correspond au référentiel des types de dépense."];
  2008.         }
  2010.         // 4b. Ratios financiers (dernier tableau : EBE/CAPEX ; TRI Equity ; Dette)
  2011.         $ratios = $this->parseRatiosFromRows($rows);
  2013.         // 5. Version cible :
  2014.         //    - dernière version = brouillon (isVersion = false) → on la réutilise et on la fige (isVersion = true)
  2015.         //    - pas de version OU dernière déjà figée → on crée une nouvelle version et on reprend ses engagés
  2016.         $version = $this->engagementVersionRepo->findLatestByEngagementProjet($ep->getId());
  2017.         if ($version && !$version->getIsVersion()) {
  2018.             $version->setIsVersion(true);
  2019.         } else {
  2020.             $previous = $version;
  2021.             $version  = new EngagementVersion();
  2022.             $version->setEngagementProjet($ep);
  2023.             $version->setIsVersion(true);
  2024.             $this->em->persist($version);
  2026.             // Reprise des engagés (engagementBudgetEngage) de la version précédente
  2027.             if ($previous) {
  2028.                 $this->carryOverEngages($previous, $version);
  2029.             }
  2030.         }
  2032.         // 6. Jalon (champ libre) : réutilise un jalon existant du même nom, sinon le crée.
  2033.         $jalon     = null;
  2034.         $jalonName = isset($data['newJalon']) ? trim((string) $data['newJalon']) : '';
  2035.         if ($jalonName !== '') {
  2036.             $jalon = $this->em->getRepository(EngagementJalon::class)->findOneBy(['name' => $jalonName]);
  2037.             if (!$jalon) {
  2038.                 $jalon = new EngagementJalon();
  2039.                 $jalon->setName($jalonName);
  2040.                 $this->em->persist($jalon);
  2041.             }
  2042.         } elseif (!empty($data['jalonId'])) {
  2043.             $jalon = $this->em->getRepository(EngagementJalon::class)->find($data['jalonId']);
  2044.         }
  2045.         if ($jalon) {
  2046.             $version->setEngagementJalon($jalon);
  2047.         }
  2049.         // 7. Document, montants des seuils et commentaire
  2050.         $version->setFileBudget($doc);
  2051.         // Business plan (fichier optionnel téléversé dans la modale d'import)
  2052.         if (!empty($data['businessPlan'])) {
  2053.             $docBp = $this->em->getRepository(DocUpload::class)->findOneBy(['token' => $data['businessPlan']]);
  2054.             if ($docBp) {
  2055.                 $version->setFileBusinessPlan($docBp);
  2056.             }
  2057.         }
  2058.         $version->setProspectionMontant($this->toFloat($data['prospectionMontant'] ?? null));
  2059.         $version->setMontageAdministratifMontant($this->toFloat($data['montageAdministratifMontant'] ?? null));
  2060.         $version->setDeveloppementMontant($this->toFloat($data['developpementMontant'] ?? null));
  2061.         $version->setConstructionMontant($this->toFloat($data['constructionMontant'] ?? null));
  2062.         // Ratios financiers du dernier tableau de la fiche transfert
  2063.         $version->setEbeCapex($ratios['ebeCapex']);
  2064.         $version->setEquity($ratios['equity']);
  2065.         $version->setDette($ratios['dette']);
  2066.         if (isset($data['comment'])) {
  2067.             $version->setComment($data['comment']);
  2068.         }
  2070.         // 8. Garantir une ligne EngagementBudget par TypeDepense (suivi) avant l'import
  2071.         $this->ensureBudgetLinesForAllTypes($version);
  2073.         // 9. Lignes budget : upsert par TypeDepense dans la version
  2074.         foreach ($lignes as $ligne) {
  2075.             /** @var TypeDepense $type */
  2076.             $type    = $ligne['type'];
  2077.             $montant = $ligne['montant'];
  2079.             $eb = $this->findBudgetLineByType($version, $type);
  2080.             if (!$eb) {
  2081.                 $eb = new EngagementBudget();
  2082.                 $eb->setEngagementVersion($version);
  2083.                 $eb->setTypeDepense($type);
  2084.                 $eb->setClassificationBudget($type->getLibelle());
  2085.                 $eb->setCategorie($type->getParent() ? $type->getParent()->getLibelle() : null);
  2086.                 $this->em->persist($eb);
  2087.                 $version->addEngagementBudget($eb);
  2088.             }
  2090.             // Le montant prévisionnel est porté UNIQUEMENT par EngagementBudgetPrevisionel
  2091.             $prev = $eb->getEngagementBudgetPrevisionel() ?: new EngagementBudgetPrevisionel();
  2092.             $prev->setMontant($montant);
  2093.             $this->em->persist($prev);
  2094.             $eb->setEngagementBudgetPrevisionel($prev);
  2095.         }
  2097.         $this->logAction($version, "Import d'un budget", $user);
  2098.         $this->em->flush();
  2100.         return ['success' => true, 'message' => "Le budget a été importé avec succès."];
  2101.     }
  2103.     /**
  2104.      * Reprend les engagés (EngagementBudgetEngage) de la version $from vers la version $to.
  2105.      * On partage la MÊME entité EngagementBudgetEngage (pas de clone) : une nouvelle ligne
  2106.      * EngagementBudget est créée dans $to pour chaque ligne de $from qui porte un engagé,
  2107.      * en réutilisant son TypeDepense, sa classification et son engagé.
  2108.      * Le prévisionnel n'est pas recopié : il proviendra du nouveau CSV importé.
  2109.      */
  2110.     private function carryOverEngages(EngagementVersion $from, EngagementVersion $to): void
  2111.     {
  2112.         foreach ($this->engagementBudgetRepo->findByVersionWithRelations($from->getId()) as $source) {
  2113.             $details = $this->ebEngageDetails($source);
  2114.             if (empty($details)) {
  2115.                 continue;
  2116.             }
  2118.             $eb = new EngagementBudget();
  2119.             $eb->setEngagementVersion($to);
  2120.             $eb->setTypeDepense($source->getTypeDepense());
  2121.             $eb->setClassificationBudget($source->getClassificationBudget());
  2122.             $eb->setCategorie($source->getCategorie());
  2124.             // Un détail par engagé : on CLONE chaque détail dans la nouvelle version (l'engagé
  2125.             // EngagementBudgetEngage reste partagé, mais chaque version possède ses propres détails).
  2126.             foreach ($details as $srcDetail) {
  2127.                 $srcEbe = $srcDetail->getEngagementBudgetEngage();
  2128.                 if (!$srcEbe) {
  2129.                     continue;
  2130.                 }
  2131.                 $clone = new EngagementBudgetEngageDetail();
  2132.                 $clone->setClassificationBudget($srcDetail->getClassificationBudget());
  2133.                 $clone->setEngageMontant($srcDetail->getEngageMontant());
  2134.                 $clone->setEngagementBudgetEngage($srcEbe);
  2135.                 $clone->setProjet($srcDetail->getProjet());
  2136.                 $clone->setTimeline($srcDetail->getTimeline());
  2137.                 $clone->setEtape($srcDetail->getEtape());
  2138.                 $this->em->persist($clone);
  2139.                 $srcEbe->addEngagementBudgetEngageDetail($clone);
  2140.                 $eb->addEngagementBudgetEngageDetail($clone);
  2141.                 // liens uniques legacy (dernier engagé de la ligne)
  2142.                 $eb->setEngagementBudgetEngage($srcEbe);
  2143.                 $eb->setEngagementBudgetEngageDetail($clone);
  2144.             }
  2146.             $this->em->persist($eb);
  2147.             $to->addEngagementBudget($eb);
  2148.         }
  2149.     }
  2151.     // ─── CONFIGURATION DES TYPES DE DÉPENSE ───────────────────────────────────
  2153.     /**
  2154.      * Liste des phases / statuts administratifs (constantes CAT_* de EngagementVersion)
  2155.      * indexées par valeur → libellé, pour alimenter le <select>.
  2156.      */
  2157.     public function getStatutsAdministratifs(): array
  2158.     {
  2159.         return [
  2160.             EngagementVersion::CAT_Prospection            => 'Prospection',
  2161.             EngagementVersion::CAT_Montage_Administratif   => 'Montage administratif',
  2162.             EngagementVersion::CAT_Developpement           => 'Développement',
  2163.             EngagementVersion::CAT_Construction            => 'Construction',
  2164.         ];
  2165.     }
  2167.     /**
  2168.      * Enregistre la classification de dépense ERPI d'un type de dépense.
  2169.      */
  2170.     public function updateClassificationErpi(TypeDepense $type, ?string $value): void
  2171.     {
  2172.         $type->setClassificationDepenseErpi((string) $value);
  2173.         $this->em->flush();
  2174.     }
  2176.     /**
  2177.      * Synchronise les statuts administratifs d'un type de dépense : supprime les lignes
  2178.      * existantes et recrée une TypeDepenseStatutAdministatif par valeur sélectionnée.
  2179.      *
  2180.      * @param string[] $values
  2181.      */
  2182.     public function syncStatutsAdministratifs(TypeDepense $type, array $values): void
  2183.     {
  2184.         foreach ($type->getTypeDepenseStatutAdministatif()->toArray() as $existing) {
  2185.             $type->removeTypeDepenseStatutAdministatif($existing);
  2186.             $this->em->remove($existing);
  2187.         }
  2189.         $seen = [];
  2190.         foreach ($values as $val) {
  2191.             $val = trim((string) $val);
  2192.             if ($val === '' || isset($seen[$val])) {
  2193.                 continue;
  2194.             }
  2195.             $seen[$val] = true;
  2197.             $statut = new TypeDepenseStatutAdministatif();
  2198.             $statut->setStatutAdministratif($val);
  2199.             $statut->setTypeDepense($type);
  2200.             $this->em->persist($statut);
  2201.             $type->addTypeDepenseStatutAdministatif($statut);
  2202.         }
  2204.         $this->em->flush();
  2205.     }
  2207.     private function findBudgetLineByType(EngagementVersion $version, TypeDepense $type): ?EngagementBudget
  2208.     {
  2209.         foreach ($version->getEngagementBudget() as $eb) {
  2210.             if ($eb->getTypeDepense() && $eb->getTypeDepense()->getId() === $type->getId()) {
  2211.                 return $eb;
  2212.             }
  2213.         }
  2215.         return null;
  2216.     }
  2218.     /**
  2219.      * Garantit qu'il existe une ligne EngagementBudget par ligne de dépense
  2220.      * (TypeDepense niveau 3) suivie dans la version : crée les lignes manquantes.
  2221.      * Les niveaux 1 (code budget) et 2 (catégorie) ne sont que des regroupements
  2222.      * dans l'arbre, pas des lignes de dépense.
  2223.      */
  2224.     private function ensureBudgetLinesForAllTypes(EngagementVersion $version): void
  2225.     {
  2226.         $existing = [];
  2227.         foreach ($version->getEngagementBudget() as $eb) {
  2228.             if ($eb->getTypeDepense()) {
  2229.                 $existing[$eb->getTypeDepense()->getId()] = true;
  2230.             }
  2231.         }
  2233.         $types = $this->em->getRepository(TypeDepense::class)->findBy([
  2234.             'suiviEngagement' => true,
  2235.             'niveau'          => TypeDepense::NIVEAU_LIGNE,
  2236.         ]);
  2237.         foreach ($types as $type) {
  2238.             if (isset($existing[$type->getId()])) {
  2239.                 continue;
  2240.             }
  2242.             $eb = new EngagementBudget();
  2243.             $eb->setEngagementVersion($version);
  2244.             $eb->setTypeDepense($type);
  2245.             $eb->setClassificationBudget($type->getLibelle());
  2246.             $eb->setCategorie($type->getParent() ? $type->getParent()->getLibelle() : null);
  2247.             $this->em->persist($eb);
  2248.             $version->addEngagementBudget($eb);
  2250.             $existing[$type->getId()] = true;
  2251.         }
  2252.     }
  2254.     /** @return array<string,TypeDepense> libellé normalisé => TypeDepense */
  2255.     private function indexTypeDepenseByLibelle(int $niveau): array
  2256.     {
  2257.         $map = [];
  2258.         foreach ($this->em->getRepository(TypeDepense::class)->findByNiveau($niveau) as $td) {
  2259.             $map[$this->norm($td->getLibelle())] = $td;
  2260.         }
  2262.         return $map;
  2263.     }
  2265.     private function parseCsvFile(string $path): array
  2266.     {
  2267.         $rows    = [];
  2268.         $content = file_get_contents($path);
  2269.         if ($content === false) {
  2270.             return $rows;
  2271.         }
  2272.         // Suppression du BOM UTF-8 éventuel
  2273.         $content = preg_replace('/^\xEF\xBB\xBF/', '', $content);
  2275.         $handle = fopen('php://temp', 'r+');
  2276.         fwrite($handle, $content);
  2277.         rewind($handle);
  2278.         while (($cols = fgetcsv($handle, 0, ';')) !== false) {
  2279.             $rows[] = $cols;
  2280.         }
  2281.         fclose($handle);
  2283.         return $rows;
  2284.     }
  2286.     /**
  2287.      * Extrait les ratios financiers du dernier tableau de la Fiche transfert :
  2288.      * ligne d'entête « EBE/CAPEX ; TRI Equity ; Dette » suivie de la ligne de valeurs.
  2289.      *
  2290.      * @param array<int,array<int,string>> $rows
  2291.      * @return array{ebeCapex: ?float, equity: ?float, dette: ?float}
  2292.      */
  2293.     private function parseRatiosFromRows(array $rows): array
  2294.     {
  2295.         $default = ['ebeCapex' => null, 'equity' => null, 'dette' => null];
  2296.         for ($i = 0, $n = count($rows); $i < $n; $i++) {
  2297.             if ($this->norm($rows[$i][0] ?? '') === 'EBE/CAPEX') {
  2298.                 $valRow = $rows[$i + 1] ?? [];
  2299.                 return [
  2300.                     'ebeCapex' => $this->toFloat($valRow[0] ?? null),
  2301.                     'equity'   => $this->toFloat($valRow[1] ?? null),
  2302.                     'dette'    => $this->toFloat($valRow[2] ?? null),
  2303.                 ];
  2304.             }
  2305.         }
  2307.         return $default;
  2308.     }
  2310.     /** Normalise une chaîne pour comparaison : trim, majuscules, sans accents, espaces compactés. */
  2311.     private function norm(?string $value): string
  2312.     {
  2313.         $value = trim((string) $value);
  2314.         if ($value === '') {
  2315.             return '';
  2316.         }
  2317.         $value = strtr($value, [
  2318.             'É' => 'E', 'È' => 'E', 'Ê' => 'E', 'Ë' => 'E',
  2319.             'À' => 'A', 'Â' => 'A', 'Ä' => 'A',
  2320.             'Î' => 'I', 'Ï' => 'I', 'Ô' => 'O', 'Ö' => 'O',
  2321.             'Û' => 'U', 'Ü' => 'U', 'Ù' => 'U', 'Ç' => 'C', 'Œ' => 'OE',
  2322.             'é' => 'E', 'è' => 'E', 'ê' => 'E', 'ë' => 'E',
  2323.             'à' => 'A', 'â' => 'A', 'ä' => 'A',
  2324.             'î' => 'I', 'ï' => 'I', 'ô' => 'O', 'ö' => 'O',
  2325.             'û' => 'U', 'ü' => 'U', 'ù' => 'U', 'ç' => 'C', 'œ' => 'OE',
  2326.         ]);
  2327.         $value = mb_strtoupper($value, 'UTF-8');
  2328.         $value = preg_replace('/\s+/', ' ', $value);
  2330.         return trim($value);
  2331.     }
  2333.     private function toFloat($value): ?float
  2334.     {
  2335.         if ($value === null || $value === '') {
  2336.             return null;
  2337.         }
  2338.         $value = str_replace([' ', "\xC2\xA0"], '', (string) $value);
  2339.         $value = str_replace(',', '.', $value);
  2341.         return is_numeric($value) ? (float) $value : null;
  2342.     }
  2344.     // ─── HELPERS ──────────────────────────────────────────────────────────────
  2346.     private function logAction(EngagementVersion $version, string $action, ?object $user, ?EngagementBudgetEngage $ebe = null): void
  2347.     {
  2348.         $log = new EngagementVersionLog();
  2349.         $log->setEngagementVersion($version);
  2350.         $log->setAction($action);
  2351.         if ($user) {
  2352.             $log->setUser($user);
  2353.         }
  2354.         if ($ebe) {
  2355.             $log->setEngagementBudgetEngage($ebe);
  2356.         }
  2357.         $this->em->persist($log);
  2358.     }
  2360.     private function formatProjetNom(Project $projet): string
  2361.     {
  2362.         return (string) $projet->getName();
  2363.     }
  2365.     private function formatStatutAdministratif(?string $statut): string
  2366.     {
  2367.         $labels = [
  2368.             (string) Project::STATUS_CUSTOM_EN_ATTENT       => 'Prospection',
  2369.             (string) Project::STATUS_CUSTOM_DEVELOPPEMENT   => 'Développement',
  2370.             (string) Project::STATUS_CUSTOM_CONSTRUCTION    => 'Construction',
  2371.             (string) Project::STATUS_CUSTOM_EXPLOITATION    => 'Exploitation',
  2372.         ];
  2374.         return $labels[$statut] ?? ($statut ?: '-');
  2375.     }
  2377.     private function emptyTotaux(): array
  2378.     {
  2379.         return ['previsionnel' => '0', 'engage' => '0', 'facture' => '0'];
  2380.     }
  2381. }