koprogo_api/application/use_cases/

resolution_use_cases.rs

use crate::application::error::AppError;
use crate::application::ports::{
    MeetingRepository, ResolutionRepository, UnitOwnerRepository, UnitRepository, VoteRepository,
};
use crate::domain::entities::{
    assert_vote_auth_sufficient, assert_voting_right_active, MajorityType, Resolution,
    ResolutionStatus, ResolutionType, Vote, VoteAuthMethod, VoteChoice,
};
use std::sync::Arc;
use uuid::Uuid;

pub struct ResolutionUseCases {
    resolution_repository: Arc<dyn ResolutionRepository>,
    vote_repository: Arc<dyn VoteRepository>,
    meeting_repository: Arc<dyn MeetingRepository>,
    // Story H17 — résolution du droit de vote du lot (Art. 3.87 §1).
    unit_owner_repository: Arc<dyn UnitOwnerRepository>,
    // #850 — la quotité du lot, lue sur l'acte de base plutôt que déclarée.
    unit_repository: Arc<dyn UnitRepository>,
}

impl ResolutionUseCases {
    pub fn new(
        resolution_repository: Arc<dyn ResolutionRepository>,
        vote_repository: Arc<dyn VoteRepository>,
        meeting_repository: Arc<dyn MeetingRepository>,
        unit_owner_repository: Arc<dyn UnitOwnerRepository>,
        unit_repository: Arc<dyn UnitRepository>,
    ) -> Self {
        Self {
            resolution_repository,
            vote_repository,
            meeting_repository,
            unit_owner_repository,
            unit_repository,
        }
    }

    /// Create a new resolution for a meeting
    /// Enforces quorum validation per Art. 3.87 §5 CC before allowing resolution creation.
    /// Issue #310: Validates agenda_item_index if provided (Art. 3.87 CC - only agenda items can be voted on)
    pub async fn create_resolution(
        &self,
        meeting_id: Uuid,
        title: String,
        description: String,
        resolution_type: ResolutionType,
        majority_required: MajorityType,
        agenda_item_index: Option<usize>,
    ) -> Result<Resolution, String> {
        // Fetch the meeting and check quorum (Art. 3.87 §5 CC)
        let meeting = self
            .meeting_repository
            .find_by_id(meeting_id)
            .await?
            .ok_or_else(|| format!("Meeting not found: {}", meeting_id))?;

        // Enforce quorum validation before allowing resolution creation
        meeting.check_quorum_for_voting()?;

        // Issue #310: If agenda_item_index provided, validate it exists and is non-empty
        if let Some(index) = agenda_item_index {
            if index >= meeting.agenda.len() {
                return Err(
                    "Resolution must correspond to a valid agenda item (Art. 3.87 CC)".to_string(),
                );
            }
            let agenda_item = &meeting.agenda[index];
            if agenda_item.trim().is_empty() {
                return Err("Agenda item cannot be empty (Art. 3.87 CC)".to_string());
            }
        }

        let resolution = Resolution::new(
            meeting_id,
            title,
            description,
            resolution_type,
            majority_required,
            agenda_item_index,
        )?;

        self.resolution_repository.create(&resolution).await
    }

    /// Get a resolution by ID
    pub async fn get_resolution(&self, id: Uuid) -> Result<Option<Resolution>, String> {
        let resolution = self.resolution_repository.find_by_id(id).await?;
        match resolution {
            Some(r) => Ok(Some(self.plafonner_pour_lecture(r).await)),
            None => Ok(None),
        }
    }

    /// Applique le plafond de l'Art. 3.87 § 7 al. 4 au décompte **avant de le
    /// rendre**, sans rien persister.
    ///
    /// **Pourquoi c'est nécessaire.** Les compteurs de la résolution
    /// accumulent les voix **brutes** à chaque bulletin (`record_vote_pour`
    /// et consorts). Seul `close_voting` les recalculait plafonnés. Toute
    /// lecture antérieure à la clôture rendait donc un décompte légalement
    /// faux — et c'est celui-là que le syndic lit à l'écran pendant la
    /// séance, puisque `pour_percentage()` en dérive. Constaté en recette le
    /// 2026-09-04 (R3-1, R3-2) : Alice, 550 ‰ sur 1000, apparaissait à 550 au
    /// lieu des 450 que lui laisse la somme des autres présents.
    ///
    /// **Pourquoi en mémoire seulement.** La clôture reste le seul moment où
    /// le décompte officiel est arrêté et écrit. Persister ici ferait deux
    /// écritures concurrentes du même fait, et une lecture pourrait figer un
    /// décompte alors que des bulletins restent à venir.
    ///
    /// **Pourquoi réutiliser et ne pas recalculer.** `plafonner_les_voix` et
    /// `repartir_le_plafond` sont les fonctions que `close_voting` emploie.
    /// Une seconde implémentation du plafond, même correcte le jour où on
    /// l'écrit, finirait par diverger de celle qui fait foi.
    ///
    /// En cas d'échec de lecture des bulletins, la résolution est rendue
    /// telle quelle plutôt que de faire échouer la requête : une page qui
    /// s'affiche vaut mieux qu'un 500. Le décompte reste alors brut, ce qui
    /// est l'ancien comportement, jamais pire.
    async fn plafonner_pour_lecture(&self, mut resolution: Resolution) -> Resolution {
        let Ok(votes) = self
            .vote_repository
            .find_by_resolution_id(resolution.id)
            .await
        else {
            return resolution;
        };
        if votes.is_empty() {
            return resolution;
        }
        let decompte = crate::domain::copropriete::plafonner_les_voix(&votes);
        if decompte.ecarts().is_empty() {
            return resolution;
        }
        let poids_retenus = crate::domain::copropriete::repartir_le_plafond(&votes, &decompte);
        resolution.recompter_avec(&votes, &poids_retenus);
        resolution
    }

    /// Get all resolutions for a meeting
    pub async fn get_meeting_resolutions(
        &self,
        meeting_id: Uuid,
    ) -> Result<Vec<Resolution>, String> {
        let resolutions = self
            .resolution_repository
            .find_by_meeting_id(meeting_id)
            .await?;
        // Même plafonnement qu'en lecture unitaire : la liste d'une séance est
        // ce que le syndic a sous les yeux pendant qu'il préside.
        let mut plafonnees = Vec::with_capacity(resolutions.len());
        for r in resolutions {
            plafonnees.push(self.plafonner_pour_lecture(r).await);
        }
        Ok(plafonnees)
    }

    /// Get resolutions by status
    pub async fn get_resolutions_by_status(
        &self,
        status: ResolutionStatus,
    ) -> Result<Vec<Resolution>, String> {
        self.resolution_repository.find_by_status(status).await
    }

    /// Update a resolution (only allowed if status is Pending).
    ///
    /// Refuse aussi toute résolution générée d'office (Story 4.6, #581) :
    /// immuable quel que soit son statut — le syndic qu'elle évalue ne peut
    /// pas la réécrire.
    pub async fn update_resolution(&self, resolution: &Resolution) -> Result<Resolution, AppError> {
        if resolution.is_auto_generated() {
            return Err(AppError::ResolutionAutoNotRemovable);
        }
        if resolution.status != ResolutionStatus::Pending {
            return Err(AppError::Validation(
                "Cannot update a resolution that is not pending".to_string(),
            ));
        }

        self.resolution_repository
            .update(resolution)
            .await
            .map_err(AppError::from)
    }

    /// Delete a resolution (only allowed if no votes have been cast).
    ///
    /// Refuse aussi toute résolution générée d'office (Story 4.6, #581) —
    /// c'est le cœur de la story : le point évalue le syndic, il ne peut donc
    /// pas le retirer de l'ordre du jour.
    pub async fn delete_resolution(&self, id: Uuid) -> Result<bool, AppError> {
        let resolution = self
            .resolution_repository
            .find_by_id(id)
            .await
            .map_err(AppError::from)?
            .ok_or_else(|| AppError::NotFound(format!("resolution {}", id)))?;

        if resolution.is_auto_generated() {
            return Err(AppError::ResolutionAutoNotRemovable);
        }

        // Check if any votes exist
        let votes = self
            .vote_repository
            .find_by_resolution_id(id)
            .await
            .map_err(AppError::from)?;
        if !votes.is_empty() {
            return Err(AppError::Validation(
                "Cannot delete a resolution with existing votes".to_string(),
            ));
        }

        self.resolution_repository
            .delete(id)
            .await
            .map_err(AppError::from)
    }

    /// Cast a vote on a resolution
    ///
    /// `caller_owner_id` est le copropriétaire résolu depuis l'utilisateur
    /// authentifié (#850) — jamais un identifiant repris tel quel du corps de
    /// la requête. `owner_id` et `proxy_owner_id`, eux, restent ce que le
    /// client envoie ; c'est précisément ce que ce cas d'usage vérifie
    /// désormais contre `caller_owner_id`, plutôt que de les transmettre les
    /// yeux fermés.
    ///
    /// `auth_method` (Story 4.2, #48) est validé contre la modalité de l'AG :
    /// absent → 422 (`VOTE_AUTH_METHOD_REQUIRED`), insuffisant pour un mode
    /// remote/hybrid → 403 (`VOTE_AUTH_INSUFFICIENT`).
    #[allow(clippy::too_many_arguments)]
    pub async fn cast_vote(
        &self,
        resolution_id: Uuid,
        owner_id: Uuid,
        unit_id: Uuid,
        vote_choice: VoteChoice,
        proxy_owner_id: Option<Uuid>,
        auth_method: Option<VoteAuthMethod>,
        caller_owner_id: Uuid,
    ) -> Result<Vote, String> {
        // Check if resolution exists and is pending
        let resolution = self
            .resolution_repository
            .find_by_id(resolution_id)
            .await?
            .ok_or_else(|| "Resolution not found".to_string())?;

        if resolution.status != ResolutionStatus::Pending {
            return Err("Cannot vote on a resolution that is not pending".to_string());
        }

        // Story H10 — Art. 3.87 §5 CC : un vote n'est valable que si le quorum de
        // l'AG est atteint (sauf 2e convocation). Gate défense-en-profondeur sur
        // le chemin VOTE (en plus du gate à la création de résolution, l.47) :
        // résout la réunion via `resolution.meeting_id` puis `check_quorum_for_voting`.
        let meeting = self
            .meeting_repository
            .find_by_id(resolution.meeting_id)
            .await?
            .ok_or_else(|| format!("Meeting not found: {}", resolution.meeting_id))?;
        meeting.check_quorum_for_voting()?;

        // Art. 3.87 § 2 CC — une décision portant sur un point ABSENT de l'ordre
        // du jour est nulle. On refuse donc le VOTE, pas la rédaction.
        //
        // La validation existait déjà à la création, et elle est correcte :
        //
        //     if let Some(index) = agenda_item_index { … }
        //
        // Mais `None` traverse le `if let` sans rien déclencher. La garde ne
        // s'appliquait qu'à ceux qui se déclarent, alors que la nullité, elle,
        // n'est pas optionnelle. Une résolution rattachée à aucun point était
        // créée, votée et clôturée normalement — exactement le cas que
        // l'article annule.
        //
        // POURQUOI AU VOTE ET NON À LA CRÉATION (#840, voie 2 sur 3).
        //
        // L'article annule la DÉCISION, pas la proposition. Refuser à la
        // création casserait `meeting_handlers.rs:633` et
        // `meeting_minutes_exporter.rs:407`, qui construisent légitimement des
        // résolutions sans index, et exigerait une migration des lignes dont la
        // colonne est NULL. Refuser au vote suit le texte au plus près et ne
        // casse ni appelant ni donnée : une résolution hors ordre du jour peut
        // exister en brouillon, elle ne peut simplement pas être mise aux voix.
        //
        // Les deux autres voies restent ouvertes — champ obligatoire avec
        // migration, ou refus à la clôture — si l'usage montre que celle-ci ne
        // suffit pas.
        let Some(index) = resolution.agenda_item_index else {
            return Err(
                // Le remède nommé doit être atteignable : aucune route HTTP ne
                // rattache une résolution existante à un point (`update_resolution`
                // n'est pas exposé), donc la seule voie est de la recréer. Dire
                // « rattachez-la » enverrait le syndic chercher un bouton absent.
                "Cette résolution n'est rattachée à aucun point de l'ordre du jour : \
                 la mettre aux voix produirait une décision nulle (Art. 3.87 § 2 CC). \
                 Inscrivez le point à l'ordre du jour, puis recréez la résolution \
                 en la rattachant à ce point."
                    .to_string(),
            );
        };
        // Le point doit exister ET porter un intitulé : un point vide ne
        // renseigne personne sur ce qui est mis aux voix.
        match meeting.agenda.get(index) {
            None => {
                return Err(format!(
                    "Le point d'ordre du jour n° {index} n'existe pas dans cette \
                     assemblée, qui en compte {} : la décision serait nulle \
                     (Art. 3.87 § 2 CC).",
                    meeting.agenda.len()
                ))
            }
            Some(intitule) if intitule.trim().is_empty() => {
                return Err(format!(
                    "Le point d'ordre du jour n° {index} est vide : une décision ne \
                     peut pas porter sur un point qui n'énonce rien \
                     (Art. 3.87 § 2 CC)."
                ))
            }
            Some(_) => {}
        }

        // Story H17 — Art. 3.87 §1 CC : un lot démembré (usufruit/nue-propriété,
        // emphytéose, superficie) ou en indivision a son droit de vote SUSPENDU
        // tant qu'un représentant unique n'est pas désigné. Gate → rejet
        // `VOTING_RIGHT_SUSPENDED`. Un lot suspendu ne peut donc pas voter : il
        // est de facto exclu du décompte/quorum (cohérence H9). Rétro-compat :
        // un lot sans titularité qualifiée reste `Active` (cf. domaine).
        let holders = self
            .unit_owner_repository
            .find_voting_holders_by_unit(unit_id)
            .await?;
        assert_voting_right_active(unit_id, &holders)?;

        // #850 — QUI vote pour ce lot doit se vérifier, pas se déclarer.
        //
        // `owner_id` arrivait du corps de la requête et partait tel quel dans
        // `Vote::new`, sans qu'aucun rapprochement ne soit fait avec
        // l'appelant. Tout utilisateur authentifié de l'organisation pouvait
        // donc voter au nom d'un autre copropriétaire — et, en omettant
        // `proxy_owner_id`, échapper du même coup à la limite de trois
        // procurations de l'Art. 3.87 § 7, qui n'était vérifiée que si
        // `proxy_owner_id` était fourni (`validate_proxy_limit` plus bas).
        //
        // Le vote n'est légitime que dans deux cas :
        //   - l'appelant vote pour lui-même (`owner_id == caller_owner_id`),
        //     sans procuration ;
        //   - l'appelant se déclare mandataire de `owner_id`
        //     (`proxy_owner_id == Some(caller_owner_id)`) — et passe alors,
        //     plus bas, par `validate_proxy_limit` comme n'importe quel
        //     mandataire.
        //
        // Se taire sur la procuration n'est plus une manière de l'esquiver :
        // ne pas être `owner_id` ET ne pas se déclarer son mandataire est un
        // refus, quel que soit l'état de ses procurations — précisément le
        // contournement que #850 décrit.
        match proxy_owner_id {
            Some(declare) if declare != caller_owner_id => {
                return Err(format!(
                    "FORBIDDEN: {caller_owner_id} ne peut se déclarer mandataire \
                     que de lui-même, pas de {declare}."
                ));
            }
            None if owner_id != caller_owner_id => {
                return Err(format!(
                    "FORBIDDEN: {caller_owner_id} ne peut pas voter au nom du \
                     copropriétaire {owner_id} sans se déclarer son mandataire \
                     (Art. 3.87 § 7 CC)."
                ));
            }
            Some(_) | None => {}
        }

        // Le lot doit réellement appartenir à `owner_id` — soi-même dans un
        // vote direct, ou le mandant représenté dans un vote par procuration.
        // Rien ne le vérifiait : n'importe quel `owner_id` de l'organisation
        // passait, pourvu que le lot ne soit pas suspendu (gate ci-dessus).
        if self
            .unit_owner_repository
            .find_active_by_unit_and_owner(unit_id, owner_id)
            .await?
            .is_none()
        {
            return Err(format!(
                "FORBIDDEN: le copropriétaire {owner_id} ne détient pas le lot \
                 {unit_id} : il ne peut pas voter pour lui (Art. 3.87 § 1er CC)."
            ));
        }

        // Check if unit has already voted
        if self
            .vote_repository
            .has_voted(resolution_id, unit_id)
            .await?
        {
            return Err("This unit has already voted on this resolution".to_string());
        }

        // #850 — la puissance de vote se LIT, elle ne se déclare pas.
        //
        // Elle arrivait jusqu'ici depuis le corps de la requête et partait
        // telle quelle dans `Vote::new`. Or la voix d'un lot est sa quotité
        // dans l'acte de base (Art. 3.87 § 2 et § 8 CC) : un copropriétaire ne
        // choisit pas son poids, pas plus qu'il ne choisit ses tantièmes.
        //
        // POURQUOI `unit.quota` ET NON LA QUOTE-PART DE CHARGE.
        //
        // `find_active_quota_shares_by_building` rend
        // `(unit.quota / total) × ownership_percentage`, qui est la formule de
        // RÉPARTITION des charges (Art. 3.84). Elle ne convient pas au vote :
        // un lot en indivision vote par son représentant unique (Art. 3.87 §1,
        // vérifié plus haut) et vote la quotité ENTIÈRE du lot, pas la fraction
        // détenue par ce représentant. Diviser la voix entre indivisaires
        // reviendrait à affaiblir un lot parce qu'il est détenu à plusieurs.
        let unit = self
            .unit_repository
            .find_by_id(unit_id)
            .await?
            .ok_or_else(|| format!("Lot introuvable : {unit_id}"))?;

        // Un lot d'un AUTRE immeuble n'a rien à voter ici. Rien ne l'empêchait :
        // la route acceptait n'importe quel `unit_id`, et le seul contrôle
        // portait sur la titularité de ce lot, pas sur son rattachement à
        // l'assemblée.
        if unit.building_id != meeting.building_id {
            return Err(format!(
                "Le lot {unit_id} n'appartient pas à l'immeuble de cette \
                 assemblée : il ne peut pas prendre part à ce vote."
            ));
        }

        let voting_power = unit.quota;

        // Art. 3.87 §7 CC — un mandataire ne peut détenir plus de 3 procurations
        // Exception : si le total des voix de ses procurations < 10% du total général
        if let Some(proxy_id) = proxy_owner_id {
            self.validate_proxy_limit(resolution_id, proxy_id, voting_power)
                .await?;
        }

        // Story 4.2 (#48) — Art. 3.87 §1er, §4 CC : un vote distant/hybride
        // exige une méthode qui engage réellement le votant (itsme/eID), ou
        // une procuration en bonne et due forme ; une méthode qui ne fait
        // qu'affirmer une présence ne suffit pas à distance. `auth_method`
        // est par ailleurs toujours requis : un vote sans méthode déclarée
        // n'est pas exploitable en cas de contestation.
        let auth_method =
            assert_vote_auth_sufficient(meeting.mode, auth_method, proxy_owner_id.is_some())?;

        // Create and save the vote
        let vote = Vote::new_with_auth_method(
            resolution_id,
            owner_id,
            unit_id,
            vote_choice.clone(),
            voting_power,
            proxy_owner_id,
            auth_method,
        )?;

        let created_vote = self.vote_repository.create(&vote).await?;

        // Update vote counts on the resolution
        self.update_resolution_vote_counts(resolution_id).await?;

        Ok(created_vote)
    }

    /// Change a vote (if allowed by business rules)
    pub async fn change_vote(&self, vote_id: Uuid, new_choice: VoteChoice) -> Result<Vote, String> {
        let mut vote = self
            .vote_repository
            .find_by_id(vote_id)
            .await?
            .ok_or_else(|| "Vote not found".to_string())?;

        // Check if resolution is still pending
        let resolution = self
            .resolution_repository
            .find_by_id(vote.resolution_id)
            .await?
            .ok_or_else(|| "Resolution not found".to_string())?;

        if resolution.status != ResolutionStatus::Pending {
            return Err("Cannot change vote on a closed resolution".to_string());
        }

        // Update the vote
        vote.change_vote(new_choice)?;
        let updated_vote = self.vote_repository.update(&vote).await?;

        // Recalculate vote counts
        self.update_resolution_vote_counts(vote.resolution_id)
            .await?;

        Ok(updated_vote)
    }

    /// Get all votes for a resolution
    pub async fn get_resolution_votes(&self, resolution_id: Uuid) -> Result<Vec<Vote>, String> {
        self.vote_repository
            .find_by_resolution_id(resolution_id)
            .await
    }

    /// Get all votes by an owner
    pub async fn get_owner_votes(&self, owner_id: Uuid) -> Result<Vec<Vote>, String> {
        self.vote_repository.find_by_owner_id(owner_id).await
    }

    /// Close voting on a resolution and calculate final result
    pub async fn close_voting(
        &self,
        resolution_id: Uuid,
        total_voting_power: rust_decimal::Decimal,
    ) -> Result<Resolution, String> {
        let mut resolution = self
            .resolution_repository
            .find_by_id(resolution_id)
            .await?
            .ok_or_else(|| "Resolution not found".to_string())?;

        if resolution.status != ResolutionStatus::Pending {
            return Err("Resolution voting is already closed".to_string());
        }

        // Art. 3.87 § 7 — les plafonds de procuration se vérifient à la
        // CLÔTURE, pas à chaque vote : ils portent sur l'ensemble des voix
        // exprimées, et le dernier vote enregistré peut faire basculer une
        // séance qui était licite jusque-là.
        //
        // Le refus est bloquant. Une assemblée tenue en violation de ces
        // plafonds est attaquable, et ce sont ses décisions — travaux,
        // budgets, mandats — qui tombent avec elle. Mieux vaut refuser de
        // clore que proclamer un résultat annulable.
        let votes = self
            .vote_repository
            .find_by_resolution_id(resolution_id)
            .await?;
        crate::domain::copropriete::verifier_procurations(&votes, total_voting_power, None)
            .map_err(|refus| refus.to_string())?;

        // Art. 3.87 § 9 — le prestataire ne délibère pas sur sa propre
        // mission. Même moment, même raison : c'est l'ensemble des bulletins
        // qu'il faut regarder, pas le dernier déposé.
        crate::domain::copropriete::verifier_conflit_dinterets(
            &votes,
            resolution.prestataire_de_la_mission,
        )
        .map_err(|conflit| conflit.to_string())?;

        // Art. 3.87 § 7 al. 4 — le plafonnement des voix.
        //
        // Arbitrage humain du 2026-09-04 : le texte interdit de prendre part au
        // vote POUR un nombre de voix supérieur à la somme des autres, il ne
        // frappe pas la séance de nullité. On ramène donc le majoritaire au
        // poids des autres et on délibère sur ce décompte corrigé, au lieu de
        // refuser de clore — ce qui rendait ingouvernable toute copropriété où
        // un seul détient la majorité.
        let decompte = crate::domain::copropriete::plafonner_les_voix(&votes);
        let voix_plafonnees = if decompte.ecarts().is_empty() {
            None
        } else {
            let poids_retenus = crate::domain::copropriete::repartir_le_plafond(&votes, &decompte);
            resolution.recompter_avec(&votes, &poids_retenus);
            // Le décompte corrigé doit être PERSISTÉ, pas seulement servir au
            // calcul : sans cela la base garderait les voix brutes tandis que
            // le statut refléterait les voix plafonnées. Le procès-verbal
            // afficherait alors un décompte que son propre résultat contredit,
            // ce qui est indéfendable si la décision est attaquée.
            self.resolution_repository
                .update_vote_counts(
                    resolution_id,
                    resolution.vote_count_pour,
                    resolution.vote_count_contre,
                    resolution.vote_count_abstention,
                    resolution.total_voting_power_pour,
                    resolution.total_voting_power_contre,
                    resolution.total_voting_power_abstention,
                )
                .await?;
            Some(serde_json::json!(decompte
                .ecarts()
                .iter()
                .map(|e| serde_json::json!({
                    "votant": e.votant,
                    "voix_brutes": e.voix_brutes,
                    "voix_retenues": e.voix_retenues,
                }))
                .collect::<Vec<_>>()))
        };

        // Calculate final result
        resolution.close_voting(total_voting_power)?;

        // Update resolution with final status
        self.resolution_repository
            .close_voting(resolution_id, resolution.status.clone(), voix_plafonnees)
            .await?;

        // Fetch updated resolution
        self.resolution_repository
            .find_by_id(resolution_id)
            .await?
            .ok_or_else(|| "Resolution not found after closing".to_string())
    }

    /// Get vote summary for a meeting (all resolutions with their results)
    pub async fn get_meeting_vote_summary(
        &self,
        meeting_id: Uuid,
    ) -> Result<Vec<Resolution>, String> {
        self.resolution_repository
            .get_meeting_vote_summary(meeting_id)
            .await
    }

    /// Helper: Update vote counts for a resolution based on actual votes
    async fn update_resolution_vote_counts(&self, resolution_id: Uuid) -> Result<(), String> {
        // Get vote counts
        let (pour_count, contre_count, abstention_count) = self
            .vote_repository
            .count_by_resolution_and_choice(resolution_id)
            .await?;

        // Get voting power totals
        let (pour_power, contre_power, abstention_power) = self
            .vote_repository
            .sum_voting_power_by_resolution(resolution_id)
            .await?;

        // Update resolution
        self.resolution_repository
            .update_vote_counts(
                resolution_id,
                pour_count,
                contre_count,
                abstention_count,
                pour_power,
                contre_power,
                abstention_power,
            )
            .await
    }

    /// Check if a unit has voted on a resolution
    pub async fn has_unit_voted(&self, resolution_id: Uuid, unit_id: Uuid) -> Result<bool, String> {
        self.vote_repository.has_voted(resolution_id, unit_id).await
    }

    /// Valide la limite de procurations par mandataire (Art. 3.87 §7 CC).
    ///
    /// Règle: un mandataire ne peut détenir plus de 3 procurations.
    /// Exception: si le total des voix représentées < 10% du total général,
    /// la limite de 3 ne s'applique pas.
    ///
    /// Le `new_voting_power` est le pouvoir de vote de la nouvelle procuration
    /// envisagée (utilisé pour le calcul de l'exception 10%).
    async fn validate_proxy_limit(
        &self,
        resolution_id: Uuid,
        proxy_owner_id: Uuid,
        new_voting_power: rust_decimal::Decimal,
    ) -> Result<(), String> {
        let (existing_count, existing_power) = self
            .vote_repository
            .count_proxy_votes_for_mandataire(resolution_id, proxy_owner_id)
            .await?;

        // Total du pouvoir de vote représenté après ajout de la nouvelle procuration
        let total_proxy_power = existing_power + new_voting_power;

        // Exception 10% : si le total des procurations < 10% du total AG, pas de limite
        // On récupère le total de la résolution
        let resolution = self
            .resolution_repository
            .find_by_id(resolution_id)
            .await?
            .ok_or_else(|| "Resolution not found".to_string())?;

        // total_voting_power_* contient les votes déjà exprimés
        // Pour l'exception, on compare la puissance des procurations au total millièmes
        // En pratique, le syndic passe le total_quotas du meeting — on utilise une heuristique
        let total_all_votes = resolution.total_voting_power_pour
            + resolution.total_voting_power_contre
            + resolution.total_voting_power_abstention
            + new_voting_power; // inclure ce qu'on est en train d'ajouter

        // Exception: si total procurations < 10% du total général → pas de limite
        if total_all_votes > rust_decimal::Decimal::ZERO
            && (total_proxy_power / total_all_votes) < rust_decimal_macros::dec!(0.10)
        {
            return Ok(()); // Exception 10% s'applique
        }

        // Règle générale: max 3 procurations
        if existing_count >= 3 {
            return Err(format!(
                "Le mandataire détient déjà {} procurations. Maximum autorisé : 3 (Art. 3.87 §7 CC). \
                 Exception 10% non applicable (procurations représentent >{:.1}% des votes).",
                existing_count,
                if total_all_votes > rust_decimal::Decimal::ZERO {
                    (total_proxy_power / total_all_votes) * rust_decimal_macros::dec!(100)
                } else {
                    rust_decimal::Decimal::ZERO
                }
            ));
        }

        Ok(())
    }

    /// Get vote statistics for a resolution
    pub async fn get_vote_statistics(&self, resolution_id: Uuid) -> Result<VoteStatistics, String> {
        let resolution = self
            .resolution_repository
            .find_by_id(resolution_id)
            .await?
            .ok_or_else(|| "Resolution not found".to_string())?;

        Ok(VoteStatistics {
            total_votes: resolution.total_votes(),
            vote_count_pour: resolution.vote_count_pour,
            vote_count_contre: resolution.vote_count_contre,
            vote_count_abstention: resolution.vote_count_abstention,
            total_voting_power_pour: resolution.total_voting_power_pour,
            total_voting_power_contre: resolution.total_voting_power_contre,
            total_voting_power_abstention: resolution.total_voting_power_abstention,
            pour_percentage: resolution.pour_percentage(),
            contre_percentage: resolution.contre_percentage(),
            abstention_percentage: resolution.abstention_percentage(),
            status: resolution.status,
        })
    }
}

/// Vote statistics for a resolution
#[derive(Debug, Clone)]
pub struct VoteStatistics {
    pub total_votes: i32,
    pub vote_count_pour: i32,
    pub vote_count_contre: i32,
    pub vote_count_abstention: i32,
    pub total_voting_power_pour: rust_decimal::Decimal,
    pub total_voting_power_contre: rust_decimal::Decimal,
    pub total_voting_power_abstention: rust_decimal::Decimal,
    pub pour_percentage: f64,
    pub contre_percentage: f64,
    pub abstention_percentage: f64,
    pub status: ResolutionStatus,
}

#[cfg(test)]
mod tests {
    // `status_code()` vient du trait `ResponseError` : sans l'importer, la
    // méthode n'existe pas sur `AppError` au point d'appel. Deux branches
    // ont ajouté des tests qui l'emploient, aucune n'a apporté l'import.
    use super::*;
    use crate::application::dto::{PageRequest, UnitFilters};
    use crate::application::ports::{
        MeetingRepository, ResolutionRepository, UnitOwnerRepository, UnitRepository,
        VoteRepository,
    };
    use crate::domain::entities::{
        LotHolder, Meeting, MeetingMode, MeetingType, OwnershipType, Unit, UnitOwner, UnitType,
        VoteChoice,
    };
    use actix_web::ResponseError;
    use async_trait::async_trait;
    use chrono::Utc;
    use rust_decimal_macros::dec;
    use std::collections::HashMap;
    use std::sync::Mutex;

    // Story H17 — mock UnitOwnerRepository : `find_voting_holders_by_unit`
    // configurable par lot (défaut vide → `voting_right_status` Active, donc
    // les tests existants ne changent pas de comportement).
    struct MockUnitOwnerRepository {
        holders: Mutex<HashMap<Uuid, Vec<LotHolder>>>,
        /// #850 — paires (lot, owner) dont la détention est refusée par
        /// `find_active_by_unit_and_owner`. Vide par défaut : la détention
        /// est acceptée pour toute paire, comme `holders` vide laisse le
        /// droit de vote actif. Les tests antérieurs à #850 n'ont jamais
        /// enregistré qui détient quoi ; seuls ceux qui éprouvent précisément
        /// l'usurpation de lot la peuplent via `refuse_detention`.
        detentions_refusees: Mutex<std::collections::HashSet<(Uuid, Uuid)>>,
    }

    impl MockUnitOwnerRepository {
        fn new() -> Self {
            Self {
                holders: Mutex::new(HashMap::new()),
                detentions_refusees: Mutex::new(std::collections::HashSet::new()),
            }
        }

        fn with_holders(unit_id: Uuid, holders: Vec<LotHolder>) -> Self {
            let m = Self::new();
            m.holders.lock().unwrap().insert(unit_id, holders);
            m
        }

        /// Marque `(unit_id, owner_id)` comme une détention refusée : le lot
        /// n'appartient pas à cet owner selon le dépôt.
        fn refuse_detention(&self, unit_id: Uuid, owner_id: Uuid) {
            self.detentions_refusees
                .lock()
                .unwrap()
                .insert((unit_id, owner_id));
        }
    }

    #[async_trait]
    impl UnitOwnerRepository for MockUnitOwnerRepository {
        async fn create(&self, unit_owner: &UnitOwner) -> Result<UnitOwner, String> {
            Ok(unit_owner.clone())
        }
        async fn find_by_id(&self, _id: Uuid) -> Result<Option<UnitOwner>, String> {
            Ok(None)
        }
        async fn find_current_owners_by_unit(
            &self,
            _unit_id: Uuid,
        ) -> Result<Vec<UnitOwner>, String> {
            Ok(vec![])
        }
        async fn find_current_units_by_owner(
            &self,
            _owner_id: Uuid,
        ) -> Result<Vec<UnitOwner>, String> {
            Ok(vec![])
        }
        async fn find_all_owners_by_unit(&self, _unit_id: Uuid) -> Result<Vec<UnitOwner>, String> {
            Ok(vec![])
        }
        async fn find_all_units_by_owner(&self, _owner_id: Uuid) -> Result<Vec<UnitOwner>, String> {
            Ok(vec![])
        }
        async fn update(&self, unit_owner: &UnitOwner) -> Result<UnitOwner, String> {
            Ok(unit_owner.clone())
        }
        async fn delete(&self, _id: Uuid) -> Result<(), String> {
            Ok(())
        }
        async fn has_active_owners(&self, _unit_id: Uuid) -> Result<bool, String> {
            Ok(true)
        }
        async fn get_total_ownership_percentage(
            &self,
            _unit_id: Uuid,
        ) -> Result<rust_decimal::Decimal, String> {
            Ok(rust_decimal::Decimal::ONE)
        }
        async fn find_active_by_unit_and_owner(
            &self,
            unit_id: Uuid,
            owner_id: Uuid,
        ) -> Result<Option<UnitOwner>, String> {
            if self
                .detentions_refusees
                .lock()
                .unwrap()
                .contains(&(unit_id, owner_id))
            {
                return Ok(None);
            }
            Ok(Some(
                UnitOwner::new(unit_id, owner_id, rust_decimal::Decimal::ONE, true)
                    .expect("détention de test"),
            ))
        }
        async fn find_active_by_building(
            &self,
            _building_id: Uuid,
        ) -> Result<Vec<(Uuid, Uuid, rust_decimal::Decimal)>, String> {
            Ok(vec![])
        }

        /// Même source que ci-dessus dans les tests : les fixtures posent
        /// directement des quotes-parts déjà résolues.
        async fn find_active_quota_shares_by_building(
            &self,
            _building_id: Uuid,
        ) -> Result<Vec<(Uuid, Uuid, rust_decimal::Decimal)>, String> {
            Ok(vec![])
        }
        async fn find_voting_holders_by_unit(
            &self,
            unit_id: Uuid,
        ) -> Result<Vec<LotHolder>, String> {
            Ok(self
                .holders
                .lock()
                .unwrap()
                .get(&unit_id)
                .cloned()
                .unwrap_or_default())
        }

        async fn is_voting_representative(&self, _unit_owner_id: Uuid) -> Result<bool, String> {
            Ok(false)
        }

        async fn set_voting_representative(&self, _unit_owner_id: Uuid) -> Result<(), String> {
            Ok(())
        }
    }

    // Mock repositories for testing
    /// Les lots, pour que la quotité se LISE (#850).
    ///
    /// `defaut` sert les tests écrits avant #850 : ils votent sur des lots
    /// qu'ils n'ont jamais créés, parce que la puissance de vote arrivait
    /// alors dans l'appel. Plutôt que de réécrire quarante scénarios, le mock
    /// fabrique un lot à la demande, rattaché à l'immeuble qu'on lui indique.
    ///
    /// Les tests qui éprouvent PRÉCISÉMENT la quotité, eux, enregistrent leur
    /// lot explicitement.
    struct MockUnitRepository {
        units: Mutex<HashMap<Uuid, Unit>>,
        defaut: Mutex<Option<(Uuid, rust_decimal::Decimal)>>,
    }

    impl MockUnitRepository {
        fn new() -> Self {
            Self {
                units: Mutex::new(HashMap::new()),
                defaut: Mutex::new(None),
            }
        }

        fn enregistre(&self, unit: Unit) {
            self.units.lock().unwrap().insert(unit.id, unit);
        }

        /// Pose le lot par défaut une fois l'immeuble connu.
        ///
        /// Le constructeur est appelé avant que le test n'ait tiré son
        /// `building_id` ; cette méthode permet de le lui donner ensuite.
        fn pose_defaut(&self, building_id: Uuid, quota: rust_decimal::Decimal) {
            *self.defaut.lock().unwrap() = Some((building_id, quota));
        }

        /// Enregistre un lot d'une quotité donnée, dans l'immeuble donné.
        fn lot(&self, unit_id: Uuid, building_id: Uuid, quota: rust_decimal::Decimal) {
            let mut unit = Unit::new(
                Uuid::new_v4(),
                building_id,
                format!("L{}", &unit_id.to_string()[..4]),
                UnitType::Apartment,
                Some(0),
                50.0,
                quota,
            )
            .expect("lot de test");
            unit.id = unit_id;
            self.enregistre(unit);
        }
    }

    #[async_trait]
    impl UnitRepository for MockUnitRepository {
        async fn create(&self, unit: &Unit) -> Result<Unit, String> {
            self.units.lock().unwrap().insert(unit.id, unit.clone());
            Ok(unit.clone())
        }

        async fn find_by_id(&self, id: Uuid) -> Result<Option<Unit>, String> {
            if let Some(unit) = self.units.lock().unwrap().get(&id).cloned() {
                return Ok(Some(unit));
            }
            let defaut = *self.defaut.lock().unwrap();
            Ok(defaut.map(|(building_id, quota)| {
                let mut unit = Unit::new(
                    Uuid::new_v4(),
                    building_id,
                    format!("L{}", &id.to_string()[..4]),
                    UnitType::Apartment,
                    Some(0),
                    50.0,
                    quota,
                )
                .expect("lot de test");
                unit.id = id;
                unit
            }))
        }

        async fn find_by_building(&self, building_id: Uuid) -> Result<Vec<Unit>, String> {
            Ok(self
                .units
                .lock()
                .unwrap()
                .values()
                .filter(|u| u.building_id == building_id)
                .cloned()
                .collect())
        }

        async fn find_by_owner(&self, _owner_id: Uuid) -> Result<Vec<Unit>, String> {
            Ok(vec![])
        }

        async fn find_all_paginated(
            &self,
            _page_request: &PageRequest,
            _filters: &UnitFilters,
        ) -> Result<(Vec<Unit>, i64), String> {
            let units: Vec<_> = self.units.lock().unwrap().values().cloned().collect();
            let total = units.len() as i64;
            Ok((units, total))
        }

        async fn update(&self, unit: &Unit) -> Result<Unit, String> {
            self.units.lock().unwrap().insert(unit.id, unit.clone());
            Ok(unit.clone())
        }

        async fn delete(&self, id: Uuid) -> Result<bool, String> {
            Ok(self.units.lock().unwrap().remove(&id).is_some())
        }
    }

    struct MockMeetingRepository {
        meetings: Mutex<HashMap<Uuid, Meeting>>,
    }

    impl MockMeetingRepository {
        fn new() -> Self {
            Self {
                meetings: Mutex::new(HashMap::new()),
            }
        }
    }

    #[async_trait]
    impl MeetingRepository for MockMeetingRepository {
        async fn create(&self, meeting: &Meeting) -> Result<Meeting, String> {
            self.meetings
                .lock()
                .unwrap()
                .insert(meeting.id, meeting.clone());
            Ok(meeting.clone())
        }

        async fn find_by_id(&self, id: Uuid) -> Result<Option<Meeting>, String> {
            Ok(self.meetings.lock().unwrap().get(&id).cloned())
        }

        async fn find_by_building(&self, building_id: Uuid) -> Result<Vec<Meeting>, String> {
            Ok(self
                .meetings
                .lock()
                .unwrap()
                .values()
                .filter(|m| m.building_id == building_id)
                .cloned()
                .collect())
        }

        async fn update(&self, meeting: &Meeting) -> Result<Meeting, String> {
            self.meetings
                .lock()
                .unwrap()
                .insert(meeting.id, meeting.clone());
            Ok(meeting.clone())
        }

        async fn delete(&self, id: Uuid) -> Result<bool, String> {
            Ok(self.meetings.lock().unwrap().remove(&id).is_some())
        }

        async fn find_all_paginated(
            &self,
            _page_request: &PageRequest,
            _organization_id: Option<Uuid>,
        ) -> Result<(Vec<Meeting>, i64), String> {
            let meetings: Vec<_> = self.meetings.lock().unwrap().values().cloned().collect();
            let total = meetings.len() as i64;
            Ok((meetings, total))
        }
    }

    struct MockResolutionRepository {
        resolutions: Mutex<HashMap<Uuid, Resolution>>,
        /// Ce que la dernière clôture a consigné au titre de l'Art. 3.87 § 7
        /// al. 4. Sans ce champ, la trace du plafonnement serait invérifiable
        /// en test unitaire, et le seul moyen de la constater serait la base.
        dernier_plafonnement: Mutex<Option<serde_json::Value>>,
    }

    impl MockResolutionRepository {
        fn new() -> Self {
            Self {
                resolutions: Mutex::new(HashMap::new()),
                dernier_plafonnement: Mutex::new(None),
            }
        }
    }

    #[async_trait]
    impl ResolutionRepository for MockResolutionRepository {
        async fn create(&self, resolution: &Resolution) -> Result<Resolution, String> {
            self.resolutions
                .lock()
                .unwrap()
                .insert(resolution.id, resolution.clone());
            Ok(resolution.clone())
        }

        async fn find_by_id(&self, id: Uuid) -> Result<Option<Resolution>, String> {
            Ok(self.resolutions.lock().unwrap().get(&id).cloned())
        }

        async fn find_by_meeting_id(&self, meeting_id: Uuid) -> Result<Vec<Resolution>, String> {
            Ok(self
                .resolutions
                .lock()
                .unwrap()
                .values()
                .filter(|r| r.meeting_id == meeting_id)
                .cloned()
                .collect())
        }

        async fn find_by_status(
            &self,
            status: ResolutionStatus,
        ) -> Result<Vec<Resolution>, String> {
            Ok(self
                .resolutions
                .lock()
                .unwrap()
                .values()
                .filter(|r| r.status == status)
                .cloned()
                .collect())
        }

        async fn update(&self, resolution: &Resolution) -> Result<Resolution, String> {
            self.resolutions
                .lock()
                .unwrap()
                .insert(resolution.id, resolution.clone());
            Ok(resolution.clone())
        }

        async fn delete(&self, id: Uuid) -> Result<bool, String> {
            Ok(self.resolutions.lock().unwrap().remove(&id).is_some())
        }

        async fn update_vote_counts(
            &self,
            resolution_id: Uuid,
            vote_count_pour: i32,
            vote_count_contre: i32,
            vote_count_abstention: i32,
            total_voting_power_pour: rust_decimal::Decimal,
            total_voting_power_contre: rust_decimal::Decimal,
            total_voting_power_abstention: rust_decimal::Decimal,
        ) -> Result<(), String> {
            if let Some(resolution) = self.resolutions.lock().unwrap().get_mut(&resolution_id) {
                resolution.vote_count_pour = vote_count_pour;
                resolution.vote_count_contre = vote_count_contre;
                resolution.vote_count_abstention = vote_count_abstention;
                resolution.total_voting_power_pour = total_voting_power_pour;
                resolution.total_voting_power_contre = total_voting_power_contre;
                resolution.total_voting_power_abstention = total_voting_power_abstention;
            }
            Ok(())
        }

        async fn close_voting(
            &self,
            resolution_id: Uuid,
            final_status: ResolutionStatus,
            voix_plafonnees: Option<serde_json::Value>,
        ) -> Result<(), String> {
            // La trace du plafonnement est conservée par le mock, sans quoi
            // aucun test unitaire ne pourrait vérifier qu'elle est bien écrite.
            *self.dernier_plafonnement.lock().unwrap() = voix_plafonnees;
            if let Some(resolution) = self.resolutions.lock().unwrap().get_mut(&resolution_id) {
                resolution.status = final_status;
                resolution.voted_at = Some(chrono::Utc::now());
            }
            Ok(())
        }

        async fn get_meeting_vote_summary(
            &self,
            meeting_id: Uuid,
        ) -> Result<Vec<Resolution>, String> {
            self.find_by_meeting_id(meeting_id).await
        }
    }

    struct MockVoteRepository {
        votes: Mutex<HashMap<Uuid, Vote>>,
    }

    impl MockVoteRepository {
        fn new() -> Self {
            Self {
                votes: Mutex::new(HashMap::new()),
            }
        }
    }

    #[async_trait]
    impl VoteRepository for MockVoteRepository {
        async fn create(&self, vote: &Vote) -> Result<Vote, String> {
            self.votes.lock().unwrap().insert(vote.id, vote.clone());
            Ok(vote.clone())
        }

        async fn find_by_id(&self, id: Uuid) -> Result<Option<Vote>, String> {
            Ok(self.votes.lock().unwrap().get(&id).cloned())
        }

        async fn find_by_resolution_id(&self, resolution_id: Uuid) -> Result<Vec<Vote>, String> {
            Ok(self
                .votes
                .lock()
                .unwrap()
                .values()
                .filter(|v| v.resolution_id == resolution_id)
                .cloned()
                .collect())
        }

        async fn find_by_owner_id(&self, owner_id: Uuid) -> Result<Vec<Vote>, String> {
            Ok(self
                .votes
                .lock()
                .unwrap()
                .values()
                .filter(|v| v.owner_id == owner_id)
                .cloned()
                .collect())
        }

        async fn find_by_resolution_and_unit(
            &self,
            resolution_id: Uuid,
            unit_id: Uuid,
        ) -> Result<Option<Vote>, String> {
            Ok(self
                .votes
                .lock()
                .unwrap()
                .values()
                .find(|v| v.resolution_id == resolution_id && v.unit_id == unit_id)
                .cloned())
        }

        async fn has_voted(&self, resolution_id: Uuid, unit_id: Uuid) -> Result<bool, String> {
            Ok(self
                .find_by_resolution_and_unit(resolution_id, unit_id)
                .await?
                .is_some())
        }

        async fn update(&self, vote: &Vote) -> Result<Vote, String> {
            self.votes.lock().unwrap().insert(vote.id, vote.clone());
            Ok(vote.clone())
        }

        async fn delete(&self, id: Uuid) -> Result<bool, String> {
            Ok(self.votes.lock().unwrap().remove(&id).is_some())
        }

        async fn count_by_resolution_and_choice(
            &self,
            resolution_id: Uuid,
        ) -> Result<(i32, i32, i32), String> {
            let votes = self.find_by_resolution_id(resolution_id).await?;
            let pour = votes
                .iter()
                .filter(|v| v.vote_choice == VoteChoice::Pour)
                .count() as i32;
            let contre = votes
                .iter()
                .filter(|v| v.vote_choice == VoteChoice::Contre)
                .count() as i32;
            let abstention = votes
                .iter()
                .filter(|v| v.vote_choice == VoteChoice::Abstention)
                .count() as i32;
            Ok((pour, contre, abstention))
        }

        async fn sum_voting_power_by_resolution(
            &self,
            resolution_id: Uuid,
        ) -> Result<
            (
                rust_decimal::Decimal,
                rust_decimal::Decimal,
                rust_decimal::Decimal,
            ),
            String,
        > {
            let votes = self.find_by_resolution_id(resolution_id).await?;
            let pour: rust_decimal::Decimal = votes
                .iter()
                .filter(|v| v.vote_choice == VoteChoice::Pour)
                .map(|v| v.voting_power)
                .sum();
            let contre: rust_decimal::Decimal = votes
                .iter()
                .filter(|v| v.vote_choice == VoteChoice::Contre)
                .map(|v| v.voting_power)
                .sum();
            let abstention: rust_decimal::Decimal = votes
                .iter()
                .filter(|v| v.vote_choice == VoteChoice::Abstention)
                .map(|v| v.voting_power)
                .sum();
            Ok((pour, contre, abstention))
        }

        async fn count_proxy_votes_for_mandataire(
            &self,
            resolution_id: Uuid,
            proxy_owner_id: Uuid,
        ) -> Result<(i64, rust_decimal::Decimal), String> {
            let votes = self.find_by_resolution_id(resolution_id).await?;
            let proxy_votes: Vec<_> = votes
                .iter()
                .filter(|v| v.proxy_owner_id == Some(proxy_owner_id))
                .collect();
            let count = proxy_votes.len() as i64;
            let power: rust_decimal::Decimal = proxy_votes.iter().map(|v| v.voting_power).sum();
            Ok((count, power))
        }
    }

    /// Le décompte servi **avant** la clôture est déjà plafonné.
    ///
    /// Reproduction exacte de la recette du 2026-09-04 (R3-1) : Alice pèse
    /// 550 ‰ et vote « pour », Bob (250) et Claire (200) votent « contre ».
    /// L'Art. 3.87 § 7 al. 4 ramène Alice à 450, la somme des autres présents.
    ///
    /// Le testeur lisait 550 et concluait que le plafonnement n'était pas
    /// implémenté. Il l'était — mais seulement dans `close_voting`, que rien
    /// ne déclenche automatiquement. Toute la séance se déroulait donc sous
    /// les yeux du syndic avec un décompte légalement faux.
    ///
    /// **Ce test lit sans clôturer.** C'était précisément l'angle mort : les
    /// tests du domaine passaient, `close_voting` était correct, et l'API
    /// restait fausse. Un test qui clôture d'abord ne prouverait rien ici.
    #[tokio::test]
    async fn test_art_3_87_la_lecture_avant_cloture_est_deja_plafonnee() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            Arc::new(MockMeetingRepository::new()),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let resolution = Resolution::new(
            Uuid::new_v4(),
            "RECETTE-Approbation des comptes".to_string(),
            "Scénario de recette du 2026-09-04".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            Some(1),
        )
        .expect("résolution valide");
        let resolution_id = resolution.id;
        resolution_repo
            .create(&resolution)
            .await
            .expect("résolution enregistrée");

        for (voix, choix) in [
            (dec!(550), VoteChoice::Pour),
            (dec!(250), VoteChoice::Contre),
            (dec!(200), VoteChoice::Contre),
        ] {
            vote_repo
                .create(
                    &Vote::new(
                        resolution_id,
                        Uuid::new_v4(),
                        Uuid::new_v4(),
                        choix,
                        voix,
                        None,
                    )
                    .expect("vote valide"),
                )
                .await
                .expect("vote enregistré");
        }

        // AUCUNE clôture ici. C'est tout l'objet du test.
        let lue = use_cases
            .get_resolution(resolution_id)
            .await
            .expect("lecture réussie")
            .expect("résolution trouvée");

        assert_eq!(
            lue.total_voting_power_pour,
            dec!(450),
            "Alice doit être ramenée à la somme des autres présents (250 + 200), \
             pas servie à ses 550 ‰ bruts"
        );
        assert_eq!(lue.total_voting_power_contre, dec!(450));
        assert_eq!(
            lue.pour_percentage(),
            50.0,
            "50 % n'est pas la majorité absolue : le pourcentage affiché doit \
             répondre au résultat que la clôture proclamera"
        );
        assert_eq!(
            lue.status,
            ResolutionStatus::Pending,
            "plafonner la lecture ne clôt pas la résolution"
        );
    }

    /// Le plafonnement de lecture ne persiste rien.
    ///
    /// Deux lectures successives doivent rendre le même résultat. Si la
    /// première écrivait le décompte corrigé, la seconde replafonnerait un
    /// décompte déjà plafonné et le rétrécirait encore.
    #[tokio::test]
    async fn test_la_lecture_plafonnee_est_idempotente_et_ne_persiste_rien() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            Arc::new(MockMeetingRepository::new()),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let resolution = Resolution::new(
            Uuid::new_v4(),
            "Lecture répétée".to_string(),
            "Contrôle d'idempotence".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            Some(1),
        )
        .expect("résolution valide");
        let resolution_id = resolution.id;
        resolution_repo.create(&resolution).await.expect("créée");

        for (voix, choix) in [
            (dec!(550), VoteChoice::Pour),
            (dec!(250), VoteChoice::Contre),
            (dec!(200), VoteChoice::Contre),
        ] {
            vote_repo
                .create(
                    &Vote::new(
                        resolution_id,
                        Uuid::new_v4(),
                        Uuid::new_v4(),
                        choix,
                        voix,
                        None,
                    )
                    .expect("vote valide"),
                )
                .await
                .expect("vote enregistré");
        }

        let une = use_cases
            .get_resolution(resolution_id)
            .await
            .unwrap()
            .unwrap();
        let deux = use_cases
            .get_resolution(resolution_id)
            .await
            .unwrap()
            .unwrap();
        assert_eq!(une.total_voting_power_pour, deux.total_voting_power_pour);
        assert_eq!(deux.total_voting_power_pour, dec!(450));
    }

    /// Art. 3.87 § 7 : la clôture refuse une séance où un votant pèse plus
    /// que tous les autres réunis : ses voix sont **ramenées** à la somme des
    /// leurs, et l'écart est consigné.
    ///
    /// Le contrôle est à la clôture et pas au vote, parce qu'il porte sur
    /// l'ensemble des voix : c'est le dernier bulletin déposé qui peut faire
    /// basculer une séance licite jusque-là.
    ///
    /// Anciennement `..._refuse_un_votant_plus_lourd_...`, qui attendait un
    /// refus de clore. Arbitrage humain du 2026-09-04, confirmé par la
    /// doctrine belge : l'Art. 3.87 § 7 al. 4 plafonne, il n'annule pas.
    #[tokio::test]
    async fn test_art_3_87_la_cloture_plafonne_un_votant_plus_lourd_que_tous_les_autres() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            Arc::new(MockMeetingRepository::new()),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let resolution = Resolution::new(
            Uuid::new_v4(),
            "Réfection de la toiture".to_string(),
            "Travaux de couverture votés en AGO".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            Some(1),
        )
        .expect("résolution valide");
        let resolution_id = resolution.id;
        resolution_repo
            .create(&resolution)
            .await
            .expect("résolution enregistrée");

        // 600 pour un seul, 399 pour tous les autres réunis.
        for (voix, _) in [(dec!(600), 0), (dec!(200), 1), (dec!(199), 2)] {
            vote_repo
                .create(
                    &Vote::new(
                        resolution_id,
                        Uuid::new_v4(),
                        Uuid::new_v4(),
                        VoteChoice::Pour,
                        voix,
                        None,
                    )
                    .expect("vote valide"),
                )
                .await
                .expect("vote enregistré");
        }

        // La séance se clôture : le poids d'un votant ne fait plus obstacle.
        use_cases
            .close_voting(resolution_id, dec!(1000))
            .await
            .expect("le plafonnement remplace le refus");

        // L'écart est consigné, sans quoi le procès-verbal afficherait un
        // décompte que rien dans les bulletins ne permettrait de retrouver.
        let trace = resolution_repo
            .dernier_plafonnement
            .lock()
            .unwrap()
            .clone()
            .expect("un plafonnement a eu lieu, il doit être tracé");
        let ecarts = trace.as_array().expect("un tableau d'écarts");
        assert_eq!(
            ecarts.len(),
            1,
            "un seul votant dépassait la somme des autres"
        );
        assert_eq!(ecarts[0]["voix_brutes"], serde_json::json!(dec!(600)));
        assert_eq!(
            ecarts[0]["voix_retenues"],
            serde_json::json!(dec!(399)),
            "ramené à 200 + 199"
        );
    }

    /// Reproduction du scénario de recette du 2026-09-04.
    ///
    /// Alice pèse 550 et vote « pour ». Bob (250) et Claire (200) votent
    /// « contre ». Après plafonnement, Alice est ramenée à 450 : le décompte
    /// devient 450 contre 450.
    ///
    /// La majorité absolue de l'Art. 3.88 § 1er exige **plus** de la moitié
    /// des voix exprimées. Une égalité n'est pas une majorité : la résolution
    /// doit être REJETÉE.
    #[tokio::test]
    async fn test_art_3_88_une_egalite_apres_plafonnement_nest_pas_une_majorite() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            Arc::new(MockMeetingRepository::new()),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let resolution = Resolution::new(
            Uuid::new_v4(),
            "Approbation des comptes".to_string(),
            "Comptes annuels".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            Some(1),
        )
        .expect("résolution valide");
        let resolution_id = resolution.id;
        resolution_repo
            .create(&resolution)
            .await
            .expect("enregistrée");

        for (voix, choix) in [
            (dec!(550), VoteChoice::Pour),
            (dec!(250), VoteChoice::Contre),
            (dec!(200), VoteChoice::Contre),
        ] {
            vote_repo
                .create(
                    &Vote::new(
                        resolution_id,
                        Uuid::new_v4(),
                        Uuid::new_v4(),
                        choix,
                        voix,
                        None,
                    )
                    .expect("vote valide"),
                )
                .await
                .expect("vote enregistré");
        }

        let close = use_cases
            .close_voting(resolution_id, dec!(1000))
            .await
            .expect("la clôture aboutit");

        assert_eq!(
            close.total_voting_power_pour,
            dec!(450),
            "Alice est ramenée à la somme des autres"
        );
        assert_eq!(close.total_voting_power_contre, dec!(450));
        assert_eq!(
            close.status,
            ResolutionStatus::Rejected,
            "450 contre 450 : égalité, donc pas de majorité absolue"
        );
    }

    /// La même séance, répartie normalement, se clôture sans obstacle.
    #[tokio::test]
    async fn test_art_3_87_une_seance_equilibree_se_cloture() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            Arc::new(MockMeetingRepository::new()),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let resolution = Resolution::new(
            Uuid::new_v4(),
            "Réfection de la toiture".to_string(),
            "Travaux de couverture votés en AGO".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            Some(1),
        )
        .expect("résolution valide");
        let resolution_id = resolution.id;
        resolution_repo
            .create(&resolution)
            .await
            .expect("résolution enregistrée");

        for voix in [dec!(400), dec!(300), dec!(300)] {
            vote_repo
                .create(
                    &Vote::new(
                        resolution_id,
                        Uuid::new_v4(),
                        Uuid::new_v4(),
                        VoteChoice::Pour,
                        voix,
                        None,
                    )
                    .expect("vote valide"),
                )
                .await
                .expect("vote enregistré");
        }

        assert!(use_cases
            .close_voting(resolution_id, dec!(1000))
            .await
            .is_ok());
    }

    #[tokio::test]
    async fn test_create_resolution() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let meeting_id = Uuid::new_v4();

        // Create a meeting with quorum reached
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        // Validate quorum (600/1000 = 60% > 50%)
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let result = use_cases
            .create_resolution(
                meeting_id,
                "Test Resolution".to_string(),
                "Description".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await;

        assert!(result.is_ok());
        let resolution = result.unwrap();
        assert_eq!(resolution.title, "Test Resolution");
        assert_eq!(resolution.status, ResolutionStatus::Pending);
    }

    #[tokio::test]
    async fn test_create_resolution_fails_without_quorum() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let meeting_id = Uuid::new_v4();

        // Create a meeting with quorum NOT reached
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        // Validate quorum (400/1000 = 40% < 50%) — quorum NOT reached
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(400),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let result = use_cases
            .create_resolution(
                meeting_id,
                "Test Resolution".to_string(),
                "Description".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await;

        // Should fail because quorum not reached
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("second convocation"));
    }

    /// #850 — Art. 3.87 § 2 et § 8 CC : la voix d'un lot est sa quotité dans
    /// l'acte de base. Elle ne se déclare pas.
    ///
    /// Le serveur acceptait `voting_power` depuis le corps de la requête et
    /// l'enregistrait sans la recalculer. Un copropriétaire pouvait donc
    /// choisir son propre poids dans l'assemblée.
    #[tokio::test]
    async fn security_la_puissance_de_vote_vient_du_lot_pas_de_lappelant() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        // Le lot vaut 42 millièmes à l'acte de base. L'appelant n'a plus aucun
        // moyen d'en proposer d'autres : le paramètre a disparu de la
        // signature, ce qui est plus sûr que de l'ignorer en silence.
        let meeting = meeting_repo
            .find_by_id(resolution.meeting_id)
            .await
            .unwrap()
            .unwrap();
        let unit_id = Uuid::new_v4();
        unit_repo.lot(unit_id, meeting.building_id, dec!(42));

        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let owner_id = Uuid::new_v4();
        let vote = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                // #850 — vote pour soi-même : l'appelant EST l'owner_id.
                owner_id,
            )
            .await
            .expect("le vote doit aboutir");

        assert_eq!(
            vote.voting_power,
            dec!(42),
            "la voix enregistrée doit être la quotité du lot (Art. 3.87 § 8 CC), \
             pas une valeur choisie par l'appelant"
        );
    }

    /// #850 — un lot d'un AUTRE immeuble n'a rien à voter dans cette assemblée.
    ///
    /// La route acceptait n'importe quel `unit_id` : le seul contrôle portait
    /// sur la titularité du lot, jamais sur son rattachement à l'assemblée.
    /// Un lot d'un immeuble voisin pouvait donc peser sur une décision qui ne
    /// le concerne pas.
    #[tokio::test]
    async fn security_un_lot_dun_autre_immeuble_ne_peut_pas_voter() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        let lot_etranger = Uuid::new_v4();
        unit_repo.lot(lot_etranger, Uuid::new_v4(), dec!(100));

        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let owner_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                lot_etranger,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .expect_err("un lot d'un autre immeuble ne peut pas voter ici");

        assert!(
            erreur.contains("n'appartient pas à l'immeuble"),
            "le refus doit dire POURQUOI, got: {erreur}"
        );
    }

    /// #850 — un lot qui n'existe pas ne vote pas.
    ///
    /// Avant, la puissance de vote arrivant dans l'appel, rien n'obligeait le
    /// lot à exister : un `unit_id` inventé produisait un vote valide, compté
    /// dans la majorité.
    #[tokio::test]
    async fn negative_un_lot_inexistant_ne_peut_pas_voter() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        // Sans lot par défaut : le dépôt ne connaît aucun lot.
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;
        *unit_repo.defaut.lock().unwrap() = None;

        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let owner_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                Uuid::new_v4(),
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .expect_err("un lot inexistant ne peut pas voter");

        assert!(erreur.contains("Lot introuvable"), "got: {erreur}");
    }

    #[tokio::test]
    async fn test_cast_vote_updates_counts() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        // Create a resolution
        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        // #850 — chaque lot voté existe désormais, et porte sa quotité.
        unit_repo.pose_defaut(building_id, dec!(100));
        let meeting_id = Uuid::new_v4();

        // Create a meeting with quorum reached
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let resolution = use_cases
            .create_resolution(
                meeting_id,
                "Test Resolution".to_string(),
                "Description".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await
            .unwrap();

        // Cast a vote
        let owner_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();
        let result = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await;

        assert!(result.is_ok());

        // Check that vote counts were updated
        let updated_resolution = use_cases
            .get_resolution(resolution.id)
            .await
            .unwrap()
            .unwrap();
        assert_eq!(updated_resolution.vote_count_pour, 1);
        assert_eq!(
            updated_resolution.total_voting_power_pour,
            rust_decimal_macros::dec!(100)
        );
    }

    #[tokio::test]
    async fn test_cannot_vote_twice() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        // Create resolution
        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        // #850 — chaque lot voté existe désormais, et porte sa quotité.
        unit_repo.pose_defaut(building_id, dec!(100));
        let meeting_id = Uuid::new_v4();

        // Create a meeting with quorum reached
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let resolution = use_cases
            .create_resolution(
                meeting_id,
                "Test".to_string(),
                "Desc".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await
            .unwrap();

        let owner_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();

        // First vote succeeds
        let result1 = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await;
        assert!(result1.is_ok());

        // Second vote from same unit fails
        let result2 = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Contre,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await;
        assert!(result2.is_err());
        assert!(result2.unwrap_err().contains("already voted"));
    }

    /// Art. 3.87 §7 CC — un mandataire ne peut pas détenir plus de 3 procurations
    #[tokio::test]
    async fn test_proxy_limit_max_3_enforced() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        // #850 — chaque lot voté existe désormais, et porte sa quotité.
        unit_repo.pose_defaut(building_id, dec!(100));
        let meeting_id = Uuid::new_v4();

        // Create a meeting with quorum reached
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let resolution = use_cases
            .create_resolution(
                meeting_id,
                "Test procurations".to_string(),
                "Description".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await
            .unwrap();

        let mandataire_id = Uuid::new_v4();

        // Cast 3 proxy votes for the same mandataire (should all succeed)
        for i in 0..3 {
            let owner_id = Uuid::new_v4();
            let unit_id = Uuid::new_v4();
            let result = use_cases
                .cast_vote(
                    resolution.id,
                    owner_id,
                    unit_id,
                    VoteChoice::Pour, // 100 millièmes chacun = 300 total
                    Some(mandataire_id),
                    Some(VoteAuthMethod::Proxy),
                    // #850 — le mandataire déclaré EST l'appelant.
                    mandataire_id,
                )
                .await;
            assert!(
                result.is_ok(),
                "Proxy vote {} should succeed, got: {:?}",
                i + 1,
                result.err()
            );
        }

        // 4th proxy vote for the same mandataire should fail (>3 proxies AND >10% of votes)
        let owner_id_4 = Uuid::new_v4();
        let unit_id_4 = Uuid::new_v4();
        let result4 = use_cases
            .cast_vote(
                resolution.id,
                owner_id_4,
                unit_id_4,
                VoteChoice::Pour,
                Some(mandataire_id),
                Some(VoteAuthMethod::Proxy),
                mandataire_id,
            )
            .await;
        assert!(result4.is_err(), "4th proxy vote should be rejected");
        assert!(
            result4.unwrap_err().contains("3"),
            "Error should mention the 3-proxy limit"
        );
    }

    /// @edge — Art. 3.87 § 7 : la limite de trois procurations s'applique même
    /// si le mandataire, pour son 4ᵉ vote, choisit de NE PAS se déclarer
    /// mandataire — c'est-à-dire d'envoyer l'`owner_id` de sa victime sans
    /// remplir `proxy_owner_id`.
    ///
    /// Avant #850, `validate_proxy_limit` n'était appelée QUE si
    /// `proxy_owner_id` était fourni (resolution_use_cases.rs:237 à l'époque
    /// du constat) : la limite légale ne s'appliquait donc qu'à ceux qui la
    /// respectaient déjà. Ce test reproduit exactement le contournement.
    #[tokio::test]
    async fn edge_la_limite_de_trois_procurations_sapplique_meme_non_declaree() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        unit_repo.pose_defaut(building_id, dec!(100));
        let meeting_id = Uuid::new_v4();

        let mut meeting = Meeting::new(
            Uuid::new_v4(),
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let resolution = use_cases
            .create_resolution(
                meeting_id,
                "Test contournement procurations".to_string(),
                "Description".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await
            .unwrap();

        let mandataire_id = Uuid::new_v4();

        // Trois procurations DÉCLARÉES, correctement, pour le mandataire.
        for _ in 0..3 {
            let owner_id = Uuid::new_v4();
            let unit_id = Uuid::new_v4();
            let result = use_cases
                .cast_vote(
                    resolution.id,
                    owner_id,
                    unit_id,
                    VoteChoice::Pour,
                    Some(mandataire_id),
                    Some(VoteAuthMethod::Proxy),
                    mandataire_id,
                )
                .await;
            assert!(result.is_ok(), "les 3 premières procurations passent");
        }

        // La quatrième : le mandataire envoie l'owner_id de sa victime SANS
        // remplir `proxy_owner_id`. C'est exactement le contournement que
        // #850 documente — et il doit être refusé, pas compté comme un vote
        // normal du copropriétaire visé.
        let victime_id = Uuid::new_v4();
        let unit_victime = Uuid::new_v4();
        let resultat = use_cases
            .cast_vote(
                resolution.id,
                victime_id,
                unit_victime,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                // L'appelant réel reste le mandataire, quoi que dise le corps
                // de la requête.
                mandataire_id,
            )
            .await;

        assert!(
            resultat.is_err(),
            "le 4ᵉ vote non déclaré doit être refusé, pas silencieusement accepté"
        );
        let erreur = resultat.unwrap_err();
        assert!(
            erreur.contains("FORBIDDEN"),
            "le refus doit être typé usurpation/mandat non déclaré, got: {erreur}"
        );
    }

    /// Art. 3.87 §7 CC — exception 10% : si total procurations < 10% → pas de limite
    #[tokio::test]
    async fn test_proxy_limit_10_percent_exception_allows_more() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        // #850 — chaque lot voté existe désormais, et porte sa quotité.
        unit_repo.pose_defaut(building_id, dec!(100));
        let meeting_id = Uuid::new_v4();

        // Create a meeting with quorum reached
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            org_id,
            building_id,
            MeetingType::Ordinary,
            "AGO 2024".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle des fêtes".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let resolution = use_cases
            .create_resolution(
                meeting_id,
                "Test exception 10%".to_string(),
                "Description".to_string(),
                ResolutionType::Ordinary,
                MajorityType::Absolute,
                Some(0),
            )
            .await
            .unwrap();

        let mandataire_id = Uuid::new_v4();

        // First, add many direct votes to make the total large (900 millièmes direct)
        for _ in 0..9 {
            let owner_id = Uuid::new_v4();
            let _ = use_cases
                .cast_vote(
                    resolution.id,
                    owner_id,
                    Uuid::new_v4(),
                    VoteChoice::Pour,
                    None,
                    Some(VoteAuthMethod::Presence),
                    owner_id,
                )
                .await;
        }

        // Quatre procurations sur de PETITS lots : 5 millièmes chacun, soit
        // 20 sur 920 → 2,2 % < 10 %, l'exception de l'Art. 3.87 § 7 s'applique.
        //
        // Le scénario passait auparavant par une puissance de vote déclarée
        // dans l'appel. Il passe désormais par la quotité RÉELLE de lots
        // modestes — ce qui est précisément le fait que l'exception vise : un
        // mandataire de petits lots ne pèse pas sur l'assemblée.
        for i in 0..4 {
            let petit_lot = Uuid::new_v4();
            unit_repo.lot(petit_lot, building_id, dec!(5));
            let result = use_cases
                .cast_vote(
                    resolution.id,
                    Uuid::new_v4(),
                    petit_lot,
                    VoteChoice::Pour,
                    Some(mandataire_id),
                    Some(VoteAuthMethod::Proxy),
                    mandataire_id,
                )
                .await;
            assert!(
                result.is_ok(),
                "Proxy vote {} (10% exception) should succeed, got: {:?}",
                i + 1,
                result.err()
            );
        }
    }

    // ------------------------------------------------------------------------
    // Story H10 (CL3) — Gate quorum sur le chemin VOTE (Art. 3.87 §5).
    // ------------------------------------------------------------------------

    /// @security — voter sur une AG sans quorum validé est rejeté (gate
    /// défense-en-profondeur sur `cast_vote`). On insère une résolution Pending
    /// directement (bypass `create_resolution`) avec une réunion SANS quorum.
    #[tokio::test]
    async fn security_cast_vote_rejected_without_quorum() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let meeting_id = Uuid::new_v4();
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            Uuid::new_v4(),
            Uuid::new_v4(),
            MeetingType::Ordinary,
            "AGO sans quorum".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        // PAS de validate_quorum → quorum_percentage = None.
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let mut resolution = Resolution::new(
            meeting_id,
            "R".to_string(),
            "D".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            // Rattachée au point 0, sans quoi elle ne peut pas être mise aux
            // voix (Art. 3.87 § 2 CC). Ces deux tests éprouvent le droit de
            // vote d'un lot, pas l'ordre du jour : leur donner un point valide
            // évite qu'ils échouent pour une autre raison que la leur.
            Some(0),
        )
        .unwrap();
        resolution.status = ResolutionStatus::Pending;
        resolution_repo.create(&resolution).await.unwrap();

        let owner_id = Uuid::new_v4();
        let err = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                Uuid::new_v4(),
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .unwrap_err();
        assert!(
            err.contains("Quorum"),
            "le vote sans quorum doit être rejeté, got: {}",
            err
        );
    }

    /// @negative — résolution dont la réunion n'existe plus (drift data) →
    /// vote rejeté proprement (pas de panic).
    #[tokio::test]
    async fn negative_cast_vote_meeting_not_found() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new()); // vide
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        );

        let mut resolution = Resolution::new(
            Uuid::new_v4(), // meeting_id absent du repo
            "R".to_string(),
            "D".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            // Rattachée au point 0 : Art. 3.87 § 2 CC interdit de mettre aux
            // voix une résolution hors ordre du jour. Ces tests éprouvent
            // autre chose, et doivent donc franchir cette garde.
            Some(0),
        )
        .unwrap();
        resolution.status = ResolutionStatus::Pending;
        resolution_repo.create(&resolution).await.unwrap();

        let owner_id = Uuid::new_v4();
        let err = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                Uuid::new_v4(),
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .unwrap_err();
        assert!(
            err.contains("Meeting not found"),
            "réunion absente → erreur typée, got: {}",
            err
        );
    }

    // ------------------------------------------------------------------------
    // Story H17 (CL3) — Gate droit de vote sur `cast_vote` (Art. 3.87 §1).
    // ------------------------------------------------------------------------

    /// Helper — réunion avec quorum validé + résolution Pending prête à voter.
    /// Une assemblée en quorum, avec sa résolution — et **les lots de son
    /// immeuble** (#850).
    ///
    /// Le dépôt de lots entre dans la signature parce que voter exige
    /// désormais un lot qui existe, rattaché à l'immeuble de l'assemblée. Le
    /// passer en paramètre plutôt que de laisser chaque test y penser évite
    /// qu'un scénario futur échoue sur « Lot introuvable » sans rapport avec
    /// ce qu'il éprouve.
    async fn meeting_with_quorum_and_resolution(
        resolution_repo: &Arc<MockResolutionRepository>,
        meeting_repo: &Arc<MockMeetingRepository>,
        unit_repo: &Arc<MockUnitRepository>,
    ) -> Resolution {
        let meeting_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        unit_repo.pose_defaut(building_id, dec!(100));
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            Uuid::new_v4(),
            building_id,
            MeetingType::Ordinary,
            "AGO".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Salle".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        // Un point d'ordre du jour, sans quoi aucune résolution ne peut être
        // mise aux voix : Art. 3.87 § 2 CC annule une décision portant sur un
        // point absent. Ces tests votaient jusqu'ici sur des résolutions
        // rattachées à rien — le cas exact que l'article annule.
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let mut resolution = Resolution::new(
            meeting_id,
            "R".to_string(),
            "D".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            // Rattachée au point 0 : Art. 3.87 § 2 CC interdit de mettre aux
            // voix une résolution hors ordre du jour. Ces tests éprouvent
            // autre chose, et doivent donc franchir cette garde.
            Some(0),
        )
        .unwrap();
        resolution.status = ResolutionStatus::Pending;
        resolution_repo.create(&resolution).await.unwrap();
        resolution
    }

    /// Story 4.2 — même montage que `meeting_with_quorum_and_resolution`,
    /// mais l'AG est tenue en mode `Remote` (Art. 3.87 §1er CC) : c'est cette
    /// modalité qui déclenche l'exigence d'authentification forte.
    async fn meeting_with_quorum_and_resolution_remote(
        resolution_repo: &Arc<MockResolutionRepository>,
        meeting_repo: &Arc<MockMeetingRepository>,
        unit_repo: &Arc<MockUnitRepository>,
    ) -> Resolution {
        let meeting_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        unit_repo.pose_defaut(building_id, dec!(100));
        let mut meeting = Meeting::new(
            Uuid::new_v4(), // acp_id
            Uuid::new_v4(),
            building_id,
            MeetingType::Ordinary,
            "AGO distancielle".to_string(),
            None,
            Utc::now() + chrono::Duration::days(30),
            "Visioconférence".to_string(),
        )
        .unwrap();
        meeting.id = meeting_id;
        meeting
            .set_mode(
                MeetingMode::Remote,
                Some("https://visio.example/ago".to_string()),
            )
            .unwrap();
        meeting
            .validate_quorum(
                rust_decimal_macros::dec!(600),
                rust_decimal_macros::dec!(1000),
            )
            .unwrap();
        meeting
            .add_agenda_item("Approbation des comptes".to_string())
            .unwrap();
        meeting_repo.create(&meeting).await.unwrap();

        let mut resolution = Resolution::new(
            meeting_id,
            "R".to_string(),
            "D".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            Some(0),
        )
        .unwrap();
        resolution.status = ResolutionStatus::Pending;
        resolution_repo.create(&resolution).await.unwrap();
        resolution
    }

    // ------------------------------------------------------------------------
    // Story 4.2 — `cast_vote` × `auth_method` (Art. 3.87 §1er, §4 CC, #48)
    // ------------------------------------------------------------------------

    /// @happy — un vote distant authentifié par itsme est enregistré avec
    /// `auth_method = itsme`.
    #[tokio::test]
    async fn happy_vote_distant_avec_itsme_est_enregistre() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution_remote(&resolution_repo, &meeting_repo, &unit_repo)
                .await;
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo,
        );

        let owner_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();
        let vote = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Itsme),
                owner_id,
            )
            .await
            .expect("un vote itsme sur une AG distancielle doit aboutir");

        assert_eq!(vote.auth_method, VoteAuthMethod::Itsme);
    }

    /// @edge — un vote distant par procuration en bonne et due forme est
    /// autorisé (Art. 3.87 §4) : la procuration elle-même reste régie par ses
    /// propres conditions (limite de trois mandats), pas par cette garde.
    #[tokio::test]
    async fn edge_vote_distant_par_procuration_est_autorise() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution_remote(&resolution_repo, &meeting_repo, &unit_repo)
                .await;
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo,
        );

        let mandant_id = Uuid::new_v4();
        let mandataire_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();
        let vote = use_cases
            .cast_vote(
                resolution.id,
                mandant_id,
                unit_id,
                VoteChoice::Pour,
                Some(mandataire_id),
                Some(VoteAuthMethod::Proxy),
                mandataire_id,
            )
            .await
            .expect("une procuration réelle doit être autorisée à distance");

        assert_eq!(vote.auth_method, VoteAuthMethod::Proxy);
    }

    /// @security — déclarer `presence` pour un vote distant est exactement la
    /// fraude que l'authentification forte doit rendre impossible (#48) :
    /// refusé en 403 typé `VOTE_AUTH_INSUFFICIENT`, pas silencieusement
    /// accepté.
    #[tokio::test]
    async fn security_vote_distant_avec_presence_est_refuse_403() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution_remote(&resolution_repo, &meeting_repo, &unit_repo)
                .await;
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo,
        );

        let owner_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .expect_err("presence ne doit pas suffire à distance");

        assert_eq!(
            erreur, "VOTE_AUTH_INSUFFICIENT:remote:presence",
            "le refus doit être typé, parsable par le handler : {erreur}"
        );
        let app_err: crate::application::error::AppError =
            crate::domain::entities::VoteAuthError::Insufficient {
                mode: MeetingMode::Remote,
                auth_method: VoteAuthMethod::Presence,
            }
            .into();
        assert_eq!(
            app_err.status_code(),
            actix_web::http::StatusCode::FORBIDDEN
        );
    }

    /// @negative — un vote sans `auth_method` est refusé en 422 typé
    /// `VOTE_AUTH_METHOD_REQUIRED`, quel que soit le mode de l'AG.
    #[tokio::test]
    async fn negative_vote_sans_auth_method_est_refuse_422() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo,
        );

        let owner_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                None,
                owner_id,
            )
            .await
            .expect_err("un vote sans auth_method ne peut pas être enregistré");

        assert_eq!(
            erreur, "VOTE_AUTH_METHOD_REQUIRED",
            "le refus doit être typé, parsable par le handler : {erreur}"
        );
        let app_err: crate::application::error::AppError =
            crate::domain::entities::VoteAuthError::Missing.into();
        assert_eq!(
            app_err.status_code(),
            actix_web::http::StatusCode::UNPROCESSABLE_ENTITY
        );
    }

    /// @security — une résolution hors ordre du jour ne peut pas être mise aux
    /// voix (Art. 3.87 § 2 CC).
    ///
    /// La validation existait à la création et ne s'appliquait qu'aux
    /// résolutions qui DÉCLARENT un point : `if let Some(index)` laissait
    /// passer `None`. Une résolution rattachée à rien était créée, votée et
    /// clôturée — le cas exact que l'article annule.
    ///
    /// Le refus est au VOTE et non à la création : l'article annule la
    /// décision, pas la proposition (#840, voie 2 sur 3).
    #[tokio::test]
    async fn security_vote_refuse_sur_resolution_hors_ordre_du_jour() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        // On détache la résolution de son point d'ordre du jour.
        let mut orpheline = resolution.clone();
        orpheline.agenda_item_index = None;
        resolution_repo.create(&orpheline).await.unwrap();

        let unit_id = Uuid::new_v4();
        let unit_owner_repo = Arc::new(MockUnitOwnerRepository::with_holders(
            unit_id,
            vec![LotHolder::new(OwnershipType::FullOwner, false)],
        ));
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            unit_owner_repo,
            // #850 — la quotité du lot se lit sur l'acte de base.
            Arc::new(MockUnitRepository::new()),
        );

        let owner_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                orpheline.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .expect_err("une résolution hors ordre du jour ne doit pas être votable");

        assert!(
            erreur.contains("ordre du jour") && erreur.contains("3.87"),
            "le refus doit citer l'ordre du jour et l'article : {erreur}"
        );
        assert!(
            erreur.contains("nulle"),
            "le refus doit dire POURQUOI — la décision serait nulle : {erreur}"
        );
    }

    /// @security — la garde a trois branches ; une seule était éprouvée.
    ///
    /// Un index qui désigne un point INEXISTANT est aussi grave qu'un index
    /// absent : la résolution prétend porter sur un point de l'ordre du jour,
    /// et ce point n'existe pas. Sans ce test, la branche serait du code que
    /// rien n'exécute, et qui pourrait être supprimé sans qu'un test bronche.
    #[tokio::test]
    async fn security_vote_refuse_sur_point_inexistant() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        // L'assemblée ne compte qu'un point (n° 0) : le n° 7 n'existe pas.
        let mut hors_bornes = resolution.clone();
        hors_bornes.agenda_item_index = Some(7);
        resolution_repo.create(&hors_bornes).await.unwrap();

        let unit_id = Uuid::new_v4();
        let unit_owner_repo = Arc::new(MockUnitOwnerRepository::with_holders(
            unit_id,
            vec![LotHolder::new(OwnershipType::FullOwner, false)],
        ));
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            unit_owner_repo,
            // #850 — la quotité du lot se lit sur l'acte de base.
            Arc::new(MockUnitRepository::new()),
        );

        let owner_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                hors_bornes.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .expect_err("un point d'ordre du jour inexistant ne doit pas être votable");

        assert!(
            erreur.contains("n'existe pas") && erreur.contains("3.87"),
            "le refus doit dire que le point n'existe pas, et citer l'article : {erreur}"
        );
    }

    /// @security — un point d'ordre du jour VIDE ne renseigne personne sur ce
    /// qui est mis aux voix. La convocation doit énoncer l'objet des décisions
    /// (Art. 3.87 § 2 CC) ; un intitulé blanc n'énonce rien.
    #[tokio::test]
    async fn security_vote_refuse_sur_point_dordre_du_jour_vide() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        // On blanchit l'intitulé du point 0, auquel la résolution est rattachée.
        let mut reunion = meeting_repo
            .find_by_id(resolution.meeting_id)
            .await
            .unwrap()
            .expect("l'assemblée du helper doit exister");
        reunion.agenda = vec!["   ".to_string()];
        meeting_repo.update(&reunion).await.unwrap();

        let unit_id = Uuid::new_v4();
        let unit_owner_repo = Arc::new(MockUnitOwnerRepository::with_holders(
            unit_id,
            vec![LotHolder::new(OwnershipType::FullOwner, false)],
        ));
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            unit_owner_repo,
            // #850 — la quotité du lot se lit sur l'acte de base.
            Arc::new(MockUnitRepository::new()),
        );

        let owner_id = Uuid::new_v4();
        let erreur = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .expect_err("un point vide ne doit pas être votable");

        assert!(
            erreur.contains("vide") && erreur.contains("3.87"),
            "le refus doit dire que le point est vide, et citer l'article : {erreur}"
        );
    }

    /// @security — un lot en indivision SANS représentant unique désigné a son
    /// droit de vote suspendu (Art. 3.87 §1) : `cast_vote` est rejeté avec
    /// `VOTING_RIGHT_SUSPENDED`, et le lot ne contribue donc pas au quorum.
    #[tokio::test]
    async fn security_cast_vote_rejected_when_voting_right_suspended() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        let unit_id = Uuid::new_v4();
        // Lot indivis (2 indivisaires), aucun représentant désigné → suspendu.
        let unit_owner_repo = Arc::new(MockUnitOwnerRepository::with_holders(
            unit_id,
            vec![
                LotHolder::new(OwnershipType::Indivisaire, false),
                LotHolder::new(OwnershipType::Indivisaire, false),
            ],
        ));
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            unit_owner_repo,
            // #850 — la quotité du lot se lit sur l'acte de base.
            Arc::new(MockUnitRepository::new()),
        );

        let owner_id = Uuid::new_v4();
        let err = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await
            .unwrap_err();
        assert!(
            err.contains("VOTING_RIGHT_SUSPENDED"),
            "lot suspendu → vote rejeté typé, got: {}",
            err
        );
    }

    /// @happy — un lot démembré AVEC représentant unique désigné peut voter :
    /// le gate H17 laisse passer (Art. 3.87 §1).
    #[tokio::test]
    async fn happy_cast_vote_allowed_with_designated_representative() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        let unit_id = Uuid::new_v4();
        // Usufruit + nue-propriété, l'usufruitier est le représentant → actif.
        let unit_owner_repo = Arc::new(MockUnitOwnerRepository::with_holders(
            unit_id,
            vec![
                LotHolder::new(OwnershipType::Usufruct, true),
                LotHolder::new(OwnershipType::BareOwner, false),
            ],
        ));
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo,
            meeting_repo,
            unit_owner_repo,
            // #850 — la quotité du lot se lit sur l'acte de base.
            unit_repo.clone(),
        );

        let owner_id = Uuid::new_v4();
        let result = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await;
        assert!(
            result.is_ok(),
            "lot avec représentant désigné doit pouvoir voter, got: {:?}",
            result.err()
        );
    }

    /// @negative — usurpation : l'appelant vote au nom d'un `owner_id` qui
    /// n'est pas le sien, sans se déclarer mandataire. Aujourd'hui (avant
    /// #850) c'était accepté : rien ne rapprochait cet identifiant de celui
    /// de l'appelant.
    #[tokio::test]
    async fn negative_voter_au_nom_dautrui_sans_procuration_est_refuse() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let victime_id = Uuid::new_v4();
        let attaquant_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();

        let resultat = use_cases
            .cast_vote(
                resolution.id,
                victime_id, // le vote prétend être émis par la victime…
                unit_id,
                VoteChoice::Pour,
                None, // … sans que l'attaquant se déclare son mandataire.
                Some(VoteAuthMethod::Presence),
                attaquant_id, // … alors que l'appelant réel est un tiers.
            )
            .await;

        assert!(
            resultat.is_err(),
            "voter au nom d'autrui sans procuration doit être refusé"
        );
        let erreur = resultat.unwrap_err();
        assert!(
            erreur.contains("FORBIDDEN"),
            "le refus doit être typé (403), pas une chaîne quelconque : {erreur}"
        );

        // Aucun vote ne doit avoir été enregistré : le refus est total, pas
        // une simple erreur cosmétique sur un enregistrement déjà fait.
        assert!(
            !vote_repo
                .has_voted(resolution.id, unit_id)
                .await
                .expect("lecture du dépôt"),
            "aucun vote ne doit être enregistré après un refus d'usurpation"
        );
    }

    /// @negative — se déclarer mandataire de quelqu'un d'autre que soi-même
    /// n'a pas de sens et doit être refusé, pas silencieusement corrigé.
    #[tokio::test]
    async fn negative_se_declarer_mandataire_dun_tiers_est_refuse() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;
        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            Arc::new(MockUnitOwnerRepository::new()),
            unit_repo.clone(),
        );

        let owner_id = Uuid::new_v4();
        let appelant_id = Uuid::new_v4();
        let quelquun_dautre = Uuid::new_v4();

        let resultat = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                Uuid::new_v4(),
                VoteChoice::Pour,
                Some(quelquun_dautre), // déclare un mandataire qui n'est pas l'appelant
                Some(VoteAuthMethod::Presence),
                appelant_id,
            )
            .await;

        assert!(
            resultat.is_err(),
            "une procuration déclarée pour un tiers doit être refusée"
        );
        assert!(resultat.unwrap_err().contains("FORBIDDEN"));
    }

    /// @negative — le lot n'appartient pas à `owner_id` : même en votant
    /// « pour soi-même » (`owner_id == caller_owner_id`), si le dépôt ne
    /// rattache pas ce copropriétaire au lot, le vote est refusé.
    #[tokio::test]
    async fn negative_voter_pour_un_lot_quon_ne_detient_pas_est_refuse() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let vote_repo = Arc::new(MockVoteRepository::new());
        let meeting_repo = Arc::new(MockMeetingRepository::new());
        let unit_repo = Arc::new(MockUnitRepository::new());
        let resolution =
            meeting_with_quorum_and_resolution(&resolution_repo, &meeting_repo, &unit_repo).await;

        let owner_id = Uuid::new_v4();
        let unit_id = Uuid::new_v4();
        let unit_owner_repo = Arc::new(MockUnitOwnerRepository::new());
        unit_owner_repo.refuse_detention(unit_id, owner_id);

        let use_cases = ResolutionUseCases::new(
            resolution_repo.clone(),
            vote_repo.clone(),
            meeting_repo.clone(),
            unit_owner_repo,
            unit_repo.clone(),
        );

        let resultat = use_cases
            .cast_vote(
                resolution.id,
                owner_id,
                unit_id,
                VoteChoice::Pour,
                None,
                Some(VoteAuthMethod::Presence),
                owner_id,
            )
            .await;

        assert!(
            resultat.is_err(),
            "voter pour un lot qu'on ne détient pas doit être refusé"
        );
        let erreur = resultat.unwrap_err();
        assert!(
            erreur.contains("FORBIDDEN") && erreur.contains("ne détient pas"),
            "le refus doit dire POURQUOI, got: {erreur}"
        );
    }

    // ------------------------------------------------------------------------
    // Story 4.6 — ResolutionAutoNotRemovable guard (#581)
    // ------------------------------------------------------------------------

    fn build_use_cases_pour_resolution(
        resolution_repo: Arc<MockResolutionRepository>,
        vote_repo: Arc<MockVoteRepository>,
        meeting_repo: Arc<MockMeetingRepository>,
    ) -> ResolutionUseCases {
        ResolutionUseCases::new(
            resolution_repo,
            vote_repo,
            meeting_repo,
            Arc::new(MockUnitOwnerRepository::new()),
            Arc::new(MockUnitRepository::new()),
        )
    }

    /// @security — le syndic tente de supprimer la résolution d'évaluation
    /// des prestataires générée d'office : refus typé 403
    /// (`ResolutionAutoNotRemovable`), jamais un 400 générique. C'est le
    /// cœur de la story : le point évalue le syndic, il ne peut pas le
    /// retirer lui-même de l'ordre du jour.
    #[tokio::test]
    async fn security_delete_resolution_auto_generated_refuse() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let auto = Resolution::new_evaluation_contractors_auto(Uuid::new_v4());
        resolution_repo.create(&auto).await.unwrap();
        let use_cases = build_use_cases_pour_resolution(
            resolution_repo,
            Arc::new(MockVoteRepository::new()),
            Arc::new(MockMeetingRepository::new()),
        );

        let result = use_cases.delete_resolution(auto.id).await;

        assert!(matches!(result, Err(AppError::ResolutionAutoNotRemovable)));
    }

    /// @negative — modifier le texte d'une résolution auto-générée est
    /// refusé même si son statut est `Pending`, le cas normalement
    /// modifiable : l'immutabilité de Story 4.6 ne dépend pas du statut.
    #[tokio::test]
    async fn negative_update_resolution_auto_generated_refuse() {
        let use_cases = build_use_cases_pour_resolution(
            Arc::new(MockResolutionRepository::new()),
            Arc::new(MockVoteRepository::new()),
            Arc::new(MockMeetingRepository::new()),
        );
        let mut auto = Resolution::new_evaluation_contractors_auto(Uuid::new_v4());
        auto.description = "Texte modifié par le syndic".to_string();

        let result = use_cases.update_resolution(&auto).await;

        assert!(matches!(result, Err(AppError::ResolutionAutoNotRemovable)));
    }

    /// @happy — une résolution standard, sans vote, reste supprimable comme
    /// avant Story 4.6 : la nouvelle garde ne touche pas au cas nominal.
    #[tokio::test]
    async fn happy_delete_resolution_standard_sans_votes_reussit() {
        let resolution_repo = Arc::new(MockResolutionRepository::new());
        let standard = Resolution::new(
            Uuid::new_v4(),
            "Titre".to_string(),
            "Description".to_string(),
            ResolutionType::Ordinary,
            MajorityType::Absolute,
            None,
        )
        .unwrap();
        resolution_repo.create(&standard).await.unwrap();
        let use_cases = build_use_cases_pour_resolution(
            resolution_repo,
            Arc::new(MockVoteRepository::new()),
            Arc::new(MockMeetingRepository::new()),
        );

        let result = use_cases.delete_resolution(standard.id).await;

        assert!(result.unwrap());
    }

    /// @edge — supprimer une résolution introuvable rend un 404 typé, pas un
    /// panic ni un 400 générique.
    #[tokio::test]
    async fn edge_delete_resolution_introuvable_rend_404() {
        let use_cases = build_use_cases_pour_resolution(
            Arc::new(MockResolutionRepository::new()),
            Arc::new(MockVoteRepository::new()),
            Arc::new(MockMeetingRepository::new()),
        );

        let result = use_cases.delete_resolution(Uuid::new_v4()).await;

        assert!(matches!(result, Err(AppError::NotFound(_))));
    }
}