objets_metier_rs 1.0.2

//! DocumentStock - Documents de mouvement de stock
//!
//! ✅ IMPLÉMENTATION ENRICHIE - Version Phase 6
//!
//! Wrapper enrichi pour l'objet COM DocumentStock de Sage 100c.
//! 50+ méthodes pour gestion complète des mouvements de stock.
//!
//! Types de documents (DO_Type):
//! - 0: Entrée de stock
//! - 1: Sortie de stock
//! - 2: Transfert entre dépôts
//! - 3: Inventaire
//! - 4: Mouvement divers

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;
use windows::Win32::System::Com::IDispatch;

/// Représente un document de stock dans Sage 100c
pub struct DocumentStock {
    pub(crate) dispatch: IDispatch,
}

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

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS EN-TÊTE (8 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 mouvement (0=Entrée, 1=Sortie, 2=Transfert, 3=Inventaire, 4=Divers)
    pub fn do_type(&self) -> SageResult<i16> {
        self.dispatch()
            .call_method_by_name("DO_Type", &[])?
            .to_short()
    }

    /// Date du mouvement de stock
    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()
    }

    /// Dépôt source (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()
    }

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

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

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS DE MOUVEMENT (5 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Dépôt de destination (pour transferts)
    pub fn do_depot_dest(&self) -> SageResult<Option<Depot>> {
        let variant = self.dispatch().call_method_by_name("DO_DepotDest", &[])?;
        if variant.is_empty_or_null() {
            return Ok(None);
        }
        let dispatch = variant.to_dispatch()?;
        Ok(Some(Depot { dispatch }))
    }

    /// Quantité totale du mouvement
    pub fn do_quantite(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_Quantite", &[])?
            .to_f64()
    }

    /// Valorisation du mouvement (coût)
    pub fn do_valeur(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_Valeur", &[])?
            .to_f64()
    }

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

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

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

    /// 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 }))
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS DE TRAÇABILITÉ (5 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Numéro de lot (pour traçabilité)
    pub fn do_lot(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Lot", &[])?
            .to_string()
    }

    /// Numéro de série
    pub fn do_serie(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Serie", &[])?
            .to_string()
    }

    /// DLUO (Date Limite d'Utilisation Optimale)
    pub fn do_dluo(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_DLUO", &[])?
            .to_string()
    }

    /// DLC (Date Limite de Consommation)
    pub fn do_dlc(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_DLC", &[])?
            .to_string()
    }

    /// Numéro de fabrication
    pub fn do_num_fab(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_NumFab", &[])?
            .to_string()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS DE TRANSPORT (4 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Transporteur
    pub fn do_transporteur(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Transporteur", &[])?
            .to_string()
    }

    /// Numéro de colis
    pub fn do_colis(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Colis", &[])?
            .to_string()
    }

    /// Poids net du document
    pub fn do_poids_net(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_PoidsNet", &[])?
            .to_f64()
    }

    /// Poids brut du document
    pub fn do_poids_brut(&self) -> SageResult<f64> {
        self.dispatch()
            .call_method_by_name("DO_PoidsBrut", &[])?
            .to_f64()
    }

    // ═══════════════════════════════════════════════════════════════════════
    // PROPRIÉTÉS ANALYTIQUES (3 propriétés)
    // ═══════════════════════════════════════════════════════════════════════

    /// Code section analytique
    pub fn do_section(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Section", &[])?
            .to_string()
    }

    /// Code affaire
    pub fn do_affaire(&self) -> SageResult<String> {
        self.dispatch()
            .call_method_by_name("DO_Affaire", &[])?
            .to_string()
    }

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

    // ═══════════════════════════════════════════════════════════════════════
    // 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 dépôt source 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(())
    }

    /// Assigne un dépôt de destination (pour transferts)
    pub fn set_do_depot_dest(&self, de_intitule: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(de_intitule);
        self.dispatch()
            .call_property_put("DO_DepotDest", &[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(())
    }

    /// Valide le document (mise à jour du stock)
    pub fn set_do_valide(&self, valide: bool) -> SageResult<()> {
        let param = SafeVariant::from_bool(valide);
        self.dispatch().call_property_put("DO_Valide", &[param])?;
        Ok(())
    }

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

    /// Modifie le numéro de série
    pub fn set_do_serie(&self, serie: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(serie);
        self.dispatch().call_property_put("DO_Serie", &[param])?;
        Ok(())
    }

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

    /// Modifie le code section analytique
    pub fn set_do_section(&self, section: &str) -> SageResult<()> {
        let param = SafeVariant::from_string(section);
        self.dispatch().call_property_put("DO_Section", &[param])?;
        Ok(())
    }

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

    /// Modifie le statut imprimé
    pub fn set_do_imprime(&self, imprime: bool) -> SageResult<()> {
        let param = SafeVariant::from_bool(imprime);
        self.dispatch().call_property_put("DO_Imprime", &[param])?;
        Ok(())
    }

    /// Modifie le statut clôturé
    pub fn set_do_cloture(&self, cloture: bool) -> SageResult<()> {
        let param = SafeVariant::from_bool(cloture);
        self.dispatch().call_property_put("DO_Cloture", &[param])?;
        Ok(())
    }

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

    /// Valide le document et met à jour les stocks
    pub fn validate_document(&self) -> SageResult<()> {
        self.set_do_valide(true)?;
        Ok(())
    }

    /// 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(())
    }

    /// 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])
    }

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

    // ═══════════════════════════════════════════════════════════════════════
    // 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(())
    }
}