objets_metier_rs 1.0.2

//! DocumentAchat - Document d'achat (Commande, Bon de réception, Facture fournisseur)
//!
//! Wrapper enrichi pour l'objet COM DocumentAchat de Sage 100c.
//! Gère les documents d'achat avec toutes leurs propriétés et méthodes métier.
//!
//! ✅ IMPLÉMENTATION ENRICHIE - Version Phase 6
//! **Phase 6 - Enrichissement complet**: 66+ méthodes pour gestion complète
//!
//! Types de documents (DO_Type):
//! - 0: Demande de prix
//! - 1: Commande fournisseur
//! - 2: Bon de réception
//! - 3: Facture fournisseur
//! - 4: Facture comptabilisée

use crate::com::{SafeDispatch, SafeVariant};
use crate::errors::SageResult;
use crate::wrappers::cial::objects::{article_wrapper::Article, depot_wrapper::Depot};
use crate::wrappers::cpta::objects::{
    collaborateur_wrapper::Collaborateur, contact_wrapper::Contact, reglement_wrapper::Reglement,
    tiers_wrapper::Tiers,
};
use windows::Win32::System::Com::IDispatch;

/// Représente un document d'achat dans Sage 100c
pub struct DocumentAchat {
    pub(crate) dispatch: IDispatch,
}

impl DocumentAchat {
    fn dispatch(&self) -> SafeDispatch<'_> {
        SafeDispatch::new(&self.dispatch)
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS EN-TÊTE (15 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Numéro de pièce du document
    pub fn do_piece(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Piece", &[])?
            .to_string()
    }

    /// Type de document (0=Demande prix, 1=Commande, 2=BR, 3=Facture)
    pub fn do_type(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Type", &[])?
            .to_short()
    }

    /// Date du document
    pub fn do_date(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Date", &[])?
            .to_string()
    }

    /// Référence externe du document
    pub fn do_ref(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Ref", &[])?
            .to_string()
    }

    /// Fournisseur du document (typed reference)
    pub fn do_tiers(&self) -> SageResult<Option<Tiers>> {
        let variant = self.dispatch().call_method_by_name("DO_Tiers", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Tiers { dispatch }))
    }

    /// Contact fournisseur (typed reference)
    pub fn do_contact(&self) -> SageResult<Option<Contact>> {
        let variant = self.dispatch().call_method_by_name("DO_Contact", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Contact { dispatch }))
    }

    /// Dépôt de réception (typed reference)
    pub fn do_depot(&self) -> SageResult<Option<Depot>> {
        let variant = self.dispatch().call_method_by_name("DO_Depot", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Depot { dispatch }))
    }

    /// Souche de numérotation
    pub fn do_souche(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Souche", &[])?
            .to_short()
    }

    /// Code devise (0=Euro, 1=USD, etc.)
    pub fn do_devise(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Devise", &[])?
            .to_short()
    }

    /// Cours de change appliqué
    pub fn do_cours(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_Cours", &[])?
            .to_f64()
    }

    /// Code langue (0=Français, 1=Anglais, etc.)
    pub fn do_langue(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Langue", &[])?
            .to_short()
    }

    /// Acheteur responsable (typed reference)
    pub fn do_acheteur(&self) -> SageResult<Option<Collaborateur>> {
        let variant = self.dispatch().call_method_by_name("DO_Acheteur", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Collaborateur { dispatch }))
    }

    /// Statut du document
    pub fn do_statut(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Statut", &[])?
            .to_short()
    }

    /// Commentaire global du document
    pub fn do_commentaire(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Commentaire", &[])?
            .to_string()
    }

    /// Mode d'expédition
    pub fn do_expedit(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Expedit", &[])?
            .to_string()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS FINANCIÈRES (12 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Montant total HT du document
    pub fn do_total_ht(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_TotalHT", &[])?
            .to_f64()
    }

    /// Montant total TTC du document
    pub fn do_total_ttc(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_TotalTTC", &[])?
            .to_f64()
    }

    /// Montant total de TVA
    pub fn do_montant_tva(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_MontantTVA", &[])?
            .to_f64()
    }

    /// Net à payer (après remises et frais)
    pub fn do_net_a_payer(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_NetAPayer", &[])?
            .to_f64()
    }

    /// Taux de remise globale (en %)
    pub fn do_remise(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_Remise", &[])?
            .to_f64()
    }

    /// Montant de la remise globale
    pub fn do_montant_remise(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_MontantRemise", &[])?
            .to_f64()
    }

    /// Frais de port HT
    pub fn do_port_ht(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_PortHT", &[])?
            .to_f64()
    }

    /// Frais de port TTC
    pub fn do_port_ttc(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_PortTTC", &[])?
            .to_f64()
    }

    /// Taux de taxe parafiscale
    pub fn do_taxe1(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_Taxe1", &[])?
            .to_f64()
    }

    /// Montant de la taxe parafiscale
    pub fn do_montant_taxe1(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_MontantTaxe1", &[])?
            .to_f64()
    }

    /// Régime (UE, Export, France, etc.)
    pub fn do_regime(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Regime", &[])?
            .to_short()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS DE RÈGLEMENT (5 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Conditions de règlement (typed reference)
    pub fn do_reglement(&self) -> SageResult<Option<Reglement>> {
        let variant = self.dispatch().call_method_by_name("DO_Reglement", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Reglement { dispatch }))
    }

    /// Nombre d'échéances
    pub fn do_nb_echeance(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_NbEcheance", &[])?
            .to_short()
    }

    /// Banque de règlement
    pub fn do_banque(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Banque", &[])?
            .to_short()
    }

    /// Date de première échéance
    pub fn do_date_echeance(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_DateEcheance", &[])?
            .to_string()
    }

    /// Solde restant à payer
    pub fn do_solde(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_Solde", &[])?
            .to_f64()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS DE SUIVI (8 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Document transféré vers un autre type
    pub fn do_transf(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("DO_Transf", &[])?
            .to_bool()
    }

    /// Document clôturé
    pub fn do_cloture(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("DO_Cloture", &[])?
            .to_bool()
    }

    /// Document imprimé
    pub fn do_imprime(&self) -> SageResult<bool> {
        self.dispatch()
            .call_method_by_name("DO_Imprime", &[])?
            .to_bool()
    }

    /// Date de création du document
    pub fn do_date_cr(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_DateCr", &[])?
            .to_string()
    }

    /// Date de dernière modification
    pub fn do_date_modif(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_DateModif", &[])?
            .to_string()
    }

    /// Utilisateur créateur (typed reference)
    pub fn do_user_cr(&self) -> SageResult<Option<Collaborateur>> {
        let variant = self.dispatch().call_method_by_name("DO_UserCr", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Collaborateur { dispatch }))
    }

    /// Utilisateur modificateur (typed reference)
    pub fn do_user_modif(&self) -> SageResult<Option<Collaborateur>> {
        let variant = self.dispatch().call_method_by_name("DO_UserModif", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Collaborateur { dispatch }))
    }

    /// Numéro du document d'origine (lors de transfert)
    pub fn do_num_origine(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_NumOrigine", &[])?
            .to_string()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // COLLECTIONS DE LIGNES (3 méthodes)
    // ═══════════════════════════════════════════════════════════════════════

    /// Accès à la collection des lignes du document
    pub fn document_lignes(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("DocumentLignes", &[])
    }

    /// Crée une nouvelle ligne dans le document
    pub fn create_ligne(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("CreateLigne", &[])
    }

    /// Nombre de lignes dans le document
    pub fn nb_lignes(&self) -> SageResult<i32> {
        let lignes = self.document_lignes()?;
        let dispatch = lignes.to_dispatch()?;
        let safe_dispatch = SafeDispatch::new(&dispatch);
        safe_dispatch.call_method_by_name("Count", &[])?.to_i32()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // SETTERS - MODIFICATION DU DOCUMENT (15 setters)
    // ═══════════════════════════════════════════════════════════════════════

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

    /// Modifie la date du document
    pub fn set_do_date(&self, date: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(date);
        self.dispatch().call_property_put("DO_Date", &[param])?;
        Ok(())
    }

    /// Modifie la référence du document
    pub fn set_do_ref(&self, ref_ext: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(ref_ext);
        self.dispatch().call_property_put("DO_Ref", &[param])?;
        Ok(())
    }

    /// Assigne un fournisseur au document (par code)
    pub fn set_do_tiers(&self, ct_num: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(ct_num);
        self.dispatch().call_property_put("DO_Tiers", &[param])?;
        Ok(())
    }

    /// Assigne un contact au document
    pub fn set_do_contact(&self, co_num: i32) -> SageResult<()> {
        let param = SafeVariant::from_i32(co_num);
        self.dispatch().call_property_put("DO_Contact", &[param])?;
        Ok(())
    }

    /// Assigne un dépôt au document (par intitulé)
    pub fn set_do_depot(&self, de_intitule: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(de_intitule);
        self.dispatch().call_property_put("DO_Depot", &[param])?;
        Ok(())
    }

    /// Modifie la souche de numérotation
    pub fn set_do_souche(&self, souche: i16) -> SageResult<()> {
        let param = SafeVariant::from_i16(souche);
        self.dispatch().call_property_put("DO_Souche", &[param])?;
        Ok(())
    }

    /// Modifie le commentaire
    pub fn set_do_commentaire(&self, comment: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(comment);
        self.dispatch()
            .call_property_put("DO_Commentaire", &[param])?;
        Ok(())
    }

    /// Modifie le mode d'expédition
    pub fn set_do_expedit(&self, expedit: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(expedit);
        self.dispatch().call_property_put("DO_Expedit", &[param])?;
        Ok(())
    }

    /// Modifie la remise globale
    pub fn set_do_remise(&self, remise: f64) -> SageResult<()> {
        let param = SafeVariant::from_f64(remise);
        self.dispatch().call_property_put("DO_Remise", &[param])?;
        Ok(())
    }

    /// Modifie les frais de port HT
    pub fn set_do_port_ht(&self, port: f64) -> SageResult<()> {
        let param = SafeVariant::from_f64(port);
        self.dispatch().call_property_put("DO_PortHT", &[param])?;
        Ok(())
    }

    /// Modifie la taxe parafiscale
    pub fn set_do_taxe1(&self, taxe: f64) -> SageResult<()> {
        let param = SafeVariant::from_f64(taxe);
        self.dispatch().call_property_put("DO_Taxe1", &[param])?;
        Ok(())
    }

    /// Modifie le régime
    pub fn set_do_regime(&self, regime: i16) -> SageResult<()> {
        let param = SafeVariant::from_i16(regime);
        self.dispatch().call_property_put("DO_Regime", &[param])?;
        Ok(())
    }

    /// Assigne un mode de règlement (par code)
    pub fn set_do_reglement(&self, r_code: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(r_code);
        self.dispatch()
            .call_property_put("DO_Reglement", &[param])?;
        Ok(())
    }

    /// Modifie le nombre d'échéances
    pub fn set_do_nb_echeance(&self, nb: i16) -> SageResult<()> {
        let param = SafeVariant::from_i16(nb);
        self.dispatch()
            .call_property_put("DO_NbEcheance", &[param])?;
        Ok(())
    }

    // ═══════════════════════════════════════════════════════════════════════
    // MÉTHODES MÉTIER (6 méthodes)
    // ═══════════════════════════════════════════════════════════════════════

    /// Recalcule tous les montants du document (HT, TVA, TTC)
    pub fn recalculate_totals(&self) -> SageResult<()> {
        self.dispatch()
            .call_method_by_name("RecalculateTotals", &[])?;
        Ok(())
    }

    /// Valide la cohérence du document
    pub fn validate_document(&self) -> SageResult<()> {
        self.dispatch()
            .call_method_by_name("ValidateDocument", &[])?;
        Ok(())
    }

    /// Duplique le document
    pub fn duplicate(&self) -> SageResult<SafeVariant> {
        self.dispatch().call_method_by_name("Duplicate", &[])
    }

    /// Transfère le document vers un autre type
    ///
    /// Exemples:
    /// - Demande prix (0) → Commande (1)
    /// - Commande (1) → Bon de réception (2)
    /// - Bon de réception (2) → Facture (3)
    pub fn transfer_to(&self, doc_type: i16) -> SageResult<SafeVariant> {
        let param = SafeVariant::from_i16(doc_type);
        self.dispatch().call_method_by_name("TransferTo", &[param])
    }

    /// Ajoute un article au document avec sa quantité
    pub fn add_article(&self, article: &Article, quantite: f64) -> SageResult<SafeVariant> {
        let ar_ref = article.ar_ref()?;
        let param_ref = SafeVariant::from_string(&ar_ref);
        let param_qte = SafeVariant::from_f64(quantite);
        self.dispatch()
            .call_method_by_name("AddArticle", &[param_ref, param_qte])
    }

    /// Clôture définitivement le document
    pub fn close_document(&self) -> SageResult<()> {
        let param = SafeVariant::from_bool(true);
        self.dispatch().call_property_put("DO_Cloture", &[param])?;
        Ok(())
    }

    // ═══════════════════════════════════════════════════════════════════════
    // MÉTHODES STANDARD (3 méthodes)
    // ═══════════════════════════════════════════════════════════════════════

    /// Identifiant unique interne
    pub fn cbmarq(&self) -> SageResult<i32> {
        self.dispatch().call_method_by_name("cbMarq", &[])?.to_i32()
    }

    /// Enregistre les modifications
    pub fn write(&self) -> SageResult<()> {
        self.dispatch().call_method_by_name("Write", &[])?;
        Ok(())
    }

    /// Supprime le document
    pub fn remove(&self) -> SageResult<()> {
        self.dispatch().call_method_by_name("Remove", &[])?;
        Ok(())
    }
}