<?php

declare(strict_types=1);

namespace App\Module\Technique\Domain\Entity;

use ApiPlatform\Metadata\ApiResource;
use ApiPlatform\Metadata\Get;
use ApiPlatform\Metadata\GetCollection;
use ApiPlatform\Metadata\Patch;
use ApiPlatform\Metadata\Post;
use App\Module\Commercial\Domain\Entity\Bank;
use App\Module\Commercial\Domain\Entity\PaymentDelay;
use App\Module\Commercial\Domain\Entity\PaymentType;
use App\Module\Commercial\Domain\Entity\TvaMode;
use App\Module\Technique\Infrastructure\ApiPlatform\State\Processor\ProviderProcessor;
use App\Module\Technique\Infrastructure\ApiPlatform\State\Provider\ProviderProvider;
use App\Module\Technique\Infrastructure\Doctrine\DoctrineProviderRepository;
use App\Shared\Domain\Attribute\Auditable;
use App\Shared\Domain\Contract\BlamableInterface;
use App\Shared\Domain\Contract\CategoryInterface;
use App\Shared\Domain\Contract\SiteInterface;
use App\Shared\Domain\Contract\TimestampableInterface;
use App\Shared\Domain\Trait\TimestampableBlamableTrait;
use DateTimeImmutable;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Serializer\Attribute\Groups;
use Symfony\Component\Serializer\Attribute\SerializedName;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;

/**
 * Prestataire (M3 Technique) — entite racine du repertoire prestataires, jumelle
 * du Fournisseur (M2). Porte le formulaire principal (nom + categories + sites),
 * l'onglet Comptabilite, le mecanisme d'archivage (is_archived / archived_at) et
 * le soft-delete technique prepare mais non expose au M3 (deleted_at, HP M4).
 *
 * Differences structurantes vs Supplier (cf. spec M3 § 3.1) :
 *  - PAS d'onglet Information : aucun champ description / competitors / founded_at
 *    / employees_count / revenue_amount / director_name / profit_amount /
 *    volume_forecast. Le prestataire est minimal : nom + comptabilite.
 *  - AJOUT de `sites` (M2M `provider_site`) : sites rattaches DIRECTEMENT au
 *    prestataire sur le formulaire principal (RG-3.03, >= 1). Nouveau vs supplier
 *    (qui n'avait des sites que sur l'adresse). Sert aussi le cloisonnement par
 *    site (§ 2.13, ticket Provider/Processor ERP-134).
 *
 * Referentiels comptables (TvaMode / PaymentDelay / PaymentType / Bank) et Site /
 * Category : consommes en RELATION ORM PARTAGEE (decision Matthieu, § 2.1). Site /
 * Category passent par les contrats Shared (SiteInterface / CategoryInterface +
 * resolve_target_entities) comme le fait deja Supplier (regle ABSOLUE n°1). Les 4
 * referentiels comptables vivent dans le module Commercial et sont references en
 * direct, faute de contrat Shared dedie (remontee dans Shared tracee HP-M4-2) —
 * reference de donnees de reference, pas de logique inter-module.
 *
 * Contrat de serialisation (RETEX M1, 3 maillons — spec § 4.0) : les read-groups
 * sont poses ICI (source unique). L'#[ApiResource] cable (ERP-134) le ProviderProvider
 * (liste paginee anti-N+1, exclusion archives, cloisonnement site lecture + detail
 * 404) et le ProviderProcessor (normalisation, archivage, mode strict par groupe,
 * cloisonnement site ecriture, 409 doublon). Le groupe provider:read:accounting est
 * ajoute dynamiquement au contexte par le ProviderReadGroupContextBuilder selon la
 * permission accounting.view (ERP-134) — jamais pose en dur sur l'operation.
 *
 * Audite (#[Auditable], tous champs — y compris RIB embarques, § 2.7) +
 * Timestampable / Blamable via le trait Shared.
 */
#[ApiResource(
    operations: [
        new GetCollection(
            security: "is_granted('technique.providers.view')",
            // La liste embarque les categories (code/name, groupe category:read) et
            // les sites du prestataire (name/postalCode, groupe site:read — relation
            // DIRECTE provider.sites, RG-3.03). Maillon (c) : category:read +
            // site:read presents dans le contexte. Hydratation anti-N+1 cablee par
            // le ProviderProvider (cf. DoctrineProviderRepository::hydrateListCollections).
            normalizationContext: ['groups' => ['provider:read', 'category:read', 'site:read', 'default:read']],
            provider: ProviderProvider::class,
        ),
        new Get(
            security: "is_granted('technique.providers.view')",
            // Detail : prestataire + sous-collections embarquees (contacts, adresses
            // + leurs sites/categories/contacts) + RIB (gates compta). Le groupe
            // provider:read:accounting est volontairement ABSENT : il est ajoute au
            // contexte par le ProviderReadGroupContextBuilder selon la permission
            // accounting.view (parade fuite IBAN/BIC — bug #4 M1).
            normalizationContext: ['groups' => [
                'provider:read',
                'provider:item:read',
                'category:read',
                'site:read',
                'default:read',
            ]],
            provider: ProviderProvider::class,
        ),
        new Post(
            security: "is_granted('technique.providers.manage')",
            normalizationContext: ['groups' => ['provider:read', 'category:read', 'site:read', 'default:read']],
            denormalizationContext: ['groups' => ['provider:write:main']],
            processor: ProviderProcessor::class,
        ),
        new Patch(
            // Security elargie : `manage` OU `accounting.manage` — le role Compta n'a
            // pas `manage` global mais doit pouvoir editer l'onglet Comptabilite d'un
            // prestataire existant (§ 2.9). Le re-gating onglet par onglet (mode strict
            // RG-3.15) est porte par le ProviderProcessor (ERP-134).
            security: "is_granted('technique.providers.manage') or is_granted('technique.providers.accounting.manage')",
            normalizationContext: ['groups' => ['provider:read', 'category:read', 'site:read', 'default:read']],
            denormalizationContext: ['groups' => [
                'provider:write:main',
                'provider:write:accounting',
                'provider:write:archive',
            ]],
            provider: ProviderProvider::class,
            processor: ProviderProcessor::class,
        ),
        // Pas de Delete au M3 (HP M4). Archivage via PATCH { isArchived: true }.
    ],
)]
#[ORM\Entity(repositoryClass: DoctrineProviderRepository::class)]
#[ORM\Table(name: 'provider')]
// Index nommes pour matcher la migration (Version20260612100000). L'index unique
// partiel uq_provider_company_name_active reste possede par la migration : Doctrine
// ORM ne sait pas exprimer un index fonctionnel (LOWER) + partiel (WHERE) via
// attribut. Pas de #[ORM\UniqueConstraint] (§ 2.6).
#[ORM\Index(name: 'idx_provider_is_archived', columns: ['is_archived'])]
#[ORM\Index(name: 'idx_provider_deleted_at', columns: ['deleted_at'])]
#[ORM\Index(name: 'idx_provider_created_by', columns: ['created_by'])]
#[ORM\Index(name: 'idx_provider_updated_by', columns: ['updated_by'])]
#[Auditable]
class Provider implements TimestampableInterface, BlamableInterface
{
    use TimestampableBlamableTrait;

    /**
     * RG-3.09 : seules les categories PORTANT ce type sont autorisees sur le
     * prestataire (entite principale) ET sur ses adresses. Miroir de
     * ProviderAddress. S'appuie sur CategoryInterface::getCategoryTypeCodes()
     * (pas d'import du module Catalog — regle ABSOLUE n°1).
     */
    private const string REQUIRED_CATEGORY_TYPE_CODE = 'PRESTATAIRE';

    /** Code pivot du type de reglement imposant une banque (RG-3.07). */
    private const string PAYMENT_TYPE_VIREMENT = 'VIREMENT';

    /** Code pivot du type de reglement imposant au moins un RIB (RG-3.08). */
    private const string PAYMENT_TYPE_LCR = 'LCR';

    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    #[Groups(['provider:read'])]
    private ?int $id = null;

    // === Formulaire principal ===
    #[ORM\Column(length: 180)]
    #[Assert\NotBlank(message: 'Le nom du prestataire est obligatoire.', normalizer: 'trim')]
    #[Assert\Length(min: 2, max: 180, minMessage: 'Le nom du prestataire doit comporter au moins {{ limit }} caractères.', maxMessage: 'Le nom du prestataire ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    #[Groups(['provider:read', 'provider:write:main'])]
    private ?string $companyName = null;

    // RG-3.09 : au moins une categorie (Count min 1), de type PRESTATAIRE (verifie
    // par validateCategoryType). M2M vers Category via le contrat CategoryInterface
    // (resolve_target_entities -> Category). Embarquee en LISTE ET DETAIL ; maillon
    // (c) : le contexte inclut 'category:read' pour exposer id/code/name.
    /** @var Collection<int, CategoryInterface> */
    #[ORM\ManyToMany(targetEntity: CategoryInterface::class)]
    #[ORM\JoinTable(name: 'provider_category')]
    #[ORM\JoinColumn(name: 'provider_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    #[ORM\InverseJoinColumn(name: 'category_id', referencedColumnName: 'id', onDelete: 'RESTRICT')]
    #[Assert\Count(min: 1, minMessage: 'Au moins une catégorie est obligatoire.')]
    #[Groups(['provider:read', 'provider:write:main'])]
    private Collection $categories;

    // RG-3.03 (SPECIFICITE M3) : au moins un site (Count min 1). Sites rattaches
    // DIRECTEMENT au prestataire sur le formulaire principal (le fournisseur n'avait
    // des sites que sur l'adresse). M2M vers Site via le contrat SiteInterface
    // (resolve_target_entities -> Site). Embarquee en LISTE ET DETAIL ; maillon (c) :
    // le contexte inclut 'site:read' pour exposer name/postalCode (Site n'a pas de
    // `code`). L'ecriture cloisonnee par user_site (§ 2.13) est portee par le
    // ProviderProcessor (ERP-134).
    /** @var Collection<int, SiteInterface> */
    #[ORM\ManyToMany(targetEntity: SiteInterface::class)]
    #[ORM\JoinTable(name: 'provider_site')]
    #[ORM\JoinColumn(name: 'provider_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    #[ORM\InverseJoinColumn(name: 'site_id', referencedColumnName: 'id', onDelete: 'RESTRICT')]
    #[Assert\Count(min: 1, minMessage: 'Au moins un site est obligatoire.')]
    #[Groups(['provider:read', 'provider:write:main'])]
    private Collection $sites;

    // === Onglet Comptabilite ===
    // Lecture conditionnee via le groupe `provider:read:accounting` (ajoute au
    // contexte par le ProviderProvider / ReadGroupContextBuilder si l'user a
    // accounting.view — ERP-134). Ecriture via `provider:write:accounting` (le
    // Processor exige accounting.manage).
    #[ORM\Column(length: 20, nullable: true)]
    #[Assert\Length(max: 20, maxMessage: 'Le SIREN ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?string $siren = null;

    #[ORM\Column(length: 40, nullable: true)]
    #[Assert\Length(max: 40, maxMessage: 'Le numéro de compte ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?string $accountNumber = null;

    #[ORM\ManyToOne(targetEntity: TvaMode::class)]
    #[ORM\JoinColumn(name: 'tva_mode_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?TvaMode $tvaMode = null;

    #[ORM\Column(length: 40, nullable: true)]
    #[Assert\Length(max: 40, maxMessage: 'Le numéro de TVA ne peut dépasser {{ limit }} caractères.', normalizer: 'trim')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?string $nTva = null;

    #[ORM\ManyToOne(targetEntity: PaymentDelay::class)]
    #[ORM\JoinColumn(name: 'payment_delay_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?PaymentDelay $paymentDelay = null;

    #[ORM\ManyToOne(targetEntity: PaymentType::class)]
    #[ORM\JoinColumn(name: 'payment_type_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?PaymentType $paymentType = null;

    #[ORM\ManyToOne(targetEntity: Bank::class)]
    #[ORM\JoinColumn(name: 'bank_id', referencedColumnName: 'id', nullable: true, onDelete: 'RESTRICT')]
    #[Groups(['provider:read:accounting', 'provider:write:accounting'])]
    private ?Bank $bank = null;

    // === Sous-collections — EMBARQUEES dans le DETAIL (RETEX M1 §2) ===
    // Maillon (a) : le read-group est porte par le GETTER (getContacts / getAddresses
    // / getRibs) — sans #[Groups], jamais serialisees. Edition via sous-ressources
    // (ticket ulterieur M3).
    /** @var Collection<int, ProviderContact> */
    #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderContact::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
    private Collection $contacts;

    /** @var Collection<int, ProviderAddress> */
    #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderAddress::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
    private Collection $addresses;

    /** @var Collection<int, ProviderRib> */
    #[ORM\OneToMany(mappedBy: 'provider', targetEntity: ProviderRib::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
    private Collection $ribs;

    // === Archive / Soft delete ===
    // Groupe d'ECRITURE uniquement sur la propriete (denormalisation PATCH archive).
    // Le groupe de LECTURE est declare sur le getter isArchived() avec
    // SerializedName('isArchived') : sans cela, Symfony strip le prefixe "is" et
    // exposerait la cle JSON "archived" — en pratique la cle est totalement DROPPEE
    // (piege n°3 du M1). Pattern corrige : Groups + SerializedName sur le getter.
    #[ORM\Column(name: 'is_archived', options: ['default' => false])]
    #[Groups(['provider:write:archive'])]
    private bool $isArchived = false;

    #[ORM\Column(type: 'datetime_immutable', nullable: true)]
    #[Groups(['provider:read'])]
    private ?DateTimeImmutable $archivedAt = null;

    // Soft delete technique (HP M4) : non expose en lecture/ecriture au M3.
    #[ORM\Column(type: 'datetime_immutable', nullable: true)]
    private ?DateTimeImmutable $deletedAt = null;

    public function __construct()
    {
        $this->categories = new ArrayCollection();
        $this->sites      = new ArrayCollection();
        $this->contacts   = new ArrayCollection();
        $this->addresses  = new ArrayCollection();
        $this->ribs       = new ArrayCollection();
    }

    /**
     * RG-3.09 : toute categorie posee sur le prestataire doit etre de type
     * PRESTATAIRE -> sinon 422 avec violation sur le champ `categories`
     * (propertyPath aligne ERP-101, message FR ERP-107). Miroir de
     * ProviderAddress::validateCategoryType. S'appuie sur
     * CategoryInterface::getCategoryTypeCodes() (multi-type — la categorie est
     * acceptee des qu'elle PORTE le type PRESTATAIRE ; pas d'import du module
     * Catalog, regle ABSOLUE n°1). Joue avant la base via la validation API
     * Platform, sur POST (categories ∈ provider:write:main) comme sur PATCH.
     */
    #[Assert\Callback]
    public function validateCategoryType(ExecutionContextInterface $context): void
    {
        foreach ($this->categories as $category) {
            if ($category instanceof CategoryInterface
                && !in_array(self::REQUIRED_CATEGORY_TYPE_CODE, $category->getCategoryTypeCodes(), true)) {
                $context->buildViolation('Type de catégorie non autorisé (PRESTATAIRE attendu).')
                    ->atPath('categories')
                    ->addViolation()
                ;

                return;
            }
        }
    }

    /**
     * RG-3.07 / RG-3.08 : coherence du type de reglement comptable. Comme au M2
     * (decision figee ERP-89, jumeau Supplier::validatePaymentTypeConsistency),
     * ces RG inter-champs passent par une contrainte d'entite (Assert\Callback +
     * ->atPath()) et NON par le ProviderProcessor, afin que chaque 422 porte un
     * propertyPath exploitable par extractApiViolations (mapping inline sous le
     * champ, pas un toast — convention ERP-101).
     *  - RG-3.07 : paymentType = VIREMENT impose une banque -> violation sur `bank`.
     *  - RG-3.08 : paymentType = LCR impose au moins un RIB -> violation sur
     *    `paymentType` (les RIB n'ont pas de champ de formulaire ou s'ancrer quand
     *    la liste est vide ; l'erreur s'affiche donc sous le select « Type de
     *    règlement », binde cote front). Le 409 sur DELETE du dernier RIB en LCR est
     *    porte par le ProviderRibProcessor (ERP-135).
     *
     * Ces champs vivant dans le groupe d'ecriture comptable (absent du POST, qui
     * n'expose que provider:write:main), la contrainte ne mord en pratique que sur
     * le PATCH de l'onglet Comptabilite.
     */
    #[Assert\Callback]
    public function validatePaymentTypeConsistency(ExecutionContextInterface $context): void
    {
        $paymentCode = $this->paymentType?->getCode();

        if (self::PAYMENT_TYPE_VIREMENT === $paymentCode && null === $this->bank) {
            $context->buildViolation('La banque est obligatoire pour le type de règlement Virement.')
                ->atPath('bank')
                ->addViolation()
            ;
        }

        if (self::PAYMENT_TYPE_LCR === $paymentCode && $this->ribs->isEmpty()) {
            $context->buildViolation('Au moins un RIB est obligatoire pour le type de règlement LCR.')
                ->atPath('paymentType')
                ->addViolation()
            ;
        }
    }

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

    public function getCompanyName(): ?string
    {
        return $this->companyName;
    }

    public function setCompanyName(string $companyName): static
    {
        $this->companyName = $companyName;

        return $this;
    }

    /** @return Collection<int, CategoryInterface> */
    public function getCategories(): Collection
    {
        return $this->categories;
    }

    public function addCategory(CategoryInterface $category): static
    {
        if (!$this->categories->contains($category)) {
            $this->categories->add($category);
        }

        return $this;
    }

    public function removeCategory(CategoryInterface $category): static
    {
        $this->categories->removeElement($category);

        return $this;
    }

    /** @return Collection<int, SiteInterface> */
    public function getSites(): Collection
    {
        return $this->sites;
    }

    public function addSite(SiteInterface $site): static
    {
        if (!$this->sites->contains($site)) {
            $this->sites->add($site);
        }

        return $this;
    }

    public function removeSite(SiteInterface $site): static
    {
        $this->sites->removeElement($site);

        return $this;
    }

    public function getSiren(): ?string
    {
        return $this->siren;
    }

    public function setSiren(?string $siren): static
    {
        $this->siren = $siren;

        return $this;
    }

    public function getAccountNumber(): ?string
    {
        return $this->accountNumber;
    }

    public function setAccountNumber(?string $accountNumber): static
    {
        $this->accountNumber = $accountNumber;

        return $this;
    }

    public function getTvaMode(): ?TvaMode
    {
        return $this->tvaMode;
    }

    public function setTvaMode(?TvaMode $tvaMode): static
    {
        $this->tvaMode = $tvaMode;

        return $this;
    }

    public function getNTva(): ?string
    {
        return $this->nTva;
    }

    public function setNTva(?string $nTva): static
    {
        $this->nTva = $nTva;

        return $this;
    }

    public function getPaymentDelay(): ?PaymentDelay
    {
        return $this->paymentDelay;
    }

    public function setPaymentDelay(?PaymentDelay $paymentDelay): static
    {
        $this->paymentDelay = $paymentDelay;

        return $this;
    }

    public function getPaymentType(): ?PaymentType
    {
        return $this->paymentType;
    }

    public function setPaymentType(?PaymentType $paymentType): static
    {
        $this->paymentType = $paymentType;

        return $this;
    }

    public function getBank(): ?Bank
    {
        return $this->bank;
    }

    public function setBank(?Bank $bank): static
    {
        $this->bank = $bank;

        return $this;
    }

    /** @return Collection<int, ProviderContact> */
    #[Groups(['provider:item:read'])]
    public function getContacts(): Collection
    {
        return $this->contacts;
    }

    public function addContact(ProviderContact $contact): static
    {
        if (!$this->contacts->contains($contact)) {
            $this->contacts->add($contact);
            $contact->setProvider($this);
        }

        return $this;
    }

    public function removeContact(ProviderContact $contact): static
    {
        if ($this->contacts->removeElement($contact) && $contact->getProvider() === $this) {
            $contact->setProvider(null);
        }

        return $this;
    }

    /** @return Collection<int, ProviderAddress> */
    #[Groups(['provider:item:read'])]
    public function getAddresses(): Collection
    {
        return $this->addresses;
    }

    public function addAddress(ProviderAddress $address): static
    {
        if (!$this->addresses->contains($address)) {
            $this->addresses->add($address);
            $address->setProvider($this);
        }

        return $this;
    }

    public function removeAddress(ProviderAddress $address): static
    {
        if ($this->addresses->removeElement($address) && $address->getProvider() === $this) {
            $address->setProvider(null);
        }

        return $this;
    }

    // Embed gate sur le groupe COMPTABLE (et non provider:item:read comme contacts/
    // adresses) : provider:read:accounting n'est ajoute au contexte que si l'user a
    // accounting.view (ProviderProvider / ReadGroupContextBuilder, ERP-134). Resultat :
    // la cle `ribs` est TOTALEMENT ABSENTE du detail pour un user sans accounting.view
    // (ex. Commerciale), au meme titre que les scalaires comptables — evite la fuite
    // IBAN/BIC (piege n°4 M1).
    /** @return Collection<int, ProviderRib> */
    #[Groups(['provider:read:accounting'])]
    public function getRibs(): Collection
    {
        return $this->ribs;
    }

    public function addRib(ProviderRib $rib): static
    {
        if (!$this->ribs->contains($rib)) {
            $this->ribs->add($rib);
            $rib->setProvider($this);
        }

        return $this;
    }

    public function removeRib(ProviderRib $rib): static
    {
        if ($this->ribs->removeElement($rib) && $rib->getProvider() === $this) {
            $rib->setProvider(null);
        }

        return $this;
    }

    // Groupe de lecture + nom serialise explicite : sans SerializedName, Symfony
    // exposerait la cle "archived" (strip du prefixe "is" sur les getters) et
    // droppait silencieusement la cle du JSON (piege n°3 du M1).
    #[Groups(['provider:read'])]
    #[SerializedName('isArchived')]
    public function isArchived(): bool
    {
        return $this->isArchived;
    }

    public function setIsArchived(bool $isArchived): static
    {
        $this->isArchived = $isArchived;

        return $this;
    }

    public function getArchivedAt(): ?DateTimeImmutable
    {
        return $this->archivedAt;
    }

    public function setArchivedAt(?DateTimeImmutable $archivedAt): static
    {
        $this->archivedAt = $archivedAt;

        return $this;
    }

    public function getDeletedAt(): ?DateTimeImmutable
    {
        return $this->deletedAt;
    }

    public function setDeletedAt(?DateTimeImmutable $deletedAt): static
    {
        $this->deletedAt = $deletedAt;

        return $this;
    }
}
