koprogo_api/infrastructure/database/

seed.rs

use crate::domain::entities::{Account, AccountType, User, UserRole};
use bcrypt::{hash, DEFAULT_COST};
use chrono::{NaiveDate, Utc};
use fake::faker::address::en::*;
use fake::faker::name::en::*;
use fake::Fake;
use rand::RngExt;
use rust_decimal::Decimal;
use serde::Serialize;
use sqlx::{PgPool, Row};
use uuid::Uuid;

/// Result struct returned by `seed_scenario_world` with all created IDs and credentials.
#[derive(Debug, Clone, Serialize)]
pub struct ScenarioWorldResult {
    pub organization_id: Uuid,
    pub building_id: Uuid,
    pub meeting_id: Uuid,
    pub resolution_id: Uuid,
    pub users: Vec<ScenarioUserResult>,
    pub owners: Vec<ScenarioOwnerResult>,
    pub units: Vec<ScenarioUnitResult>,
    pub building2_id: Uuid,
    pub building2_name: String,
    pub building2_owners: Vec<ScenarioOwnerResult>,
    pub building2_units: Vec<ScenarioUnitResult>,
    pub building3_id: Uuid,
    pub building3_name: String,
    pub building3_owners: Vec<ScenarioOwnerResult>,
    pub building3_units: Vec<ScenarioUnitResult>,
}

#[derive(Debug, Clone, Serialize)]
pub struct ScenarioUserResult {
    pub user_id: Uuid,
    pub email: String,
    pub password: String,
    pub role: String,
    pub first_name: String,
    pub last_name: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct ScenarioOwnerResult {
    pub owner_id: Uuid,
    pub user_id: Uuid,
    pub first_name: String,
    pub last_name: String,
    pub email: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct ScenarioUnitResult {
    pub unit_id: Uuid,
    pub unit_number: String,
    pub owner_id: Uuid,
    pub tantièmes: f64,
}

pub struct DatabaseSeeder {
    pool: PgPool,
    /// Empreintes bcrypt précalculées, par mot de passe en clair.
    ///
    /// Le semis du monde crée vingt-six comptes. Hachés un par un, à
    /// `DEFAULT_COST`, cela prenait **44 secondes** (mesuré sur la recette
    /// le 2026-09-17) — au point de bloquer sept tests d'accessibilité dont
    /// le plafond de requête est de 10 s, et d'en faire expirer quatre
    /// autres qui attendaient derrière.
    ///
    /// Le coût bcrypt n'est PAS abaissé : ces comptes servent aussi la
    /// démo. Ce sont les hachages qui sont menés de front.
    empreintes: std::sync::Mutex<std::collections::HashMap<String, String>>,
}

impl DatabaseSeeder {
    pub fn new(pool: PgPool) -> Self {
        Self {
            pool,
            empreintes: std::sync::Mutex::new(std::collections::HashMap::new()),
        }
    }

    /// Le cache d'empreintes, en reprenant la main sur un verrou empoisonné.
    ///
    /// Ce cache n'est qu'une optimisation : si une panique ailleurs a
    /// empoisonné le verrou, s'arrêter ici ne protégerait rien et ferait
    /// échouer un semis pour une raison sans rapport. Au pire une empreinte
    /// manque, et `create_demo_user` la recalcule.
    ///
    /// C'est aussi ce qui garde `garde_paniques_en_production` à sa place :
    /// trois points de panique ajoutés ici le 2026-09-17 avaient suffi à
    /// faire passer son compte de 39 à 42, et le barrage de déploiement à
    /// rougir pendant huit passages sans que personne le remarque.
    fn cache_empreintes(
        &self,
    ) -> std::sync::MutexGuard<'_, std::collections::HashMap<String, String>> {
        self.empreintes
            .lock()
            .unwrap_or_else(|verrou_empoisonne| verrou_empoisonne.into_inner())
    }

    /// Hache d'avance, EN PARALLÈLE, les mots de passe qui vont servir.
    ///
    /// Sans cela, chaque `create_demo_user` attend son propre bcrypt avant
    /// que le suivant ne commence : vingt-six attentes en file. Ici les
    /// `spawn_blocking` partent ensemble et le temps total tombe au plus
    /// lent divisé par le nombre de cœurs.
    ///
    /// Idempotent : un mot de passe déjà connu n'est pas rehaché.
    async fn precalculer_empreintes(&self, mots_de_passe: &[&str]) {
        let a_faire: Vec<String> = {
            let connues = self.cache_empreintes();
            let mut vus = std::collections::HashSet::new();
            mots_de_passe
                .iter()
                .filter(|m| !connues.contains_key(**m) && vus.insert(**m))
                .map(|m| m.to_string())
                .collect()
        };
        if a_faire.is_empty() {
            return;
        }

        let calculs = a_faire.into_iter().map(|mot| {
            tokio::task::spawn_blocking(move || {
                let empreinte = hash(&mot, DEFAULT_COST);
                (mot, empreinte)
            })
        });

        for issue in futures_util::future::join_all(calculs).await {
            // Un hachage interrompu n'est pas fatal : `create_demo_user`
            // retombera sur le calcul direct. On ne masque rien, on ne
            // bloque pas le semis pour autant.
            if let Ok((mot, Ok(empreinte))) = issue {
                self.cache_empreintes().insert(mot, empreinte);
            }
        }
    }

    /// Hotfix #602 follow-up — resolves `acp_id` from `org_id` for seed flows.
    /// Looks up the default ACP for the org, creates one on demand if absent.
    /// Post-#602, `buildings.organization_id` was dropped ; seeds must go
    /// through `acps` to associate a building with an organization.
    async fn ensure_default_acp_for_org(&self, org_id: Uuid) -> Result<Uuid, String> {
        let existing: Option<(Uuid,)> = sqlx::query_as(
            "SELECT id FROM acps WHERE organization_id = $1 ORDER BY created_at ASC LIMIT 1",
        )
        .bind(org_id)
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| format!("Failed to lookup acp for org {}: {}", org_id, e))?;

        if let Some((id,)) = existing {
            return Ok(id);
        }

        let acp_id = Uuid::new_v4();
        let now = Utc::now();
        let short = org_id.simple().to_string();
        let short_prefix = &short[..8];

        // Copropriétés bruxelloises plausibles plutôt que « ACP par defaut »
        // avec « Adresse a completer, 0000 A completer ». Le site de
        // démonstration montrait ces valeurs telles quelles, ce qui donnait
        // l'impression d'un produit inachevé.
        //
        // Rues et codes postaux réels de la Région bruxelloise ; noms de
        // résidences inventés. `bce_number` reste NULL : un numéro
        // d'entreprise syntaxiquement valide risquerait de correspondre à une
        // vraie société.
        const ACP_MODELES: [(&str, &str, &str, &str); 6] = [
            (
                "Résidence Les Tilleuls",
                "Avenue Louise 143",
                "1050",
                "Ixelles",
            ),
            (
                "Résidence Dansaert",
                "Rue Antoine Dansaert 62",
                "1000",
                "Bruxelles",
            ),
            (
                "Résidence Parc Léopold",
                "Rue Belliard 28",
                "1040",
                "Etterbeek",
            ),
            (
                "Résidence Flagey",
                "Place Eugène Flagey 18",
                "1050",
                "Ixelles",
            ),
            (
                "Résidence Montgomery",
                "Avenue de Tervueren 96",
                "1150",
                "Woluwe-Saint-Pierre",
            ),
            (
                "Résidence Val d'Or",
                "Chaussée de Waterloo 715",
                "1180",
                "Uccle",
            ),
        ];

        // Choix déterministe : un même identifiant d'organisation rend
        // toujours la même adresse, donc un seed rejoué reste stable.
        let index = (org_id.as_u128() % ACP_MODELES.len() as u128) as usize;
        let (residence, rue, code_postal, commune) = ACP_MODELES[index];

        let acp_name = format!("ACP {residence}");
        let acp_slug = format!("acp-seed-{}", short_prefix);

        sqlx::query(
            r#"INSERT INTO acps (id, organization_id, name, slug, legal_status,
                address_street, address_postal_code, address_city, created_at, updated_at)
               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"#,
        )
        .bind(acp_id)
        .bind(org_id)
        .bind(&acp_name)
        .bind(&acp_slug)
        .bind("copropriete_belge")
        .bind(rue)
        .bind(code_postal)
        .bind(commune)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create default acp for org {}: {}", org_id, e))?;

        Ok(acp_id)
    }

    /// Create or update the default superadmin user
    pub async fn seed_superadmin(&self) -> Result<User, String> {
        // Configurables par l'environnement, avec repli sur les valeurs
        // historiques pour ne rien casser là où rien n'est configuré.
        //
        // Ces identifiants donnent le rôle `superadmin`. Codés en dur dans un
        // dépôt AGPL, ils sont lisibles par quiconque, et l'API de la démo est
        // publiquement joignable. Le repli n'est donc pas une solution : c'est
        // une compatibilité le temps que `KOPROGO_SUPERADMIN_PASSWORD` soit
        // renseigné sur chaque déploiement. Voir l'issue de suivi.
        let superadmin_email = std::env::var("KOPROGO_SUPERADMIN_EMAIL")
            .unwrap_or_else(|_| "admin@koprogo.com".to_string());
        let superadmin_password =
            std::env::var("KOPROGO_SUPERADMIN_PASSWORD").unwrap_or_else(|_| "admin123".to_string());

        if superadmin_password == "admin123" {
            log::warn!(
                "SÉCURITÉ : le superadmin utilise le mot de passe par défaut, \
                 lisible dans le dépôt public. Renseignez \
                 KOPROGO_SUPERADMIN_PASSWORD."
            );
        }

        // Hash password
        let password_hash = hash(&superadmin_password, DEFAULT_COST)
            .map_err(|e| format!("Failed to hash password: {}", e))?;

        let superadmin_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")
            .map_err(|e| format!("Failed to parse UUID: {}", e))?;

        let now = Utc::now();

        // Upsert superadmin (insert or update if exists)
        sqlx::query!(
            r#"
            INSERT INTO users (id, email, password_hash, first_name, last_name, role, organization_id, is_active, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
            ON CONFLICT (email)
            DO UPDATE SET
                password_hash = EXCLUDED.password_hash,
                updated_at = EXCLUDED.updated_at,
                is_active = true
            "#,
            superadmin_id,
            superadmin_email,
            password_hash,
            "Super",
            "Admin",
            "superadmin",
            None::<Uuid>,
            true,
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to upsert superadmin: {}", e))?;

        // Upsert superadmin role (preserve if exists, create if missing)
        // Note: Use INSERT ... ON CONFLICT DO NOTHING for idempotency
        // The migration backfill (20250130000000) already creates the role with is_primary=true
        sqlx::query(
            r#"
            INSERT INTO user_roles (id, user_id, role, organization_id, is_primary, created_at, updated_at)
            VALUES (
                gen_random_uuid(),
                $1,
                'superadmin',
                NULL,
                NOT EXISTS (SELECT 1 FROM user_roles WHERE user_id = $1 AND is_primary = true),
                NOW(),
                NOW()
            )
            ON CONFLICT DO NOTHING
            "#,
        )
        .bind(superadmin_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to upsert superadmin role: {}", e))?;

        log::info!("✅ Superadmin ready: {}", superadmin_email);

        Ok(User {
            id: superadmin_id,
            email: superadmin_email.to_string(),
            password_hash,
            first_name: "Super".to_string(),
            last_name: "Admin".to_string(),
            role: UserRole::SuperAdmin,
            organization_id: None,
            is_active: true,
            processing_restricted: false,
            processing_restricted_at: None,
            marketing_opt_out: false,
            marketing_opt_out_at: None,
            created_at: now,
            updated_at: now,
        })
    }

    /// Seed Belgian PCMN (Plan Comptable Minimum Normalisé) for all organizations
    /// This ensures every organization has the base chart of accounts
    pub async fn seed_belgian_pcmn_for_all_organizations(&self) -> Result<String, String> {
        log::info!("🌱 Seeding Belgian PCMN for all organizations...");

        // Get all organizations
        let organizations = sqlx::query!("SELECT id FROM organizations")
            .fetch_all(&self.pool)
            .await
            .map_err(|e| format!("Failed to fetch organizations: {}", e))?;

        let mut total_created = 0;
        let mut orgs_seeded = 0;

        for org in organizations {
            let org_id = org.id;

            // Check if this organization already has accounts
            let existing_count = sqlx::query!(
                "SELECT COUNT(*) as count FROM accounts WHERE organization_id = $1",
                org_id
            )
            .fetch_one(&self.pool)
            .await
            .map_err(|e| format!("Failed to count accounts: {}", e))?;

            if existing_count.count.unwrap_or(0) > 0 {
                log::debug!(
                    "Organization {} already has {} accounts, skipping",
                    org_id,
                    existing_count.count.unwrap_or(0)
                );
                continue;
            }

            // Seed PCMN for this organization
            let created = self.seed_belgian_pcmn_for_org(org_id).await?;
            total_created += created;
            orgs_seeded += 1;
        }

        let message = format!(
            "✅ Seeded {} accounts across {} organizations",
            total_created, orgs_seeded
        );
        log::info!("{}", message);
        Ok(message)
    }

    /// Seed Belgian PCMN for a specific organization (idempotent)
    async fn seed_belgian_pcmn_for_org(&self, organization_id: Uuid) -> Result<i64, String> {
        // Base PCMN accounts based on Belgian accounting standards
        let base_accounts = vec![
            // Class 6: Charges (Expenses)
            (
                "6100",
                "Charges courantes",
                None,
                AccountType::Expense,
                true,
            ),
            (
                "6110",
                "Entretien et réparations",
                None,
                AccountType::Expense,
                true,
            ),
            ("6120", "Personnel", None, AccountType::Expense, true),
            (
                "6130",
                "Services extérieurs",
                None,
                AccountType::Expense,
                true,
            ),
            (
                "6140",
                "Honoraires et commissions",
                None,
                AccountType::Expense,
                true,
            ),
            ("6150", "Assurances", None, AccountType::Expense, true),
            (
                "6200",
                "Travaux extraordinaires",
                None,
                AccountType::Expense,
                true,
            ),
            // Class 7: Produits (Revenue)
            (
                "7000",
                "Produits de gestion",
                None,
                AccountType::Revenue,
                true,
            ),
            (
                "7100",
                "Appels de fonds",
                Some("7000"),
                AccountType::Revenue,
                true,
            ),
            (
                "7200",
                "Autres produits",
                Some("7000"),
                AccountType::Revenue,
                true,
            ),
            // Class 4: Tiers (Third parties)
            (
                "4000",
                "Comptes de tiers",
                None,
                AccountType::Liability,
                false,
            ),
            (
                "4100",
                "TVA à récupérer",
                Some("4000"),
                AccountType::Asset,
                true,
            ),
            (
                "4110",
                "TVA récupérable",
                Some("4100"),
                AccountType::Asset,
                true,
            ),
            (
                "4400",
                "Fournisseurs",
                Some("4000"),
                AccountType::Liability,
                true,
            ),
            (
                "4500",
                "Copropriétaires",
                Some("4000"),
                AccountType::Asset,
                true,
            ),
            // Class 5: Trésorerie (Cash/Bank)
            ("5500", "Banque", None, AccountType::Asset, true),
            ("5700", "Caisse", None, AccountType::Asset, true),
        ];

        let mut created_count = 0;

        for (code, label, parent_code, account_type, direct_use) in base_accounts {
            // Create account using domain entity
            let account = Account::new(
                code.to_string(),
                label.to_string(),
                parent_code.map(|s| s.to_string()),
                account_type,
                direct_use,
                organization_id,
            )?;

            // Insert into database (idempotent - skip if exists)
            let result = sqlx::query!(
                r#"
                INSERT INTO accounts (id, code, label, parent_code, account_type, direct_use, organization_id, created_at, updated_at)
                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
                ON CONFLICT (code, organization_id) DO NOTHING
                "#,
                account.id,
                account.code,
                account.label,
                account.parent_code,
                account.account_type as AccountType,
                account.direct_use,
                account.organization_id,
                account.created_at,
                account.updated_at
            )
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to insert account {}: {}", code, e))?;

            if result.rows_affected() > 0 {
                created_count += 1;
            }
        }

        log::info!(
            "Created {} PCMN accounts for organization {}",
            created_count,
            organization_id
        );
        Ok(created_count)
    }

    /// Seed demo data for production demonstration
    pub async fn seed_demo_data(&self) -> Result<String, String> {
        log::info!("🌱 Starting demo data seeding...");

        // Check if seed data already exists (only check for seed organizations, not all)
        let existing_seed_orgs =
            sqlx::query!("SELECT COUNT(*) as count FROM organizations WHERE is_seed_data = true")
                .fetch_one(&self.pool)
                .await
                .map_err(|e| format!("Failed to count seed organizations: {}", e))?;

        if existing_seed_orgs.count.unwrap_or(0) > 0 {
            return Err(
                "Seed data already exists. Please use 'Clear Seed Data' first.".to_string(),
            );
        }

        // ORGANIZATION 1
        let org1_id = Uuid::new_v4();
        let now = Utc::now();

        sqlx::query(
            r#"
            INSERT INTO organizations (id, name, slug, contact_email, contact_phone, subscription_plan, max_buildings, max_users, is_active, is_seed_data, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#
        )
        .bind(org1_id)
        .bind("Résidence Grand Place SPRL")
        .bind("residence-grand-place")
        .bind("contact@grandplace.be")
        .bind("+32 2 501 23 45")
        .bind("professional")
        .bind(20)
        .bind(50)
        .bind(true) // is_active
        .bind(true) // is_seed_data
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create demo organization 1: {}", e))?;

        log::info!("✅ Organization 1 created: Résidence Grand Place SPRL");

        // Create demo users ORG 1
        let syndic1_id = self
            .create_demo_user(
                "syndic@grandplace.be",
                "syndic123",
                "Jean",
                "Dupont",
                "syndic",
                Some(org1_id),
            )
            .await?;

        let _accountant_id = self
            .create_demo_user(
                "comptable@grandplace.be",
                "comptable123",
                "Marie",
                "Martin",
                "accountant",
                Some(org1_id),
            )
            .await?;

        let owner1_user_id = self
            .create_demo_user(
                "proprietaire1@grandplace.be",
                "owner123",
                "Pierre",
                "Durand",
                "owner",
                Some(org1_id),
            )
            .await?;

        let owner2_user_id = self
            .create_demo_user(
                "proprietaire2@grandplace.be",
                "owner123",
                "Sophie",
                "Bernard",
                "owner",
                Some(org1_id),
            )
            .await?;

        log::info!("✅ Demo users created");

        // Create demo buildings ORG 1
        let building1_id = self
            .create_demo_building(
                org1_id,
                "Résidence Grand Place",
                "Grand Place 15",
                "Bruxelles",
                "1000",
                "Belgique",
                15,
                1995,
            )
            .await?;

        let building2_id = self
            .create_demo_building(
                org1_id,
                "Les Jardins d'Ixelles",
                "Rue du Trône 85",
                "Bruxelles",
                "1050",
                "Belgique",
                8,
                2010,
            )
            .await?;

        log::info!("✅ Demo buildings created");

        // Create demo owners
        let owner1_db_id = self
            .create_demo_owner(
                org1_id,
                "Pierre",
                "Durand",
                "pierre.durand@email.be",
                "+32 476 12 34 56",
                "Avenue Louise 15",
                "Bruxelles",
                "1050",
                "Belgique",
            )
            .await?;

        let owner2_db_id = self
            .create_demo_owner(
                org1_id,
                "Sophie",
                "Bernard",
                "sophie.bernard@email.be",
                "+32 495 98 76 54",
                "Rue Royale 28",
                "Bruxelles",
                "1000",
                "Belgique",
            )
            .await?;

        let owner3_db_id = self
            .create_demo_owner(
                org1_id,
                "Michel",
                "Lefebvre",
                "michel.lefebvre@email.be",
                "+32 477 11 22 33",
                "Boulevard d'Avroy 42",
                "Liège",
                "4000",
                "Belgique",
            )
            .await?;

        log::info!("✅ Demo owners created");

        // Link users to owners (for portal access)
        sqlx::query("UPDATE owners SET user_id = $1 WHERE id = $2")
            .bind(owner1_user_id)
            .bind(owner1_db_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to link owner1 to user: {}", e))?;

        sqlx::query("UPDATE owners SET user_id = $1 WHERE id = $2")
            .bind(owner2_user_id)
            .bind(owner2_db_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to link owner2 to user: {}", e))?;

        log::info!("✅ Users linked to owners");

        // Create demo units (owner_id is now deprecated, set to None)
        let unit1_id = self
            .create_demo_unit(
                org1_id,
                building1_id,
                None, // owner_id deprecated
                "101",
                "apartment",
                Some(1),
                75.5,
                250.0,
            )
            .await?;

        let unit2_id = self
            .create_demo_unit(
                org1_id,
                building1_id,
                None, // owner_id deprecated
                "102",
                "apartment",
                Some(1),
                62.0,
                200.0,
            )
            .await?;

        let unit3_id = self
            .create_demo_unit(
                org1_id,
                building1_id,
                None, // owner_id deprecated
                "103",
                "apartment",
                Some(1),
                85.0,
                300.0,
            )
            .await?;

        let unit4_id = self
            .create_demo_unit(
                org1_id,
                building2_id,
                None, // owner_id deprecated
                "201",
                "apartment",
                Some(2),
                95.0,
                350.0,
            )
            .await?;

        log::info!("✅ Demo units created");

        // Create unit_owners relationships
        // Scenario 1: Unit 101 - Single owner (Pierre Durand 100%)
        self.create_demo_unit_owner(
            unit1_id,
            owner1_db_id,
            rust_decimal_macros::dec!(1), // 100%
            true,                         // primary contact
            None,                         // no end_date (active)
        )
        .await?;

        // Scenario 2: Unit 102 - Co-ownership (Sophie Bernard 60%, Michel Lefebvre 40%)
        self.create_demo_unit_owner(
            unit2_id,
            owner2_db_id,
            rust_decimal_macros::dec!(0.6), // 60%
            true,                           // primary contact
            None,
        )
        .await?;

        self.create_demo_unit_owner(
            unit2_id,
            owner3_db_id,
            rust_decimal_macros::dec!(0.4), // 40%
            false,                          // not primary contact
            None,
        )
        .await?;

        // Scenario 3: Unit 103 - Co-ownership with 3 owners (50%, 30%, 20%)
        self.create_demo_unit_owner(
            unit3_id,
            owner1_db_id,
            rust_decimal_macros::dec!(0.5), // 50%
            true,                           // primary contact
            None,
        )
        .await?;

        self.create_demo_unit_owner(
            unit3_id,
            owner2_db_id,
            rust_decimal_macros::dec!(0.3), // 30%
            false,
            None,
        )
        .await?;

        self.create_demo_unit_owner(
            unit3_id,
            owner3_db_id,
            rust_decimal_macros::dec!(0.2), // 20%
            false,
            None,
        )
        .await?;

        // Scenario 4: Unit 201 - Michel Lefebvre owns multiple units (100% of this one)
        self.create_demo_unit_owner(
            unit4_id,
            owner3_db_id,
            rust_decimal_macros::dec!(1), // 100%
            true,                         // primary contact
            None,
        )
        .await?;

        log::info!("✅ Demo unit_owners relationships created");

        // Seed Belgian PCMN accounts for this organization
        self.seed_pcmn_accounts(org1_id).await?;
        log::info!("✅ Belgian PCMN accounts seeded");

        // Create demo expenses with realistic Belgian VAT rates and accounting links
        // Expense 1: Quarterly condo fees (paid) - 21% VAT
        let expense1_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                "Charges copropriété T1 2025",
                4132.23, // HT
                21.0,    // VAT 21%
                "2025-01-15",
                "2025-02-15", // due date
                "administration",
                "paid",
                Some("Syndic Services SPRL"),
                Some("SYN-2025-001"),
                Some("6100"), // PCMN: Charges courantes
            )
            .await?;

        // Expense 2: Elevator repair (paid) - 21% VAT
        let expense2_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                "Réparation ascenseur - Remplacement moteur",
                2066.12, // HT
                21.0,    // VAT 21%
                "2025-02-10",
                "2025-03-10",
                "maintenance",
                "paid",
                Some("Ascenseurs Plus SA"),
                Some("ASC-2025-023"),
                Some("6110"), // PCMN: Entretien et réparations
            )
            .await?;

        // Expense 3: Quarterly condo fees building 2 (pending, will become overdue) - 21% VAT
        let expense3_id = self
            .create_demo_expense_with_vat(
                building2_id,
                org1_id,
                "Charges copropriété T1 2025",
                2479.34, // HT
                21.0,    // VAT 21%
                "2025-01-15",
                "2025-02-15", // OVERDUE (due 2 months ago)
                "administration",
                "overdue",
                Some("Syndic Services SPRL"),
                Some("SYN-2025-002"),
                Some("6100"), // PCMN: Charges courantes
            )
            .await?;

        // Expense 4: Cleaning (paid) - 6% VAT (reduced rate for certain services)
        let expense4_id = self
            .create_demo_expense_with_vat(
                building2_id,
                org1_id,
                "Nettoyage parties communes - Forfait annuel",
                1132.08, // HT
                6.0,     // VAT 6% (reduced rate)
                "2025-01-01",
                "2025-01-31",
                "cleaning",
                "paid",
                Some("CleanPro Belgium SPRL"),
                Some("CLN-2025-156"),
                Some("6130"), // PCMN: Services extérieurs
            )
            .await?;

        // Expense 5: Insurance (pending) - 0% VAT (insurance exempt)
        let expense5_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                "Assurance incendie immeuble 2025",
                1850.00, // HT (no VAT)
                0.0,     // VAT 0% (exempt)
                "2025-01-05",
                "2025-02-05",
                "insurance",
                "pending",
                Some("AXA Belgium"),
                Some("AXA-2025-8472"),
                Some("6150"), // PCMN: Assurances
            )
            .await?;

        // Expense 6: Facade works (pending approval) - 21% VAT
        let expense6_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                "Rénovation façade - Devis Entreprise Martin",
                12396.69, // HT
                21.0,     // VAT 21%
                "2025-03-01",
                "2025-04-30",
                "works",
                "pending",
                Some("Entreprise Martin & Fils SPRL"),
                Some("MART-2025-042"),
                Some("6200"), // PCMN: Travaux extraordinaires
            )
            .await?;

        // ===== CURRENT MONTH EXPENSES =====
        // Use relative dates based on today's date
        let now = Utc::now();
        let current_month = now.format("%B %Y").to_string();
        let month_start = format!("{}", now.format("%Y-%m-01"));
        let day_3 = format!("{}", now.format("%Y-%m-03"));
        let day_5 = format!("{}", now.format("%Y-%m-05"));
        let day_8 = format!("{}", now.format("%Y-%m-08"));
        let day_10 = format!("{}", now.format("%Y-%m-10"));
        let month_end = format!("{}", (now + chrono::Duration::days(30)).format("%Y-%m-%d"));

        // Expense 7: Elevator maintenance (current month) - paid - 21% VAT
        let expense7_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                &format!("Maintenance ascenseur {}", current_month),
                826.45, // HT
                21.0,   // VAT 21%
                &day_5,
                &month_end,
                "maintenance",
                "paid",
                Some("Ascenseurs Plus SA"),
                Some(&format!("ASC-{}-001", now.format("%Y-%m"))),
                Some("6110"), // PCMN: Entretien et réparations
            )
            .await?;

        // Expense 8: Electricity bill (current month) - paid - 21% VAT
        let expense8_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                &format!("Électricité communs {}", current_month),
                387.60, // HT
                21.0,   // VAT 21%
                &day_3,
                &format!("{}", (now + chrono::Duration::days(25)).format("%Y-%m-%d")),
                "utilities",
                "paid",
                Some("Engie Electrabel"),
                Some(&format!("ENGIE-{}-3847", now.format("%Y-%m"))),
                Some("6100"), // PCMN: Charges courantes (Électricité)
            )
            .await?;

        // Expense 9: Cleaning service (current month) - paid - 6% VAT
        let expense9_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                &format!("Nettoyage communs {}", current_month),
                471.70, // HT
                6.0,    // VAT 6% (labor-intensive services)
                &month_start,
                &format!("{}", (now + chrono::Duration::days(20)).format("%Y-%m-%d")),
                "cleaning",
                "paid",
                Some("NetClean Services SPRL"),
                Some(&format!("CLEAN-{}-074", now.format("%Y-%m"))),
                Some("6130"), // PCMN: Services extérieurs (Nettoyage)
            )
            .await?;

        // Expense 10: Water bill (current month) - pending - 6% VAT
        let expense10_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                &format!("Eau communs {}", current_month),
                156.60, // HT
                6.0,    // VAT 6%
                &day_8,
                &format!("{}", (now + chrono::Duration::days(30)).format("%Y-%m-%d")),
                "utilities",
                "pending",
                Some("Vivaqua"),
                Some(&format!("VIVA-{}-9284", now.format("%Y-%m"))),
                Some("6100"), // PCMN: Charges courantes (Eau)
            )
            .await?;

        // Expense 11: Heating gas (current month) - paid - 21% VAT
        let expense11_id = self
            .create_demo_expense_with_vat(
                building1_id,
                org1_id,
                &format!("Chauffage gaz {}", current_month),
                1240.00, // HT
                21.0,    // VAT 21%
                &day_10,
                &format!("{}", (now + chrono::Duration::days(30)).format("%Y-%m-%d")),
                "utilities",
                "paid",
                Some("Sibelga"),
                Some(&format!("SIBEL-{}-7453", now.format("%Y-%m"))),
                Some("6100"), // PCMN: Charges courantes (Chauffage)
            )
            .await?;

        log::info!("✅ Demo expenses with VAT created (including current month)");

        // Calculate and save charge distributions
        self.create_demo_distributions(expense1_id, org1_id).await?;
        self.create_demo_distributions(expense2_id, org1_id).await?;
        self.create_demo_distributions(expense3_id, org1_id).await?;
        self.create_demo_distributions(expense4_id, org1_id).await?;
        self.create_demo_distributions(expense5_id, org1_id).await?;
        self.create_demo_distributions(expense6_id, org1_id).await?;
        self.create_demo_distributions(expense7_id, org1_id).await?;
        self.create_demo_distributions(expense8_id, org1_id).await?;
        self.create_demo_distributions(expense9_id, org1_id).await?;
        self.create_demo_distributions(expense10_id, org1_id)
            .await?;
        self.create_demo_distributions(expense11_id, org1_id)
            .await?;
        log::info!("✅ Charge distributions calculated");

        // Create payment reminders for overdue expense
        self.create_demo_payment_reminder(
            expense3_id,
            owner2_db_id, // Sophie Bernard
            org1_id,
            "FirstReminder",
            20, // 20 days overdue
        )
        .await?;

        self.create_demo_payment_reminder(
            expense3_id,
            owner3_db_id, // Michel Lefebvre
            org1_id,
            "SecondReminder",
            35, // 35 days overdue
        )
        .await?;

        log::info!("✅ Payment reminders created");

        // Create owner contributions (revenue) for current month
        log::info!("Creating owner contributions...");

        // Get quarter number for current month (using Datelike trait)
        use chrono::Datelike;
        let quarter = ((now.month() - 1) / 3) + 1;
        let year = now.year();

        // Regular contributions (appels de fonds) for current month
        // Each owner pays quarterly fees
        self.create_demo_owner_contribution(
            org1_id,
            owner1_db_id, // Jean Dupont
            Some(unit1_id),
            &format!("Appel de fonds T{} {} - Charges courantes", quarter, year),
            650.0,
            "regular",
            &month_start,
            "paid",
            Some(&day_5),
            Some("7000"), // PCMN: Regular contributions
        )
        .await?;

        self.create_demo_owner_contribution(
            org1_id,
            owner2_db_id, // Sophie Bernard
            Some(unit2_id),
            &format!("Appel de fonds T{} {} - Charges courantes", quarter, year),
            750.0,
            "regular",
            &month_start,
            "paid",
            Some(&day_8),
            Some("7000"),
        )
        .await?;

        self.create_demo_owner_contribution(
            org1_id,
            owner3_db_id, // Michel Lefebvre
            Some(unit3_id),
            &format!("Appel de fonds T{} {} - Charges courantes", quarter, year),
            600.0,
            "regular",
            &month_start,
            "pending",
            None, // Not paid yet
            Some("7000"),
        )
        .await?;

        // Note: Only 3 owners in seed data, so we skip owner4

        // Extraordinary contribution for roof repairs (previous month)
        let prev_month = (now - chrono::Duration::days(20))
            .format("%Y-%m-05")
            .to_string();
        let prev_month_payment = (now - chrono::Duration::days(15))
            .format("%Y-%m-10")
            .to_string();

        self.create_demo_owner_contribution(
            org1_id,
            owner1_db_id, // Jean Dupont
            Some(unit1_id),
            "Appel de fonds extraordinaire - Réfection toiture",
            1200.0,
            "extraordinary",
            &prev_month,
            "paid",
            Some(&prev_month_payment),
            Some("7100"), // PCMN: Extraordinary contributions
        )
        .await?;

        self.create_demo_owner_contribution(
            org1_id,
            owner2_db_id, // Sophie Bernard
            Some(unit2_id),
            "Appel de fonds extraordinaire - Réfection toiture",
            1400.0,
            "extraordinary",
            &prev_month,
            "pending",
            None, // Not paid yet
            Some("7100"),
        )
        .await?;

        log::info!("✅ Owner contributions created");

        // Create meetings ORG 1 (in the past, 3-6 months ago)
        let meeting1_date = (now - chrono::Duration::days(90))
            .format("%Y-%m-%d")
            .to_string();
        let meeting2_date = (now - chrono::Duration::days(60))
            .format("%Y-%m-%d")
            .to_string();

        let meeting1_id = self
            .create_demo_meeting(
                building1_id,
                org1_id,
                &format!("Assemblée Générale Ordinaire {}", year),
                "ordinary",
                &meeting1_date,
                "completed",
            )
            .await?;

        let meeting2_id = self
            .create_demo_meeting(
                building2_id,
                org1_id,
                "Assemblée Générale Extraordinaire - Travaux",
                "extraordinary",
                &meeting2_date,
                "completed",
            )
            .await?;

        log::info!("✅ Demo meetings created");

        // Create board members ORG 1
        // Board mandates are for 1 year from meeting1_date
        let mandate_start = meeting1_date.clone();
        let mandate_end = (now + chrono::Duration::days(275))
            .format("%Y-%m-%d")
            .to_string(); // ~9 months from now

        // Elect owner1 as president for building1 (mandate: ~1 year as per Belgian law)
        self.create_demo_board_member(
            owner1_db_id,
            building1_id,
            org1_id,
            meeting1_id,
            "president",
            &mandate_start,
            &mandate_end,
        )
        .await?;

        // Elect owner2 as treasurer for building2 (mandate: ~1 year)
        self.create_demo_board_member(
            owner2_db_id,
            building2_id,
            org1_id,
            meeting2_id,
            "treasurer",
            &meeting2_date,
            &format!("{}", (now + chrono::Duration::days(305)).format("%Y-%m-%d")),
        )
        .await?;

        log::info!("✅ Demo board members elected");

        // Create board decisions ORG 1
        // Decision 1: Pending with deadline in 25 days (medium urgency)
        self.create_demo_board_decision(
            building1_id,
            org1_id,
            meeting1_id,
            "Rénovation de la façade",
            "Approuver les devis pour la rénovation de la façade principale",
            Some("2025-11-26"), // ~25 days from 2025-11-01
            "pending",
        )
        .await?;

        // Decision 2: In progress with deadline in 4 days (critical urgency)
        self.create_demo_board_decision(
            building1_id,
            org1_id,
            meeting1_id,
            "Contrat d'assurance",
            "Signer le nouveau contrat d'assurance avec AXA",
            Some("2025-11-05"), // 4 days from 2025-11-01
            "in_progress",
        )
        .await?;

        // Decision 3: Overdue (deadline passed)
        self.create_demo_board_decision(
            building1_id,
            org1_id,
            meeting1_id,
            "Nettoyage des gouttières",
            "Engager une entreprise pour le nettoyage annuel des gouttières",
            Some("2025-10-15"), // Past deadline
            "pending",
        )
        .await?;

        // Decision 4: Completed
        self.create_demo_board_decision(
            building1_id,
            org1_id,
            meeting1_id,
            "Installation caméras",
            "Installation du système de vidéosurveillance dans le hall",
            Some("2025-10-01"),
            "completed",
        )
        .await?;

        // Decision 5: Pending with deadline in 10 days (high urgency)
        self.create_demo_board_decision(
            building2_id,
            org1_id,
            meeting2_id,
            "Remplacement chaudière",
            "Valider le choix du fournisseur pour la nouvelle chaudière",
            Some("2025-11-11"), // 10 days from 2025-11-01
            "pending",
        )
        .await?;

        // Decision 6: In progress with deadline in 20 days (medium urgency)
        self.create_demo_board_decision(
            building2_id,
            org1_id,
            meeting2_id,
            "Aménagement parking vélos",
            "Organiser l'aménagement du parking à vélos au rez-de-chaussée",
            Some("2025-11-21"), // 20 days from 2025-11-01
            "in_progress",
        )
        .await?;

        log::info!("✅ Demo board decisions created");

        // Create documents ORG 1
        self.create_demo_document(
            building1_id,
            org1_id,
            "Procès-Verbal AG 2024",
            "meeting_minutes",
            "/uploads/demo/pv-ag-2024.pdf",
            syndic1_id,
        )
        .await?;

        self.create_demo_document(
            building1_id,
            org1_id,
            "Règlement de copropriété",
            "regulation",
            "/uploads/demo/reglement.pdf",
            syndic1_id,
        )
        .await?;

        log::info!("✅ Demo documents created");

        // ORGANIZATION 2 - Bruxelles
        let org2_id = Uuid::new_v4();
        sqlx::query(
            r#"
            INSERT INTO organizations (id, name, slug, contact_email, contact_phone, subscription_plan, max_buildings, max_users, is_active, is_seed_data, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#
        )
        .bind(org2_id)
        .bind("Copropriété Bruxelles SPRL")
        .bind("copro-bruxelles")
        .bind("info@copro-bruxelles.be")
        .bind("+32 2 123 45 67")
        .bind("starter")
        .bind(5)
        .bind(10)
        .bind(true) // is_active
        .bind(true) // is_seed_data
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create demo organization 2: {}", e))?;

        let _syndic2_id = self
            .create_demo_user(
                "syndic@copro-bruxelles.be",
                "syndic123",
                "Marc",
                "Dubois",
                "syndic",
                Some(org2_id),
            )
            .await?;

        let building3_id = self
            .create_demo_building(
                org2_id,
                "Résidence Européenne",
                "Avenue Louise 123",
                "Bruxelles",
                "1050",
                "Belgique",
                12,
                2005,
            )
            .await?;

        self.create_demo_meeting(
            building3_id,
            org2_id,
            "AG Annuelle 2025",
            "ordinary",
            "2025-05-10",
            "scheduled",
        )
        .await?;

        log::info!("✅ Organization 2 created");

        // ORGANIZATION 3 - Liège
        let org3_id = Uuid::new_v4();
        sqlx::query(
            r#"
            INSERT INTO organizations (id, name, slug, contact_email, contact_phone, subscription_plan, max_buildings, max_users, is_active, is_seed_data, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#
        )
        .bind(org3_id)
        .bind("Syndic Liège SA")
        .bind("syndic-liege")
        .bind("contact@syndic-liege.be")
        .bind("+32 4 222 33 44")
        .bind("enterprise")
        .bind(50)
        .bind(100)
        .bind(true) // is_active
        .bind(true) // is_seed_data
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create demo organization 3: {}", e))?;

        let _syndic3_id = self
            .create_demo_user(
                "syndic@syndic-liege.be",
                "syndic123",
                "Sophie",
                "Lambert",
                "syndic",
                Some(org3_id),
            )
            .await?;

        let _building4_id = self
            .create_demo_building(
                org3_id,
                "Les Terrasses de Liège",
                "Boulevard de la Sauvenière 45",
                "Liège",
                "4000",
                "Belgique",
                8,
                2018,
            )
            .await?;

        log::info!("✅ Organization 3 created");

        Ok("✅ Demo data seeded successfully!\n\n\
            📊 Summary:\n\
            - 3 Organizations: Grand Place (Bruxelles), Bruxelles Louise, Liège\n\
            - 6+ Users: 3 Syndics, 1 Accountant, 2+ Owners\n\
            - 4 Buildings across Belgium\n\
            - 3 Owners (database records)\n\
            - 4 Units\n\
            - 4 Expenses\n\
            - 3 Meetings\n\
            - 2 Documents\n\n\
            🇧🇪 Belgian Demo - Credentials:\n\
            - Org 1 (Grand Place): syndic@grandplace.be / syndic123\n\
            - Org 2 (Bruxelles): syndic@copro-bruxelles.be / syndic123\n\
            - Org 3 (Liège): syndic@syndic-liege.be / syndic123\n\
            - SuperAdmin: admin@koprogo.com / admin123"
            .to_string())
    }

    async fn create_demo_user(
        &self,
        email: &str,
        password: &str,
        first_name: &str,
        last_name: &str,
        role: &str,
        organization_id: Option<Uuid>,
    ) -> Result<Uuid, String> {
        // Empreinte PRÉCALCULÉE si elle l'a été, sinon hachée ici.
        //
        // `precalculer_empreintes` lance les bcrypt de front avant les
        // boucles de création ; ce chemin-ci reste pour les comptes créés à
        // l'unité, hors liste.
        //
        // Dans les deux cas le hachage sort des threads de travail Actix,
        // comme #718 l'a fait pour l'authentification : sinon un semis gèle
        // l'API entière quand `ACTIX_WORKERS` vaut 1.
        let deja_connue = self.cache_empreintes().get(password).cloned();
        let password_hash = match deja_connue {
            Some(empreinte) => empreinte,
            None => {
                let mot_de_passe = password.to_string();
                tokio::task::spawn_blocking(move || hash(&mot_de_passe, DEFAULT_COST))
                    .await
                    .map_err(|e| format!("Hachage interrompu : {e}"))?
                    .map_err(|e| format!("Failed to hash password: {}", e))?
            }
        };

        let user_id = Uuid::new_v4();
        let now = Utc::now();

        sqlx::query!(
            r#"
            INSERT INTO users (id, email, password_hash, first_name, last_name, role, organization_id, is_active, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
            "#,
            user_id,
            email,
            password_hash,
            first_name,
            last_name,
            role,
            organization_id,
            true,
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create user {}: {}", email, e))?;

        sqlx::query(
            r#"
            INSERT INTO user_roles (id, user_id, role, organization_id, is_primary, created_at, updated_at)
            VALUES (gen_random_uuid(), $1, $2, $3, true, $4, $4)
            ON CONFLICT (user_id, role, organization_id)
            DO UPDATE SET is_primary = true, updated_at = EXCLUDED.updated_at
            "#,
        )
        .bind(user_id)
        .bind(role)
        .bind(organization_id)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to assign role {} to user {}: {}", role, email, e))?;

        Ok(user_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_building(
        &self,
        org_id: Uuid,
        name: &str,
        address: &str,
        city: &str,
        postal_code: &str,
        country: &str,
        total_units: i32,
        construction_year: i32,
    ) -> Result<Uuid, String> {
        let building_id = Uuid::new_v4();
        let now = Utc::now();
        // Hotfix #602 follow-up : resolve acp_id from org_id
        let acp_id = self.ensure_default_acp_for_org(org_id).await?;

        sqlx::query!(
            r#"
            INSERT INTO buildings (id, acp_id, name, address, city, postal_code, country, total_units, construction_year, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
            "#,
            building_id,
            acp_id,
            name,
            address,
            city,
            postal_code,
            country,
            total_units,
            construction_year,
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create building {}: {}", name, e))?;

        Ok(building_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_owner(
        &self,
        organization_id: Uuid,
        first_name: &str,
        last_name: &str,
        email: &str,
        phone: &str,
        address: &str,
        city: &str,
        postal_code: &str,
        country: &str,
    ) -> Result<Uuid, String> {
        let owner_id = Uuid::new_v4();
        let now = Utc::now();

        sqlx::query!(
            r#"
            INSERT INTO owners (id, organization_id, first_name, last_name, email, phone, address, city, postal_code, country, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#,
            owner_id,
            organization_id,
            first_name,
            last_name,
            email,
            phone,
            address,
            city,
            postal_code,
            country,
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create owner {} {}: {}", first_name, last_name, e))?;

        Ok(owner_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_unit(
        &self,
        // Story H15 — units.organization_id a été DROP ; le lot dérive son
        // acp_id de son building parent (sous-requête ci-dessous). Param
        // conservé pour la signature des appelants (scope org du seed).
        _organization_id: Uuid,
        building_id: Uuid,
        owner_id: Option<Uuid>,
        unit_number: &str,
        unit_type: &str,
        floor: Option<i32>,
        surface_area: f64,
        quota: f64,
    ) -> Result<Uuid, String> {
        let unit_id = Uuid::new_v4();
        let now = Utc::now();

        sqlx::query(
            r#"
            INSERT INTO units (id, acp_id, building_id, owner_id, unit_number, unit_type, floor, surface_area, quota, created_at, updated_at)
            VALUES ($1, (SELECT acp_id FROM buildings WHERE id = $2), $2, $3, $4, $5::unit_type, $6, $7, $8, $9, $10)
            "#
        )
        .bind(unit_id)
        .bind(building_id)
        .bind(owner_id)
        .bind(unit_number)
        .bind(unit_type)
        .bind(floor)
        .bind(surface_area)
        .bind(quota)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create unit {}: {}", unit_number, e))?;

        Ok(unit_id)
    }

    async fn create_demo_unit_owner(
        &self,
        unit_id: Uuid,
        owner_id: Uuid,
        ownership_percentage: rust_decimal::Decimal,
        is_primary_contact: bool,
        end_date: Option<chrono::DateTime<Utc>>,
    ) -> Result<Uuid, String> {
        let unit_owner_id = Uuid::new_v4();
        let now = Utc::now();

        sqlx::query!(
            r#"
            INSERT INTO unit_owners (id, unit_id, owner_id, ownership_percentage, start_date, end_date, is_primary_contact, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
            "#,
            unit_owner_id,
            unit_id,
            owner_id,
            ownership_percentage,
            now, // start_date
            end_date,
            is_primary_contact,
            now, // created_at
            now  // updated_at
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create unit_owner relationship: {}", e))?;

        Ok(unit_owner_id)
    }

    #[allow(dead_code)]
    #[allow(clippy::too_many_arguments)]
    async fn create_demo_expense(
        &self,
        building_id: Uuid,
        organization_id: Uuid,
        description: &str,
        amount: f64,
        expense_date: &str,
        category: &str,
        payment_status: &str,
        supplier: Option<&str>,
        invoice_number: Option<&str>,
    ) -> Result<Uuid, String> {
        let expense_id = Uuid::new_v4();
        let now = Utc::now();
        let expense_date_parsed =
            chrono::DateTime::parse_from_rfc3339(&format!("{}T00:00:00Z", expense_date))
                .map_err(|e| format!("Failed to parse date: {}", e))?
                .with_timezone(&Utc);

        // Set approval_status based on payment_status
        let approval_status = if payment_status == "paid" {
            "approved" // If already paid, it must be approved
        } else {
            "draft" // Otherwise, start as draft
        };

        // Set paid_date if already paid
        let paid_date = if payment_status == "paid" {
            Some(expense_date_parsed)
        } else {
            None
        };

        // Check if expense already exists (idempotency)
        let existing: Option<(Uuid,)> =
            sqlx::query_as("SELECT id FROM expenses WHERE description = $1 AND building_id = $2")
                .bind(description)
                .bind(building_id)
                .fetch_optional(&self.pool)
                .await
                .map_err(|e| format!("Failed to check existing expense: {}", e))?;

        let final_expense_id = if let Some((existing_id,)) = existing {
            // Update existing expense
            sqlx::query(
                r#"
                UPDATE expenses SET
                    category = $1::expense_category,
                    amount = $2,
                    expense_date = $3,
                    payment_status = $4::payment_status,
                    approval_status = $5::approval_status,
                    paid_date = $6,
                    supplier = $7,
                    invoice_number = $8,
                    updated_at = $9
                WHERE id = $10
                "#,
            )
            .bind(category)
            .bind(amount)
            .bind(expense_date_parsed)
            .bind(payment_status)
            .bind(approval_status)
            .bind(paid_date)
            .bind(supplier)
            .bind(invoice_number)
            .bind(now)
            .bind(existing_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to update expense: {}", e))?;
            existing_id
        } else {
            // Insert new expense
            sqlx::query(
                r#"
                -- L'ACP se deduit de l'immeuble : la depense appartient a la
                -- copropriete, pas au syndic qui la saisit (ADR-0045).
                INSERT INTO expenses (id, acp_id, organization_id, building_id, category, description, amount, expense_date, payment_status, approval_status, paid_date, supplier, invoice_number, created_at, updated_at)
                VALUES ($1, (SELECT acp_id FROM buildings WHERE id = $3), $2, $3, $4::expense_category, $5, $6, $7, $8::payment_status, $9::approval_status, $10, $11, $12, $13, $14)
                "#
            )
            .bind(expense_id)
            .bind(organization_id)
            .bind(building_id)
            .bind(category)
            .bind(description)
            .bind(amount)
            .bind(expense_date_parsed)
            .bind(payment_status)
            .bind(approval_status)
            .bind(paid_date)
            .bind(supplier)
            .bind(invoice_number)
            .bind(now)
            .bind(now)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to create expense: {}", e))?;
            expense_id
        };

        Ok(final_expense_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_meeting(
        &self,
        building_id: Uuid,
        org_id: Uuid,
        title: &str,
        meeting_type: &str,
        scheduled_date: &str,
        status: &str,
    ) -> Result<Uuid, String> {
        let meeting_id = Uuid::new_v4();
        let now = Utc::now();
        let scheduled_date_parsed =
            chrono::DateTime::parse_from_rfc3339(&format!("{}T10:00:00Z", scheduled_date))
                .map_err(|e| format!("Failed to parse date: {}", e))?
                .with_timezone(&Utc);

        let agenda_json = serde_json::json!([
            "Approbation des comptes",
            "Travaux à prévoir",
            "Questions diverses"
        ]);

        sqlx::query(
            r#"
            -- Idem : l'assemblee est celle de l'ACP (ADR-0045).
            INSERT INTO meetings (id, acp_id, building_id, organization_id, meeting_type, title, description, scheduled_date, location, status, agenda, created_at, updated_at)
            VALUES ($1, (SELECT acp_id FROM buildings WHERE id = $2), $2, $3, $4::meeting_type, $5, $6, $7, $8, $9::meeting_status, $10, $11, $12)
            "#
        )
        .bind(meeting_id)
        .bind(building_id)
        .bind(org_id)
        .bind(meeting_type)
        .bind(title)
        .bind(Some("Assemblée générale annuelle"))
        .bind(scheduled_date_parsed)
        .bind("Salle polyvalente")
        .bind(status)
        .bind(agenda_json)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create meeting: {}", e))?;

        Ok(meeting_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_document(
        &self,
        building_id: Uuid,
        org_id: Uuid,
        title: &str,
        document_type: &str,
        file_path: &str,
        uploaded_by: Uuid,
    ) -> Result<Uuid, String> {
        let document_id = Uuid::new_v4();
        let now = Utc::now();

        sqlx::query(
            r#"
            INSERT INTO documents (id, building_id, organization_id, document_type, title, description, file_path, file_size, mime_type, uploaded_by, created_at, updated_at)
            VALUES ($1, $2, $3, $4::document_type, $5, $6, $7, $8, $9, $10, $11, $12)
            "#
        )
        .bind(document_id)
        .bind(building_id)
        .bind(org_id)
        .bind(document_type)
        .bind(title)
        .bind(Some("Document de démonstration"))
        .bind(file_path)
        .bind(1024_i64)
        .bind("application/pdf")
        .bind(uploaded_by)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create document: {}", e))?;

        Ok(document_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_board_member(
        &self,
        owner_id: Uuid,
        building_id: Uuid,
        org_id: Uuid,
        meeting_id: Uuid,
        position: &str,
        mandate_start: &str,
        mandate_end: &str,
    ) -> Result<Uuid, String> {
        let board_member_id = Uuid::new_v4();
        let now = Utc::now();

        let mandate_start_parsed = NaiveDate::parse_from_str(mandate_start, "%Y-%m-%d")
            .map_err(|e| format!("Failed to parse mandate_start date: {}", e))?
            .and_hms_opt(0, 0, 0)
            .ok_or("Failed to create datetime")?;

        let mandate_end_parsed = NaiveDate::parse_from_str(mandate_end, "%Y-%m-%d")
            .map_err(|e| format!("Failed to parse mandate_end date: {}", e))?
            .and_hms_opt(0, 0, 0)
            .ok_or("Failed to create datetime")?;

        sqlx::query(
            r#"
            INSERT INTO board_members (id, owner_id, building_id, organization_id, position, mandate_start, mandate_end, elected_by_meeting_id, is_active, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5::board_position, $6, $7, $8, $9, $10, $11)
            "#
        )
        .bind(board_member_id)
        .bind(owner_id)
        .bind(building_id)
        .bind(org_id)
        .bind(position)
        .bind(mandate_start_parsed)
        .bind(mandate_end_parsed)
        .bind(meeting_id)
        .bind(true)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create board member: {}", e))?;

        Ok(board_member_id)
    }

    #[allow(clippy::too_many_arguments)]
    async fn create_demo_board_decision(
        &self,
        building_id: Uuid,
        org_id: Uuid,
        meeting_id: Uuid,
        subject: &str,
        decision_text: &str,
        deadline: Option<&str>,
        status: &str,
    ) -> Result<Uuid, String> {
        let decision_id = Uuid::new_v4();
        let now = Utc::now();

        let deadline_parsed = if let Some(deadline_str) = deadline {
            Some(
                NaiveDate::parse_from_str(deadline_str, "%Y-%m-%d")
                    .map_err(|e| format!("Failed to parse deadline date: {}", e))?
                    .and_hms_opt(0, 0, 0)
                    .ok_or("Failed to create datetime")?,
            )
        } else {
            None
        };

        sqlx::query(
            r#"
            INSERT INTO board_decisions (id, building_id, organization_id, meeting_id, subject, decision_text, deadline, status, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8::decision_status, $9, $10)
            "#
        )
        .bind(decision_id)
        .bind(building_id)
        .bind(org_id)
        .bind(meeting_id)
        .bind(subject)
        .bind(decision_text)
        .bind(deadline_parsed)
        .bind(status)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create board decision: {}", e))?;

        Ok(decision_id)
    }

    /// Seed realistic data for load testing (optimized for 1 vCPU / 2GB RAM)
    /// Generates: 3 orgs, ~23 buildings, ~190 units, ~127 owners, ~60 expenses
    pub async fn seed_realistic_data(&self) -> Result<String, String> {
        log::info!("🌱 Starting realistic data seeding...");

        // Check if data already exists
        let existing_orgs = sqlx::query("SELECT COUNT(*) as count FROM organizations")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| format!("Failed to count organizations: {}", e))?;

        let count: i64 = existing_orgs
            .try_get("count")
            .map_err(|e| format!("Failed to get count: {}", e))?;
        if count > 0 {
            return Err("Data already exists. Please clear the database first.".to_string());
        }

        let mut rng = rand::rng();

        // Belgian cities for variety
        let cities = [
            "Bruxelles",
            "Anvers",
            "Gand",
            "Charleroi",
            "Liège",
            "Bruges",
            "Namur",
            "Louvain",
        ];
        let street_types = ["Rue", "Avenue", "Boulevard", "Place", "Chaussée"];
        let street_names = [
            "des Fleurs",
            "du Parc",
            "de la Gare",
            "Royale",
            "de l'Église",
            "du Commerce",
            "de la Liberté",
            "des Arts",
            "Victor Hugo",
            "Louise",
        ];

        // Create 3 organizations with different sizes
        let org_configs = [
            ("Petite Copropriété SPRL", "small", 5, 30), // 5 buildings, ~30 units
            ("Copropriété Moyenne SA", "medium", 8, 60), // 8 buildings, ~60 units
            ("Grande Résidence NV", "large", 10, 100),   // 10 buildings, ~100 units
        ];

        let mut total_buildings = 0;
        let mut total_units = 0;
        let mut total_owners = 0;
        let mut total_expenses = 0;

        for (idx, (org_name, size, num_buildings, target_units)) in org_configs.iter().enumerate() {
            let org_id = Uuid::new_v4();
            let now = Utc::now();

            log::info!(
                "📍 Organization {}: {} ({} buildings, ~{} units)",
                idx + 1,
                org_name,
                num_buildings,
                target_units
            );

            // Create organization
            sqlx::query(
                "INSERT INTO organizations (id, name, slug, contact_email, contact_phone, subscription_plan, max_buildings, max_users, is_active, created_at, updated_at)
                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)"
            )
            .bind(org_id)
            .bind(*org_name)
            .bind(format!("{}-{}", size, idx))
            .bind(format!("contact@{}.be", size))
            .bind(format!("+32 2 {} {} {}", rng.random_range(100..999), rng.random_range(10..99), rng.random_range(10..99)))
            .bind(if *size == "large" { "enterprise" } else if *size == "medium" { "professional" } else { "starter" })
            .bind(*num_buildings)
            .bind(if *size == "large" { 50 } else if *size == "medium" { 20 } else { 10 })
            .bind(true)
            .bind(now)
            .bind(now)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to create organization: {}", e))?;

            // Create admin user for this org
            let user_id = Uuid::new_v4();
            let password_hash = hash("admin123", DEFAULT_COST)
                .map_err(|e| format!("Failed to hash password: {}", e))?;

            sqlx::query(
                "INSERT INTO users (id, email, password_hash, first_name, last_name, role, organization_id, is_active, created_at, updated_at)
                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
            )
            .bind(user_id)
            .bind(format!("admin@{}.be", size))
            .bind(&password_hash)
            .bind("Admin")
            .bind(org_name.split_whitespace().next().unwrap_or("User"))
            .bind("syndic")
            .bind(Some(org_id))
            .bind(true)
            .bind(now)
            .bind(now)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to create user: {}", e))?;

            // Create owners pool for this org
            let num_owners = (target_units * 2 / 3) as usize; // ~66% occupancy
            let mut owner_ids = Vec::new();

            for o in 0..num_owners {
                let owner_id = Uuid::new_v4();

                // Use faker for realistic Belgian data
                let first_name: String = FirstName().fake();
                let last_name: String = LastName().fake();
                let street: String = StreetName().fake();
                let city_idx = rng.random_range(0..cities.len());
                let owner_city = cities[city_idx];

                sqlx::query(
                    "INSERT INTO owners (id, organization_id, first_name, last_name, email, phone, address, city, postal_code, country, created_at, updated_at)
                     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)"
                )
                .bind(owner_id)
                .bind(org_id)
                .bind(&first_name)
                .bind(&last_name)
                .bind(format!("{}. {}{}@{}.be", first_name.chars().next().unwrap_or('x'), last_name.to_lowercase(), o + 1, size))
                .bind(format!("+32 {} {} {} {}",
                    if rng.random_bool(0.5) { "2" } else { "4" },
                    rng.random_range(100..999),
                    rng.random_range(10..99),
                    rng.random_range(10..99)
                ))
                .bind(format!("{} {}", street, rng.random_range(1..200)))
                .bind(owner_city)
                .bind(format!("{}", rng.random_range(1000..9999)))
                .bind("Belgium")
                .bind(now)
                .bind(now)
                .execute(&self.pool)
                .await
                .map_err(|e| format!("Failed to create owner: {}", e))?;

                owner_ids.push(owner_id);
            }

            total_owners += num_owners;

            // Create buildings for this org
            let units_per_building = target_units / num_buildings;
            let mut org_units = 0;
            // Hotfix #602 follow-up : resolve acp_id once for all buildings of this org
            let acp_id = self.ensure_default_acp_for_org(org_id).await?;

            for b in 0..*num_buildings {
                let building_id = Uuid::new_v4();
                let city = cities[rng.random_range(0..cities.len())];
                let street_type = street_types[rng.random_range(0..street_types.len())];
                let street_name = street_names[rng.random_range(0..street_names.len())];
                let building_name = format!("Résidence {}", street_name);

                sqlx::query(
                    "INSERT INTO buildings (id, acp_id, name, address, city, postal_code, country, total_units, construction_year, created_at, updated_at)
                     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)"
                )
                .bind(building_id)
                .bind(acp_id)
                .bind(&building_name)
                .bind(format!("{} {} {}", street_type, street_name, rng.random_range(1..200)))
                .bind(city)
                .bind(format!("{}", rng.random_range(1000..9999)))
                .bind("Belgium")
                .bind(units_per_building)
                .bind(rng.random_range(1960..2024))
                .bind(now)
                .bind(now)
                .execute(&self.pool)
                .await
                .map_err(|e| format!("Failed to create building: {}", e))?;

                // Create units for this building
                let units_this_building = if b == num_buildings - 1 {
                    // Last building gets remainder
                    target_units - org_units
                } else {
                    units_per_building
                };

                for u in 0..units_this_building {
                    let floor = u / 4; // 4 units per floor
                    let unit_number = format!("{}.{}", floor, (u % 4) + 1);

                    // 66% chance to have an owner
                    let owner_id = if rng.random_bool(0.66) && !owner_ids.is_empty() {
                        Some(owner_ids[rng.random_range(0..owner_ids.len())])
                    } else {
                        None
                    };

                    // Valid unit_type ENUM values: apartment, parking, cellar, commercial, other
                    let unit_types = ["apartment", "apartment", "apartment", "parking", "cellar"];
                    let unit_type = unit_types[rng.random_range(0..unit_types.len())];

                    sqlx::query(
                        // Story H15 — acp_id dérivé du building parent (units.organization_id DROP).
                        "INSERT INTO units (id, acp_id, building_id, unit_number, unit_type, floor, surface_area, quota, owner_id, created_at, updated_at)
                         VALUES ($1, (SELECT acp_id FROM buildings WHERE id = $2), $2, $3, $4::unit_type, $5, $6, $7, $8, $9, $10)"
                    )
                    .bind(Uuid::new_v4())
                    .bind(building_id)
                    .bind(&unit_number)
                    .bind(unit_type)
                    .bind(floor)
                    .bind(rng.random_range(45.0..150.0))
                    .bind(rng.random_range(50..200) as i32)
                    .bind(owner_id)
                    .bind(now)
                    .bind(now)
                    .execute(&self.pool)
                    .await
                    .map_err(|e| format!("Failed to create unit: {}", e))?;
                }

                org_units += units_this_building;

                // Check if expenses already exist for this building (idempotency)
                let existing_expenses: (i64,) =
                    sqlx::query_as("SELECT COUNT(*) FROM expenses WHERE building_id = $1")
                        .bind(building_id)
                        .fetch_one(&self.pool)
                        .await
                        .map_err(|e| format!("Failed to check existing expenses: {}", e))?;

                // Only create random expenses if none exist yet
                if existing_expenses.0 == 0 {
                    // Create 2-3 expenses per building
                    let num_expenses = rng.random_range(2..=3);
                    let expense_types = [
                        ("Entretien ascenseur", 450.0, 800.0),
                        ("Nettoyage parties communes", 300.0, 600.0),
                        ("Chauffage collectif", 1500.0, 3000.0),
                        ("Assurance immeuble", 800.0, 1500.0),
                        ("Travaux façade", 5000.0, 15000.0),
                    ];

                    for _ in 0..num_expenses {
                        let (desc, min_amount, max_amount) =
                            expense_types[rng.random_range(0..expense_types.len())];
                        let amount = rng.random_range(min_amount..max_amount);
                        let days_ago = rng.random_range(0..90);
                        let expense_date = Utc::now() - chrono::Duration::days(days_ago);

                        // Valid expense_category ENUM: maintenance, repairs, insurance, utilities, cleaning, administration, works, other
                        let categories = [
                            "maintenance",
                            "repairs",
                            "insurance",
                            "utilities",
                            "cleaning",
                            "administration",
                            "works",
                        ];
                        let category = categories[rng.random_range(0..categories.len())];

                        // Valid payment_status ENUM: pending, paid, overdue, cancelled
                        let payment_status = if rng.random_bool(0.7) {
                            "paid"
                        } else {
                            "pending"
                        };

                        // Set approval_status based on payment_status
                        let approval_status = if payment_status == "paid" {
                            "approved" // If already paid, it must be approved
                        } else {
                            "draft" // Otherwise, start as draft
                        };

                        // Set paid_date if already paid
                        let paid_date = if payment_status == "paid" {
                            Some(expense_date)
                        } else {
                            None
                        };

                        sqlx::query(
                        "INSERT INTO expenses (id, acp_id, organization_id, building_id, category, description, amount, expense_date, payment_status, approval_status, paid_date, created_at, updated_at)
                         VALUES ($1, (SELECT acp_id FROM buildings WHERE id = $3), $2, $3, $4::expense_category, $5, $6, $7, $8::payment_status, $9::approval_status, $10, $11, $12)"
                    )
                    .bind(Uuid::new_v4())
                    .bind(org_id)
                    .bind(building_id)
                    .bind(category)
                    .bind(desc)
                    .bind(amount)
                    .bind(expense_date)
                    .bind(payment_status)
                    .bind(approval_status)
                    .bind(paid_date)
                    .bind(now)
                    .bind(now)
                    .execute(&self.pool)
                    .await
                    .map_err(|e| format!("Failed to create expense: {}", e))?;

                        total_expenses += 1;
                    }
                } // End if existing_expenses.0 == 0
            }

            total_buildings += num_buildings;
            total_units += org_units as usize;

            log::info!(
                "  ✅ Created {} buildings, {} units, {} owners",
                num_buildings,
                org_units,
                num_owners
            );
        }

        Ok(format!(
            "✅ Realistic seed data created successfully!\n\
             Total: {} orgs, {} buildings, {} units, {} owners, {} expenses\n\
             \nTest credentials:\n\
             - Small org:  admin@small.be / admin123\n\
             - Medium org: admin@medium.be / admin123\n\
             - Large org:  admin@large.be / admin123",
            org_configs.len(),
            total_buildings,
            total_units,
            total_owners,
            total_expenses
        ))
    }

    /// Seed Belgian PCMN accounts for an organization
    async fn seed_pcmn_accounts(&self, organization_id: Uuid) -> Result<(), String> {
        // Call the existing account seeding endpoint logic
        // We'll seed the essential accounts for demo purposes
        let accounts = vec![
            // Class 6: Charges (Expenses)
            ("6100", "Charges courantes", "EXPENSE"),
            ("6110", "Entretien et réparations", "EXPENSE"),
            ("6120", "Personnel", "EXPENSE"),
            ("6130", "Services extérieurs", "EXPENSE"),
            ("6140", "Honoraires et commissions", "EXPENSE"),
            ("6150", "Assurances", "EXPENSE"),
            ("6200", "Travaux extraordinaires", "EXPENSE"),
            // Class 7: Produits (Revenue)
            ("7000", "Appels de fonds ordinaires", "REVENUE"),
            ("7100", "Appels de fonds extraordinaires", "REVENUE"),
            ("7200", "Autres produits", "REVENUE"),
            // Class 4: Créances et dettes (Assets/Liabilities)
            ("4000", "Copropriétaires débiteurs", "ASSET"),
            ("4110", "TVA à récupérer", "ASSET"),
            ("4400", "Fournisseurs", "LIABILITY"),
            ("4500", "TVA à payer", "LIABILITY"),
            // Class 5: Trésorerie (Assets)
            ("5500", "Banque compte courant", "ASSET"),
            ("5700", "Caisse", "ASSET"),
        ];

        let now = Utc::now();

        for (code, label, account_type_str) in accounts {
            sqlx::query(
                r#"
                INSERT INTO accounts (id, code, label, parent_code, account_type, direct_use, organization_id, created_at, updated_at)
                VALUES ($1, $2, $3, $4, $5::account_type, $6, $7, $8, $9)
                ON CONFLICT (code, organization_id) DO NOTHING
                "#
            )
            .bind(Uuid::new_v4())
            .bind(code)
            .bind(label)
            .bind(None::<String>) // parent_code
            .bind(account_type_str)
            .bind(true) // direct_use
            .bind(organization_id)
            .bind(now)
            .bind(now)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to seed account {}: {}", code, e))?;
        }

        Ok(())
    }

    /// Create a demo expense with VAT calculation
    #[allow(clippy::too_many_arguments)]
    async fn create_demo_expense_with_vat(
        &self,
        building_id: Uuid,
        organization_id: Uuid,
        description: &str,
        amount_excl_vat: f64,
        vat_rate: f64,
        expense_date: &str,
        due_date: &str,
        category: &str,
        payment_status: &str,
        supplier: Option<&str>,
        invoice_number: Option<&str>,
        account_code: Option<&str>,
    ) -> Result<Uuid, String> {
        let expense_id = Uuid::new_v4();
        let now = Utc::now();

        // Calculate VAT and total
        let vat_amount = (amount_excl_vat * vat_rate / 100.0 * 100.0).round() / 100.0;
        let amount = amount_excl_vat + vat_amount;

        let expense_date_parsed =
            chrono::DateTime::parse_from_rfc3339(&format!("{}T00:00:00Z", expense_date))
                .map_err(|e| format!("Failed to parse expense_date: {}", e))?
                .with_timezone(&Utc);

        let due_date_parsed =
            chrono::DateTime::parse_from_rfc3339(&format!("{}T00:00:00Z", due_date))
                .map_err(|e| format!("Failed to parse due_date: {}", e))?
                .with_timezone(&Utc);

        // Set paid_date if payment_status is "paid"
        let paid_date = if payment_status == "paid" {
            Some(expense_date_parsed) // Use expense_date as paid_date
        } else {
            None
        };

        // Check if expense already exists (idempotency)
        let existing: Option<(Uuid,)> =
            sqlx::query_as("SELECT id FROM expenses WHERE description = $1 AND building_id = $2")
                .bind(description)
                .bind(building_id)
                .fetch_optional(&self.pool)
                .await
                .map_err(|e| format!("Failed to check existing expense: {}", e))?;

        let expense_id = if let Some((existing_id,)) = existing {
            // Update existing expense
            sqlx::query(
                r#"
                UPDATE expenses SET
                    category = $1::expense_category,
                    amount = $2,
                    amount_excl_vat = $3,
                    vat_rate = $4,
                    expense_date = $5,
                    due_date = $6,
                    payment_status = $7::payment_status,
                    paid_date = $8,
                    approval_status = $9::approval_status,
                    supplier = $10,
                    invoice_number = $11,
                    account_code = $12,
                    updated_at = $13
                WHERE id = $14
                "#,
            )
            .bind(category)
            .bind(amount)
            .bind(amount_excl_vat)
            .bind(vat_rate)
            .bind(expense_date_parsed)
            .bind(due_date_parsed)
            .bind(payment_status)
            .bind(paid_date)
            .bind("approved")
            .bind(supplier)
            .bind(invoice_number)
            .bind(account_code)
            .bind(now)
            .bind(existing_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to update expense: {}", e))?;
            existing_id
        } else {
            // Insert new expense
            sqlx::query(
                r#"
                INSERT INTO expenses (
                    id, acp_id, organization_id, building_id, category, description,
                    amount, amount_excl_vat, vat_rate, expense_date, due_date,
                    payment_status, paid_date, approval_status, supplier, invoice_number,
                    account_code, created_at, updated_at
                )
                VALUES ($1, (SELECT acp_id FROM buildings WHERE id = $3), $2, $3, $4::expense_category, $5, $6, $7, $8, $9, $10, $11::payment_status, $12, $13::approval_status, $14, $15, $16, $17, $18)
                "#
            )
            .bind(expense_id)
            .bind(organization_id)
            .bind(building_id)
            .bind(category)
            .bind(description)
            .bind(amount)
            .bind(amount_excl_vat)
            .bind(vat_rate)
            .bind(expense_date_parsed)
            .bind(due_date_parsed)
            .bind(payment_status)
            .bind(paid_date)
            .bind("approved")
            .bind(supplier)
            .bind(invoice_number)
            .bind(account_code)
            .bind(now)
            .bind(now)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to create expense with VAT: {}", e))?;
            expense_id
        };

        // Generate journal entry for this expense (double-entry bookkeeping)
        if let Some(acc_code) = account_code {
            self.generate_journal_entry_for_expense(
                expense_id,
                organization_id,
                building_id,
                description,
                amount_excl_vat,
                vat_rate,
                amount,
                expense_date_parsed,
                acc_code,
                supplier,
                invoice_number,
            )
            .await?;
        }

        Ok(expense_id)
    }

    /// Generate journal entry for an expense (double-entry bookkeeping)
    ///
    /// This creates the accounting entries following Belgian PCMN:
    /// - Debit: Expense account (class 6)
    /// - Debit: VAT recoverable (4110)
    /// - Credit: Supplier account (4400)
    #[allow(clippy::too_many_arguments)]
    async fn generate_journal_entry_for_expense(
        &self,
        expense_id: Uuid,
        organization_id: Uuid,
        _building_id: Uuid,
        description: &str,
        amount_excl_vat: f64,
        vat_rate: f64,
        total_amount: f64,
        expense_date: chrono::DateTime<Utc>,
        account_code: &str,
        supplier: Option<&str>,
        invoice_number: Option<&str>,
    ) -> Result<(), String> {
        let journal_entry_id = Uuid::new_v4();
        let now = Utc::now();

        // Calculate VAT amount
        let vat_amount = total_amount - amount_excl_vat;

        // Start a transaction - the deferred trigger will only check at COMMIT
        let mut tx = self
            .pool
            .begin()
            .await
            .map_err(|e| format!("Failed to begin transaction: {}", e))?;

        // Insert journal entry header
        sqlx::query!(
            r#"
            INSERT INTO journal_entries (
                id, acp_id, organization_id, entry_date, description,
                document_ref, expense_id, created_at, updated_at
            )
            VALUES ($1, (SELECT acp_id FROM expenses WHERE id = $6), $2, $3, $4, $5, $6, $7, $8)
            "#,
            journal_entry_id,
            organization_id,
            expense_date,
            format!("{} - {}", description, supplier.unwrap_or("Fournisseur")),
            invoice_number,
            expense_id,
            now,
            now
        )
        .execute(&mut *tx)
        .await
        .map_err(|e| format!("Failed to create journal entry: {}", e))?;

        // Line 1: Debit expense account (class 6)
        sqlx::query!(
            r#"
            INSERT INTO journal_entry_lines (
                journal_entry_id, organization_id, account_code,
                debit, credit, description
            )
            VALUES ($1, $2, $3, $4, $5, $6)
            "#,
            journal_entry_id,
            organization_id,
            account_code,
            rust_decimal::Decimal::from_f64_retain(amount_excl_vat).unwrap_or_default(),
            rust_decimal::Decimal::from_f64_retain(0.0).unwrap_or_default(),
            format!("Dépense: {}", description)
        )
        .execute(&mut *tx)
        .await
        .map_err(|e| format!("Failed to create expense debit line: {}", e))?;

        // Line 2: Debit VAT recoverable (4110) if VAT > 0
        if vat_amount > 0.01 {
            sqlx::query!(
                r#"
                INSERT INTO journal_entry_lines (
                    journal_entry_id, organization_id, account_code,
                    debit, credit, description
                )
                VALUES ($1, $2, $3, $4, $5, $6)
                "#,
                journal_entry_id,
                organization_id,
                "4110", // VAT Recoverable account
                rust_decimal::Decimal::from_f64_retain(vat_amount).unwrap_or_default(),
                rust_decimal::Decimal::from_f64_retain(0.0).unwrap_or_default(),
                format!("TVA récupérable {}%", vat_rate)
            )
            .execute(&mut *tx)
            .await
            .map_err(|e| format!("Failed to create VAT debit line: {}", e))?;
        }

        // Line 3: Credit supplier account (4400)
        sqlx::query!(
            r#"
            INSERT INTO journal_entry_lines (
                journal_entry_id, organization_id, account_code,
                debit, credit, description
            )
            VALUES ($1, $2, $3, $4, $5, $6)
            "#,
            journal_entry_id,
            organization_id,
            "4400", // Suppliers account
            rust_decimal::Decimal::from_f64_retain(0.0).unwrap_or_default(),
            rust_decimal::Decimal::from_f64_retain(total_amount).unwrap_or_default(),
            supplier.map(|s| format!("Fournisseur: {}", s))
        )
        .execute(&mut *tx)
        .await
        .map_err(|e| format!("Failed to create supplier credit line: {}", e))?;

        // Commit transaction - trigger will validate balance here
        tx.commit()
            .await
            .map_err(|e| format!("Failed to commit journal entry transaction: {}", e))?;

        Ok(())
    }

    /// Create demo charge distributions for an expense
    async fn create_demo_distributions(
        &self,
        expense_id: Uuid,
        _organization_id: Uuid,
    ) -> Result<(), String> {
        // Get all units for the expense's building
        let expense_row = sqlx::query!(
            "SELECT building_id, amount FROM expenses WHERE id = $1",
            expense_id
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| format!("Failed to fetch expense: {}", e))?;

        let building_id = expense_row.building_id;
        let total_amount: Decimal = expense_row.amount;

        // Get all units with their quotas (NOT unit_owners - one record per unit)
        let units = sqlx::query!(
            r#"
            SELECT u.id as unit_id, u.quota
            FROM units u
            WHERE u.building_id = $1
            "#,
            building_id
        )
        .fetch_all(&self.pool)
        .await
        .map_err(|e| format!("Failed to fetch units: {}", e))?;

        if units.is_empty() {
            return Ok(()); // No units to distribute to
        }

        // Calculate total quotas for the building.
        // Decimal end-to-end (ADR-0007/0008): quota is NUMERIC since #534 C1,
        // and this feeds a monetary charge distribution (amount_due) — no f64.
        let total_quota: Decimal = units.iter().map(|u| u.quota).sum();

        let now = Utc::now();

        // Create ONE distribution per unit (not per owner)
        // The primary owner will be responsible for collecting from co-owners
        for unit in units {
            // Get the primary contact owner for this unit
            let primary_owner = sqlx::query!(
                r#"
                SELECT owner_id
                FROM unit_owners
                WHERE unit_id = $1 AND end_date IS NULL AND is_primary_contact = true
                ORDER BY created_at ASC
                LIMIT 1
                "#,
                unit.unit_id
            )
            .fetch_optional(&self.pool)
            .await
            .map_err(|e| format!("Failed to fetch primary owner: {}", e))?;

            // Skip if no owner found for this unit
            let owner_id = match primary_owner {
                Some(owner) => owner.owner_id,
                None => continue, // Skip this unit if no owner
            };

            let quota_percentage: Decimal = if total_quota > Decimal::ZERO {
                unit.quota / total_quota
            } else {
                Decimal::ZERO
            };

            let amount_due: Decimal = if total_quota > Decimal::ZERO {
                (quota_percentage * total_amount).round_dp(2)
            } else {
                Decimal::ZERO
            };

            sqlx::query(
                r#"
                INSERT INTO charge_distributions (
                    id, expense_id, unit_id, owner_id,
                    quota_percentage, amount_due, created_at
                )
                VALUES ($1, $2, $3, $4, $5, $6, $7)
                "#,
            )
            .bind(Uuid::new_v4())
            .bind(expense_id)
            .bind(unit.unit_id)
            .bind(owner_id)
            .bind(quota_percentage)
            .bind(amount_due)
            .bind(now)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to create charge distribution: {}", e))?;
        }

        Ok(())
    }

    /// Create a demo owner contribution (revenue)
    #[allow(clippy::too_many_arguments)]
    async fn create_demo_owner_contribution(
        &self,
        organization_id: Uuid,
        owner_id: Uuid,
        unit_id: Option<Uuid>,
        description: &str,
        amount: f64,
        contribution_type: &str,
        contribution_date: &str,
        payment_status: &str,
        payment_date: Option<&str>,
        account_code: Option<&str>,
    ) -> Result<Uuid, String> {
        let contribution_id = Uuid::new_v4();
        let contribution_date = NaiveDate::parse_from_str(contribution_date, "%Y-%m-%d")
            .map_err(|e| format!("Invalid contribution date: {}", e))?
            .and_hms_opt(10, 0, 0)
            .ok_or("Invalid contribution time")?
            .and_local_timezone(Utc)
            .unwrap();

        let payment_date_tz = payment_date
            .map(|date_str| {
                NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
                    .map_err(|e| format!("Invalid payment date: {}", e))
                    .and_then(|date| {
                        date.and_hms_opt(10, 0, 0)
                            .ok_or("Invalid payment time".to_string())
                    })
                    .map(|dt| dt.and_local_timezone(Utc).unwrap())
            })
            .transpose()?;

        let payment_method = if payment_status == "paid" {
            Some("bank_transfer")
        } else {
            None
        };

        let now = Utc::now();

        sqlx::query(
            r#"
            INSERT INTO owner_contributions (
                id, acp_id, organization_id, owner_id, unit_id,
                description, amount, account_code,
                contribution_type, contribution_date, payment_date,
                payment_method, payment_status,
                created_at, updated_at
            )
            VALUES ($1, (SELECT acp_id FROM units WHERE id = $4), $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
            "#,
        )
        .bind(contribution_id)
        .bind(organization_id)
        .bind(owner_id)
        .bind(unit_id)
        .bind(description)
        .bind(amount)
        .bind(account_code)
        .bind(contribution_type)
        .bind(contribution_date)
        .bind(payment_date_tz)
        .bind(payment_method)
        .bind(payment_status)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create owner contribution: {}", e))?;

        // Generate journal entry for this contribution (double-entry bookkeeping)
        if let Some(acc_code) = account_code {
            self.generate_journal_entry_for_contribution(
                contribution_id,
                organization_id,
                description,
                amount,
                contribution_date,
                acc_code,
            )
            .await?;
        }

        Ok(contribution_id)
    }

    /// Generate journal entry for an owner contribution (double-entry bookkeeping)
    ///
    /// This creates the accounting entries following Belgian PCMN:
    /// - Debit: Owner receivables (4000) - Money owed by owner
    /// - Credit: Revenue account (class 7) - Income for ACP
    async fn generate_journal_entry_for_contribution(
        &self,
        contribution_id: Uuid,
        organization_id: Uuid,
        description: &str,
        amount: f64,
        contribution_date: chrono::DateTime<Utc>,
        account_code: &str,
    ) -> Result<(), String> {
        let journal_entry_id = Uuid::new_v4();
        let now = Utc::now();

        // Start a transaction with deferred constraints
        let mut tx = self
            .pool
            .begin()
            .await
            .map_err(|e| format!("Failed to begin transaction: {}", e))?;

        // Set constraints to deferred for this transaction
        sqlx::query("SET CONSTRAINTS ALL DEFERRED")
            .execute(&mut *tx)
            .await
            .map_err(|e| format!("Failed to defer constraints: {}", e))?;

        // Create journal entry header
        sqlx::query(
            r#"
            INSERT INTO journal_entries (
                id, acp_id, organization_id, entry_date, description,
                contribution_id, created_at, updated_at
            )
            VALUES ($1, (SELECT acp_id FROM owner_contributions WHERE id = $5), $2, $3, $4, $5, $6, $7)
            "#,
        )
        .bind(journal_entry_id)
        .bind(organization_id)
        .bind(contribution_date)
        .bind(description)
        .bind(contribution_id)
        .bind(now)
        .bind(now)
        .execute(&mut *tx)
        .await
        .map_err(|e| format!("Failed to create journal entry: {}", e))?;

        // Line 1: DEBIT - Owner receivables (4000 = Copropriétaires débiteurs)
        sqlx::query(
            r#"
            INSERT INTO journal_entry_lines (
                id, journal_entry_id, organization_id, account_code,
                description, debit, credit, created_at
            )
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
            "#,
        )
        .bind(Uuid::new_v4())
        .bind(journal_entry_id)
        .bind(organization_id)
        .bind("4000") // Owner receivables
        .bind(format!("Créance - {}", description))
        .bind(amount) // Debit
        .bind(0.0) // Credit
        .bind(now)
        .execute(&mut *tx)
        .await
        .map_err(|e| format!("Failed to create debit line (4000): {}", e))?;

        // Line 2: CREDIT - Revenue account (class 7)
        sqlx::query(
            r#"
            INSERT INTO journal_entry_lines (
                id, journal_entry_id, organization_id, account_code,
                description, debit, credit, created_at
            )
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
            "#,
        )
        .bind(Uuid::new_v4())
        .bind(journal_entry_id)
        .bind(organization_id)
        .bind(account_code) // Revenue account (e.g., 7000)
        .bind(format!("Produit - {}", description))
        .bind(0.0) // Debit
        .bind(amount) // Credit
        .bind(now)
        .execute(&mut *tx)
        .await
        .map_err(|e| format!("Failed to create credit line ({}): {}", account_code, e))?;

        // Commit transaction (constraints will be checked here)
        tx.commit()
            .await
            .map_err(|e| format!("Failed to commit transaction: {}", e))?;

        Ok(())
    }

    /// Create a demo payment reminder
    #[allow(clippy::too_many_arguments)]
    async fn create_demo_payment_reminder(
        &self,
        expense_id: Uuid,
        owner_id: Uuid,
        organization_id: Uuid,
        reminder_level: &str,
        days_overdue: i64,
    ) -> Result<Uuid, String> {
        let reminder_id = Uuid::new_v4();
        let now = Utc::now();

        // Get expense amount and due date
        let expense = sqlx::query!(
            "SELECT amount, due_date FROM expenses WHERE id = $1",
            expense_id
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| format!("Failed to fetch expense: {}", e))?;

        let amount_owed: Decimal = expense.amount;
        let due_date = expense
            .due_date
            .expect("Due date required for payment reminder");

        // Calculate penalty (8% annual rate)
        let penalty_amount: Decimal = if days_overdue > 0 {
            let yearly_penalty = amount_owed * Decimal::new(8, 2); // 0.08
            let daily_penalty = yearly_penalty / Decimal::from(365);
            (daily_penalty * Decimal::from(days_overdue)).round_dp(2)
        } else {
            Decimal::ZERO
        };

        let total_amount = amount_owed + penalty_amount;
        let sent_date = now - chrono::Duration::days(5); // Sent 5 days ago

        sqlx::query(
            r#"
            INSERT INTO payment_reminders (
                id, acp_id, organization_id, expense_id, owner_id,
                level, status, amount_owed, penalty_amount, total_amount,
                due_date, days_overdue, delivery_method, sent_date,
                created_at, updated_at
            )
            VALUES ($1, (SELECT acp_id FROM expenses WHERE id = $3), $2, $3, $4, $5::reminder_level, $6::reminder_status, $7, $8, $9, $10, $11, $12::delivery_method, $13, $14, $15)
            "#
        )
        .bind(reminder_id)
        .bind(organization_id)
        .bind(expense_id)
        .bind(owner_id)
        .bind(reminder_level) // FirstReminder, SecondReminder, etc.
        .bind("Sent") // status
        .bind(amount_owed)
        .bind(penalty_amount)
        .bind(total_amount)
        .bind(due_date)
        .bind(days_overdue as i32)
        .bind("Email") // delivery_method
        .bind(sent_date)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create payment reminder: {}", e))?;

        Ok(reminder_id)
    }

    /// Clear all data (DANGEROUS - use with caution!)
    pub async fn clear_demo_data(&self) -> Result<String, String> {
        log::warn!("⚠️  Clearing seed data only (preserving production data)...");

        // Get seed organization IDs
        let seed_org_ids: Vec<Uuid> =
            sqlx::query_scalar!("SELECT id FROM organizations WHERE is_seed_data = true")
                .fetch_all(&self.pool)
                .await
                .map_err(|e| format!("Failed to fetch seed organizations: {}", e))?;

        if seed_org_ids.is_empty() {
            return Ok("ℹ️  No seed data found to clear.".to_string());
        }

        log::info!("Found {} seed organizations to clean", seed_org_ids.len());

        // Delete in correct order due to foreign key constraints
        // 1. Board decisions (reference board_members and meetings)
        sqlx::query!(
            "DELETE FROM board_decisions WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete board_decisions: {}", e))?;

        // 2. Board members (reference meetings)
        sqlx::query!(
            "DELETE FROM board_members WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete board_members: {}", e))?;

        // 3. Payment reminders (reference expenses and owners)
        sqlx::query!(
            "DELETE FROM payment_reminders WHERE organization_id = ANY($1)",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete payment_reminders: {}", e))?;

        // 3b. Owner contributions (revenue)
        sqlx::query!(
            "DELETE FROM owner_contributions WHERE organization_id = ANY($1)",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete owner_contributions: {}", e))?;

        // 4. Charge distributions (reference expenses)
        sqlx::query(
            "DELETE FROM charge_distributions WHERE expense_id IN (SELECT id FROM expenses WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1)))"
        )
        .bind(&seed_org_ids)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete charge_distributions: {}", e))?;

        // 5. Invoice line items (reference expenses)
        sqlx::query(
            "DELETE FROM invoice_line_items WHERE expense_id IN (SELECT id FROM expenses WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1)))"
        )
        .bind(&seed_org_ids)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete invoice_line_items: {}", e))?;

        // 6. Documents linked to buildings or expenses
        sqlx::query!(
            "DELETE FROM documents WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete documents: {}", e))?;

        // 7. Meetings (now safe to delete after board members)
        sqlx::query!(
            "DELETE FROM meetings WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete meetings: {}", e))?;

        // 8. Journal entry lines (reference accounts) - MUST be deleted before accounts
        sqlx::query!(
            "DELETE FROM journal_entry_lines WHERE organization_id = ANY($1)",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete journal_entry_lines: {}", e))?;

        // 9. Journal entries (now safe after lines are deleted)
        sqlx::query!(
            "DELETE FROM journal_entries WHERE organization_id = ANY($1)",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete journal_entries: {}", e))?;

        // 10. Expenses (now safe to delete after distributions, line items, and journal entries)
        sqlx::query!(
            "DELETE FROM expenses WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete expenses: {}", e))?;

        // Unit owners (junction table)
        sqlx::query(
            "DELETE FROM unit_owners WHERE unit_id IN (SELECT u.id FROM units u INNER JOIN buildings b ON u.building_id = b.id INNER JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))"
        )
        .bind(&seed_org_ids)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete unit_owners: {}", e))?;

        // Units
        sqlx::query!(
            "DELETE FROM units WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete units: {}", e))?;

        // Owners (only those linked to seed organizations through unit_owners)
        sqlx::query!(
            "DELETE FROM owners WHERE organization_id = ANY($1)",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete owners: {}", e))?;

        // Buildings (Hotfix #602 : via acps since buildings.organization_id was dropped)
        sqlx::query!(
            "DELETE FROM buildings WHERE acp_id IN (SELECT id FROM acps WHERE organization_id = ANY($1))",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete buildings: {}", e))?;

        // PCMN Accounts
        sqlx::query!(
            "DELETE FROM accounts WHERE organization_id = ANY($1)",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete accounts: {}", e))?;

        // User roles (before deleting users)
        sqlx::query(
            "DELETE FROM user_roles WHERE user_id IN (SELECT id FROM users WHERE organization_id = ANY($1) AND role != 'superadmin')"
        )
        .bind(&seed_org_ids)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete user_roles: {}", e))?;

        // Users (except superadmin)
        sqlx::query!(
            "DELETE FROM users WHERE organization_id = ANY($1) AND role != 'superadmin'",
            &seed_org_ids
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete users: {}", e))?;

        // Finally, delete seed organizations
        sqlx::query!("DELETE FROM organizations WHERE is_seed_data = true")
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to delete organizations: {}", e))?;

        log::info!("✅ Seed data cleared (production data and superadmin preserved)");

        Ok(format!(
            "✅ Seed data cleared successfully! ({} organizations removed)",
            seed_org_ids.len()
        ))
    }

    /// Seed the "Résidence du Parc Royal" scenario world with all 14 personas.
    ///
    /// Creates one organization, one building, 12 units, 10 co-owners, 3 professionals,
    /// 4 community members, one meeting (2nd convocation) and one pending resolution.
    pub async fn seed_scenario_world(&self) -> Result<ScenarioWorldResult, String> {
        log::info!("🌱 Starting scenario world seeding (Résidence du Parc Royal)...");

        // Les comptes créés À L'UNITÉ, hors des trois listes de personas.
        //
        // Sept mots de passe, quinze appels. Précalculés ici, ils partent de
        // front avec le reste au lieu d'attendre chacun leur tour. Ce sont
        // des littéraux du fichier : si l'un change, le hachage retombe
        // simplement sur le chemin direct de `create_demo_user` — rien ne
        // casse, on perd juste le gain pour celui-là.
        self.precalculer_empreintes(&[
            "syndic123",
            "sophie123",
            "francois123",
            "gisele123",
            "marc123",
            "comptable123",
            "owner123",
        ])
        .await;

        // Check if scenario world already exists
        let existing = sqlx::query_scalar!(
            "SELECT COUNT(*) as count FROM organizations WHERE slug = 'residence-parc-royal-test'"
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| format!("Failed to check existing scenario world: {}", e))?;

        if existing.unwrap_or(0) > 0 {
            return Err(
                "Scenario world already exists. Please clear it first with DELETE /seed/scenario/world."
                    .to_string(),
            );
        }

        let org_id = Uuid::new_v4();
        let now = Utc::now();

        // 1. Create organization
        sqlx::query(
            r#"
            INSERT INTO organizations (id, name, slug, contact_email, contact_phone, subscription_plan, max_buildings, max_users, is_active, is_seed_data, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#,
        )
        .bind(org_id)
        .bind("Résidence du Parc Royal ASBL")
        .bind("residence-parc-royal-test")
        .bind("contact@residence-parc.be")
        .bind("+32 2 600 00 00")
        .bind("professional")
        .bind(5)
        .bind(50)
        .bind(true)
        .bind(true) // is_seed_data
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create scenario organization: {}", e))?;

        log::info!("✅ Scenario organization created: Résidence du Parc Royal ASBL");

        // 2. Create building: 42 Avenue Louise, 182 lots, 10000 tantièmes, 1965
        let building_id = Uuid::new_v4();
        // Hotfix #602 follow-up : resolve acp_id from org_id
        let acp_id = self.ensure_default_acp_for_org(org_id).await?;
        sqlx::query!(
            r#"
            INSERT INTO buildings (id, acp_id, name, address, city, postal_code, country, total_units, construction_year, slug, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#,
            building_id,
            acp_id,
            "Résidence du Parc Royal",
            "Avenue Louise 42",
            "Bruxelles",
            "1050",
            "Belgique",
            182,
            1965,
            "residence-du-parc-royal-bruxelles",
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create scenario building: {}", e))?;

        log::info!("✅ Scenario building created: Résidence du Parc Royal");

        // 3. Create users and owners
        let mut users_result: Vec<ScenarioUserResult> = Vec::new();
        let mut owners_result: Vec<ScenarioOwnerResult> = Vec::new();
        let mut units_result: Vec<ScenarioUnitResult> = Vec::new();

        // --- 10 copropriétaires (users + owners + units + unit_owners) ---
        struct OwnerPersona {
            first_name: &'static str,
            last_name: &'static str,
            email: &'static str,
            password: &'static str,
            lots: Vec<(&'static str, f64)>, // (unit_number, tantièmes)
        }

        let owner_personas = vec![
            OwnerPersona {
                first_name: "Alice",
                last_name: "Dubois",
                email: "alice@residence-parc.be",
                password: "alice123",
                lots: vec![("2A", 450.0)],
            },
            OwnerPersona {
                first_name: "Bob",
                last_name: "Janssen",
                email: "bob@residence-parc.be",
                password: "bob123",
                lots: vec![("2B", 430.0)],
            },
            OwnerPersona {
                first_name: "Charlie",
                last_name: "Martin",
                email: "charlie@residence-parc.be",
                password: "charlie123",
                lots: vec![("3B", 660.0)],
            },
            OwnerPersona {
                first_name: "Diane",
                last_name: "Peeters",
                email: "diane@residence-parc.be",
                password: "diane123",
                lots: vec![("3A", 580.0)],
            },
            OwnerPersona {
                first_name: "Emmanuel",
                last_name: "Claes",
                email: "emmanuel@residence-parc.be",
                password: "emmanuel123",
                lots: vec![("5A", 1280.0)],
            },
            OwnerPersona {
                first_name: "Nadia",
                last_name: "Benali",
                email: "nadia@residence-parc.be",
                password: "nadia123",
                lots: vec![("4A", 320.0)],
            },
            OwnerPersona {
                first_name: "Marguerite",
                last_name: "Lemaire",
                email: "marguerite@residence-parc.be",
                password: "marguerite123",
                lots: vec![("1A", 380.0)],
            },
            OwnerPersona {
                first_name: "Jeanne",
                last_name: "Devos",
                email: "jeanne@residence-parc.be",
                password: "jeanne123",
                lots: vec![("1B", 290.0)],
            },
            OwnerPersona {
                first_name: "Philippe",
                last_name: "Vandermeulen",
                email: "philippe@residence-parc.be",
                password: "philippe123",
                lots: vec![("6A", 600.0), ("6B", 600.0), ("6C", 600.0)],
            },
            OwnerPersona {
                first_name: "Marcel",
                last_name: "Dupont",
                email: "marcel@residence-parc.be",
                password: "marcel123",
                lots: vec![("4B", 450.0)],
            },
        ];

        // Les bcrypt de cette liste, menés de front (cf.
        // `precalculer_empreintes`) : en série, le semis prenait 44 s.
        let mots: Vec<&str> = owner_personas.iter().map(|p| p.password).collect();
        self.precalculer_empreintes(&mots).await;

        for persona in &owner_personas {
            // Create user
            let user_id = self
                .create_demo_user(
                    persona.email,
                    persona.password,
                    persona.first_name,
                    persona.last_name,
                    "owner",
                    Some(org_id),
                )
                .await?;

            users_result.push(ScenarioUserResult {
                user_id,
                email: persona.email.to_string(),
                password: persona.password.to_string(),
                role: "owner".to_string(),
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
            });

            // Create owner record
            let owner_id = self
                .create_demo_owner(
                    org_id,
                    persona.first_name,
                    persona.last_name,
                    persona.email,
                    "+32 400 00 00 00",
                    "Avenue Louise 42",
                    "Bruxelles",
                    "1050",
                    "Belgique",
                )
                .await?;

            // Link user to owner
            sqlx::query("UPDATE owners SET user_id = $1 WHERE id = $2")
                .bind(user_id)
                .bind(owner_id)
                .execute(&self.pool)
                .await
                .map_err(|e| {
                    format!("Failed to link owner {} to user: {}", persona.last_name, e)
                })?;

            owners_result.push(ScenarioOwnerResult {
                owner_id,
                user_id,
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
                email: persona.email.to_string(),
            });

            // Create units and unit_owner relationships
            for (unit_number, tantiemes) in &persona.lots {
                let unit_id = self
                    .create_demo_unit(
                        org_id,
                        building_id,
                        None,
                        unit_number,
                        "apartment",
                        None,
                        70.0, // default area
                        *tantiemes,
                    )
                    .await?;

                self.create_demo_unit_owner(
                    unit_id,
                    owner_id,
                    rust_decimal_macros::dec!(1), // 100% ownership per unit
                    true,                         // primary contact
                    None,                         // active (no end_date)
                )
                .await?;

                units_result.push(ScenarioUnitResult {
                    unit_id,
                    unit_number: unit_number.to_string(),
                    owner_id,
                    tantièmes: *tantiemes,
                });
            }
        }

        log::info!(
            "✅ {} copropriétaires created with {} units",
            owner_personas.len(),
            units_result.len()
        );

        // --- 3 professionals (users only, no units) ---
        // François Leroy - Syndic
        let francois_user_id = self
            .create_demo_user(
                "francois@syndic-leroy.be",
                "francois123",
                "François",
                "Leroy",
                "syndic",
                Some(org_id),
            )
            .await?;
        users_result.push(ScenarioUserResult {
            user_id: francois_user_id,
            email: "francois@syndic-leroy.be".to_string(),
            password: "francois123".to_string(),
            role: "syndic".to_string(),
            first_name: "François".to_string(),
            last_name: "Leroy".to_string(),
        });

        // Gisèle Vandenberghe - Accountant
        let gisele_user_id = self
            .create_demo_user(
                "gisele@cabinet-vdb.be",
                "gisele123",
                "Gisèle",
                "Vandenberghe",
                "accountant",
                Some(org_id),
            )
            .await?;
        users_result.push(ScenarioUserResult {
            user_id: gisele_user_id,
            email: "gisele@cabinet-vdb.be".to_string(),
            password: "gisele123".to_string(),
            role: "accountant".to_string(),
            first_name: "Gisèle".to_string(),
            last_name: "Vandenberghe".to_string(),
        });

        // Marc Dubois - Contractor (Plombier)
        let marc_user_id = self
            .create_demo_user(
                "marc@plomberie-dubois.be",
                "marc123",
                "Marc",
                "Dubois",
                "contractor",
                Some(org_id),
            )
            .await?;
        users_result.push(ScenarioUserResult {
            user_id: marc_user_id,
            email: "marc@plomberie-dubois.be".to_string(),
            password: "marc123".to_string(),
            role: "contractor".to_string(),
            first_name: "Marc".to_string(),
            last_name: "Dubois".to_string(),
        });
        // Create contractor profile
        sqlx::query(
            r#"INSERT INTO contractor_profiles (user_id, organization_id, profession, siren_or_vat, specialties)
               VALUES ($1, $2, 'Plombier', 'BE0123456789', ARRAY['plumbing', 'heating'])
               ON CONFLICT (user_id) DO NOTHING"#,
        )
        .bind(marc_user_id)
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create contractor profile for Marc: {}", e))?;

        // Sophie Leroux - Contractor (Électricienne)
        let sophie_user_id = self
            .create_demo_user(
                "sophie@elec-leroux.be",
                "sophie123",
                "Sophie",
                "Leroux",
                "contractor",
                Some(org_id),
            )
            .await?;
        users_result.push(ScenarioUserResult {
            user_id: sophie_user_id,
            email: "sophie@elec-leroux.be".to_string(),
            password: "sophie123".to_string(),
            role: "contractor".to_string(),
            first_name: "Sophie".to_string(),
            last_name: "Leroux".to_string(),
        });
        sqlx::query(
            r#"INSERT INTO contractor_profiles (user_id, organization_id, profession, siren_or_vat, specialties)
               VALUES ($1, $2, 'Électricienne', 'BE0987654321', ARRAY['electrical', 'security'])
               ON CONFLICT (user_id) DO NOTHING"#,
        )
        .bind(sophie_user_id)
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create contractor profile for Sophie: {}", e))?;

        // Admin (already exists globally, just reference it)
        users_result.push(ScenarioUserResult {
            user_id: Uuid::parse_str("00000000-0000-0000-0000-000000000001")
                .map_err(|e| format!("Failed to parse admin UUID: {}", e))?,
            email: "admin@koprogo.com".to_string(),
            password: "admin123".to_string(),
            role: "superadmin".to_string(),
            first_name: "Super".to_string(),
            last_name: "Admin".to_string(),
        });

        log::info!("✅ 5 professionals created (syndic, accountant, 2 contractors, admin)");

        // --- 4 community members (users only, role=owner, no units) ---
        struct CommunityPersona {
            first_name: &'static str,
            last_name: &'static str,
            email: &'static str,
            password: &'static str,
        }

        let community_personas = vec![
            CommunityPersona {
                first_name: "Ahmed",
                last_name: "Mansouri",
                email: "ahmed@gmail.com",
                password: "ahmed123",
            },
            CommunityPersona {
                first_name: "Sophie",
                last_name: "Martin",
                email: "sophie@gmail.com",
                password: "sophie123",
            },
            CommunityPersona {
                first_name: "Lucas",
                last_name: "Martin",
                email: "lucas.m@school.be",
                password: "lucas123",
            },
            CommunityPersona {
                first_name: "Fatima",
                last_name: "El Amrani",
                email: "fatima@gmail.com",
                password: "fatima123",
            },
        ];

        // Les bcrypt de cette liste, menés de front (cf.
        // `precalculer_empreintes`) : en série, le semis prenait 44 s.
        let mots: Vec<&str> = community_personas.iter().map(|p| p.password).collect();
        self.precalculer_empreintes(&mots).await;

        for persona in &community_personas {
            let user_id = self
                .create_demo_user(
                    persona.email,
                    persona.password,
                    persona.first_name,
                    persona.last_name,
                    "owner",
                    Some(org_id),
                )
                .await?;

            users_result.push(ScenarioUserResult {
                user_id,
                email: persona.email.to_string(),
                password: persona.password.to_string(),
                role: "owner".to_string(),
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
            });
        }

        log::info!("✅ 4 community members created");

        // =====================================================================
        // Building 2: Le Clos des Hirondelles (small, NO CdC, < 20 lots)
        // =====================================================================
        let building2_id = Uuid::new_v4();
        // acp_id already resolved above for building 1 (same org)
        sqlx::query!(
            r#"
            INSERT INTO buildings (id, acp_id, name, address, city, postal_code, country, total_units, construction_year, slug, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#,
            building2_id,
            acp_id,
            "Le Clos des Hirondelles",
            "8 Rue de la Station",
            "Ixelles",
            "1050",
            "Belgique",
            12,
            2005,
            "le-clos-des-hirondelles-ixelles",
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create building 2 (Le Clos des Hirondelles): {}", e))?;

        log::info!("✅ Building 2 created: Le Clos des Hirondelles (12 lots, no CdC)");

        let mut building2_owners: Vec<ScenarioOwnerResult> = Vec::new();
        let mut building2_units: Vec<ScenarioUnitResult> = Vec::new();

        // Building 2 copropriétaires
        struct Building2Persona {
            first_name: &'static str,
            last_name: &'static str,
            email: &'static str,
            password: &'static str,
            unit_number: &'static str,
            tantiemes: f64,
        }

        let building2_personas = vec![
            Building2Persona {
                first_name: "Yves",
                last_name: "Lambert",
                email: "yves@clos-hirondelles.be",
                password: "yves123",
                unit_number: "1A",
                tantiemes: 350.0,
            },
            Building2Persona {
                first_name: "Claire",
                last_name: "Fontaine",
                email: "claire@clos-hirondelles.be",
                password: "claire123",
                unit_number: "1B",
                tantiemes: 300.0,
            },
            Building2Persona {
                first_name: "Robert",
                last_name: "Mertens",
                email: "robert@clos-hirondelles.be",
                password: "robert123",
                unit_number: "2A",
                tantiemes: 350.0,
            },
        ];

        // Les bcrypt de cette liste, menés de front (cf.
        // `precalculer_empreintes`) : en série, le semis prenait 44 s.
        let mots: Vec<&str> = building2_personas.iter().map(|p| p.password).collect();
        self.precalculer_empreintes(&mots).await;

        for persona in &building2_personas {
            // Create user
            let user_id = self
                .create_demo_user(
                    persona.email,
                    persona.password,
                    persona.first_name,
                    persona.last_name,
                    "owner",
                    Some(org_id),
                )
                .await?;

            users_result.push(ScenarioUserResult {
                user_id,
                email: persona.email.to_string(),
                password: persona.password.to_string(),
                role: "owner".to_string(),
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
            });

            // Create owner record
            let owner_id = self
                .create_demo_owner(
                    org_id,
                    persona.first_name,
                    persona.last_name,
                    persona.email,
                    "+32 400 00 00 00",
                    "8 Rue de la Station",
                    "Ixelles",
                    "1050",
                    "Belgique",
                )
                .await?;

            // Link user to owner
            sqlx::query("UPDATE owners SET user_id = $1 WHERE id = $2")
                .bind(user_id)
                .bind(owner_id)
                .execute(&self.pool)
                .await
                .map_err(|e| {
                    format!(
                        "Failed to link building2 owner {} to user: {}",
                        persona.last_name, e
                    )
                })?;

            building2_owners.push(ScenarioOwnerResult {
                owner_id,
                user_id,
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
                email: persona.email.to_string(),
            });

            // Create unit
            let unit_id = self
                .create_demo_unit(
                    org_id,
                    building2_id,
                    None,
                    persona.unit_number,
                    "apartment",
                    None,
                    70.0,
                    persona.tantiemes,
                )
                .await?;

            // Create unit_owner relationship
            self.create_demo_unit_owner(
                unit_id,
                owner_id,
                rust_decimal_macros::dec!(1), // 100% ownership
                true,                         // primary contact
                None,                         // active (no end_date)
            )
            .await?;

            building2_units.push(ScenarioUnitResult {
                unit_id,
                unit_number: persona.unit_number.to_string(),
                owner_id,
                tantièmes: persona.tantiemes,
            });
        }

        log::info!(
            "✅ Building 2: {} copropriétaires created with {} units",
            building2_personas.len(),
            building2_units.len()
        );

        // =====================================================================
        // Building 3: Les Terrasses de Flagey (medium, CdC obligatoire, >= 20 lots)
        // =====================================================================
        let building3_id = Uuid::new_v4();
        // acp_id already resolved above for building 1 (same org)
        sqlx::query!(
            r#"
            INSERT INTO buildings (id, acp_id, name, address, city, postal_code, country, total_units, construction_year, slug, created_at, updated_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
            "#,
            building3_id,
            acp_id,
            "Les Terrasses de Flagey",
            "25 Place Flagey",
            "Ixelles",
            "1050",
            "Belgique",
            48,
            1990,
            "les-terrasses-de-flagey-ixelles",
            now,
            now
        )
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create building 3 (Les Terrasses de Flagey): {}", e))?;

        log::info!("✅ Building 3 created: Les Terrasses de Flagey (48 lots, CdC obligatoire)");

        let mut building3_owners: Vec<ScenarioOwnerResult> = Vec::new();
        let mut building3_units: Vec<ScenarioUnitResult> = Vec::new();

        // Building 3 copropriétaires
        struct Building3Persona {
            first_name: &'static str,
            last_name: &'static str,
            email: &'static str,
            password: &'static str,
            unit_number: &'static str,
            tantiemes: f64,
        }

        let building3_personas = vec![
            Building3Persona {
                first_name: "Isabelle",
                last_name: "Renard",
                email: "isabelle@terrasses-flagey.be",
                password: "isabelle123",
                unit_number: "1A",
                tantiemes: 450.0,
            },
            Building3Persona {
                first_name: "Thomas",
                last_name: "Berger",
                email: "thomas@terrasses-flagey.be",
                password: "thomas123",
                unit_number: "2A",
                tantiemes: 380.0,
            },
            Building3Persona {
                first_name: "Aminata",
                last_name: "Diallo",
                email: "aminata@terrasses-flagey.be",
                password: "aminata123",
                unit_number: "3A",
                tantiemes: 520.0,
            },
            Building3Persona {
                first_name: "Victor",
                last_name: "Claessens",
                email: "victor@terrasses-flagey.be",
                password: "victor123",
                unit_number: "4A",
                tantiemes: 400.0,
            },
        ];

        for persona in &building3_personas {
            // Create user
            let user_id = self
                .create_demo_user(
                    persona.email,
                    persona.password,
                    persona.first_name,
                    persona.last_name,
                    "owner",
                    Some(org_id),
                )
                .await?;

            users_result.push(ScenarioUserResult {
                user_id,
                email: persona.email.to_string(),
                password: persona.password.to_string(),
                role: "owner".to_string(),
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
            });

            // Create owner record
            let owner_id = self
                .create_demo_owner(
                    org_id,
                    persona.first_name,
                    persona.last_name,
                    persona.email,
                    "+32 400 00 00 00",
                    "25 Place Flagey",
                    "Ixelles",
                    "1050",
                    "Belgique",
                )
                .await?;

            // Link user to owner
            sqlx::query("UPDATE owners SET user_id = $1 WHERE id = $2")
                .bind(user_id)
                .bind(owner_id)
                .execute(&self.pool)
                .await
                .map_err(|e| {
                    format!(
                        "Failed to link building3 owner {} to user: {}",
                        persona.last_name, e
                    )
                })?;

            building3_owners.push(ScenarioOwnerResult {
                owner_id,
                user_id,
                first_name: persona.first_name.to_string(),
                last_name: persona.last_name.to_string(),
                email: persona.email.to_string(),
            });

            // Create unit
            let unit_id = self
                .create_demo_unit(
                    org_id,
                    building3_id,
                    None,
                    persona.unit_number,
                    "apartment",
                    None,
                    70.0,
                    persona.tantiemes,
                )
                .await?;

            // Create unit_owner relationship
            self.create_demo_unit_owner(
                unit_id,
                owner_id,
                rust_decimal_macros::dec!(1), // 100% ownership
                true,                         // primary contact
                None,                         // active (no end_date)
            )
            .await?;

            building3_units.push(ScenarioUnitResult {
                unit_id,
                unit_number: persona.unit_number.to_string(),
                owner_id,
                tantièmes: persona.tantiemes,
            });
        }

        log::info!(
            "✅ Building 3: {} copropriétaires created with {} units",
            building3_personas.len(),
            building3_units.len()
        );

        // --- Meeting: AG Ordinaire 2026 — 2e convocation ---
        let meeting_date = (now + chrono::Duration::days(30))
            .format("%Y-%m-%d")
            .to_string();

        let meeting_id = self
            .create_demo_meeting(
                building_id,
                org_id,
                "AG Ordinaire 2026 — 2e convocation",
                "ordinary",
                &meeting_date,
                "scheduled",
            )
            .await?;

        // Set is_second_convocation = true directly in SQL
        sqlx::query("UPDATE meetings SET is_second_convocation = true WHERE id = $1")
            .bind(meeting_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to set is_second_convocation: {}", e))?;

        log::info!("✅ Meeting created: AG Ordinaire 2026 — 2e convocation");

        // --- Resolution: Approbation des comptes 2025 (Pending, Absolute majority) ---
        let resolution_id = Uuid::new_v4();
        sqlx::query(
            r#"
            -- `agenda_item_index` est OBLIGATOIRE pour qu'une résolution soit
            -- votable : Art. 3.87 § 2 CC annule une décision portant sur un
            -- point absent de l'ordre du jour, et `cast_vote` la refuse depuis
            -- #840. Le point 0 de cette assemblée est « Approbation des comptes
            -- annuels », que cette résolution met précisément aux voix.
            INSERT INTO resolutions (id, meeting_id, title, description, resolution_type, majority_required, status, agenda_item_index, created_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
            "#,
        )
        .bind(resolution_id)
        .bind(meeting_id)
        .bind("Approbation des comptes 2025")
        .bind("Approbation des comptes annuels de l'exercice 2025 et décharge au syndic.")
        .bind("Ordinary")
        .bind("Absolute")
        .bind("Pending")
        .bind(0_i32)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to create scenario resolution: {}", e))?;

        log::info!("✅ Resolution created: Approbation des comptes 2025");

        // L'ACP doit être CONFORME à son acte de base, sinon rien ne s'y fait.
        //
        // `ensure_default_acp_for_org` insère `total_tantiemes = 1000` en dur.
        // Le monde de scénario y attache ensuite trois immeubles dont les lots
        // totalisent bien davantage. L'ACP naissait donc non conforme, et le
        // portique « valider avant de calculer » (Art. 3.85, Story H2) refusait
        // toute création de dépense :
        //
        //     POST /expenses → 422 ACP_NOT_CONFORMANT
        //     quota_basis 1000, quota_delta -8390, units_delta 223
        //
        // Le refus est le bon comportement du produit. C'est le monde de
        // démonstration qui violait son propre acte de base — et une
        // documentation vivante ne peut pas montrer la comptabilité d'une
        // copropriété où l'on ne peut rien comptabiliser.
        //
        // On aligne donc l'acte de base sur ce qui a été créé : la somme des
        // quotités des lots, et le nombre réel de lots par immeuble. Aligner
        // dans ce sens (l'acte suit les lots) est le seul possible ici,
        // puisque les lots portent les données du scénario.
        sqlx::query(
            r#"
            UPDATE acps SET total_tantiemes = sub.somme, updated_at = NOW()
            FROM (
                -- Même expression que la requête de métriques
                -- (`acp_repository_impl.rs`) : `SUM(u.quota::NUMERIC)`. La
                -- conformité se juge sur une ÉGALITÉ exacte, donc toute
                -- divergence d'arrondi entre les deux calculs rendrait l'ACP
                -- non conforme malgré la réconciliation.
                SELECT b.acp_id,
                       COALESCE(SUM(u.quota::NUMERIC), 0)::int AS somme
                FROM buildings b
                JOIN units u ON u.building_id = b.id
                WHERE b.acp_id = (SELECT acp_id FROM buildings WHERE id = $1)
                GROUP BY b.acp_id
            ) AS sub
            WHERE acps.id = sub.acp_id AND sub.somme > 0
            "#,
        )
        .bind(building_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to reconcile scenario ACP tantiemes: {}", e))?;

        // Et le nombre de lots déclaré par chaque immeuble sur le nombre réel :
        // `units_delta` valait 223, ce qui rendait le contrôle bruyant même une
        // fois les quotités alignées.
        sqlx::query(
            r#"
            UPDATE buildings SET total_units = sub.n, updated_at = NOW()
            FROM (
                SELECT b.id, COUNT(u.id)::int AS n
                FROM buildings b LEFT JOIN units u ON u.building_id = b.id
                WHERE b.acp_id = (SELECT acp_id FROM buildings WHERE id = $1)
                GROUP BY b.id
            ) AS sub
            WHERE buildings.id = sub.id
            "#,
        )
        .bind(building_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to reconcile scenario building unit counts: {}", e))?;

        log::info!("✅ ACP réconciliée avec son acte de base (quotités et lots)");

        let result = ScenarioWorldResult {
            organization_id: org_id,
            building_id,
            meeting_id,
            resolution_id,
            users: users_result,
            owners: owners_result,
            units: units_result,
            building2_id,
            building2_name: "Le Clos des Hirondelles".to_string(),
            building2_owners,
            building2_units,
            building3_id,
            building3_name: "Les Terrasses de Flagey".to_string(),
            building3_owners,
            building3_units,
        };

        log::info!("✅ Scenario world seeded successfully (Résidence du Parc Royal)");

        Ok(result)
    }

    /// Clear all data created by `seed_scenario_world`.
    ///
    /// Deletes in reverse FK order, scoped by the scenario organization slug.
    pub async fn clear_scenario_world(&self) -> Result<String, String> {
        log::warn!("⚠️  Clearing scenario world data (Résidence du Parc Royal)...");

        // Find the scenario organization
        let org_id: Option<Uuid> = sqlx::query_scalar(
            "SELECT id FROM organizations WHERE slug = 'residence-parc-royal-test'",
        )
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| format!("Failed to find scenario organization: {}", e))?;

        let org_id =
            match org_id {
                Some(id) => id,
                None => return Ok(
                    "ℹ️  No scenario world found to clear (residence-parc-royal-test not found)."
                        .to_string(),
                ),
            };

        log::info!("Found scenario organization: {} — clearing data...", org_id);

        // Delete in reverse FK order

        // 1. Votes (reference resolutions and owners)
        sqlx::query(
            "DELETE FROM votes WHERE resolution_id IN (SELECT r.id FROM resolutions r INNER JOIN meetings m ON r.meeting_id = m.id WHERE m.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete votes: {}", e))?;

        // 2. Resolutions (reference meetings)
        sqlx::query(
            "DELETE FROM resolutions WHERE meeting_id IN (SELECT id FROM meetings WHERE organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete resolutions: {}", e))?;

        // 3. Convocation recipients (reference convocations)
        sqlx::query(
            "DELETE FROM convocation_recipients WHERE convocation_id IN (SELECT id FROM convocations WHERE organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete convocation_recipients: {}", e))?;

        // 4. Convocations (reference meetings)
        sqlx::query("DELETE FROM convocations WHERE organization_id = $1")
            .bind(org_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to delete convocations: {}", e))?;

        // 5. Board decisions (reference meetings)
        sqlx::query(
            "DELETE FROM board_decisions WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete board_decisions: {}", e))?;

        // 6. Board members (reference meetings)
        sqlx::query(
            "DELETE FROM board_members WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete board_members: {}", e))?;

        // 7. Meetings
        sqlx::query(
            "DELETE FROM meetings WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete meetings: {}", e))?;

        // 8. Unit owners (junction table)
        sqlx::query(
            "DELETE FROM unit_owners WHERE unit_id IN (SELECT u.id FROM units u INNER JOIN buildings b ON u.building_id = b.id INNER JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete unit_owners: {}", e))?;

        // 9. Units
        sqlx::query(
            "DELETE FROM units WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete units: {}", e))?;

        // 10. Owners
        sqlx::query("DELETE FROM owners WHERE organization_id = $1")
            .bind(org_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to delete owners: {}", e))?;

        // 11. Documents (Hotfix #602 : via acps since buildings.organization_id was dropped)
        sqlx::query(
            "DELETE FROM documents WHERE building_id IN (SELECT b.id FROM buildings b JOIN acps a ON a.id = b.acp_id WHERE a.organization_id = $1)",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete documents: {}", e))?;

        // 12. Buildings (Hotfix #602 : via acps)
        sqlx::query("DELETE FROM buildings WHERE acp_id IN (SELECT id FROM acps WHERE organization_id = $1)")
            .bind(org_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to delete buildings: {}", e))?;

        // 13. User roles (before users, except superadmin)
        sqlx::query(
            "DELETE FROM user_roles WHERE user_id IN (SELECT id FROM users WHERE organization_id = $1 AND role != 'superadmin')",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete user_roles: {}", e))?;

        // 14. Users (except admin@koprogo.com)
        sqlx::query(
            "DELETE FROM users WHERE organization_id = $1 AND email != 'admin@koprogo.com'",
        )
        .bind(org_id)
        .execute(&self.pool)
        .await
        .map_err(|e| format!("Failed to delete users: {}", e))?;

        // 15. PCMN accounts
        sqlx::query("DELETE FROM accounts WHERE organization_id = $1")
            .bind(org_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to delete accounts: {}", e))?;

        // 16. Organization
        sqlx::query("DELETE FROM organizations WHERE id = $1")
            .bind(org_id)
            .execute(&self.pool)
            .await
            .map_err(|e| format!("Failed to delete organization: {}", e))?;

        log::info!("✅ Scenario world cleared (Résidence du Parc Royal)");

        Ok("✅ Scenario world cleared successfully (Résidence du Parc Royal).".to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use sqlx::PgPool;

    /// Test that seed_superadmin() is idempotent - can be called multiple times without errors
    ///
    /// This test ensures production deployments can safely restart without constraint violations
    #[sqlx::test]
    #[ignore = "requires DATABASE_URL (integration test)"]
    async fn test_seed_superadmin_is_idempotent(pool: PgPool) -> sqlx::Result<()> {
        let seeder = DatabaseSeeder::new(pool.clone());

        // First call: Create superadmin
        let result1 = seeder.seed_superadmin().await;
        assert!(result1.is_ok(), "First seed_superadmin call should succeed");
        let user1 = result1.unwrap();
        assert_eq!(user1.email, "admin@koprogo.com");
        assert_eq!(user1.role, UserRole::SuperAdmin);

        // Second call: Should succeed (idempotent upsert)
        let result2 = seeder.seed_superadmin().await;
        assert!(
            result2.is_ok(),
            "Second seed_superadmin call should succeed (idempotent): {:?}",
            result2.err()
        );
        let user2 = result2.unwrap();
        assert_eq!(user2.email, "admin@koprogo.com");
        assert_eq!(user2.id, user1.id, "Superadmin UUID should remain the same");

        // Third call: Should still succeed
        let result3 = seeder.seed_superadmin().await;
        assert!(
            result3.is_ok(),
            "Third seed_superadmin call should succeed (idempotent): {:?}",
            result3.err()
        );

        // Verify only ONE primary role exists for superadmin
        let primary_role_count = sqlx::query_scalar::<_, i64>(
            r#"
            SELECT COUNT(*)
            FROM user_roles
            WHERE user_id = $1 AND is_primary = true
            "#,
        )
        .bind(user1.id)
        .fetch_one(&pool)
        .await?;

        assert_eq!(
            primary_role_count, 1,
            "Superadmin should have exactly ONE primary role, found {}",
            primary_role_count
        );

        // Verify the superadmin role exists in user_roles
        let role_count = sqlx::query_scalar::<_, i64>(
            r#"
            SELECT COUNT(*)
            FROM user_roles
            WHERE user_id = $1 AND role = 'superadmin' AND organization_id IS NULL
            "#,
        )
        .bind(user1.id)
        .fetch_one(&pool)
        .await?;

        assert_eq!(
            role_count, 1,
            "Superadmin should have exactly ONE superadmin role, found {}",
            role_count
        );

        Ok(())
    }

    /// Test that seed_superadmin() handles existing user_roles correctly
    ///
    /// Ensures the UPSERT doesn't violate the idx_user_roles_primary_per_user constraint
    #[sqlx::test]
    #[ignore = "requires DATABASE_URL (integration test)"]
    async fn test_seed_superadmin_preserves_existing_primary_role(
        pool: PgPool,
    ) -> sqlx::Result<()> {
        let seeder = DatabaseSeeder::new(pool.clone());

        // First call: Create superadmin
        seeder.seed_superadmin().await.unwrap();

        // Manually check is_primary state before second call
        let is_primary_before = sqlx::query_scalar::<_, bool>(
            r#"
            SELECT is_primary
            FROM user_roles
            WHERE user_id = '00000000-0000-0000-0000-000000000001'
              AND role = 'superadmin'
              AND organization_id IS NULL
            "#,
        )
        .fetch_one(&pool)
        .await?;

        assert!(
            is_primary_before,
            "Superadmin role should be primary after first seed"
        );

        // Second call: Should not violate unique constraint
        let result = seeder.seed_superadmin().await;
        assert!(
            result.is_ok(),
            "Second seed should not violate idx_user_roles_primary_per_user constraint: {:?}",
            result.err()
        );

        // Verify is_primary is still true (preserved, not updated)
        let is_primary_after = sqlx::query_scalar::<_, bool>(
            r#"
            SELECT is_primary
            FROM user_roles
            WHERE user_id = '00000000-0000-0000-0000-000000000001'
              AND role = 'superadmin'
              AND organization_id IS NULL
            "#,
        )
        .fetch_one(&pool)
        .await?;

        assert!(
            is_primary_after,
            "Superadmin role should remain primary after second seed"
        );

        Ok(())
    }
}