objets_metier_rs 1.0.2

use crate::com::{ComInstance, SafeDispatch, SafeVariant};
use crate::errors::{SageError, SageResult};
use crate::wrappers::cial::factories::{
    FactoryAgenda, FactoryArrondi, FactoryArticle, FactoryArticleStat, FactoryBaremeCommission,
    FactoryBaremeRabais, FactoryBaremeSolde, FactoryCategorieComptaAchat,
    FactoryCategorieComptaStock, FactoryCategorieComptaVente, FactoryCategorieTarif,
    FactoryConditionLivraison, FactoryConditionnement, FactoryDepot, FactoryDocument,
    FactoryDocumentAchat, FactoryDocumentInterne, FactoryDocumentStock, FactoryDocumentVente,
    FactoryDossier, FactoryDossierParam, FactoryExpedition, FactoryFamille, FactoryGamme,
    FactoryGlossaire, FactoryModele, FactoryMotifDevis, FactoryParamDocAchat,
    FactoryParamDocInterne, FactoryParamDocStock, FactoryParamDocVente, FactoryPeriodicite,
    FactoryProduit, FactorySoucheAchat, FactorySoucheInterne, FactorySoucheStock,
    FactorySoucheVente, FactoryUnite,
};
use crate::wrappers::cpta::ILoggable;

/// Wrapper pour l'application BSCIALApplication100c (Gestion Commerciale Sage 100c)
///
/// Cette structure encapsule l'objet COM BSCIALApplication100c et fournit
/// un accès typé et sécurisé aux fonctionnalités de gestion commerciale :
/// - Gestion des articles et références produits
/// - Documents commerciaux (vente, achat, stock)
/// - Dépôts et gestion des stocks
/// - Familles d'articles et classifications
/// - Tarifs, barèmes et remises
/// - Configuration commerciale
///
/// # Exemples
///
/// ```no_run
/// use objets_metier_rs::wrappers::cial::CialApplication;
///
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// // Créer l'application commerciale
/// let cial = CialApplication::new("Objets100c.CIAL")?;
///
/// // Définir le chemin de la base commerciale
/// cial.set_name("D:\\Sage\\BIJOU.MAE")?;
///
/// // Se connecter
/// let loggable = cial.loggable()?;
/// loggable.set_user_name("<Administrateur>")?;
/// loggable.set_user_pwd("")?;
///
/// // Ouvrir la base
/// cial.open()?;
///
/// // Travailler avec les factories...
/// // let factory_article = cial.factory_article()?;
///
/// // Fermer la base
/// cial.close()?;
/// # Ok(())
/// # }
/// ```
pub struct CialApplication {
    instance: ComInstance,
}

impl CialApplication {
    /// Crée un wrapper CialApplication à partir d'un CLSID
    ///
    /// # Arguments
    ///
    /// * `clsid` - CLSID de l'application COM (ex: "ED0EC116-16B8-44CC-A68A-41BF6E15EB3F")
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let cial = CialApplication::new("ED0EC116-16B8-44CC-A68A-41BF6E15EB3F")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new(clsid: &str) -> SageResult<Self> {
        let instance = ComInstance::new(clsid)?;

        Ok(CialApplication { instance })
    }

    /// Crée une instance en détectant automatiquement la dernière version BSCial installée
    ///
    /// Cette méthode interroge le registre Windows pour trouver la dernière version
    /// de Sage Commercial installée et l'utilise automatiquement.
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// // Détecte et utilise automatiquement la dernière version Sage installée
    /// let cial = CialApplication::new_auto()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new_auto() -> SageResult<Self> {
        let (prog_id, clsid) = crate::com::find_latest_bscial()?;
        println!(
            "🔍 Version Sage Commercial détectée: {} ({})",
            prog_id, clsid
        );
        Self::new(&clsid)
    }

    /// Crée une instance pour une version Sage spécifique
    ///
    /// # Arguments
    ///
    /// * `version` - Version Sage (ex: "100c", "130", "140")
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// // Utilise spécifiquement Sage 100c
    /// let cial = CialApplication::new_version("100c")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new_version(version: &str) -> SageResult<Self> {
        let prog_id = format!("Sage.BSCial.Application.{}", version);
        Self::from_prog_id(&prog_id)
    }

    /// Crée une instance à partir d'un ProgID complet
    ///
    /// # Arguments
    ///
    /// * `prog_id` - ProgID complet (ex: "Sage.BSCial.Application.100c")
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let cial = CialApplication::from_prog_id("Sage.BSCial.Application.100c")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn from_prog_id(prog_id: &str) -> SageResult<Self> {
        let clsid = crate::com::resolve_prog_id(prog_id)?;
        Self::new(&clsid)
    }

    /// Accès à l'instance COM sous-jacente pour les opérations avancées
    pub fn instance(&self) -> &ComInstance {
        &self.instance
    }

    /// Crée un SafeDispatch temporaire pour les appels
    fn dispatch(&'_ self) -> SageResult<SafeDispatch<'_>> {
        let dispatch_ref = self.instance.dispatch()?;
        Ok(SafeDispatch::new(dispatch_ref))
    }

    /// Vérifie si une base de données commerciale est ouverte
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// if cial.is_open()? {
    ///     println!("Base commerciale ouverte");
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub fn is_open(&self) -> SageResult<bool> {
        self.dispatch()?
            .call_method_by_name("IsOpen", &[])?
            .to_bool()
    }

    /// Obtient le nom/chemin de la base de données commerciale
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// let name = cial.get_name()?;
    /// println!("Base commerciale : {}", name);
    /// # Ok(())
    /// # }
    /// ```
    pub fn get_name(&self) -> SageResult<String> {
        self.dispatch()?
            .call_method_by_name("Name", &[])?
            .to_string()
    }

    /// Définit le chemin de la base de données commerciale
    ///
    /// Cette méthode doit être appelée avant `open()` pour spécifier
    /// le fichier de base commerciale (.MAE) à ouvrir.
    ///
    /// # Arguments
    ///
    /// * `database_path` - Chemin complet vers le fichier .MAE
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// cial.set_name("D:\\Sage\\Bases\\BIJOU.MAE")?;
    /// cial.open()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn set_name(&self, database_path: &str) -> SageResult<()> {
        let path_variant = SafeVariant::from_string(database_path);
        self.dispatch()?
            .call_property_put("Name", &[path_variant])?;
        Ok(())
    }

    /// Définit la référence à l'application comptable (CptaApplication)
    ///
    /// **IMPORTANT** : Cette méthode DOIT être appelée avant `open()` pour lier
    /// la base commerciale à sa base comptable associée. Sans cette liaison,
    /// la création de documents commerciaux échouera avec "Valeur invalide".
    ///
    /// # Arguments
    ///
    /// * `cpta_app` - Instance ComInstance de l'application comptable (CptaApplication)
    ///
    /// # Workflow correct
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cpta::CptaApplication;
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// // 1. Créer et ouvrir la base comptable
    /// let cpta = CptaApplication::new("309DE0FB-9FB8-4F4E-8295-CC60C60DAA33")?;
    /// cpta.set_name("D:\\Sage\\BIJOU.MAE")?;
    /// cpta.open()?;
    ///
    /// // 2. Créer la base commerciale et LA LIER à la comptabilité
    /// let cial = CialApplication::new("Objets100c.CIAL")?;
    /// cial.set_cpta_application(cpta.instance())?; // ⚠️ CRUCIAL !
    /// cial.set_name("D:\\Sage\\BIJOU.MAE")?;
    /// cial.open()?;
    ///
    /// // 3. Maintenant on peut créer des documents
    /// let doc = cial.factory_document_vente()?.create_type(1)?; // ✓ Fonctionne !
    /// # Ok(())
    /// # }
    /// ```
    pub fn set_cpta_application(&self, cpta_instance: &ComInstance) -> SageResult<()> {
        let cpta_variant = SafeVariant::from_dispatch(cpta_instance.dispatch()?.clone());
        self.dispatch()?
            .call_property_put("CptaApplication", &[cpta_variant])?;
        Ok(())
    }

    /// Accède à l'objet Loggable pour l'authentification
    ///
    /// L'objet Loggable permet de gérer la connexion utilisateur
    /// à la base commerciale.
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// let loggable = cial.loggable()?;
    /// loggable.set_user_name("<Administrateur>")?;
    /// loggable.set_user_pwd("")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn loggable(&self) -> SageResult<ILoggable> {
        let loggable_variant = self.dispatch()?.call_method_by_name("Loggable", &[])?;

        if !loggable_variant.is_object() {
            return Err(SageError::ConversionError {
                from_type: loggable_variant.type_name().to_string(),
                to_type: "IBILoggable".to_string(),
                value: "Propriété Loggable n'est pas un objet COM".to_string(),
            });
        }

        let loggable_dispatch = loggable_variant.to_dispatch()?;

        Ok(ILoggable {
            dispatch: loggable_dispatch,
        })
    }

    /// Ouvre une base de données commerciale
    ///
    /// Utilise le chemin défini précédemment avec `set_name()`.
    /// L'utilisateur doit définir `UserName` et `UserPwd` via `loggable()`
    /// avant l'ouverture.
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// cial.set_name("D:\\Sage\\BIJOU.MAE")?;
    /// let loggable = cial.loggable()?;
    /// loggable.set_user_name("<Administrateur>")?;
    /// loggable.set_user_pwd("")?;
    /// cial.open()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn open(&self) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Open", &[])?;
        Ok(())
    }

    /// Ouvre une base de données commerciale avec un paramètre variant
    ///
    /// Version alternative de `open()` acceptant un paramètre VARIANT.
    /// Utilisé pour des scénarios d'ouverture avancés.
    ///
    /// # Arguments
    ///
    /// * `param` - Paramètre d'ouverture (variant)
    pub fn open_with_param(&self, param: SafeVariant) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Open", &[param])?;
        Ok(())
    }

    /// Ferme la base de données commerciale courante
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// # cial.set_name("D:\\Sage\\BIJOU.MAE")?;
    /// # cial.open()?;
    /// // ... travail avec la base ...
    /// cial.close()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn close(&self) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Close", &[])?;
        Ok(())
    }

    /// Crée une nouvelle base de données commerciale
    ///
    /// Cette méthode crée une nouvelle base de données au chemin
    /// spécifié avec `set_name()`.
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// cial.set_name("D:\\Sage\\Nouvelle\\BASE.MAE")?;
    /// cial.create()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn create(&self) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Create", &[])?;
        Ok(())
    }

    /// Obtient les informations sur la base de données commerciale
    ///
    /// Retourne des informations détaillées sur la base ouverte
    /// (version, propriétés, etc.)
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// # cial.set_name("D:\\Sage\\BIJOU.MAE")?;
    /// # cial.open()?;
    /// let info = cial.database_info()?;
    /// println!("Informations base : {}", info);
    /// # Ok(())
    /// # }
    /// ```
    pub fn database_info(&self) -> SageResult<String> {
        self.dispatch()?
            .call_method_by_name("DatabaseInfo", &[])?
            .to_string()
    }

    /// Gère la synchronisation de la base commerciale
    ///
    /// Cette méthode retourne un variant contenant les informations
    /// de synchronisation.
    pub fn synchro(&self) -> SageResult<SafeVariant> {
        self.dispatch()?.call_method_by_name("Synchro", &[])
    }

    /// Lecture depuis une source spécifique
    ///
    /// Cette méthode retourne un variant contenant les données
    /// lues depuis la source spécifiée.
    pub fn read_from(&self) -> SageResult<SafeVariant> {
        self.dispatch()?.call_method_by_name("ReadFrom", &[])
    }

    // ============================================================================
    // ACCESSEURS AUX FACTORIES - Phase 1 (Factories Cœur)
    // ============================================================================
    // Les méthodes suivantes seront implémentées progressivement lors
    // des phases 1 à 4 du développement du module CIAL.
    // Pour l'instant, nous gardons une méthode générique retournant SafeVariant.

    /// Accède à l'objet FactoryArticle - ÉQUIVALENT .FactoryArticle en C#/VB
    ///
    /// Retourne la factory pour gérer les articles et références produits.
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cial::CialApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// # let cial = CialApplication::new("Objets100c.CIAL")?;
    /// # cial.set_name("D:\\Sage\\BIJOU.MAE")?;
    /// # cial.open()?;
    /// let factory = cial.factory_article()?;
    /// let article = factory.read_reference("REF001")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn factory_article(&self) -> SageResult<FactoryArticle> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryArticle", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryArticle { dispatch })
    }

    /// Accède à l'objet FactoryDocumentVente
    ///
    /// Retourne la factory pour gérer les documents de vente (devis, commandes, factures, avoirs).
    pub fn factory_document_vente(&self) -> SageResult<FactoryDocumentVente> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDocumentVente", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryDocumentVente { dispatch })
    }

    /// Accède à l'objet FactoryDocumentAchat
    ///
    /// Retourne la factory pour gérer les documents d'achat (commandes, factures fournisseurs, avoirs).
    pub fn factory_document_achat(&self) -> SageResult<FactoryDocumentAchat> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDocumentAchat", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryDocumentAchat { dispatch })
    }

    /// Accède à l'objet FactoryDocumentStock
    ///
    /// Retourne la factory pour gérer les mouvements de stock (entrées, sorties, transferts, inventaires).
    pub fn factory_document_stock(&self) -> SageResult<FactoryDocumentStock> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDocumentStock", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryDocumentStock { dispatch })
    }

    /// Accède à l'objet FactoryDocumentInterne
    ///
    /// Retourne la factory pour gérer les documents internes.
    pub fn factory_document_interne(&self) -> SageResult<FactoryDocumentInterne> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDocumentInterne", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryDocumentInterne { dispatch })
    }

    /// Accède à l'objet FactoryDocument (générique)
    ///
    /// Retourne la factory générique pour accéder aux documents tous types confondus.
    pub fn factory_document(&self) -> SageResult<FactoryDocument> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDocument", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryDocument { dispatch })
    }

    /// Accède à l'objet FactoryDepot
    ///
    /// Retourne la factory pour gérer les dépôts de stockage.
    pub fn factory_depot(&self) -> SageResult<FactoryDepot> {
        let result = self.dispatch()?.call_method_by_name("FactoryDepot", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryDepot { dispatch })
    }

    /// Accède à l'objet FactoryFamille
    ///
    /// Retourne la factory pour gérer les familles d'articles.
    pub fn factory_famille(&self) -> SageResult<FactoryFamille> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryFamille", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryFamille { dispatch })
    }

    // ============================================================================
    // ACCESSEURS AUX FACTORIES - Phase 2 (Configuration Produits)
    // ============================================================================

    /// Accède à l'objet FactoryGamme
    ///
    /// Retourne la factory pour gérer les gammes de produits (tailles, couleurs, etc.).
    pub fn factory_gamme(&self) -> SageResult<FactoryGamme> {
        let result = self.dispatch()?.call_method_by_name("FactoryGamme", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryGamme { dispatch })
    }

    /// Accède à l'objet FactoryProduit
    ///
    /// Retourne la factory pour gérer les types de produits.
    pub fn factory_produit(&self) -> SageResult<FactoryProduit> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryProduit", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryProduit { dispatch })
    }

    /// Accède à l'objet FactoryUnite
    ///
    /// Retourne la factory pour gérer les unités de mesure (pièce, kg, m², etc.).
    pub fn factory_unite(&self) -> SageResult<FactoryUnite> {
        let result = self.dispatch()?.call_method_by_name("FactoryUnite", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryUnite { dispatch })
    }

    /// Accède à l'objet FactoryConditionnement
    ///
    /// Retourne la factory pour gérer les conditionnements d'articles (carton, palette, etc.).
    pub fn factory_conditionnement(&self) -> SageResult<FactoryConditionnement> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryConditionnement", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryConditionnement { dispatch })
    }

    /// Accède à l'objet FactoryGlossaire
    ///
    /// Retourne la factory pour gérer les termes du glossaire commercial.
    pub fn factory_glossaire(&self) -> SageResult<FactoryGlossaire> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryGlossaire", &[])?;
        let dispatch = result.to_dispatch()?;
        Ok(FactoryGlossaire { dispatch })
    }

    // ============================================================================
    // ACCESSEURS AUX FACTORIES - Phase 3 (Paramètres)
    // ============================================================================

    // Groupe A - Catégories comptables

    pub fn factory_categorie_compta_vente(&self) -> SageResult<FactoryCategorieComptaVente> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryCategorieComptaVente", &[])?;
        Ok(FactoryCategorieComptaVente {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_categorie_compta_achat(&self) -> SageResult<FactoryCategorieComptaAchat> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryCategorieComptaAchat", &[])?;
        Ok(FactoryCategorieComptaAchat {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_categorie_compta_stock(&self) -> SageResult<FactoryCategorieComptaStock> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryCategorieComptaStock", &[])?;
        Ok(FactoryCategorieComptaStock {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_categorie_tarif(&self) -> SageResult<FactoryCategorieTarif> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryCategorieTarif", &[])?;
        Ok(FactoryCategorieTarif {
            dispatch: result.to_dispatch()?,
        })
    }

    // Groupe B - Paramètres de documents

    pub fn factory_param_doc_vente(&self) -> SageResult<FactoryParamDocVente> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryParamDocVente", &[])?;
        Ok(FactoryParamDocVente {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_param_doc_achat(&self) -> SageResult<FactoryParamDocAchat> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryParamDocAchat", &[])?;
        Ok(FactoryParamDocAchat {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_param_doc_stock(&self) -> SageResult<FactoryParamDocStock> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryParamDocStock", &[])?;
        Ok(FactoryParamDocStock {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_param_doc_interne(&self) -> SageResult<FactoryParamDocInterne> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryParamDocInterne", &[])?;
        Ok(FactoryParamDocInterne {
            dispatch: result.to_dispatch()?,
        })
    }

    // Groupe C - Souches de numérotation

    pub fn factory_souche_vente(&self) -> SageResult<FactorySoucheVente> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactorySoucheVente", &[])?;
        Ok(FactorySoucheVente {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_souche_achat(&self) -> SageResult<FactorySoucheAchat> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactorySoucheAchat", &[])?;
        Ok(FactorySoucheAchat {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_souche_stock(&self) -> SageResult<FactorySoucheStock> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactorySoucheStock", &[])?;
        Ok(FactorySoucheStock {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_souche_interne(&self) -> SageResult<FactorySoucheInterne> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactorySoucheInterne", &[])?;
        Ok(FactorySoucheInterne {
            dispatch: result.to_dispatch()?,
        })
    }

    // Groupe D - Autres paramètres

    pub fn factory_modele(&self) -> SageResult<FactoryModele> {
        let result = self.dispatch()?.call_method_by_name("FactoryModele", &[])?;
        Ok(FactoryModele {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_condition_livraison(&self) -> SageResult<FactoryConditionLivraison> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryConditionLivraison", &[])?;
        Ok(FactoryConditionLivraison {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_expedition(&self) -> SageResult<FactoryExpedition> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryExpedition", &[])?;
        Ok(FactoryExpedition {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_periodicite(&self) -> SageResult<FactoryPeriodicite> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryPeriodicite", &[])?;
        Ok(FactoryPeriodicite {
            dispatch: result.to_dispatch()?,
        })
    }

    // ============================================================================
    // ACCESSEURS AUX FACTORIES - Phase 4 (Avancées)
    // ============================================================================

    // Groupe A - Barèmes tarifaires

    pub fn factory_bareme_commission(&self) -> SageResult<FactoryBaremeCommission> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryBaremeCommission", &[])?;
        Ok(FactoryBaremeCommission {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_bareme_solde(&self) -> SageResult<FactoryBaremeSolde> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryBaremeSolde", &[])?;
        Ok(FactoryBaremeSolde {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_bareme_rabais(&self) -> SageResult<FactoryBaremeRabais> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryBaremeRabais", &[])?;
        Ok(FactoryBaremeRabais {
            dispatch: result.to_dispatch()?,
        })
    }

    // Groupe B - Statistiques et configuration

    pub fn factory_article_stat(&self) -> SageResult<FactoryArticleStat> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryArticleStat", &[])?;
        Ok(FactoryArticleStat {
            dispatch: result.to_dispatch()?,
        })
    }

    pub fn factory_arrondi(&self) -> SageResult<FactoryArrondi> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryArrondi", &[])?;
        Ok(FactoryArrondi {
            dispatch: result.to_dispatch()?,
        })
    }

    // ====================================================================
    // ACCESSEURS AUX FACTORIES - Phase 4bis (Complémentaires)
    // ====================================================================

    /// Récupère la factory de gestion des agendas commerciaux
    pub fn factory_agenda(&self) -> SageResult<FactoryAgenda> {
        let result = self.dispatch()?.call_method_by_name("FactoryAgenda", &[])?;
        Ok(FactoryAgenda {
            dispatch: result.to_dispatch()?,
        })
    }

    /// Récupère la factory de gestion des dossiers commerciaux
    pub fn factory_dossier(&self) -> SageResult<FactoryDossier> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDossier", &[])?;
        Ok(FactoryDossier {
            dispatch: result.to_dispatch()?,
        })
    }

    /// Récupère la factory de gestion des paramétrages de dossiers
    pub fn factory_dossier_param(&self) -> SageResult<FactoryDossierParam> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryDossierParam", &[])?;
        Ok(FactoryDossierParam {
            dispatch: result.to_dispatch()?,
        })
    }

    /// Récupère la factory de gestion des motifs de devis perdus
    pub fn factory_motif_devis(&self) -> SageResult<FactoryMotifDevis> {
        let result = self
            .dispatch()?
            .call_method_by_name("FactoryMotifDevis", &[])?;
        Ok(FactoryMotifDevis {
            dispatch: result.to_dispatch()?,
        })
    }
}

#[cfg(test)]
mod tests {

    #[test]
    fn test_sage_application_creation() {
        // Ce test nécessiterait un environnement Sage pour fonctionner
        // Il sert de documentation pour l'utilisation
    }
}