koprogo_api/application/use_cases/

resource_booking_use_cases.rs

use crate::application::dto::{
    BookingStatisticsDto, CreateResourceBookingDto, ResourceBookingResponseDto,
    UpdateResourceBookingDto,
};
use crate::application::ports::{OwnerRepository, ResourceBookingRepository};
use crate::domain::entities::{BookingStatus, ResourceBooking, ResourceType};
use chrono::Utc;
use std::sync::Arc;
use uuid::Uuid;

/// Use cases for resource booking operations
///
/// Orchestrates business logic for community space bookings with conflict detection,
/// owner name enrichment, and authorization checks.
pub struct ResourceBookingUseCases {
    booking_repo: Arc<dyn ResourceBookingRepository>,
    owner_repo: Arc<dyn OwnerRepository>,
}

impl ResourceBookingUseCases {
    pub fn new(
        booking_repo: Arc<dyn ResourceBookingRepository>,
        owner_repo: Arc<dyn OwnerRepository>,
    ) -> Self {
        Self {
            booking_repo,
            owner_repo,
        }
    }

    /// Resolve user_id to owner via organization lookup
    async fn resolve_owner(
        &self,
        user_id: Uuid,
        organization_id: Uuid,
    ) -> Result<crate::domain::entities::Owner, String> {
        self.owner_repo
            .find_by_user_id_and_organization(user_id, organization_id)
            .await?
            // Refus LÉGITIME, message illisible.
            //
            // Le partage d'objets, l'offre de compétence et la réservation
            // engagent une personne nommée : ils supposent donc une fiche de
            // copropriétaire. Un syndic n'en a pas, et c'est normal.
            //
            // Ce qui ne l'était pas, c'est le message. « Owner not found for
            // this user in the organization » est en anglais, technique, et ne
            // dit pas à l'utilisateur ce qu'il devrait faire. En recette le
            // 2026-09-06 (RN-11), il a été lu comme une panne bloquant quatre
            // modules, alors que la création d'ANNONCE par un syndic fonctionne
            // — parce qu'un avis, lui, émane de la copropriété.
            //
            // Le syndic agissant pour le compte de l'ACP (AG, prestataires)
            // ne passe pas par ce chemin : voir `dto.on_behalf_of_acp` et
            // `create_booking_on_behalf_of_acp()` (story #588).
            .ok_or_else(|| crate::application::error::REFUS_RESERVE_AUX_COPROPRIETAIRES.to_string())
    }

    /// Create a new resource booking with conflict detection
    ///
    /// # Steps
    /// 1. Create booking entity (validates business rules)
    /// 2. Check for conflicts (overlapping bookings for same resource)
    /// 3. Persist booking
    /// 4. Enrich response with owner name
    ///
    /// # Authorization
    /// - Any authenticated owner can create bookings for themselves.
    /// - Story #588 (INV-5/FR27) — `dto.on_behalf_of_acp = true` books on
    ///   behalf of the ACP (AG, prestataires) instead of personally. Reserved
    ///   to `is_syndic` callers (403 otherwise) and requires `dto.motif`
    ///   (422 otherwise, via `ReservationOnBehalfError`). A syndic without an
    ///   owner profile who omits `on_behalf_of_acp` still hits the ordinary
    ///   `resolve_owner()` refusal below (INV-5 "no personal participation").
    pub async fn create_booking(
        &self,
        user_id: Uuid,
        organization_id: Uuid,
        is_syndic: bool,
        dto: CreateResourceBookingDto,
    ) -> Result<ResourceBookingResponseDto, String> {
        if dto.on_behalf_of_acp {
            return self
                .create_booking_on_behalf_of_acp(user_id, is_syndic, dto)
                .await;
        }

        let owner = self.resolve_owner(user_id, organization_id).await?;
        let booked_by = owner.id;
        // Create booking entity (validates business rules in constructor)
        let booking = ResourceBooking::new(
            dto.building_id,
            dto.resource_type.clone(),
            dto.resource_name.clone(),
            booked_by,
            dto.start_time,
            dto.end_time,
            dto.notes.clone(),
            dto.recurring_pattern.clone(),
            dto.recurrence_end_date,
            dto.max_duration_hours,
            dto.max_advance_days,
        )?;

        // Check for conflicts (overlapping bookings for same resource)
        let conflicts = self
            .booking_repo
            .find_conflicts(
                dto.building_id,
                dto.resource_type,
                &dto.resource_name,
                dto.start_time,
                dto.end_time,
                None, // No exclusion for new bookings
            )
            .await?;

        if !conflicts.is_empty() {
            return Err(format!(
                "Booking conflicts with {} existing booking(s) for this resource",
                conflicts.len()
            ));
        }

        // Persist booking
        let created = self.booking_repo.create(&booking).await?;

        // Enrich with owner name
        self.enrich_booking_response(created).await
    }

    /// Story #588 (INV-5/FR27) — réservation syndic "pour le compte de l'ACP".
    ///
    /// Séparée de `create_booking()` pour ne pas mêler deux légitimités
    /// différentes : celle d'un copropriétaire (fiche `Owner`) et celle d'un
    /// syndic agissant ès qualités (pas de fiche `Owner`, motif obligatoire).
    async fn create_booking_on_behalf_of_acp(
        &self,
        user_id: Uuid,
        is_syndic: bool,
        dto: CreateResourceBookingDto,
    ) -> Result<ResourceBookingResponseDto, String> {
        if !is_syndic {
            return Err(crate::application::error::REFUS_ON_BEHALF_RESERVE_AUX_SYNDICS.to_string());
        }

        let motif = dto.motif.clone().unwrap_or_default();
        let booking = ResourceBooking::new_on_behalf_of_acp(
            dto.building_id,
            dto.resource_type.clone(),
            dto.resource_name.clone(),
            user_id,
            motif,
            dto.start_time,
            dto.end_time,
            dto.notes.clone(),
            dto.recurring_pattern.clone(),
            dto.recurrence_end_date,
            dto.max_duration_hours,
            dto.max_advance_days,
        )?;

        let conflicts = self
            .booking_repo
            .find_conflicts(
                dto.building_id,
                dto.resource_type,
                &dto.resource_name,
                dto.start_time,
                dto.end_time,
                None,
            )
            .await?;

        if !conflicts.is_empty() {
            return Err(format!(
                "Booking conflicts with {} existing booking(s) for this resource",
                conflicts.len()
            ));
        }

        let created = self.booking_repo.create(&booking).await?;

        // AC @happy — "log spécifique" : distingue à l'audit une réservation
        // pour le compte de l'ACP d'une réservation personnelle, sans devoir
        // rouvrir la base pour le savoir.
        log::info!(
            "reservation_on_behalf_acp: syndic_user_id={} building_id={} resource=\"{}\" motif=\"{}\"",
            user_id,
            dto.building_id,
            dto.resource_name,
            created.motif.clone().unwrap_or_default(),
        );

        self.enrich_booking_response(created).await
    }

    /// Get booking by ID with owner name enrichment
    pub async fn get_booking(
        &self,
        booking_id: Uuid,
    ) -> Result<ResourceBookingResponseDto, String> {
        let booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        self.enrich_booking_response(booking).await
    }

    /// List all bookings for a building
    pub async fn list_building_bookings(
        &self,
        building_id: Uuid,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self.booking_repo.find_by_building(building_id).await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List bookings by building and resource type
    pub async fn list_by_resource_type(
        &self,
        building_id: Uuid,
        resource_type: ResourceType,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self
            .booking_repo
            .find_by_building_and_resource_type(building_id, resource_type)
            .await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List bookings for a specific resource (building + type + name)
    pub async fn list_by_resource(
        &self,
        building_id: Uuid,
        resource_type: ResourceType,
        resource_name: String,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self
            .booking_repo
            .find_by_resource(building_id, resource_type, &resource_name)
            .await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List bookings by user (owner who made the booking)
    pub async fn list_user_bookings(
        &self,
        user_id: Uuid,
        organization_id: Uuid,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let owner = self.resolve_owner(user_id, organization_id).await?;
        let bookings = self.booking_repo.find_by_user(owner.id).await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List bookings by user and status
    pub async fn list_user_bookings_by_status(
        &self,
        user_id: Uuid,
        organization_id: Uuid,
        status: BookingStatus,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let owner = self.resolve_owner(user_id, organization_id).await?;
        let bookings = self
            .booking_repo
            .find_by_user_and_status(owner.id, status)
            .await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List bookings by building and status
    pub async fn list_building_bookings_by_status(
        &self,
        building_id: Uuid,
        status: BookingStatus,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self
            .booking_repo
            .find_by_building_and_status(building_id, status)
            .await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List upcoming bookings (future, confirmed or pending)
    pub async fn list_upcoming_bookings(
        &self,
        building_id: Uuid,
        limit: Option<i64>,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self.booking_repo.find_upcoming(building_id, limit).await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List active bookings (currently in progress)
    pub async fn list_active_bookings(
        &self,
        building_id: Uuid,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self.booking_repo.find_active(building_id).await?;
        self.enrich_bookings_response(bookings).await
    }

    /// List past bookings
    pub async fn list_past_bookings(
        &self,
        building_id: Uuid,
        limit: Option<i64>,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let bookings = self.booking_repo.find_past(building_id, limit).await?;
        self.enrich_bookings_response(bookings).await
    }

    /// Update booking details (resource_name, notes)
    ///
    /// Time changes require cancellation and rebooking to ensure conflict detection.
    ///
    /// # Authorization
    /// - Only booking owner can update their booking
    pub async fn update_booking(
        &self,
        booking_id: Uuid,
        user_id: Uuid,
        organization_id: Uuid,
        dto: UpdateResourceBookingDto,
    ) -> Result<ResourceBookingResponseDto, String> {
        let owner = self.resolve_owner(user_id, organization_id).await?;
        let mut booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        // Authorization: Only booking owner can update
        if booking.booked_by != Some(owner.id) {
            return Err("Only the booking owner can update this booking".to_string());
        }

        // Update details (validates business rules)
        booking.update_details(dto.resource_name, dto.notes)?;

        // Persist changes
        let updated = self.booking_repo.update(&booking).await?;

        // Enrich with owner name
        self.enrich_booking_response(updated).await
    }

    /// Cancel a booking
    ///
    /// # Authorization
    /// - Only booking owner can cancel their booking
    pub async fn cancel_booking(
        &self,
        booking_id: Uuid,
        user_id: Uuid,
        organization_id: Uuid,
    ) -> Result<ResourceBookingResponseDto, String> {
        let owner = self.resolve_owner(user_id, organization_id).await?;
        let mut booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        // Cancel booking (validates authorization and state)
        booking.cancel(owner.id)?;

        // Persist changes
        let updated = self.booking_repo.update(&booking).await?;

        // Enrich with owner name
        self.enrich_booking_response(updated).await
    }

    /// Complete a booking (typically auto-called after end_time)
    ///
    /// # Authorization
    /// - Admin only (for manual completion)
    pub async fn complete_booking(
        &self,
        booking_id: Uuid,
    ) -> Result<ResourceBookingResponseDto, String> {
        let mut booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        // Complete booking (validates state)
        booking.complete()?;

        // Persist changes
        let updated = self.booking_repo.update(&booking).await?;

        // Enrich with owner name
        self.enrich_booking_response(updated).await
    }

    /// Mark booking as no-show
    ///
    /// # Authorization
    /// - Admin only
    pub async fn mark_no_show(
        &self,
        booking_id: Uuid,
    ) -> Result<ResourceBookingResponseDto, String> {
        let mut booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        // Mark as no-show (validates state)
        booking.mark_no_show()?;

        // Persist changes
        let updated = self.booking_repo.update(&booking).await?;

        // Enrich with owner name
        self.enrich_booking_response(updated).await
    }

    /// Confirm a pending booking
    ///
    /// # Authorization
    /// - Admin only (for approval workflow)
    pub async fn confirm_booking(
        &self,
        booking_id: Uuid,
    ) -> Result<ResourceBookingResponseDto, String> {
        let mut booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        // Confirm booking (validates state)
        booking.confirm()?;

        // Persist changes
        let updated = self.booking_repo.update(&booking).await?;

        // Enrich with owner name
        self.enrich_booking_response(updated).await
    }

    /// Delete a booking
    ///
    /// # Authorization
    /// - Only booking owner can delete their booking
    /// - Or admin for any booking
    pub async fn delete_booking(
        &self,
        booking_id: Uuid,
        user_id: Uuid,
        organization_id: Uuid,
    ) -> Result<(), String> {
        let owner = self.resolve_owner(user_id, organization_id).await?;
        let booking = self
            .booking_repo
            .find_by_id(booking_id)
            .await?
            .ok_or("Booking not found".to_string())?;

        // Authorization: Only booking owner can delete
        if booking.booked_by != Some(owner.id) {
            return Err("Only the booking owner can delete this booking".to_string());
        }

        self.booking_repo.delete(booking_id).await
    }

    /// Check for booking conflicts
    ///
    /// Useful for frontend to preview conflicts before creating booking.
    ///
    /// Returns list of conflicting bookings with owner names.
    pub async fn check_conflicts(
        &self,
        building_id: Uuid,
        resource_type: ResourceType,
        resource_name: String,
        start_time: chrono::DateTime<Utc>,
        end_time: chrono::DateTime<Utc>,
        exclude_booking_id: Option<Uuid>,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let conflicts = self
            .booking_repo
            .find_conflicts(
                building_id,
                resource_type,
                &resource_name,
                start_time,
                end_time,
                exclude_booking_id,
            )
            .await?;

        self.enrich_bookings_response(conflicts).await
    }

    /// Get booking statistics for a building
    pub async fn get_statistics(&self, building_id: Uuid) -> Result<BookingStatisticsDto, String> {
        self.booking_repo.get_statistics(building_id).await
    }

    /// Helper: Enrich single booking with owner name
    ///
    /// Story #588 — une réservation `on_behalf_of_acp` n'a pas d'owner (le
    /// syndic n'en a structurellement pas) : elle est étiquetée par un
    /// libellé fixe plutôt que par une recherche d'owner qui échouerait
    /// toujours.
    async fn enrich_booking_response(
        &self,
        booking: ResourceBooking,
    ) -> Result<ResourceBookingResponseDto, String> {
        let booked_by_name = if booking.on_behalf_of_acp {
            "Syndic — pour le compte de l'ACP".to_string()
        } else {
            let owner_id = booking
                .booked_by
                .ok_or("Booking has neither an owner nor on_behalf_of_acp".to_string())?;
            let owner = self
                .owner_repo
                .find_by_id(owner_id)
                .await?
                .ok_or("Booking owner not found".to_string())?;
            format!("{} {}", owner.first_name, owner.last_name)
        };

        Ok(ResourceBookingResponseDto::from_entity(
            booking,
            booked_by_name,
        ))
    }

    /// Helper: Enrich multiple bookings with owner names
    async fn enrich_bookings_response(
        &self,
        bookings: Vec<ResourceBooking>,
    ) -> Result<Vec<ResourceBookingResponseDto>, String> {
        let mut result = Vec::with_capacity(bookings.len());

        for booking in bookings {
            let enriched = self.enrich_booking_response(booking).await?;
            result.push(enriched);
        }

        Ok(result)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::application::dto::{BookingStatisticsDto, OwnerFilters, PageRequest};
    use crate::application::ports::{OwnerRepository, ResourceBookingRepository};
    use crate::domain::entities::{
        BookingStatus, Owner, RecurringPattern, ResourceBooking, ResourceType,
    };
    use async_trait::async_trait;
    use chrono::{DateTime, Duration, Utc};
    use std::collections::HashMap;
    use std::sync::{Arc, Mutex};
    use uuid::Uuid;

    // ── Mock ResourceBookingRepository ──────────────────────────────────────
    struct MockBookingRepo {
        bookings: Mutex<HashMap<Uuid, ResourceBooking>>,
    }

    impl MockBookingRepo {
        fn new() -> Self {
            Self {
                bookings: Mutex::new(HashMap::new()),
            }
        }
    }

    #[async_trait]
    impl ResourceBookingRepository for MockBookingRepo {
        async fn create(&self, booking: &ResourceBooking) -> Result<ResourceBooking, String> {
            let mut map = self.bookings.lock().unwrap();
            map.insert(booking.id, booking.clone());
            Ok(booking.clone())
        }

        async fn find_by_id(&self, id: Uuid) -> Result<Option<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map.get(&id).cloned())
        }

        async fn find_by_building(
            &self,
            building_id: Uuid,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.building_id == building_id)
                .cloned()
                .collect())
        }

        async fn find_by_building_and_resource_type(
            &self,
            building_id: Uuid,
            resource_type: ResourceType,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.building_id == building_id && b.resource_type == resource_type)
                .cloned()
                .collect())
        }

        async fn find_by_resource(
            &self,
            building_id: Uuid,
            resource_type: ResourceType,
            resource_name: &str,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| {
                    b.building_id == building_id
                        && b.resource_type == resource_type
                        && b.resource_name == resource_name
                })
                .cloned()
                .collect())
        }

        async fn find_by_user(&self, user_id: Uuid) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.booked_by == Some(user_id))
                .cloned()
                .collect())
        }

        async fn find_by_user_and_status(
            &self,
            user_id: Uuid,
            status: BookingStatus,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.booked_by == Some(user_id) && b.status == status)
                .cloned()
                .collect())
        }

        async fn find_by_building_and_status(
            &self,
            building_id: Uuid,
            status: BookingStatus,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.building_id == building_id && b.status == status)
                .cloned()
                .collect())
        }

        async fn find_upcoming(
            &self,
            building_id: Uuid,
            _limit: Option<i64>,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            let now = Utc::now();
            Ok(map
                .values()
                .filter(|b| {
                    b.building_id == building_id
                        && b.start_time > now
                        && matches!(b.status, BookingStatus::Pending | BookingStatus::Confirmed)
                })
                .cloned()
                .collect())
        }

        async fn find_active(&self, building_id: Uuid) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            let now = Utc::now();
            Ok(map
                .values()
                .filter(|b| {
                    b.building_id == building_id
                        && b.status == BookingStatus::Confirmed
                        && now >= b.start_time
                        && now < b.end_time
                })
                .cloned()
                .collect())
        }

        async fn find_past(
            &self,
            building_id: Uuid,
            _limit: Option<i64>,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            let now = Utc::now();
            Ok(map
                .values()
                .filter(|b| b.building_id == building_id && b.end_time < now)
                .cloned()
                .collect())
        }

        async fn find_conflicts(
            &self,
            building_id: Uuid,
            resource_type: ResourceType,
            resource_name: &str,
            start_time: DateTime<Utc>,
            end_time: DateTime<Utc>,
            exclude_booking_id: Option<Uuid>,
        ) -> Result<Vec<ResourceBooking>, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| {
                    b.building_id == building_id
                        && b.resource_type == resource_type
                        && b.resource_name == resource_name
                        && matches!(b.status, BookingStatus::Pending | BookingStatus::Confirmed)
                        && b.start_time < end_time
                        && start_time < b.end_time
                        && exclude_booking_id.is_none_or(|id| b.id != id)
                })
                .cloned()
                .collect())
        }

        async fn update(&self, booking: &ResourceBooking) -> Result<ResourceBooking, String> {
            let mut map = self.bookings.lock().unwrap();
            map.insert(booking.id, booking.clone());
            Ok(booking.clone())
        }

        async fn delete(&self, id: Uuid) -> Result<(), String> {
            let mut map = self.bookings.lock().unwrap();
            map.remove(&id);
            Ok(())
        }

        async fn count_by_building(&self, building_id: Uuid) -> Result<i64, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.building_id == building_id)
                .count() as i64)
        }

        async fn count_by_building_and_status(
            &self,
            building_id: Uuid,
            status: BookingStatus,
        ) -> Result<i64, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| b.building_id == building_id && b.status == status)
                .count() as i64)
        }

        async fn count_by_resource(
            &self,
            building_id: Uuid,
            resource_type: ResourceType,
            resource_name: &str,
        ) -> Result<i64, String> {
            let map = self.bookings.lock().unwrap();
            Ok(map
                .values()
                .filter(|b| {
                    b.building_id == building_id
                        && b.resource_type == resource_type
                        && b.resource_name == resource_name
                })
                .count() as i64)
        }

        async fn get_statistics(&self, building_id: Uuid) -> Result<BookingStatisticsDto, String> {
            Ok(BookingStatisticsDto {
                building_id,
                total_bookings: 0,
                confirmed_bookings: 0,
                pending_bookings: 0,
                cancelled_bookings: 0,
                completed_bookings: 0,
                no_show_bookings: 0,
                active_bookings: 0,
                upcoming_bookings: 0,
                total_hours_booked: 0.0,
                most_popular_resource: None,
            })
        }
    }

    // ── Mock OwnerRepository ────────────────────────────────────────────────
    struct MockOwnerRepo {
        owners: Mutex<HashMap<Uuid, Owner>>,
    }

    impl MockOwnerRepo {
        fn new() -> Self {
            Self {
                owners: Mutex::new(HashMap::new()),
            }
        }

        fn add_owner(&self, owner: Owner) {
            let mut map = self.owners.lock().unwrap();
            map.insert(owner.id, owner);
        }
    }

    #[async_trait]
    impl OwnerRepository for MockOwnerRepo {
        async fn create(&self, owner: &Owner) -> Result<Owner, String> {
            let mut map = self.owners.lock().unwrap();
            map.insert(owner.id, owner.clone());
            Ok(owner.clone())
        }

        async fn find_by_id(&self, id: Uuid) -> Result<Option<Owner>, String> {
            let map = self.owners.lock().unwrap();
            Ok(map.get(&id).cloned())
        }

        async fn find_by_user_id(&self, user_id: Uuid) -> Result<Option<Owner>, String> {
            let map = self.owners.lock().unwrap();
            Ok(map.values().find(|o| o.user_id == Some(user_id)).cloned())
        }

        async fn find_by_user_id_and_organization(
            &self,
            user_id: Uuid,
            organization_id: Uuid,
        ) -> Result<Option<Owner>, String> {
            let map = self.owners.lock().unwrap();
            Ok(map
                .values()
                .find(|o| o.user_id == Some(user_id) && o.organization_id == organization_id)
                .cloned())
        }

        async fn find_by_email(&self, email: &str) -> Result<Option<Owner>, String> {
            let map = self.owners.lock().unwrap();
            Ok(map.values().find(|o| o.email == email).cloned())
        }

        async fn find_all(&self) -> Result<Vec<Owner>, String> {
            let map = self.owners.lock().unwrap();
            Ok(map.values().cloned().collect())
        }

        async fn find_all_paginated(
            &self,
            _page_request: &PageRequest,
            _filters: &OwnerFilters,
        ) -> Result<(Vec<Owner>, i64), String> {
            let map = self.owners.lock().unwrap();
            let all: Vec<_> = map.values().cloned().collect();
            let count = all.len() as i64;
            Ok((all, count))
        }

        async fn update(&self, owner: &Owner) -> Result<Owner, String> {
            let mut map = self.owners.lock().unwrap();
            map.insert(owner.id, owner.clone());
            Ok(owner.clone())
        }

        async fn delete(&self, id: Uuid) -> Result<bool, String> {
            let mut map = self.owners.lock().unwrap();
            Ok(map.remove(&id).is_some())
        }

        async fn set_user_link(
            &self,
            owner_id: Uuid,
            user_id: Option<Uuid>,
        ) -> Result<bool, String> {
            let mut map = self.owners.lock().unwrap();
            if let Some(o) = map.get_mut(&owner_id) {
                o.user_id = user_id;
                Ok(true)
            } else {
                Ok(false)
            }
        }
    }

    // ── Helpers ─────────────────────────────────────────────────────────────
    fn create_test_owner(user_id: Uuid, organization_id: Uuid) -> Owner {
        let mut owner = Owner::new(
            organization_id,
            "Jean".to_string(),
            "Dupont".to_string(),
            "jean@test.com".to_string(),
            None,
            "Rue Test 1".to_string(),
            "Brussels".to_string(),
            "1000".to_string(),
            "Belgium".to_string(),
        )
        .unwrap();
        owner.user_id = Some(user_id);
        owner
    }

    fn setup_use_cases() -> (
        ResourceBookingUseCases,
        Uuid,
        Uuid,
        Uuid,
        Arc<MockBookingRepo>,
    ) {
        let user_id = Uuid::new_v4();
        let organization_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();

        let booking_repo = Arc::new(MockBookingRepo::new());
        let owner_repo = Arc::new(MockOwnerRepo::new());

        let owner = create_test_owner(user_id, organization_id);
        owner_repo.add_owner(owner);

        let use_cases = ResourceBookingUseCases::new(
            booking_repo.clone() as Arc<dyn ResourceBookingRepository>,
            owner_repo as Arc<dyn OwnerRepository>,
        );

        (
            use_cases,
            user_id,
            organization_id,
            building_id,
            booking_repo,
        )
    }

    fn make_create_dto(building_id: Uuid) -> CreateResourceBookingDto {
        let start_time = Utc::now() + Duration::hours(2);
        let end_time = start_time + Duration::hours(2);
        CreateResourceBookingDto {
            building_id,
            resource_type: ResourceType::MeetingRoom,
            resource_name: "Meeting Room A".to_string(),
            start_time,
            end_time,
            notes: Some("Team standup".to_string()),
            recurring_pattern: RecurringPattern::None,
            recurrence_end_date: None,
            max_duration_hours: None,
            max_advance_days: None,
            on_behalf_of_acp: false,
            motif: None,
        }
    }

    // ── Tests ───────────────────────────────────────────────────────────────

    #[tokio::test]
    async fn test_create_booking_success() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_create_dto(building_id);

        let result = use_cases.create_booking(user_id, org_id, false, dto).await;
        assert!(result.is_ok());
        let response = result.unwrap();
        assert_eq!(response.building_id, building_id);
        assert_eq!(response.resource_name, "Meeting Room A");
        assert_eq!(response.booked_by_name, "Jean Dupont");
    }

    #[tokio::test]
    async fn test_create_booking_conflict_detected() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_create_dto(building_id);

        // First booking succeeds
        use_cases
            .create_booking(user_id, org_id, false, dto.clone())
            .await
            .unwrap();

        // Second booking for same resource and time range should fail
        let result = use_cases.create_booking(user_id, org_id, false, dto).await;
        assert!(result.is_err());
        assert!(result.unwrap_err().contains("conflicts with"));
    }

    #[tokio::test]
    async fn test_get_booking_success() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_create_dto(building_id);

        let created = use_cases
            .create_booking(user_id, org_id, false, dto)
            .await
            .unwrap();

        let result = use_cases.get_booking(created.id).await;
        assert!(result.is_ok());
        assert_eq!(result.unwrap().id, created.id);
    }

    #[tokio::test]
    async fn test_get_booking_not_found() {
        let (use_cases, _, _, _, _) = setup_use_cases();
        let result = use_cases.get_booking(Uuid::new_v4()).await;
        assert!(result.is_err());
        assert_eq!(result.unwrap_err(), "Booking not found");
    }

    #[tokio::test]
    async fn test_cancel_booking_success() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_create_dto(building_id);

        let created = use_cases
            .create_booking(user_id, org_id, false, dto)
            .await
            .unwrap();

        let result = use_cases.cancel_booking(created.id, user_id, org_id).await;
        assert!(result.is_ok());
        let cancelled = result.unwrap();
        assert_eq!(cancelled.status, BookingStatus::Cancelled);
    }

    #[tokio::test]
    async fn test_cancel_booking_wrong_user() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_create_dto(building_id);

        let created = use_cases
            .create_booking(user_id, org_id, false, dto)
            .await
            .unwrap();

        // Try cancelling with a different user who is not registered as owner
        let other_user = Uuid::new_v4();
        let result = use_cases
            .cancel_booking(created.id, other_user, org_id)
            .await;
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err(),
            crate::application::error::REFUS_RESERVE_AUX_COPROPRIETAIRES,
            "le refus doit être celui, nommé, opposé à qui n'est pas copropriétaire"
        );
    }

    #[tokio::test]
    async fn test_delete_booking_success() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_create_dto(building_id);

        let created = use_cases
            .create_booking(user_id, org_id, false, dto)
            .await
            .unwrap();

        let result = use_cases.delete_booking(created.id, user_id, org_id).await;
        assert!(result.is_ok());

        // Confirm it's gone
        let fetch = use_cases.get_booking(created.id).await;
        assert!(fetch.is_err());
    }

    #[tokio::test]
    async fn test_confirm_booking_success() {
        let (use_cases, user_id, org_id, building_id, _booking_repo) = setup_use_cases();
        let dto = make_create_dto(building_id);

        let created = use_cases
            .create_booking(user_id, org_id, false, dto)
            .await
            .unwrap();

        // Manually confirm via the use case
        let result = use_cases.confirm_booking(created.id).await;
        assert!(result.is_ok());
        let confirmed = result.unwrap();
        assert_eq!(confirmed.status, BookingStatus::Confirmed);

        // Now we can complete it
        let completed = use_cases.complete_booking(created.id).await;
        assert!(completed.is_ok());
        assert_eq!(completed.unwrap().status, BookingStatus::Completed);
    }

    #[tokio::test]
    async fn test_list_building_bookings() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();

        let dto1 = make_create_dto(building_id);

        let mut dto2 = make_create_dto(building_id);
        dto2.resource_name = "Meeting Room B".to_string();

        use_cases
            .create_booking(user_id, org_id, false, dto1)
            .await
            .unwrap();
        use_cases
            .create_booking(user_id, org_id, false, dto2)
            .await
            .unwrap();

        let result = use_cases.list_building_bookings(building_id).await;
        assert!(result.is_ok());
        assert_eq!(result.unwrap().len(), 2);
    }

    #[tokio::test]
    async fn test_owner_not_found_for_user() {
        let booking_repo = Arc::new(MockBookingRepo::new());
        let owner_repo = Arc::new(MockOwnerRepo::new());
        // Do not add any owner
        let use_cases = ResourceBookingUseCases::new(
            booking_repo as Arc<dyn ResourceBookingRepository>,
            owner_repo as Arc<dyn OwnerRepository>,
        );

        let building_id = Uuid::new_v4();
        let dto = make_create_dto(building_id);
        let result = use_cases
            .create_booking(Uuid::new_v4(), Uuid::new_v4(), false, dto)
            .await;
        assert!(result.is_err());
        assert_eq!(
            result.unwrap_err(),
            crate::application::error::REFUS_RESERVE_AUX_COPROPRIETAIRES,
            "le refus doit être celui, nommé, opposé à qui n'est pas copropriétaire"
        );
    }

    // ------------------------------------------------------------------------
    // Story #588 (INV-5/FR27) — on_behalf_of_acp, taxonomie 4-cat
    // ------------------------------------------------------------------------

    fn make_on_behalf_dto(building_id: Uuid, motif: Option<&str>) -> CreateResourceBookingDto {
        let mut dto = make_create_dto(building_id);
        dto.on_behalf_of_acp = true;
        dto.motif = motif.map(|m| m.to_string());
        dto
    }

    #[tokio::test]
    async fn happy_syndic_books_on_behalf_of_acp_with_motif() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_on_behalf_dto(building_id, Some("AG annuelle"));

        // La légitimité vient de `is_syndic = true` : ce user_id a bien une
        // fiche Owner (créée par `setup_use_cases()`), mais le chemin
        // on_behalf_of_acp ne la consulte jamais — la garde est le rôle, pas
        // l'existence d'une fiche copropriétaire.
        let result = use_cases.create_booking(user_id, org_id, true, dto).await;
        assert!(result.is_ok(), "{:?}", result.err());
        let response = result.unwrap();
        assert!(response.on_behalf_of_acp);
        assert_eq!(response.motif.as_deref(), Some("AG annuelle"));
        assert_eq!(response.booked_by, None);
        assert_eq!(response.booked_by_name, "Syndic — pour le compte de l'ACP");
    }

    #[tokio::test]
    async fn negative_on_behalf_of_acp_without_motif_is_refused() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_on_behalf_dto(building_id, None);

        let result = use_cases.create_booking(user_id, org_id, true, dto).await;
        assert_eq!(
            result.unwrap_err(),
            crate::domain::entities::ReservationOnBehalfError::MotifRequired.to_string()
        );
    }

    #[tokio::test]
    async fn security_non_syndic_cannot_set_on_behalf_of_acp() {
        let (use_cases, user_id, org_id, building_id, _) = setup_use_cases();
        let dto = make_on_behalf_dto(building_id, Some("AG annuelle"));

        // is_syndic = false : ce user_id a pourtant une fiche Owner (créée
        // par `setup_use_cases()`) — la garde ne doit pas dépendre de
        // l'existence d'une fiche copropriétaire, mais du rôle applicatif.
        let result = use_cases.create_booking(user_id, org_id, false, dto).await;
        assert_eq!(
            result.unwrap_err(),
            crate::application::error::REFUS_ON_BEHALF_RESERVE_AUX_SYNDICS,
        );
    }

    #[tokio::test]
    async fn edge_syndic_without_owner_profile_and_on_behalf_of_acp_false_is_refused() {
        // AC @edge — "Syndic réserve on_behalf_of_acp=false → 403" : sans
        // fiche Owner, le chemin personnel reste refusé (INV-5). Ce n'est pas
        // une régression à corriger : c'est précisément l'absence de
        // participation personnelle que l'exception #588 vient nommer.
        let booking_repo = Arc::new(MockBookingRepo::new());
        let owner_repo = Arc::new(MockOwnerRepo::new()); // aucun owner enregistré
        let use_cases = ResourceBookingUseCases::new(
            booking_repo as Arc<dyn ResourceBookingRepository>,
            owner_repo as Arc<dyn OwnerRepository>,
        );
        let building_id = Uuid::new_v4();
        let dto = make_create_dto(building_id); // on_behalf_of_acp: false

        let result = use_cases
            .create_booking(Uuid::new_v4(), Uuid::new_v4(), true, dto)
            .await;
        assert_eq!(
            result.unwrap_err(),
            crate::application::error::REFUS_RESERVE_AUX_COPROPRIETAIRES,
        );
    }
}