objets_metier_rs 1.0.2

use crate::com::{FromDispatchNew, SafeDispatch, SafeVariant};
use crate::errors::{SageError, SageResult};
use crate::wrappers::cpta::objects::{CompteG, Devise, Journal, Reglement, Taxe, Tiers};
use windows::Win32::System::Com::IDispatch;

/// Wrapper pour l'objet Ecriture de Sage 100c (IBOEcriture3)
#[derive(Debug)]
pub struct EcritureG {
    pub dispatch: IDispatch,
}

impl EcritureG {
    /// Crée un SafeDispatch temporaire pour les appels
    fn dispatch(&self) -> SafeDispatch<'_> {
        SafeDispatch::new(&self.dispatch)
    }

    /// Récupère le numéro/code de l'écriture
    pub fn ec_no(&self) -> SageResult<i32> {
        self.dispatch().call_method_by_name("EC_No", &[])?.to_i32()
    }

    pub fn ec_piece(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_Piece", &[])?
            .to_string()
    }

    pub fn ec_ref_piece(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_RefPiece", &[])?
            .to_string()
    }

    pub fn ec_reference(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_Reference", &[])?
            .to_string()
    }

    pub fn ec_intitule(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_Intitule", &[])?
            .to_string()
    }

    pub fn ec_sens(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("EC_Sens", &[])?
            .to_short()
    }

    pub fn ec_montant(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("EC_Montant", &[])?
            .to_f64()
    }

    pub fn ec_lettrage(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_Lettrage", &[])?
            .to_string()
    }

    pub fn has_lettrage(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("HasLettrage", &[])?
            .to_bool()
    }

    pub fn compte_general_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("CompteG", &[])
    }

    pub fn compte_contrepartie_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch()
            .call_method_by_name("CompteGContrepartie", &[])
    }

    pub fn tiers_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("Tiers", &[])
    }

    pub fn tiers_contrepartie_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch()
            .call_method_by_name("TiersContrepartie", &[])
    }

    pub fn journal_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("Journal", &[])
    }

    /// Accède à l'objet CompteG
    /// Retourne directement un CompteG prêt à utiliser
    /// Retourne None si le journal n'a pas de compte général associé
    pub fn compte_general(&self) -> SageResult<Option<CompteG>> {
        let variant = self.dispatch().call_method_by_name("CompteG", &[])?;

        // Vérifier si c'est null/empty avant de tenter la conversion
        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        match variant.to_dispatch() {
            Ok(compte_general_dispatch) => Ok(Some(CompteG {
                dispatch: compte_general_dispatch,
            })),
            Err(_) => {
                // Si la conversion échoue, c'est probablement null
                Ok(None)
            }
        }
    }

    /// Accède au compte général de contrepartie (typed)
    pub fn compte_contrepartie(&self) -> SageResult<Option<CompteG>> {
        let variant = self
            .dispatch()
            .call_method_by_name("CompteGContrepartie", &[])?;

        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        let dispatch = variant.to_dispatch()?;
        Ok(Some(CompteG { dispatch }))
    }

    /// Accède à l'objet Journal
    /// Retourne directement un Journal prêt à utiliser
    /// Retourne None si le journal n'a pas de compte général associé
    pub fn journal(&self) -> SageResult<Option<Journal>> {
        let variant = self.dispatch().call_method_by_name("Journal", &[])?;

        // Vérifier si c'est null/empty avant de tenter la conversion
        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        match variant.to_dispatch() {
            Ok(journal_dispatch) => Ok(Some(Journal {
                dispatch: journal_dispatch,
            })),
            Err(_) => {
                // Si la conversion échoue, c'est probablement null
                Ok(None)
            }
        }
    }

    /// Accède à l'objet Tiers (typed)
    pub fn tiers(&self) -> SageResult<Option<Tiers>> {
        let variant = self.dispatch().call_method_by_name("Tiers", &[])?;

        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        let dispatch = variant.to_dispatch()?;
        Ok(Some(Tiers { dispatch }))
    }

    /// Accède à l'objet Tiers contrepartie (typed)
    pub fn tiers_contrepartie(&self) -> SageResult<Option<Tiers>> {
        let variant = self
            .dispatch()
            .call_method_by_name("TiersContrepartie", &[])?;

        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        let dispatch = variant.to_dispatch()?;
        Ok(Some(Tiers { dispatch }))
    }

    /// Accède à l'objet Devise (typed)
    pub fn devise(&self) -> SageResult<Option<Devise>> {
        let variant = self.dispatch().call_method_by_name("Devise", &[])?;

        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        let dispatch = variant.to_dispatch()?;
        Ok(Some(Devise { dispatch }))
    }

    /// Accède à la taxe (typed)
    pub fn taxe(&self) -> SageResult<Option<Taxe>> {
        let variant = self.dispatch().call_method_by_name("Taxe", &[])?;

        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        let dispatch = variant.to_dispatch()?;
        Ok(Some(Taxe { dispatch }))
    }

    /// Accède au règlement (typed)
    pub fn reglement(&self) -> SageResult<Option<Reglement>> {
        let variant = self.dispatch().call_method_by_name("Reglement", &[])?;

        if variant.is_empty_or_null() {
            return Ok(None);
        }

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

        let dispatch = variant.to_dispatch()?;
        Ok(Some(Reglement { dispatch }))
    }

    // Propriétés supplémentaires (getters) documentées dans IBOEcriture3
    pub fn date(&self) -> SageResult<String> {
        // Date renvoyée en chaîne (format COM Date -> laisser la conversion au caller)
        self.dispatch()
            .call_method_by_name("Date", &[])?
            .to_string()
    }

    pub fn date_saisie(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DateSaisie", &[])?
            .to_string()
    }

    pub fn ec_devise(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("EC_Devise", &[])?
            .to_f64()
    }

    pub fn ec_parite(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("EC_Parite", &[])?
            .to_f64()
    }

    pub fn ec_date_raappro(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_DateRappro", &[])?
            .to_string()
    }

    pub fn ec_echeance(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_Echeance", &[])?
            .to_string()
    }

    pub fn ec_quantite(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("EC_Quantite", &[])?
            .to_f64()
    }

    pub fn ec_lettrage_q(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_LettrageQ", &[])?
            .to_string()
    }

    pub fn ec_no_cloture(&self) -> SageResult<i32> {
        self.dispatch()
            .call_method_by_name("EC_NoCloture", &[])?
            .to_i32()
    }

    pub fn ec_rappel(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("EC_Rappel", &[])?
            .to_short()
    }

    pub fn ec_pointage(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_Pointage", &[])?
            .to_string()
    }

    pub fn ec_remise(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("EC_Remise", &[])?
            .to_bool()
    }

    pub fn ec_rtype(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("EC_Rtype", &[])?
            .to_bool()
    }

    pub fn ec_treso_piece(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("EC_TresoPiece", &[])?
            .to_string()
    }

    pub fn ec_type(&self) -> SageResult<i32> {
        self.dispatch()
            .call_method_by_name("EC_Type", &[])?
            .to_i32()
    }

    pub fn ec_an_type(&self) -> SageResult<i32> {
        self.dispatch()
            .call_method_by_name("EC_ANType", &[])?
            .to_i32()
    }

    pub fn ec_cloture(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("EC_Cloture", &[])?
            .to_bool()
    }

    pub fn ec_norme(&self) -> SageResult<i32> {
        self.dispatch()
            .call_method_by_name("EC_Norme", &[])?
            .to_i32()
    }

    // Méthodes importantes décrites dans la doc
    /// Initialise les valeurs par défaut sur l'écriture non persistante/persistante
    pub fn set_default(&self) -> SageResult<()> {
        // Appel sans paramètre
        self.dispatch().call_method_by_name("SetDefault", &[])?;
        Ok(())
    }

    /// Enregistre l'objet écriture dans la base
    pub fn write(&self) -> SageResult<()> {
        self.dispatch().call_method_by_name("Write", &[])?;
        Ok(())
    }

    /// WriteDefault: enregistre en recalculant/proratisant les analytiques si besoin
    pub fn write_default(&self) -> SageResult<()> {
        self.dispatch().call_method_by_name("WriteDefault", &[])?;
        Ok(())
    }

    // Annexes / flags
    pub fn has_lettrage_q(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("HasLettrageQ", &[])?
            .to_bool()
    }

    pub fn has_pointage(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("HasPointage", &[])?
            .to_bool()
    }

    pub fn has_ta_provenance(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("HasTa_Provenance", &[])?
            .to_bool()
    }

    /// Retourne une info libre par index (1-based)
    pub fn info_libre(&self, index: i16) -> SageResult<String> {
        let idx = SafeVariant::from_i16(index);
        self.dispatch()
            .call_method_by_name("InfoLibre", &[idx])?
            .to_string()
    }

    /// Registre de révision (raw variant) et helper pour vérifier existence
    pub fn registre_revision_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("RegistreRevision", &[])
    }

    /// Ecrit les registres de taxe (WriteDefaultRegistreTaxe)
    pub fn write_default_registre_taxe(&self) -> SageResult<()> {
        self.dispatch()
            .call_method_by_name("WriteDefaultRegistreTaxe", &[])?;
        Ok(())
    }

    pub fn has_registre_taxes(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("HasRegistreTaxes", &[])?
            .to_bool()
    }

    pub fn get_registre_taxes_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("GetRegistreTaxes", &[])
    }

    pub fn get_ecriture_registre_taxes_raw(&self) -> SageResult<SafeVariant> {
        self.dispatch()
            .call_method_by_name("GetEcritureRegistreTaxes", &[])
    }

    // ==================== SETTERS POUR PROPRIÉTÉS ====================

    /// Définit le journal de l'écriture
    pub fn set_journal(&self, journal: &Journal) -> SageResult<()> {
        let journal_variant = SafeVariant::from_dispatch(journal.dispatch.clone());
        self.dispatch()
            .call_property_put("Journal", &[journal_variant])?;
        Ok(())
    }

    /// Définit la date de l'écriture (format ISO: YYYY-MM-DD ou COM Date)
    pub fn set_date(&self, date: &str) -> SageResult<()> {
        let date_variant = SafeVariant::from_string(date);
        self.dispatch().call_property_put("Date", &[date_variant])?;
        Ok(())
    }

    /// Définit la date de saisie
    pub fn set_date_saisie(&self, date: &str) -> SageResult<()> {
        let date_variant = SafeVariant::from_string(date);
        self.dispatch()
            .call_property_put("DateSaisie", &[date_variant])?;
        Ok(())
    }

    /// Définit l'intitulé de l'écriture
    pub fn set_ec_intitule(&self, intitule: &str) -> SageResult<()> {
        let intitule_variant = SafeVariant::from_string(intitule);
        self.dispatch()
            .call_property_put("EC_Intitule", &[intitule_variant])?;
        Ok(())
    }

    /// Définit le numéro de pièce
    pub fn set_ec_piece(&self, piece: &str) -> SageResult<()> {
        let piece_variant = SafeVariant::from_string(piece);
        self.dispatch()
            .call_property_put("EC_Piece", &[piece_variant])?;
        Ok(())
    }

    /// Définit la référence de pièce
    pub fn set_ec_ref_piece(&self, ref_piece: &str) -> SageResult<()> {
        let ref_variant = SafeVariant::from_string(ref_piece);
        self.dispatch()
            .call_property_put("EC_RefPiece", &[ref_variant])?;
        Ok(())
    }

    /// Définit la référence
    pub fn set_ec_reference(&self, reference: &str) -> SageResult<()> {
        let ref_variant = SafeVariant::from_string(reference);
        self.dispatch()
            .call_property_put("EC_Reference", &[ref_variant])?;
        Ok(())
    }

    /// Définit le sens de l'écriture
    /// 0 = Débit, 1 = Crédit
    pub fn set_ec_sens(&self, sens: i16) -> SageResult<()> {
        let sens_variant = SafeVariant::from_i16(sens);
        self.dispatch()
            .call_property_put("EC_Sens", &[sens_variant])?;
        Ok(())
    }

    /// Définit le montant de l'écriture
    pub fn set_ec_montant(&self, montant: f64) -> SageResult<()> {
        let montant_variant = SafeVariant::R8(montant);
        self.dispatch()
            .call_property_put("EC_Montant", &[montant_variant])?;
        Ok(())
    }

    /// Définit le compte général
    pub fn set_compte_g(&self, compte: &CompteG) -> SageResult<()> {
        let compte_variant = SafeVariant::from_dispatch(compte.dispatch.clone());
        self.dispatch()
            .call_property_put("CompteG", &[compte_variant])?;
        Ok(())
    }

    /// Définit le tiers
    pub fn set_tiers(&self, tiers: &Tiers) -> SageResult<()> {
        let tiers_variant = SafeVariant::from_dispatch(tiers.dispatch.clone());
        self.dispatch()
            .call_property_put("Tiers", &[tiers_variant])?;
        Ok(())
    }

    /// Définit la devise
    pub fn set_devise(&self, devise: &Devise) -> SageResult<()> {
        let devise_variant = SafeVariant::from_dispatch(devise.dispatch.clone());
        self.dispatch()
            .call_property_put("Devise", &[devise_variant])?;
        Ok(())
    }

    /// Définit la parité
    pub fn set_ec_parite(&self, parite: f64) -> SageResult<()> {
        let parite_variant = SafeVariant::R8(parite);
        self.dispatch()
            .call_property_put("EC_Parite", &[parite_variant])?;
        Ok(())
    }

    /// Définit la quantité
    pub fn set_ec_quantite(&self, quantite: f64) -> SageResult<()> {
        let quantite_variant = SafeVariant::R8(quantite);
        self.dispatch()
            .call_property_put("EC_Quantite", &[quantite_variant])?;
        Ok(())
    }

    /// Définit l'échéance
    pub fn set_ec_echeance(&self, echeance: &str) -> SageResult<()> {
        let echeance_variant = SafeVariant::from_string(echeance);
        self.dispatch()
            .call_property_put("EC_Echeance", &[echeance_variant])?;
        Ok(())
    }

    /// Définit la taxe
    pub fn set_taxe(&self, taxe: &Taxe) -> SageResult<()> {
        let taxe_variant = SafeVariant::from_dispatch(taxe.dispatch.clone());
        self.dispatch().call_property_put("Taxe", &[taxe_variant])?;
        Ok(())
    }

    /// Définit le règlement
    pub fn set_reglement(&self, reglement: &Reglement) -> SageResult<()> {
        let reglement_variant = SafeVariant::from_dispatch(reglement.dispatch.clone());
        self.dispatch()
            .call_property_put("Reglement", &[reglement_variant])?;
        Ok(())
    }
}

impl FromDispatchNew for EcritureG {
    fn from_dispatch_new(dispatch: IDispatch) -> SageResult<Self> {
        Ok(Self { dispatch })
    }
}