<?php

declare(strict_types=1);

namespace App\Module\Commercial\Infrastructure\ApiPlatform\State\Processor;

use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProcessorInterface;
use App\Module\Commercial\Application\Service\SupplierFieldNormalizer;
use App\Module\Commercial\Application\Validator\SupplierAccountingCompletenessValidator;
use App\Module\Commercial\Domain\Entity\Supplier;
use DateTimeImmutable;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\PersistentCollection;
use JsonException;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\HttpKernel\Exception\ConflictHttpException;
use Symfony\Component\HttpKernel\Exception\UnprocessableEntityHttpException;

/**
 * Processor d'ecriture du repertoire fournisseurs (M2). Cf. spec-back M2 § 4.3 /
 * § 4.4 + RG-2.11 / RG-2.12 / RG-2.14 / RG-2.15 / RG-2.16. Jumeau du
 * ClientProcessor (M1), recentre sur le perimetre ERP-87.
 *
 * Sequence (POST / PATCH) :
 *  1. Autorisation additionnelle par groupe d'onglet (mode strict RG-2.16). La
 *     security d'operation du PATCH est elargie a `manage` OU `accounting.manage`
 *     pour laisser entrer le role Compta ; ce processor re-gate alors finement :
 *     - champ comptable modifie dans le payload -> exige accounting.manage (403) ;
 *     - champ main/information modifie -> exige manage (guardManage, 403) :
 *       empeche Compta d'editer un autre onglet que la Comptabilite (§ 2.9) ;
 *     - champ isArchived dans le payload -> exige archive (RG-2.14, 403) et
 *       interdit toute autre modification dans la meme requete (RG-2.14, 422).
 *  2. Normalisation serveur (RG-2.12) via SupplierFieldNormalizer.
 *  3. Pose / retrait de archivedAt (RG-2.14 true=now, RG-2.15 false=null).
 *  4. Persistance via le persist_processor Doctrine, avec traduction des
 *     collisions d'unicite en 409 (RG-2.11 doublon de nom ; RG-2.15 conflit de
 *     restauration).
 *
 * Validators metier (ERP-89). Ce processor porte la completude Comptabilite : a
 * la validation complete de l'onglet (les six scalaires obligatoires presents
 * dans le payload), chacun doit etre renseigne. (RG-2.03 « Information obligatoire
 * pour la Commerciale » a ete retiree, miroir client M1 — l'onglet Information est
 * desormais entierement facultatif, quel que soit le role.)
 *
 * Les RG inter-champs RG-2.07 (Virement -> banque), RG-2.08 (LCR -> >= 1 RIB) et
 * RG-2.10 (categorie de type FOURNISSEUR) sont portees par des Assert\Callback +
 * ->atPath() sur l'entite Supplier (jouees par API Platform AVANT ce processor),
 * pour que chaque 422 porte un propertyPath consommable par extractApiViolations
 * (mapping inline, pas un toast — convention ERP-101).
 *
 * @implements ProcessorInterface<Supplier, Supplier>
 */
final class SupplierProcessor implements ProcessorInterface
{
    /** Champs de l'onglet principal (groupe supplier:write:main). */
    private const array MAIN_FIELDS = [
        'companyName', 'categories',
    ];

    /** Champs de l'onglet Information (groupe supplier:write:information). */
    private const array INFORMATION_FIELDS = [
        'description', 'competitors', 'foundedAt', 'employeesCount',
        'revenueAmount', 'directorName', 'profitAmount', 'volumeForecast',
    ];

    /** Champs de l'onglet Comptabilite (groupe supplier:write:accounting). */
    private const array ACCOUNTING_FIELDS = [
        'siren', 'accountNumber', 'tvaMode', 'nTva', 'paymentDelay',
        'paymentType', 'bank',
    ];

    /**
     * Champs comptables obligatoires a la validation complete de l'onglet
     * (spec-front M2 § Onglet Comptabilite). bank est exclu : conditionnel (RG-2.07).
     */
    private const array ACCOUNTING_REQUIRED_FIELDS = [
        'siren', 'accountNumber', 'tvaMode', 'nTva', 'paymentDelay', 'paymentType',
    ];

    /** Champ d'archivage (groupe supplier:write:archive). */
    private const string ARCHIVE_FIELD = 'isArchived';

    private const string PERM_MANAGE            = 'commercial.suppliers.manage';
    private const string PERM_ACCOUNTING_MANAGE = 'commercial.suppliers.accounting.manage';
    private const string PERM_ARCHIVE           = 'commercial.suppliers.archive';

    /**
     * Memoisation du dernier corps de requete decode, clos par le contenu brut.
     * payloadKeys() est appele plusieurs fois par requete (writablePayloadKeys,
     * categoriesChanged...) : on evite de rejouer json_decode a chaque appel. La
     * cle etant le contenu lui-meme et le calcul une fonction pure de ce contenu,
     * aucune fuite n'est possible entre requetes sur ce service partage (un meme
     * corps redonne les memes cles).
     */
    private ?string $decodedContent = null;

    /** @var list<string> Cles de premier niveau correspondant au corps memoise. */
    private array $decodedPayloadKeys = [];

    public function __construct(
        #[Autowire(service: 'api_platform.doctrine.orm.state.persist_processor')]
        private readonly ProcessorInterface $persistProcessor,
        private readonly SupplierFieldNormalizer $normalizer,
        private readonly SupplierAccountingCompletenessValidator $accountingValidator,
        private readonly Security $security,
        private readonly RequestStack $requestStack,
        private readonly EntityManagerInterface $em,
    ) {}

    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
    {
        if (!$data instanceof Supplier) {
            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
        }

        // Reinitialisation de la memoisation du payload en debut de traitement :
        // le service est partage (stateful), on repart du corps de LA requete
        // courante et on n'herite jamais des cles decodees d'une requete passee.
        $this->decodedContent     = null;
        $this->decodedPayloadKeys = [];

        $writableKeys = $this->writablePayloadKeys();

        $isArchiveRequest = $this->guardArchive($data, $writableKeys);
        $this->guardAccounting($data);

        $this->normalize($data);

        // guardManage apres normalize : la comparaison « change vs etat
        // persiste » des champs texte (companyName...) se fait sur des valeurs
        // normalisees des deux cotes (l'etat persiste l'a deja ete).
        $this->guardManage($data);

        $this->validateAccountingCompleteness($data);

        try {
            return $this->persistProcessor->process($data, $operation, $uriVariables, $context);
        } catch (UniqueConstraintViolationException $e) {
            // Le seul index unique partiel est uq_supplier_company_name_active
            // (LOWER(company_name) parmi non-archives/non-deletes — § 2.6).
            if ($isArchiveRequest && false === $data->isArchived()) {
                // RG-2.15 : restauration en conflit avec un homonyme actif.
                throw new ConflictHttpException(
                    'Restauration impossible : un autre fournisseur a pris le nom entre-temps.',
                    $e,
                );
            }

            // RG-2.11 : doublon de nom de societe.
            throw new ConflictHttpException(
                sprintf('Un fournisseur nommé "%s" existe déjà.', (string) $data->getCompanyName()),
                $e,
            );
        }
    }

    /**
     * RG-2.14 / RG-2.15 : si le payload bascule reellement isArchived, exige la
     * permission archive (403), interdit toute autre modification (422) et
     * pose/retire archivedAt. Retourne true si la requete est une requete
     * d'archivage.
     *
     * Le gating est restreint a la mise a jour d'un fournisseur existant ET au
     * seul cas ou isArchived change vraiment : un POST (entite non encore geree
     * par l'ORM) ou un PATCH « representation complete » renvoyant isArchived
     * inchange ne doit declencher ni 403 ni 422 parasite.
     *
     * @param list<string> $writableKeys cles ecrivables du payload (hors @* et champs inconnus)
     */
    private function guardArchive(Supplier $data, array $writableKeys): bool
    {
        // POST / entite non geree : l'archivage est une action de mise a jour.
        if (!$this->em->contains($data)) {
            return false;
        }

        // isArchived inchange par rapport a l'etat persiste : pas une requete
        // d'archivage (cas du PATCH representation complete).
        if (!$this->fieldChanged($data, 'isArchived', $data->isArchived())) {
            return false;
        }

        if (!$this->security->isGranted(self::PERM_ARCHIVE)) {
            throw new AccessDeniedHttpException(sprintf(
                'Le champ "%s" requiert la permission "%s".',
                self::ARCHIVE_FIELD,
                self::PERM_ARCHIVE,
            ));
        }

        // RG-2.14 : une requete d'archivage ne modifie aucun autre champ ecrivable.
        if ([] !== array_diff($writableKeys, [self::ARCHIVE_FIELD])) {
            throw new UnprocessableEntityHttpException(
                'Une requête d\'archivage ne peut modifier aucun autre champ que "isArchived".',
            );
        }

        // RG-2.14 (true -> now) / RG-2.15 (false -> null).
        $data->setArchivedAt($data->isArchived() ? new DateTimeImmutable() : null);

        return true;
    }

    /**
     * RG-2.16 : la modification effective d'un champ comptable exige
     * accounting.manage, sinon 403 sur l'ensemble du payload (mode strict, pas
     * de filtrage silencieux). On ne gate que si un champ change reellement par
     * rapport a l'etat persiste : un POST/PATCH renvoyant des champs comptables
     * inchanges (ou null en creation) ne declenche pas de 403 parasite. Le
     * message precise le premier champ fautif.
     */
    private function guardAccounting(Supplier $data): void
    {
        $changed = $this->changedAccountingFields($data);

        if ([] === $changed) {
            return;
        }

        if (!$this->security->isGranted(self::PERM_ACCOUNTING_MANAGE)) {
            throw new AccessDeniedHttpException(sprintf(
                'Le champ "%s" requiert la permission "%s".',
                $changed[0],
                self::PERM_ACCOUNTING_MANAGE,
            ));
        }
    }

    /**
     * § 2.9 / RG-2.16 : la modification effective d'un champ « metier » (onglets
     * principal ou Information) exige `commercial.suppliers.manage`. Sans cette
     * permission -> 403 sur l'ensemble du payload (mode strict, miroir de
     * guardAccounting). C'est ce qui empeche le role Compta — qui entre dans le
     * PATCH via `accounting.manage` (security d'operation elargie) — d'editer
     * autre chose que l'onglet Comptabilite.
     *
     * Ne s'applique qu'aux mises a jour (entite geree) : la creation (POST) est
     * deja gardee par la security d'operation `manage`, donc inutile de la
     * re-gater ici (et un POST par un porteur de `manage` passerait de toute
     * facon).
     */
    private function guardManage(Supplier $data): void
    {
        if (!$this->em->contains($data)) {
            return;
        }

        $changed = $this->changedBusinessFields($data);

        if ([] === $changed) {
            return;
        }

        if (!$this->security->isGranted(self::PERM_MANAGE)) {
            throw new AccessDeniedHttpException(sprintf(
                'Le champ "%s" requiert la permission "%s".',
                $changed[0],
                self::PERM_MANAGE,
            ));
        }
    }

    /**
     * spec-front M2 § Onglet Comptabilite : a la validation COMPLETE de l'onglet
     * (les six champs obligatoires presents dans le payload — le front les envoie
     * toujours ensemble), chacun doit etre renseigne, sinon 422 par champ. On ne
     * declenche pas sur un PATCH ciblant un sous-ensemble de champs comptables :
     * ce n'est pas une validation d'onglet (edition ponctuelle preservee). bank /
     * RIB restent geres par validatePaymentTypeConsistency sur l'entite (RG-2.07 /
     * RG-2.08). Miroir du ClientProcessor (M1).
     */
    private function validateAccountingCompleteness(Supplier $data): void
    {
        // Declenche uniquement si TOUS les champs requis sont presents dans le
        // payload (= soumission d'onglet, pas un PATCH partiel cible).
        if ([] !== array_diff(self::ACCOUNTING_REQUIRED_FIELDS, $this->payloadKeys())) {
            return;
        }

        $this->accountingValidator->validate($data);
    }

    /**
     * Champs « metier » (onglets principal + Information, hors comptabilite et
     * archivage) dont la valeur courante differe de l'etat persiste. Memes
     * regles de comparaison que changedAccountingFields (scalaires par valeur).
     *
     * Cas particulier `categories` (M2M) : non trace par getOriginalEntityData,
     * compare par valeur via le snapshot de la PersistentCollection (cf.
     * categoriesChanged) — la simple presence dans le payload ne suffit pas, sous
     * peine de 403 parasite sur un PATCH representation complete reincluant des
     * categories inchangees.
     *
     * @return list<string>
     */
    private function changedBusinessFields(Supplier $data): array
    {
        $newValues = [
            'companyName'    => $data->getCompanyName(),
            'description'    => $data->getDescription(),
            'competitors'    => $data->getCompetitors(),
            'foundedAt'      => $data->getFoundedAt(),
            'employeesCount' => $data->getEmployeesCount(),
            'revenueAmount'  => $data->getRevenueAmount(),
            'directorName'   => $data->getDirectorName(),
            'profitAmount'   => $data->getProfitAmount(),
            'volumeForecast' => $data->getVolumeForecast(),
        ];

        $changed = [];
        foreach ($newValues as $field => $newValue) {
            if ($this->fieldChanged($data, $field, $newValue)) {
                $changed[] = $field;
            }
        }

        if ($this->categoriesChanged($data)) {
            $changed[] = 'categories';
        }

        return $changed;
    }

    /**
     * Vrai si l'ensemble des categories (M2M) differe reellement de l'etat
     * persiste. La collection n'etant pas tracee par getOriginalEntityData, on
     * compare par identifiants (independamment de l'ordre) le snapshot de la
     * PersistentCollection (etat charge depuis la base) a l'etat courant (apres
     * application du payload). Symetrique de changedAccountingFields : seul un
     * changement effectif compte, pas la simple presence dans le payload.
     *
     * - POST / entite non geree : fournir des categories est un acte metier
     *   (branche defensive, guardManage ne s'execute de toute facon que sur
     *   entite geree).
     * - categories absent du payload (PATCH partiel) : aucun changement.
     */
    private function categoriesChanged(Supplier $data): bool
    {
        if (!$this->em->contains($data)) {
            return true;
        }

        if (!in_array('categories', $this->payloadKeys(), true)) {
            return false;
        }

        $collection = $data->getCategories();

        // Hors PersistentCollection (cas limite hors flux PATCH reel) : faute
        // d'etat persiste comparable, on se rabat sur la presence payload.
        if (!$collection instanceof PersistentCollection) {
            return true;
        }

        return $this->categoryIdSet($collection->toArray())
            !== $this->categoryIdSet($collection->getSnapshot());
    }

    /**
     * Ensemble trie des identifiants d'une liste de categories — pour une
     * comparaison par valeur independante de l'ordre.
     *
     * @param array<int, object> $categories
     *
     * @return list<mixed>
     */
    private function categoryIdSet(array $categories): array
    {
        $ids = array_map(
            static fn (object $category): mixed => method_exists($category, 'getId')
                ? $category->getId()
                : spl_object_id($category),
            array_values($categories),
        );
        sort($ids);

        return $ids;
    }

    /**
     * Champs comptables dont la valeur courante differe de l'etat persiste. Les
     * relations (tvaMode, paymentDelay, paymentType, bank) sont comparees par
     * identite d'objet : l'identity map Doctrine renvoie la meme instance tant
     * que la reference est inchangee.
     *
     * @return list<string>
     */
    private function changedAccountingFields(Supplier $data): array
    {
        $changed = [];

        foreach (self::ACCOUNTING_FIELDS as $field) {
            $newValue = match ($field) {
                'siren'         => $data->getSiren(),
                'accountNumber' => $data->getAccountNumber(),
                'tvaMode'       => $data->getTvaMode(),
                'nTva'          => $data->getNTva(),
                'paymentDelay'  => $data->getPaymentDelay(),
                'paymentType'   => $data->getPaymentType(),
                'bank'          => $data->getBank(),
            };

            if ($this->fieldChanged($data, $field, $newValue)) {
                $changed[] = $field;
            }
        }

        return $changed;
    }

    /**
     * Vrai si la valeur courante d'un champ differe de l'etat persiste. Pour une
     * entite non geree (creation/POST), l'etat persiste est vide : toute valeur
     * non-null est alors un changement.
     */
    private function fieldChanged(Supplier $data, string $field, mixed $newValue): bool
    {
        $original = $this->originalData($data);

        return $newValue !== ($original[$field] ?? null);
    }

    /**
     * Snapshot des valeurs persistees de l'entite (telles que chargees, avant
     * application du payload). Vide pour une entite non geree (POST).
     *
     * @return array<string, mixed>
     */
    private function originalData(Supplier $data): array
    {
        if (!$this->em->contains($data)) {
            return [];
        }

        return $this->em->getUnitOfWork()->getOriginalEntityData($data);
    }

    /**
     * Normalisation serveur du formulaire principal (RG-2.12). Seul companyName
     * subsiste cote Supplier (le contact inline a ete retire en V1 — les champs
     * de contact sont normalises par SupplierContactProcessor, ERP-88). Le setter
     * non-nullable n'est touche que si une valeur est presente, pour ne jamais
     * ecraser l'existant lors d'un PATCH partiel.
     */
    private function normalize(Supplier $data): void
    {
        if (null !== $data->getCompanyName()) {
            $data->setCompanyName((string) $this->normalizer->normalizeCompanyName($data->getCompanyName()));
        }
    }

    /**
     * Cles ecrivables effectivement presentes dans le payload : on retire les
     * cles JSON-LD (@id, @context, @var...) et tout champ non rattache a un
     * groupe d'ecriture connu. C'est la base du 422 d'archivage (RG-2.14) —
     * sans elles, un PATCH « representation complete » porteur de @id ferait
     * croire a une modification multi-onglets.
     *
     * @return list<string>
     */
    private function writablePayloadKeys(): array
    {
        $writable = array_merge(
            self::MAIN_FIELDS,
            self::INFORMATION_FIELDS,
            self::ACCOUNTING_FIELDS,
            [self::ARCHIVE_FIELD],
        );

        return array_values(array_intersect($this->payloadKeys(), $writable));
    }

    /**
     * Cles de premier niveau effectivement envoyees par le client (payload JSON
     * brut), filtrage compris. Pour un PATCH merge-patch+json, ce sont les seuls
     * champs modifies.
     *
     * @return list<string>
     */
    private function payloadKeys(): array
    {
        $request = $this->requestStack->getCurrentRequest();
        if (null === $request) {
            return [];
        }

        $content = $request->getContent();

        // Cache hit : meme corps brut que le dernier decodage -> memes cles.
        if ($content === $this->decodedContent) {
            return $this->decodedPayloadKeys;
        }

        $this->decodedContent     = $content;
        $this->decodedPayloadKeys = $this->extractPayloadKeys($content);

        return $this->decodedPayloadKeys;
    }

    /**
     * Decode le corps brut et en extrait les cles de premier niveau (chaines).
     * Corps vide ou JSON invalide -> aucune cle.
     *
     * @return list<string>
     */
    private function extractPayloadKeys(string $content): array
    {
        if ('' === $content) {
            return [];
        }

        try {
            $decoded = json_decode($content, true, 512, JSON_THROW_ON_ERROR);
        } catch (JsonException) {
            return [];
        }

        return is_array($decoded) ? array_values(array_filter(array_keys($decoded), 'is_string')) : [];
    }
}
