koprogo_api/application/use_cases/

ticket_use_cases.rs

use crate::application::dto::{
    AssignTicketRequest, CancelTicketRequest, CreateTicketRequest, ReopenTicketRequest,
    ResolveTicketRequest, TicketResponse, UpdateTicketRequest,
};
use crate::application::error::AppError;
use crate::application::ports::TicketRepository;
use crate::domain::entities::{Ticket, TicketKind, TicketStatus};
use std::sync::Arc;
use uuid::Uuid;

pub struct TicketUseCases {
    ticket_repository: Arc<dyn TicketRepository>,
}

impl TicketUseCases {
    pub fn new(ticket_repository: Arc<dyn TicketRepository>) -> Self {
        Self { ticket_repository }
    }

    /// Create a new maintenance request ticket.
    ///
    /// Backward-compatible entry point. Pre-Story-3.6 clients keep working
    /// (kind defaults to `Request`, complaint fields default to empty).
    /// Post-3.6 clients pass `kind = Some(Complaint)` + `severity = Some(_)`
    /// and the request is validated by [`Ticket::new_with_kind`].
    pub async fn create_ticket(
        &self,
        organization_id: Uuid,
        created_by: Uuid,
        request: CreateTicketRequest,
    ) -> Result<TicketResponse, String> {
        let kind = request.kind.unwrap_or(TicketKind::Request);

        // The Story 3.6 surface (kind / severity / incident_date / evidence /
        // witnesses) is validated by `new_with_kind`. Pre-3.6 callers send
        // empty defaults so the entity-level invariants stay green.
        let ticket = Ticket::new_with_kind(
            organization_id,
            request.building_id,
            request.unit_id,
            created_by,
            request.title,
            request.description,
            request.category,
            request.priority,
            kind,
            request.severity,
            request.incident_date,
            request.evidence_attachments,
            request.witnesses,
        )
        // Bridge AppError → String for the retro-compat surface (cluster #555
        // tracks the full migration; here we only touch the surface the story
        // requires, per Phase A scope).
        .map_err(|e| e.to_string())?;

        let created = self.ticket_repository.create(&ticket).await?;
        Ok(TicketResponse::from(created))
    }

    /// Story 3.6 (FR31 / INV-24) — Patch the editable fields of a ticket.
    ///
    /// Native `AppError` surface (no legacy `String` bridging). Two failure
    /// modes that must be HTTP-distinct:
    ///
    /// - `AppError::NotFound` (404) — unknown id;
    /// - `AppError::TicketImmutable` (403) — INV-24 window elapsed;
    /// - `AppError::Validation` (400) — invariant violation on the new state.
    ///
    /// Workflow transitions (assign / resolve / close / cancel / reopen) are
    /// intentionally NOT exposed here — they have their own typed endpoints
    /// to preserve audit fidelity (PUT /tickets/{id}/{transition}).
    pub async fn update_ticket_fields(
        &self,
        id: Uuid,
        request: UpdateTicketRequest,
    ) -> Result<TicketResponse, AppError> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await
            .map_err(AppError::from)?
            .ok_or_else(|| AppError::NotFound(format!("ticket {}", id)))?;

        if !ticket.is_currently_editable() {
            return Err(AppError::TicketImmutable);
        }

        if let Some(title) = request.title {
            let trimmed = title.trim().to_string();
            if trimmed.is_empty() {
                return Err(AppError::Validation("Title cannot be empty".to_string()));
            }
            if trimmed.len() > 200 {
                return Err(AppError::Validation(
                    "Title cannot exceed 200 characters".to_string(),
                ));
            }
            ticket.title = trimmed;
        }
        if let Some(description) = request.description {
            let trimmed = description.trim().to_string();
            if trimmed.is_empty() {
                return Err(AppError::Validation(
                    "Description cannot be empty".to_string(),
                ));
            }
            if trimmed.len() > 5000 {
                return Err(AppError::Validation(
                    "Description cannot exceed 5000 characters".to_string(),
                ));
            }
            ticket.description = trimmed;
        }
        if let Some(category) = request.category {
            ticket.category = category;
        }
        if let Some(priority) = request.priority {
            ticket.priority = priority;
        }
        if let Some(severity) = request.severity {
            ticket.severity = Some(severity);
        }
        if let Some(incident_date) = request.incident_date {
            ticket.incident_date = Some(incident_date);
        }
        if let Some(evidence) = request.evidence_attachments {
            ticket.evidence_attachments = evidence;
        }
        if let Some(witnesses) = request.witnesses {
            ticket.witnesses = witnesses;
        }
        ticket.updated_at = chrono::Utc::now();

        // Re-validate the post-mutation state. Invariant violations bubble up
        // as `AppError::Validation` → 400.
        ticket.validate_invariants()?;

        let updated = self
            .ticket_repository
            .update(&ticket)
            .await
            .map_err(AppError::from)?;
        Ok(TicketResponse::from(updated))
    }

    /// Get a ticket by ID
    pub async fn get_ticket(&self, id: Uuid) -> Result<Option<TicketResponse>, String> {
        match self.ticket_repository.find_by_id(id).await? {
            Some(ticket) => Ok(Some(TicketResponse::from(ticket))),
            None => Ok(None),
        }
    }

    /// List all tickets for a building
    pub async fn list_tickets_by_building(
        &self,
        building_id: Uuid,
    ) -> Result<Vec<TicketResponse>, String> {
        let tickets = self.ticket_repository.find_by_building(building_id).await?;
        Ok(tickets.into_iter().map(TicketResponse::from).collect())
    }

    /// List all tickets for an organization
    pub async fn list_tickets_by_organization(
        &self,
        organization_id: Uuid,
    ) -> Result<Vec<TicketResponse>, String> {
        let tickets = self
            .ticket_repository
            .find_by_organization(organization_id)
            .await?;
        Ok(tickets.into_iter().map(TicketResponse::from).collect())
    }

    /// List tickets created by a specific owner
    pub async fn list_my_tickets(&self, created_by: Uuid) -> Result<Vec<TicketResponse>, String> {
        let tickets = self
            .ticket_repository
            .find_by_created_by(created_by)
            .await?;
        Ok(tickets.into_iter().map(TicketResponse::from).collect())
    }

    /// List tickets assigned to a specific user (syndic/contractor)
    pub async fn list_assigned_tickets(
        &self,
        assigned_to: Uuid,
    ) -> Result<Vec<TicketResponse>, String> {
        let tickets = self
            .ticket_repository
            .find_by_assigned_to(assigned_to)
            .await?;
        Ok(tickets.into_iter().map(TicketResponse::from).collect())
    }

    /// List tickets by status for a building
    pub async fn list_tickets_by_status(
        &self,
        building_id: Uuid,
        status: TicketStatus,
    ) -> Result<Vec<TicketResponse>, String> {
        let tickets = self
            .ticket_repository
            .find_by_status(building_id, status)
            .await?;
        Ok(tickets.into_iter().map(TicketResponse::from).collect())
    }

    /// Assign a ticket to a user (syndic or contractor)
    pub async fn assign_ticket(
        &self,
        id: Uuid,
        request: AssignTicketRequest,
    ) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.assign(request.assigned_to)?;

        let updated = self.ticket_repository.update(&ticket).await?;
        Ok(TicketResponse::from(updated))
    }

    /// Start working on a ticket (transition to InProgress)
    pub async fn start_work(&self, id: Uuid) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.start_work()?;

        let updated = self.ticket_repository.update(&ticket).await?;
        Ok(TicketResponse::from(updated))
    }

    /// Resolve a ticket (mark as work completed)
    pub async fn resolve_ticket(
        &self,
        id: Uuid,
        request: ResolveTicketRequest,
    ) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.resolve(request.resolution_notes)?;

        let updated = self.ticket_repository.update(&ticket).await?;
        Ok(TicketResponse::from(updated))
    }

    /// Close a ticket (final validation by requester or syndic)
    pub async fn close_ticket(&self, id: Uuid) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.close()?;

        let updated = self.ticket_repository.update(&ticket).await?;
        Ok(TicketResponse::from(updated))
    }

    /// Cancel a ticket with a reason
    pub async fn cancel_ticket(
        &self,
        id: Uuid,
        request: CancelTicketRequest,
    ) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.cancel(request.reason)?;

        let updated = self.ticket_repository.update(&ticket).await?;
        Ok(TicketResponse::from(updated))
    }

    /// Reopen a ticket (if incorrectly resolved)
    pub async fn reopen_ticket(
        &self,
        id: Uuid,
        request: ReopenTicketRequest,
    ) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.reopen(request.reason)?;

        let updated = self.ticket_repository.update(&ticket).await?;
        Ok(TicketResponse::from(updated))
    }

    /// Delete a ticket (only allowed for Open tickets)
    pub async fn delete_ticket(&self, id: Uuid) -> Result<bool, String> {
        let ticket = self
            .ticket_repository
            .find_by_id(id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        // Only allow deletion of Open tickets
        if ticket.status != TicketStatus::Open {
            return Err("Can only delete tickets with Open status".to_string());
        }

        self.ticket_repository.delete(id).await
    }

    /// Get ticket statistics for a building
    pub async fn get_ticket_statistics(
        &self,
        building_id: Uuid,
    ) -> Result<TicketStatistics, String> {
        let total = self
            .ticket_repository
            .count_by_building(building_id)
            .await?;

        let open = self
            .ticket_repository
            .count_by_status(building_id, TicketStatus::Open)
            .await?;

        // Domain has no separate Assigned state; surfaced as 0 for frontend display.
        let assigned: i64 = 0;

        let in_progress = self
            .ticket_repository
            .count_by_status(building_id, TicketStatus::InProgress)
            .await?;

        let resolved = self
            .ticket_repository
            .count_by_status(building_id, TicketStatus::Resolved)
            .await?;

        let closed = self
            .ticket_repository
            .count_by_status(building_id, TicketStatus::Closed)
            .await?;

        let cancelled = self
            .ticket_repository
            .count_by_status(building_id, TicketStatus::Cancelled)
            .await?;

        let overdue_tickets = self
            .ticket_repository
            .find_by_building(building_id)
            .await?
            .iter()
            .filter(|t| t.is_overdue(7))
            .count() as i64;

        Ok(TicketStatistics {
            total,
            open,
            assigned,
            in_progress,
            resolved,
            closed,
            cancelled,
            overdue_tickets,
        })
    }

    /// Check for overdue tickets (open for more than specified days)
    pub async fn get_overdue_tickets(
        &self,
        building_id: Uuid,
        max_days: i64,
    ) -> Result<Vec<TicketResponse>, String> {
        let tickets = self.ticket_repository.find_by_building(building_id).await?;

        let overdue: Vec<TicketResponse> = tickets
            .into_iter()
            .filter(|ticket| ticket.is_overdue(max_days))
            .map(TicketResponse::from)
            .collect();

        Ok(overdue)
    }

    /// Get ticket statistics for an organization (all buildings)
    pub async fn get_ticket_statistics_by_organization(
        &self,
        organization_id: Uuid,
    ) -> Result<TicketStatistics, String> {
        let total = self
            .ticket_repository
            .count_by_organization(organization_id)
            .await?;

        let open = self
            .ticket_repository
            .count_by_organization_and_status(organization_id, TicketStatus::Open)
            .await?;

        let assigned: i64 = 0;

        let in_progress = self
            .ticket_repository
            .count_by_organization_and_status(organization_id, TicketStatus::InProgress)
            .await?;

        let resolved = self
            .ticket_repository
            .count_by_organization_and_status(organization_id, TicketStatus::Resolved)
            .await?;

        let closed = self
            .ticket_repository
            .count_by_organization_and_status(organization_id, TicketStatus::Closed)
            .await?;

        let cancelled = self
            .ticket_repository
            .count_by_organization_and_status(organization_id, TicketStatus::Cancelled)
            .await?;

        let overdue_tickets = self
            .ticket_repository
            .find_by_organization(organization_id)
            .await?
            .iter()
            .filter(|t| t.is_overdue(7))
            .count() as i64;

        Ok(TicketStatistics {
            total,
            open,
            assigned,
            in_progress,
            resolved,
            closed,
            cancelled,
            overdue_tickets,
        })
    }

    /// Check for overdue tickets in organization (all buildings)
    pub async fn get_overdue_tickets_by_organization(
        &self,
        organization_id: Uuid,
        max_days: i64,
    ) -> Result<Vec<TicketResponse>, String> {
        let tickets = self
            .ticket_repository
            .find_by_organization(organization_id)
            .await?;

        let overdue: Vec<TicketResponse> = tickets
            .into_iter()
            .filter(|ticket| ticket.is_overdue(max_days))
            .map(TicketResponse::from)
            .collect();

        Ok(overdue)
    }

    /// Send work order to contractor via PWA magic link (Issue #309)
    /// Validates ticket is in InProgress status and sends work order notification
    pub async fn send_work_order(&self, ticket_id: Uuid) -> Result<TicketResponse, String> {
        let mut ticket = self
            .ticket_repository
            .find_by_id(ticket_id)
            .await?
            .ok_or_else(|| "Ticket not found".to_string())?;

        ticket.send_work_order_to_contractor()?;
        let updated = self.ticket_repository.update(&ticket).await?;

        Ok(TicketResponse::from(updated))
    }
}

/// Ticket statistics for a building
#[derive(Debug, serde::Serialize)]
pub struct TicketStatistics {
    #[serde(rename = "total_tickets")]
    pub total: i64,
    #[serde(rename = "open_tickets")]
    pub open: i64,
    #[serde(rename = "assigned_tickets")]
    pub assigned: i64,
    #[serde(rename = "in_progress_tickets")]
    pub in_progress: i64,
    #[serde(rename = "resolved_tickets")]
    pub resolved: i64,
    #[serde(rename = "closed_tickets")]
    pub closed: i64,
    #[serde(rename = "cancelled_tickets")]
    pub cancelled: i64,
    pub overdue_tickets: i64,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::application::ports::TicketRepository;
    use crate::domain::entities::{Ticket, TicketCategory, TicketPriority, TicketStatus};
    use async_trait::async_trait;
    use std::collections::HashMap;
    use std::sync::Mutex;

    // ── Manual mock for TicketRepository ──────────────────────────────

    struct MockTicketRepository {
        tickets: Mutex<HashMap<Uuid, Ticket>>,
    }

    impl MockTicketRepository {
        fn new() -> Self {
            Self {
                tickets: Mutex::new(HashMap::new()),
            }
        }
    }

    #[async_trait]
    impl TicketRepository for MockTicketRepository {
        async fn create(&self, ticket: &Ticket) -> Result<Ticket, String> {
            self.tickets
                .lock()
                .unwrap()
                .insert(ticket.id, ticket.clone());
            Ok(ticket.clone())
        }

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

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

        async fn find_by_organization(&self, organization_id: Uuid) -> Result<Vec<Ticket>, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.organization_id == organization_id)
                .cloned()
                .collect())
        }

        async fn find_by_created_by(&self, created_by: Uuid) -> Result<Vec<Ticket>, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.created_by == created_by)
                .cloned()
                .collect())
        }

        async fn find_by_assigned_to(&self, assigned_to: Uuid) -> Result<Vec<Ticket>, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.assigned_to == Some(assigned_to))
                .cloned()
                .collect())
        }

        async fn find_by_status(
            &self,
            building_id: Uuid,
            status: TicketStatus,
        ) -> Result<Vec<Ticket>, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.building_id == building_id && t.status == status)
                .cloned()
                .collect())
        }

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

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

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

        async fn count_by_status(
            &self,
            building_id: Uuid,
            status: TicketStatus,
        ) -> Result<i64, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.building_id == building_id && t.status == status)
                .count() as i64)
        }

        async fn count_by_organization(&self, organization_id: Uuid) -> Result<i64, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.organization_id == organization_id)
                .count() as i64)
        }

        async fn count_by_organization_and_status(
            &self,
            organization_id: Uuid,
            status: TicketStatus,
        ) -> Result<i64, String> {
            Ok(self
                .tickets
                .lock()
                .unwrap()
                .values()
                .filter(|t| t.organization_id == organization_id && t.status == status)
                .count() as i64)
        }
    }

    // ── Helpers ──────────────────────────────────────────────────────

    fn make_use_cases(repo: Arc<dyn TicketRepository>) -> TicketUseCases {
        TicketUseCases::new(repo)
    }

    fn make_create_request(building_id: Uuid) -> CreateTicketRequest {
        CreateTicketRequest {
            building_id,
            unit_id: None,
            title: "Fuite d'eau cuisine".to_string(),
            description: "L'eau coule sous l'évier de la cuisine commune".to_string(),
            category: TicketCategory::Plumbing,
            priority: TicketPriority::High,
            // Story 3.6 — defaults preserve pre-3.6 behavior.
            kind: None,
            severity: None,
            incident_date: None,
            evidence_attachments: Vec::new(),
            witnesses: Vec::new(),
        }
    }

    /// Helper: create a ticket through the use case and return its id
    async fn create_ticket_helper(
        use_cases: &TicketUseCases,
        org_id: Uuid,
        building_id: Uuid,
    ) -> TicketResponse {
        let user_id = Uuid::new_v4();
        let request = make_create_request(building_id);
        use_cases
            .create_ticket(org_id, user_id, request)
            .await
            .expect("create_ticket should succeed")
    }

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

    #[tokio::test]
    async fn test_create_ticket_success() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let user_id = Uuid::new_v4();
        let request = make_create_request(building_id);

        let result = use_cases.create_ticket(org_id, user_id, request).await;

        assert!(result.is_ok());
        let ticket = result.unwrap();
        assert_eq!(ticket.status, TicketStatus::Open);
        assert_eq!(ticket.building_id, building_id);
        assert_eq!(ticket.organization_id, org_id);
        assert_eq!(ticket.created_by, user_id);
        assert_eq!(ticket.title, "Fuite d'eau cuisine");
        assert!(ticket.assigned_to.is_none());
        assert!(ticket.resolution_notes.is_none());
    }

    #[tokio::test]
    async fn test_create_ticket_empty_title_fails() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let request = CreateTicketRequest {
            building_id: Uuid::new_v4(),
            unit_id: None,
            title: "   ".to_string(),
            description: "Some description".to_string(),
            category: TicketCategory::Electrical,
            priority: TicketPriority::Low,
            kind: None,
            severity: None,
            incident_date: None,
            evidence_attachments: Vec::new(),
            witnesses: Vec::new(),
        };

        let result = use_cases
            .create_ticket(Uuid::new_v4(), Uuid::new_v4(), request)
            .await;

        assert!(result.is_err());
        assert!(result.unwrap_err().contains("Title cannot be empty"));
    }

    #[tokio::test]
    async fn test_assign_contractor_transitions_to_in_progress() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;
        assert_eq!(ticket.status, TicketStatus::Open);

        let contractor_id = Uuid::new_v4();
        let assign_request = AssignTicketRequest {
            assigned_to: contractor_id,
        };

        let result = use_cases.assign_ticket(ticket.id, assign_request).await;

        assert!(result.is_ok());
        let updated = result.unwrap();
        assert_eq!(updated.status, TicketStatus::InProgress);
        assert_eq!(updated.assigned_to, Some(contractor_id));
    }

    #[tokio::test]
    async fn test_start_work_open_to_in_progress() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        let result = use_cases.start_work(ticket.id).await;

        assert!(result.is_ok());
        assert_eq!(result.unwrap().status, TicketStatus::InProgress);
    }

    #[tokio::test]
    async fn test_resolve_ticket_with_notes() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Transition to InProgress first
        use_cases.start_work(ticket.id).await.unwrap();

        let resolve_request = ResolveTicketRequest {
            resolution_notes: "Fuite réparée, joint remplacé".to_string(),
        };
        let result = use_cases.resolve_ticket(ticket.id, resolve_request).await;

        assert!(result.is_ok());
        let resolved = result.unwrap();
        assert_eq!(resolved.status, TicketStatus::Resolved);
        assert_eq!(
            resolved.resolution_notes.as_deref(),
            Some("Fuite réparée, joint remplacé")
        );
        assert!(resolved.resolved_at.is_some());
    }

    #[tokio::test]
    async fn test_close_ticket_after_resolution() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Full lifecycle: Open -> InProgress -> Resolved -> Closed
        use_cases.start_work(ticket.id).await.unwrap();
        use_cases
            .resolve_ticket(
                ticket.id,
                ResolveTicketRequest {
                    resolution_notes: "Done".to_string(),
                },
            )
            .await
            .unwrap();

        let result = use_cases.close_ticket(ticket.id).await;

        assert!(result.is_ok());
        let closed = result.unwrap();
        assert_eq!(closed.status, TicketStatus::Closed);
        assert!(closed.closed_at.is_some());
    }

    #[tokio::test]
    async fn test_close_open_ticket_fails() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Attempt to close directly from Open (skipping Resolved)
        let result = use_cases.close_ticket(ticket.id).await;

        assert!(result.is_err());
        assert!(result.unwrap_err().contains("Must be Resolved first"));
    }

    #[tokio::test]
    async fn test_cancel_ticket_with_reason() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        let cancel_request = CancelTicketRequest {
            reason: "Erreur de déclaration, problème déjà résolu".to_string(),
        };
        let result = use_cases.cancel_ticket(ticket.id, cancel_request).await;

        assert!(result.is_ok());
        let cancelled = result.unwrap();
        assert_eq!(cancelled.status, TicketStatus::Cancelled);
        assert!(cancelled
            .resolution_notes
            .as_deref()
            .unwrap()
            .contains("CANCELLED"));
    }

    #[tokio::test]
    async fn test_reopen_resolved_ticket() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Open -> InProgress -> Resolved
        use_cases.start_work(ticket.id).await.unwrap();
        use_cases
            .resolve_ticket(
                ticket.id,
                ResolveTicketRequest {
                    resolution_notes: "Fixed".to_string(),
                },
            )
            .await
            .unwrap();

        // Reopen
        let reopen_request = ReopenTicketRequest {
            reason: "Problème persiste après intervention".to_string(),
        };
        let result = use_cases.reopen_ticket(ticket.id, reopen_request).await;

        assert!(result.is_ok());
        let reopened = result.unwrap();
        assert_eq!(reopened.status, TicketStatus::InProgress);
        assert!(reopened.resolved_at.is_none());
        assert!(reopened.closed_at.is_none());
        assert!(reopened
            .resolution_notes
            .as_deref()
            .unwrap()
            .contains("REOPENED"));
    }

    #[tokio::test]
    async fn test_reopen_open_ticket_fails() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Ticket is Open, cannot reopen
        let reopen_request = ReopenTicketRequest {
            reason: "Some reason".to_string(),
        };
        let result = use_cases.reopen_ticket(ticket.id, reopen_request).await;

        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .contains("Can only reopen resolved or closed tickets"));
    }

    #[tokio::test]
    async fn test_send_work_order_in_progress_ticket() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Assign contractor (auto-transitions to InProgress)
        let contractor_id = Uuid::new_v4();
        use_cases
            .assign_ticket(
                ticket.id,
                AssignTicketRequest {
                    assigned_to: contractor_id,
                },
            )
            .await
            .unwrap();

        // Send work order
        let result = use_cases.send_work_order(ticket.id).await;

        assert!(result.is_ok());
        let updated = result.unwrap();
        assert!(updated.work_order_sent_at.is_some());
        assert_eq!(updated.status, TicketStatus::InProgress);
    }

    #[tokio::test]
    async fn test_send_work_order_open_ticket_fails() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Ticket is Open (not InProgress), should fail
        let result = use_cases.send_work_order(ticket.id).await;

        assert!(result.is_err());
        assert!(result.unwrap_err().contains("InProgress"));
    }

    #[tokio::test]
    async fn test_get_overdue_tickets() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo.clone());

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

        // Create a ticket and manually age it
        let request = make_create_request(building_id);
        let created = use_cases
            .create_ticket(org_id, user_id, request)
            .await
            .unwrap();

        // Manually set created_at to 10 days ago in the mock store
        {
            let mut store = repo.tickets.lock().unwrap();
            if let Some(ticket) = store.get_mut(&created.id) {
                ticket.created_at = chrono::Utc::now() - chrono::Duration::days(10);
            }
        }

        let overdue = use_cases.get_overdue_tickets(building_id, 5).await.unwrap();
        assert_eq!(overdue.len(), 1);
        assert_eq!(overdue[0].id, created.id);

        // With a longer threshold, ticket should not be overdue
        let not_overdue = use_cases
            .get_overdue_tickets(building_id, 15)
            .await
            .unwrap();
        assert_eq!(not_overdue.len(), 0);
    }

    #[tokio::test]
    async fn test_get_ticket_statistics() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

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

        // Create 3 tickets, transition them to different states
        let _t1 = create_ticket_helper(&use_cases, org_id, building_id).await; // stays Open
        let t2 = create_ticket_helper(&use_cases, org_id, building_id).await;
        let t3 = create_ticket_helper(&use_cases, org_id, building_id).await;

        // t2 -> InProgress -> Resolved
        use_cases.start_work(t2.id).await.unwrap();
        use_cases
            .resolve_ticket(
                t2.id,
                ResolveTicketRequest {
                    resolution_notes: "Done".to_string(),
                },
            )
            .await
            .unwrap();

        // t3 -> Cancelled
        use_cases
            .cancel_ticket(
                t3.id,
                CancelTicketRequest {
                    reason: "Duplicate".to_string(),
                },
            )
            .await
            .unwrap();

        let stats = use_cases.get_ticket_statistics(building_id).await.unwrap();

        assert_eq!(stats.total, 3);
        assert_eq!(stats.open, 1); // t1
        assert_eq!(stats.in_progress, 0);
        assert_eq!(stats.resolved, 1); // t2
        assert_eq!(stats.closed, 0);
        assert_eq!(stats.cancelled, 1); // t3
    }

    #[tokio::test]
    async fn test_delete_open_ticket_succeeds() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        let result = use_cases.delete_ticket(ticket.id).await;

        assert!(result.is_ok());
        assert!(result.unwrap());

        // Verify ticket no longer exists
        let fetched = use_cases.get_ticket(ticket.id).await.unwrap();
        assert!(fetched.is_none());
    }

    #[tokio::test]
    async fn test_delete_in_progress_ticket_fails() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Transition to InProgress
        use_cases.start_work(ticket.id).await.unwrap();

        let result = use_cases.delete_ticket(ticket.id).await;

        assert!(result.is_err());
        assert!(result
            .unwrap_err()
            .contains("Can only delete tickets with Open status"));
    }

    // ========================================================================
    // Story 3.6 — Complaint creation + INV-24 PATCH immutability (FR31)
    // 4-cat taxonomy: @happy / @edge / @security / @negative
    // ========================================================================

    use crate::application::dto::UpdateTicketRequest;
    use crate::application::error::AppError;
    use crate::domain::entities::{TicketKind, TicketSeverity};

    fn make_complaint_request(building_id: Uuid) -> CreateTicketRequest {
        CreateTicketRequest {
            building_id,
            unit_id: None,
            title: "Plainte tapage nocturne".to_string(),
            description: "Bruit récurrent depuis 3 semaines, 2 témoins".to_string(),
            category: TicketCategory::Other,
            priority: TicketPriority::High,
            kind: Some(TicketKind::Complaint),
            severity: Some(TicketSeverity::Critical),
            incident_date: Some(chrono::Utc::now() - chrono::Duration::hours(2)),
            evidence_attachments: vec![
                "https://store.test/a.jpg".to_string(),
                "https://store.test/b.jpg".to_string(),
                "https://store.test/c.jpg".to_string(),
            ],
            witnesses: vec![Uuid::new_v4(), Uuid::new_v4()],
        }
    }

    // ---- @happy -------------------------------------------------------------

    #[tokio::test]
    async fn happy_create_complaint_with_severity_evidence_witnesses() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

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

        let res = use_cases
            .create_ticket(org_id, creator, make_complaint_request(building_id))
            .await
            .expect("complaint creation should succeed");

        assert_eq!(res.kind, TicketKind::Complaint);
        assert_eq!(res.severity, Some(TicketSeverity::Critical));
        assert_eq!(res.evidence_attachments.len(), 3);
        assert_eq!(res.witnesses.len(), 2);
    }

    #[tokio::test]
    async fn happy_update_ticket_within_window_persists_changes() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        let update = UpdateTicketRequest {
            title: Some("Titre corrigé".to_string()),
            description: Some("Description corrigée".to_string()),
            ..Default::default()
        };
        let updated = use_cases
            .update_ticket_fields(ticket.id, update)
            .await
            .expect("edit within 5min window should succeed");
        assert_eq!(updated.title, "Titre corrigé");
        assert_eq!(updated.description, "Description corrigée");
    }

    // ---- @edge --------------------------------------------------------------

    #[tokio::test]
    async fn edge_pre_3_6_client_without_kind_defaults_to_request() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let user_id = Uuid::new_v4();
        let request = make_create_request(building_id);

        let res = use_cases
            .create_ticket(org_id, user_id, request)
            .await
            .expect("retro-compat path should succeed");
        assert_eq!(res.kind, TicketKind::Request);
        assert!(res.severity.is_none());
        assert!(res.evidence_attachments.is_empty());
        assert!(res.witnesses.is_empty());
    }

    // ---- @security ----------------------------------------------------------

    #[tokio::test]
    async fn security_update_past_5_minute_window_returns_ticket_immutable_403() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo.clone());

        let org_id = Uuid::new_v4();
        let building_id = Uuid::new_v4();
        let ticket = create_ticket_helper(&use_cases, org_id, building_id).await;

        // Manually age the ticket past INV-24 in the mock store.
        {
            let mut store = repo.tickets.lock().unwrap();
            if let Some(t) = store.get_mut(&ticket.id) {
                t.created_at = chrono::Utc::now() - chrono::Duration::minutes(6);
            }
        }

        let update = UpdateTicketRequest {
            title: Some("Tentative tardive".to_string()),
            ..Default::default()
        };
        let err = use_cases
            .update_ticket_fields(ticket.id, update)
            .await
            .unwrap_err();
        assert!(matches!(err, AppError::TicketImmutable));
    }

    // ---- @negative ----------------------------------------------------------

    #[tokio::test]
    async fn negative_create_complaint_without_severity_returns_validation_422() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

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

        let mut req = make_complaint_request(building_id);
        req.severity = None;
        let err = use_cases
            .create_ticket(org_id, Uuid::new_v4(), req)
            .await
            .unwrap_err();
        assert!(
            err.contains("severity"),
            "expected severity-related error, got: {err}"
        );
    }

    #[tokio::test]
    async fn negative_update_unknown_ticket_returns_not_found_404() {
        let repo = Arc::new(MockTicketRepository::new());
        let use_cases = make_use_cases(repo);

        let err = use_cases
            .update_ticket_fields(Uuid::new_v4(), UpdateTicketRequest::default())
            .await
            .unwrap_err();
        assert!(matches!(err, AppError::NotFound(_)));
    }
}