objets_metier_rs 1.0.2

use crate::com::{ComInstance, SafeDispatch, SafeVariant};
use crate::errors::{SageError, SageResult};
use crate::wrappers::cpta::factories::{
    FactoryAdresse, FactoryAnalyse, FactoryAnalytique, FactoryBanque, FactoryClient,
    FactoryCollaborateur, FactoryCompte, FactoryCompteR, FactoryContact, FactoryDevise,
    FactoryEcriture, FactoryEcritureOD, FactoryFournisseur, FactoryJournal, FactoryJournalA,
    FactoryModeleReglement, FactoryNatureCompte, FactoryPays, FactoryReglement, FactoryTaxe,
    FactoryTiers,
};
use crate::wrappers::cpta::loggable_wrapper::ILoggable;
use crate::wrappers::cpta::process::PMEncoder;

/// Wrapper pour l'application BSCPTAApplication avec accès typé aux propriétés
pub struct CptaApplication {
    instance: ComInstance,
}

impl CptaApplication {
    /// Crée un wrapper CptaApplication à partir d'un CLSID
    ///
    /// # Arguments
    ///
    /// * `clsid` - CLSID COM (ex: "309DE0FB-9FB8-4F4E-8295-CC60C60DAA33")
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::CptaApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let app = CptaApplication::new("309DE0FB-9FB8-4F4E-8295-CC60C60DAA33")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new(clsid: &str) -> SageResult<Self> {
        let instance = ComInstance::new(clsid)?;

        Ok(CptaApplication { instance })
    }

    /// Crée une instance en détectant automatiquement la dernière version BSCpta installée
    ///
    /// Cette méthode interroge le registre Windows pour trouver la dernière version
    /// de Sage Comptabilité installée et l'utilise automatiquement.
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::CptaApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// // Détecte et utilise automatiquement la dernière version Sage installée
    /// let app = CptaApplication::new_auto()?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new_auto() -> SageResult<Self> {
        let (prog_id, clsid) = crate::com::find_latest_bscpta()?;
        println!(
            "🔍 Version Sage Comptabilité 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::CptaApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// // Utilise spécifiquement Sage 100c
    /// let app = CptaApplication::new_version("100c")?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn new_version(version: &str) -> SageResult<Self> {
        let prog_id = format!("Sage.BSCpta.Application.{}", version);
        Self::from_prog_id(&prog_id)
    }

    /// Crée une instance à partir d'un ProgID complet
    ///
    /// # Arguments
    ///
    /// * `prog_id` - ProgID complet (ex: "Sage.BSCpta.Application.100c")
    ///
    /// # Exemples
    ///
    /// ```no_run
    /// # use objets_metier_rs::CptaApplication;
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let app = CptaApplication::from_prog_id("Sage.BSCpta.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 est ouverte
    pub fn is_open(&self) -> SageResult<bool> {
        self.dispatch()?
            .call_method_by_name("IsOpen", &[])?
            .to_bool()
    }

    /// Obtient le nom de l'application
    pub fn get_name(&self) -> SageResult<String> {
        self.dispatch()?
            .call_method_by_name("Name", &[])?
            .to_string()
    }

    /// SETTER - Définit le chemin de la base de données - ÉQUIVALENT _mCpta.Name = "D:\\TMP\\BIJOU.MAE"
    pub fn set_name(&self, database_path: &str) -> SageResult<()> {
        let path_variant = SafeVariant::from_string(database_path);
        // Utilisation de PROPPUT pour définir la propriété
        self.dispatch()?
            .call_property_put("Name", &[path_variant])?;
        Ok(())
    }

    /// Accède à l'objet Loggable - ÉQUIVALENT .Loggable en C#/VB
    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,
        })
    }

    /// NOUVELLE MÉTHODE - Ouvre une base de données sans paramètre - ÉQUIVALENT _mCpta.Open()
    /// Utilise le chemin défini précédemment avec set_name()
    pub fn open(&self) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Open", &[])?;
        Ok(())
    }

    /// Ferme la base de données
    pub fn close(&self) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Close", &[])?;
        Ok(())
    }

    /// Crée une nouvelle base de données
    pub fn create(&self) -> SageResult<()> {
        self.dispatch()?.call_method_by_name("Create", &[])?;
        Ok(())
    }

    /// Accède à l'objet FactoryJournal - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryJournal prêt à utiliser
    /// Utilisation : app.factory_journal()?.exists_by_code("VTE")?
    pub fn factory_journal(&self) -> SageResult<FactoryJournal> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryJournal", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryJournal {
            dispatch: factory_dispatch,
        })
    }

    pub fn factory_ecriture(&self) -> SageResult<FactoryEcriture> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryEcriture", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryEcriture {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryTiers - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryTiers prêt à utiliser
    /// Utilisation : app.factory_tiers()?.exists_by_code("BAGUES")?
    pub fn factory_tiers(&self) -> SageResult<FactoryTiers> {
        let factory_variant = self.dispatch()?.call_method_by_name("FactoryTiers", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryTiers {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryClient - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryClient prêt à utiliser
    /// Utilisation : app.factory_client()?.exists_by_code("BAGUES")?
    pub fn factory_client(&self) -> SageResult<FactoryClient> {
        let factory_variant = self.dispatch()?.call_method_by_name("FactoryClient", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryClient {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryFournisseur - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryFournisseur prêt à utiliser
    /// Utilisation : app.factory_fournisseur()?.exists_by_code("FOURNISSEUR01")?
    pub fn factory_fournisseur(&self) -> SageResult<FactoryFournisseur> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryFournisseur", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryFournisseur {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryDevise - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryDevise prêt à utiliser
    /// Utilisation : app.factory_devise()?.exist_code_iso("EUR")?
    pub fn factory_devise(&self) -> SageResult<FactoryDevise> {
        let factory_variant = self.dispatch()?.call_method_by_name("FactoryDevise", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryDevise {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryTaxe - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryTaxe prêt à utiliser
    /// Utilisation : app.factory_taxe()?.exist_code("TVA20")?
    pub fn factory_taxe(&self) -> SageResult<FactoryTaxe> {
        let factory_variant = self.dispatch()?.call_method_by_name("FactoryTaxe", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryTaxe {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryReglement - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryReglement prêt à utiliser
    /// Utilisation : app.factory_reglement()?.exist_intitule("Chèque")?
    pub fn factory_reglement(&self) -> SageResult<FactoryReglement> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryReglement", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryReglement {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryBanque - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryBanque prêt à utiliser
    /// Utilisation : app.factory_banque()?.exist_intitule("BNP Paribas")?
    pub fn factory_banque(&self) -> SageResult<FactoryBanque> {
        let factory_variant = self.dispatch()?.call_method_by_name("FactoryBanque", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryBanque {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryModeleReglement - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryModeleReglement prêt à utiliser
    /// Utilisation : app.factory_modele_reglement()?.exist_intitule("30 jours fin de mois")?
    pub fn factory_modele_reglement(&self) -> SageResult<FactoryModeleReglement> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryModeleReglement", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryModeleReglement {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryCollaborateur - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryCollaborateur prêt à utiliser
    /// Utilisation : app.factory_collaborateur()?.exist_numero("001")?
    pub fn factory_collaborateur(&self) -> SageResult<FactoryCollaborateur> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryCollaborateur", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryCollaborateur {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryAnalytique - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryAnalytique prêt à utiliser
    /// Utilisation : app.factory_analytique()?.exist_numero("PRJ001")?
    pub fn factory_analytique(&self) -> SageResult<FactoryAnalytique> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryAnalytique", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryAnalytique {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryPays - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryPays prêt à utiliser
    /// Utilisation : app.factory_pays()?.exist_intitule("France")?
    pub fn factory_pays(&self) -> SageResult<FactoryPays> {
        let factory_variant = self.dispatch()?.call_method_by_name("FactoryPays", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryPays {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryEcritureOD - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryEcritureOD prêt à utiliser
    /// Utilisation : app.factory_ecriture_od()?.exist_numero(12345)?
    pub fn factory_ecriture_od(&self) -> SageResult<FactoryEcritureOD> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryEcritureOD", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryEcritureOD {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryAdresse - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryAdresse prêt à utiliser
    /// Utilisation : app.factory_adresse()?.read_by_tiers("CLIENT01")?
    pub fn factory_adresse(&self) -> SageResult<FactoryAdresse> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryAdresse", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryAdresse {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryContact - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryContact prêt à utiliser
    /// Utilisation : app.factory_contact()?.read_principal("CLIENT01")?
    pub fn factory_contact(&self) -> SageResult<FactoryContact> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryContact", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryContact {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryCompteR - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryCompteR prêt à utiliser (comptes de reporting)
    /// Utilisation : app.factory_compte_r()?.read_numero("01")?
    pub fn factory_compte_r(&self) -> SageResult<FactoryCompteR> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryCompteR", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryCompteR {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryJournalA - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryJournalA prêt à utiliser (journaux analytiques)
    /// Utilisation : app.factory_journal_a()?.read_numero(1)?
    pub fn factory_journal_a(&self) -> SageResult<FactoryJournalA> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryJournalA", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryJournalA {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryAnalyse - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryAnalyse prêt à utiliser (plans d'analyse)
    /// Utilisation : app.factory_analyse()?.read_numero(1)?
    pub fn factory_analyse(&self) -> SageResult<FactoryAnalyse> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryAnalyse", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryAnalyse {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryNatureCompte - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryNatureCompte prêt à utiliser (natures de compte)
    /// Utilisation : app.factory_nature_compte()?.read_intitule("IMMOBILISATIONS")?
    pub fn factory_nature_compte(&self) -> SageResult<FactoryNatureCompte> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryNatureCompte", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryNatureCompte {
            dispatch: factory_dispatch,
        })
    }

    /// Accède à l'objet FactoryCompteG - SYNTAXE FLUIDE DIRECTE
    /// Retourne directement un FactoryCompte prêt à utiliser (comptes généraux)
    /// Utilisation : app.factory_compte_g()?.read_numero("411000")?
    pub fn factory_compte_g(&self) -> SageResult<FactoryCompte> {
        let factory_variant = self
            .dispatch()?
            .call_method_by_name("FactoryCompteG", &[])?;

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

        let factory_dispatch = factory_variant.to_dispatch()?;

        Ok(FactoryCompte {
            dispatch: factory_dispatch,
        })
    }

    /// Version "raw" - Accède au SafeVariant FactoryJournal pour les cas avancés
    /// Utilisation avancée : app.factory_journal_raw()?.to_dispatch()?
    pub fn factory_journal_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch()?.call_method_by_name("FactoryJournal", &[])
    }

    /// Version "raw" - Accède au SafeVariant FactoryEcriture pour les cas avancés
    /// Utilisation avancée : app.factory_ecriture_raw()?.to_dispatch()?
    pub fn factory_ecriture_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch()?.call_method_by_name("FactoryEcriture", &[])
    }

    /// Obtient les informations sur la base de données
    pub fn database_info(&self) -> SageResult<String> {
        self.dispatch()?
            .call_method_by_name("DatabaseInfo", &[])?
            .to_string()
    }

    // ==================== PROCESSUS ====================

    /// Crée un processus de saisie de pièce comptable (IPMEncoder)
    /// Ce processus permet de créer des pièces comptables équilibrées avec validation.
    ///
    /// # Exemple
    /// ```no_run
    /// # use objets_metier_rs::wrappers::cpta::{CptaApplication, Journal};
    /// # fn example(app: &CptaApplication, journal: &Journal) -> objets_metier_rs::SageResult<()> {
    /// let process = app.create_process_encoder()?;
    /// process.set_journal(journal)?;
    /// process.set_date("2025-01-15")?;
    /// // ... ajouter des écritures ...
    /// if process.can_process()? {
    ///     process.process()?;
    /// }
    /// # Ok(())
    /// # }
    /// ```
    pub fn create_process_encoder(&self) -> SageResult<PMEncoder> {
        let process_variant = self
            .dispatch()?
            .call_method_by_name("CreateProcess_Encoder", &[])?;

        if !process_variant.is_object() {
            return Err(SageError::ConversionError {
                from_type: process_variant.type_name().to_string(),
                to_type: "IPMEncoder".to_string(),
                value: "CreateProcess_Encoder n'a pas retourné un objet COM".to_string(),
            });
        }

        let process_dispatch = process_variant.to_dispatch()?;

        Ok(PMEncoder {
            dispatch: process_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
    }
}