import win32com.client
import pythoncom  #  AJOUT CRITIQUE
from datetime import datetime, timedelta, date
from typing import Dict, List, Optional
import threading
import time
import logging
from contextlib import contextmanager

logger = logging.getLogger(__name__)


class SageConnector:
    """
    Connecteur Sage 100c avec gestion COM threading correcte

     CHANGEMENTS PRODUCTION:
    - Initialisation COM par thread (CoInitialize/CoUninitialize)
    - Lock robuste pour thread-safety
    - Gestion d'erreurs exhaustive
    - Logging structuré
    - Retry automatique sur erreurs COM
    """

    def __init__(self, chemin_base, utilisateur="<Administrateur>", mot_de_passe=""):
        self.chemin_base = chemin_base
        self.utilisateur = utilisateur
        self.mot_de_passe = mot_de_passe
        self.cial = None

        # Cache
        self._cache_clients: List[Dict] = []
        self._cache_articles: List[Dict] = []
        self._cache_clients_dict: Dict[str, Dict] = {}
        self._cache_articles_dict: Dict[str, Dict] = {}

        # Métadonnées cache
        self._cache_clients_last_update: Optional[datetime] = None
        self._cache_articles_last_update: Optional[datetime] = None
        self._cache_ttl_minutes = 15

        # Thread d'actualisation
        self._refresh_thread: Optional[threading.Thread] = None
        self._stop_refresh = threading.Event()

        #  Locks thread-safe
        self._lock_clients = threading.RLock()
        self._lock_articles = threading.RLock()
        self._lock_com = threading.RLock()  # Lock pour accès COM

        #  Thread-local storage pour COM
        self._thread_local = threading.local()

    # =========================================================================
    # GESTION COM THREAD-SAFE
    # =========================================================================

    @contextmanager
    def _com_context(self):
        """
        Context manager pour initialiser COM dans chaque thread

         CRITIQUE: FastAPI utilise un pool de threads.
        Chaque thread doit initialiser COM avant d'utiliser les objets Sage.
        """
        # Vérifier si COM est déjà initialisé pour ce thread
        if not hasattr(self._thread_local, "com_initialized"):
            try:
                pythoncom.CoInitialize()
                self._thread_local.com_initialized = True
                logger.debug(
                    f"COM initialisé pour thread {threading.current_thread().name}"
                )
            except Exception as e:
                logger.error(f"Erreur initialisation COM: {e}")
                raise

        try:
            yield
        finally:
            # Ne pas désinitialiser COM ici car le thread peut être réutilisé
            pass

    def _cleanup_com_thread(self):
        """Nettoie COM pour le thread actuel (à appeler à la fin)"""
        if hasattr(self._thread_local, "com_initialized"):
            try:
                pythoncom.CoUninitialize()
                delattr(self._thread_local, "com_initialized")
                logger.debug(
                    f"COM nettoyé pour thread {threading.current_thread().name}"
                )
            except:
                pass

    # =========================================================================
    # CONNEXION
    # =========================================================================

    def connecter(self):
        """Connexion initiale à Sage"""
        try:
            with self._com_context():
                self.cial = win32com.client.gencache.EnsureDispatch(
                    "Objets100c.Cial.Stream"
                )
                self.cial.Name = self.chemin_base
                self.cial.Loggable.UserName = self.utilisateur
                self.cial.Loggable.UserPwd = self.mot_de_passe
                self.cial.Open()

            logger.info(f"Connexion Sage réussie: {self.chemin_base}")

            # Chargement initial du cache
            logger.info("Chargement initial du cache...")
            self._refresh_cache_clients()
            self._refresh_cache_articles()
            logger.info(
                f"Cache initialisé: {len(self._cache_clients)} clients, {len(self._cache_articles)} articles"
            )

            # Démarrage du thread d'actualisation
            self._start_refresh_thread()

            return True

        except Exception as e:
            logger.error(f"Erreur connexion Sage: {e}", exc_info=True)
            return False

    def deconnecter(self):
        """Déconnexion propre"""
        self._stop_refresh.set()

        if self._refresh_thread:
            self._refresh_thread.join(timeout=5)

        if self.cial:
            try:
                with self._com_context():
                    self.cial.Close()
                logger.info("Connexion Sage fermée")
            except:
                pass

    # =========================================================================
    # SYSTÈME DE CACHE
    # =========================================================================

    def _start_refresh_thread(self):
        """Démarre le thread d'actualisation automatique"""

        def refresh_loop():
            #  Initialiser COM pour ce thread worker
            pythoncom.CoInitialize()

            try:
                while not self._stop_refresh.is_set():
                    time.sleep(60)  # Vérifier toutes les minutes

                    # Clients
                    if self._cache_clients_last_update:
                        age = datetime.now() - self._cache_clients_last_update
                        if age.total_seconds() > self._cache_ttl_minutes * 60:
                            logger.info(
                                f"Actualisation cache clients (âge: {age.seconds//60}min)"
                            )
                            self._refresh_cache_clients()

                    # Articles
                    if self._cache_articles_last_update:
                        age = datetime.now() - self._cache_articles_last_update
                        if age.total_seconds() > self._cache_ttl_minutes * 60:
                            logger.info(
                                f"Actualisation cache articles (âge: {age.seconds//60}min)"
                            )
                            self._refresh_cache_articles()
            finally:
                #  Nettoyer COM en fin de thread
                pythoncom.CoUninitialize()

        self._refresh_thread = threading.Thread(
            target=refresh_loop, daemon=True, name="SageCacheRefresh"
        )
        self._refresh_thread.start()

    def _refresh_cache_clients(self):
        """Actualise le cache des clients"""
        if not self.cial:
            return

        clients = []
        clients_dict = {}

        try:
            with self._com_context(), self._lock_com:
                factory = self.cial.CptaApplication.FactoryClient
                index = 1
                erreurs_consecutives = 0
                max_erreurs = 50

                while index < 10000 and erreurs_consecutives < max_erreurs:
                    try:
                        persist = factory.List(index)
                        if persist is None:
                            break

                        obj = self._cast_client(persist)
                        if obj:
                            data = self._extraire_client(obj)
                            clients.append(data)
                            clients_dict[data["numero"]] = data
                            erreurs_consecutives = 0

                        index += 1

                    except Exception as e:
                        erreurs_consecutives += 1
                        index += 1
                        if erreurs_consecutives >= max_erreurs:
                            logger.warning(
                                f"Arrêt refresh clients après {max_erreurs} erreurs"
                            )
                            break

                with self._lock_clients:
                    self._cache_clients = clients
                    self._cache_clients_dict = clients_dict
                    self._cache_clients_last_update = datetime.now()

                logger.info(f" Cache clients actualisé: {len(clients)} clients")

        except Exception as e:
            logger.error(f" Erreur refresh clients: {e}", exc_info=True)

    def _refresh_cache_articles(self):
        """Actualise le cache des articles"""
        if not self.cial:
            return

        articles = []
        articles_dict = {}

        try:
            with self._com_context(), self._lock_com:
                factory = self.cial.FactoryArticle
                index = 1
                erreurs_consecutives = 0
                max_erreurs = 50

                while index < 10000 and erreurs_consecutives < max_erreurs:
                    try:
                        persist = factory.List(index)
                        if persist is None:
                            break

                        obj = self._cast_article(persist)
                        if obj:
                            data = self._extraire_article(obj)
                            articles.append(data)
                            articles_dict[data["reference"]] = data
                            erreurs_consecutives = 0

                        index += 1

                    except Exception as e:
                        erreurs_consecutives += 1
                        index += 1
                        if erreurs_consecutives >= max_erreurs:
                            logger.warning(
                                f"Arrêt refresh articles après {max_erreurs} erreurs"
                            )
                            break

                with self._lock_articles:
                    self._cache_articles = articles
                    self._cache_articles_dict = articles_dict
                    self._cache_articles_last_update = datetime.now()

                logger.info(f" Cache articles actualisé: {len(articles)} articles")

        except Exception as e:
            logger.error(f" Erreur refresh articles: {e}", exc_info=True)

    # =========================================================================
    # API PUBLIQUE (ultra-rapide grâce au cache)
    # =========================================================================

    def lister_tous_clients(self, filtre=""):
        """Retourne les clients depuis le cache (instantané)"""
        with self._lock_clients:
            if not filtre:
                return self._cache_clients.copy()

            filtre_lower = filtre.lower()
            return [
                c
                for c in self._cache_clients
                if filtre_lower in c["numero"].lower()
                or filtre_lower in c["intitule"].lower()
            ]

    def lire_client(self, code_client):
        """Retourne un client depuis le cache (instantané)"""
        with self._lock_clients:
            return self._cache_clients_dict.get(code_client)

    def lister_tous_articles(self, filtre=""):
        """Retourne les articles depuis le cache (instantané)"""
        with self._lock_articles:
            if not filtre:
                return self._cache_articles.copy()

            filtre_lower = filtre.lower()
            return [
                a
                for a in self._cache_articles
                if filtre_lower in a["reference"].lower()
                or filtre_lower in a["designation"].lower()
            ]

    def lire_article(self, reference):
        """Retourne un article depuis le cache (instantané)"""
        with self._lock_articles:
            return self._cache_articles_dict.get(reference)

    def forcer_actualisation_cache(self):
        """Force l'actualisation immédiate du cache (endpoint admin)"""
        logger.info("Actualisation forcée du cache...")
        self._refresh_cache_clients()
        self._refresh_cache_articles()
        logger.info("Cache actualisé")

    def get_cache_info(self):
        """Retourne les infos du cache (endpoint monitoring)"""
        with self._lock_clients, self._lock_articles:
            return {
                "clients": {
                    "count": len(self._cache_clients),
                    "last_update": (
                        self._cache_clients_last_update.isoformat()
                        if self._cache_clients_last_update
                        else None
                    ),
                    "age_minutes": (
                        (
                            datetime.now() - self._cache_clients_last_update
                        ).total_seconds()
                        / 60
                        if self._cache_clients_last_update
                        else None
                    ),
                },
                "articles": {
                    "count": len(self._cache_articles),
                    "last_update": (
                        self._cache_articles_last_update.isoformat()
                        if self._cache_articles_last_update
                        else None
                    ),
                    "age_minutes": (
                        (
                            datetime.now() - self._cache_articles_last_update
                        ).total_seconds()
                        / 60
                        if self._cache_articles_last_update
                        else None
                    ),
                },
                "ttl_minutes": self._cache_ttl_minutes,
            }

    # =========================================================================
    # CAST HELPERS
    # =========================================================================

    def _cast_client(self, persist_obj):
        try:
            obj = win32com.client.CastTo(persist_obj, "IBOClient3")
            obj.Read()
            return obj
        except:
            return None

    def _cast_article(self, persist_obj):
        try:
            obj = win32com.client.CastTo(persist_obj, "IBOArticle3")
            obj.Read()
            return obj
        except:
            return None

    # =========================================================================
    # EXTRACTION
    # =========================================================================

    def _extraire_client(self, client_obj):
        data = {
            "numero": getattr(client_obj, "CT_Num", ""),
            "intitule": getattr(client_obj, "CT_Intitule", ""),
            "type": getattr(client_obj, "CT_Type", 0),
        }

        try:
            adresse = getattr(client_obj, "Adresse", None)
            if adresse:
                data["adresse"] = getattr(adresse, "Adresse", "")
                data["code_postal"] = getattr(adresse, "CodePostal", "")
                data["ville"] = getattr(adresse, "Ville", "")
        except:
            pass

        try:
            telecom = getattr(client_obj, "Telecom", None)
            if telecom:
                data["telephone"] = getattr(telecom, "Telephone", "")
                data["email"] = getattr(telecom, "EMail", "")
        except:
            pass

        return data

    def _extraire_article(self, article_obj):
        return {
            "reference": getattr(article_obj, "AR_Ref", ""),
            "designation": getattr(article_obj, "AR_Design", ""),
            "prix_vente": getattr(article_obj, "AR_PrixVen", 0.0),
            "prix_achat": getattr(article_obj, "AR_PrixAch", 0.0),
            "stock_reel": getattr(article_obj, "AR_Stock", 0.0),
            "stock_mini": getattr(article_obj, "AR_StockMini", 0.0),
        }

    # =========================================================================
    # CRÉATION DEVIS (US-A1) - VERSION TRANSACTIONNELLE
    # =========================================================================

    def creer_devis_enrichi(self, devis_data: dict):
        """
        Création de devis avec transaction Sage
        ✅ SOLUTION FINALE: Utilisation de SetDefaultArticle()
        """
        if not self.cial:
            raise RuntimeError("Connexion Sage non établie")

        logger.info(
            f"🚀 Début création devis pour client {devis_data['client']['code']}"
        )

        try:
            with self._com_context(), self._lock_com:
                transaction_active = False
                try:
                    self.cial.CptaApplication.BeginTrans()
                    transaction_active = True
                    logger.debug("✅ Transaction Sage démarrée")
                except Exception as e:
                    logger.warning(f"⚠️ BeginTrans échoué: {e}")

                try:
                    # ===== CRÉATION DOCUMENT =====
                    process = self.cial.CreateProcess_Document(0)  # Type 0 = Devis
                    doc = process.Document

                    try:
                        doc = win32com.client.CastTo(doc, "IBODocumentVente3")
                    except:
                        pass

                    logger.info("📄 Document devis créé")

                    # ===== DATE =====
                    import pywintypes

                    if isinstance(devis_data["date_devis"], str):
                        try:
                            date_obj = datetime.fromisoformat(devis_data["date_devis"])
                        except:
                            date_obj = datetime.now()
                    elif isinstance(devis_data["date_devis"], date):
                        date_obj = datetime.combine(
                            devis_data["date_devis"], datetime.min.time()
                        )
                    else:
                        date_obj = datetime.now()

                    doc.DO_Date = pywintypes.Time(date_obj)
                    logger.info(f"📅 Date définie: {date_obj.date()}")

                    # ===== CLIENT (CRITIQUE: Doit être défini AVANT les lignes) =====
                    factory_client = self.cial.CptaApplication.FactoryClient
                    persist_client = factory_client.ReadNumero(
                        devis_data["client"]["code"]
                    )

                    if not persist_client:
                        raise ValueError(
                            f"❌ Client {devis_data['client']['code']} introuvable"
                        )

                    client_obj = self._cast_client(persist_client)
                    if not client_obj:
                        raise ValueError(
                            f"❌ Impossible de charger le client {devis_data['client']['code']}"
                        )

                    # ✅ CRITIQUE: Associer le client au document
                    doc.SetDefaultClient(client_obj)
                    doc.Write()
                    logger.info(
                        f"👤 Client {devis_data['client']['code']} associé et document écrit"
                    )

                    # ===== LIGNES AVEC SetDefaultArticle() =====
                    try:
                        factory_lignes = doc.FactoryDocumentLigne
                    except:
                        factory_lignes = doc.FactoryDocumentVenteLigne

                    factory_article = self.cial.FactoryArticle

                    logger.info(f"📦 Ajout de {len(devis_data['lignes'])} lignes...")

                    for idx, ligne_data in enumerate(devis_data["lignes"], 1):
                        logger.info(
                            f"--- Ligne {idx}: {ligne_data['article_code']} ---"
                        )

                        # 🔍 ÉTAPE 1: Charger l'article RÉEL depuis Sage pour le prix
                        persist_article = factory_article.ReadReference(
                            ligne_data["article_code"]
                        )

                        if not persist_article:
                            raise ValueError(
                                f"❌ Article {ligne_data['article_code']} introuvable dans Sage"
                            )

                        article_obj = win32com.client.CastTo(
                            persist_article, "IBOArticle3"
                        )
                        article_obj.Read()

                        # 💰 ÉTAPE 2: Récupérer le prix de vente RÉEL
                        prix_sage = float(getattr(article_obj, "AR_PrixVen", 0.0))
                        designation_sage = getattr(article_obj, "AR_Design", "")
                        logger.info(f"💰 Prix Sage: {prix_sage}€")

                        if prix_sage == 0:
                            logger.warning(
                                f"⚠️ ATTENTION: Article {ligne_data['article_code']} a un prix de vente = 0€"
                            )

                        # 📝 ÉTAPE 3: Créer la ligne de devis
                        ligne_persist = factory_lignes.Create()

                        try:
                            ligne_obj = win32com.client.CastTo(
                                ligne_persist, "IBODocumentLigne3"
                            )
                        except:
                            ligne_obj = win32com.client.CastTo(
                                ligne_persist, "IBODocumentVenteLigne3"
                            )

                        # ✅✅✅ SOLUTION FINALE: SetDefaultArticleReference avec 2 paramètres ✅✅✅
                        quantite = float(ligne_data["quantite"])

                        try:
                            # Méthode 1: Via référence (plus simple et plus fiable)
                            ligne_obj.SetDefaultArticleReference(
                                ligne_data["article_code"], quantite
                            )
                            logger.info(
                                f"✅ Article associé via SetDefaultArticleReference('{ligne_data['article_code']}', {quantite})"
                            )
                        except Exception as e:
                            logger.warning(
                                f"⚠️ SetDefaultArticleReference échoué: {e}, tentative avec objet article"
                            )
                            try:
                                # Méthode 2: Via objet article
                                ligne_obj.SetDefaultArticle(article_obj, quantite)
                                logger.info(
                                    f"✅ Article associé via SetDefaultArticle(obj, {quantite})"
                                )
                            except Exception as e2:
                                logger.error(
                                    f"❌ Toutes les méthodes d'association ont échoué"
                                )
                                # Fallback: définir manuellement
                                ligne_obj.DL_Design = (
                                    designation_sage or ligne_data["designation"]
                                )
                                ligne_obj.DL_Qte = quantite
                                logger.warning("⚠️ Configuration manuelle appliquée")

                        # ⚙️ ÉTAPE 4: Vérifier le prix automatique chargé
                        prix_auto = float(getattr(ligne_obj, "DL_PrixUnitaire", 0.0))
                        logger.info(f"💰 Prix auto chargé: {prix_auto}€")

                        # 💵 ÉTAPE 5: Ajuster le prix si nécessaire
                        prix_a_utiliser = ligne_data.get("prix_unitaire_ht")

                        if prix_a_utiliser is not None and prix_a_utiliser > 0:
                            # Prix personnalisé fourni
                            ligne_obj.DL_PrixUnitaire = float(prix_a_utiliser)
                            logger.info(f"💰 Prix personnalisé: {prix_a_utiliser}€")
                        elif prix_auto == 0:
                            # Pas de prix auto, forcer le prix Sage
                            if prix_sage == 0:
                                raise ValueError(
                                    f"Prix nul pour article {ligne_data['article_code']}"
                                )
                            ligne_obj.DL_PrixUnitaire = float(prix_sage)
                            logger.info(f"💰 Prix Sage forcé: {prix_sage}€")
                        else:
                            # Prix auto correct, on le garde
                            logger.info(f"💰 Prix auto conservé: {prix_auto}€")

                        prix_final = float(getattr(ligne_obj, "DL_PrixUnitaire", 0.0))
                        montant_ligne = quantite * prix_final
                        logger.info(f"✅ {quantite} x {prix_final}€ = {montant_ligne}€")

                        # 🎁 Remise
                        remise = ligne_data.get("remise_pourcentage", 0)
                        if remise > 0:
                            try:
                                ligne_obj.DL_Remise01REM_Valeur = float(remise)
                                ligne_obj.DL_Remise01REM_Type = 0
                                montant_apres_remise = montant_ligne * (
                                    1 - remise / 100
                                )
                                logger.info(
                                    f"🎁 Remise {remise}% → {montant_apres_remise}€"
                                )
                            except Exception as e:
                                logger.warning(f"⚠️ Remise non appliquée: {e}")

                        # 💾 ÉTAPE 6: Écrire la ligne
                        ligne_obj.Write()
                        logger.info(f"✅ Ligne {idx} écrite")

                        # 🔍 VÉRIFICATION: Relire la ligne pour confirmer
                        try:
                            ligne_obj.Read()
                            prix_enregistre = float(
                                getattr(ligne_obj, "DL_PrixUnitaire", 0.0)
                            )
                            montant_enregistre = float(
                                getattr(ligne_obj, "DL_MontantHT", 0.0)
                            )
                            logger.info(
                                f"🔍 Vérif: Prix={prix_enregistre}€, Montant HT={montant_enregistre}€"
                            )

                            if montant_enregistre == 0:
                                logger.error(
                                    f"❌ PROBLÈME: Montant enregistré = 0 pour ligne {idx}"
                                )
                            else:
                                logger.info(f"✅ Ligne {idx} OK: {montant_enregistre}€")
                        except Exception as e:
                            logger.warning(f"⚠️ Impossible de vérifier la ligne: {e}")

                    # ===== VALIDATION DOCUMENT =====
                    logger.info("💾 Écriture finale du document...")
                    doc.Write()

                    logger.info("🔄 Lancement du traitement (Process)...")
                    process.Process()

                    # ===== RÉCUPÉRATION NUMÉRO =====
                    numero_devis = None
                    try:
                        doc_result = process.DocumentResult
                        if doc_result:
                            doc_result = win32com.client.CastTo(
                                doc_result, "IBODocumentVente3"
                            )
                            doc_result.Read()
                            numero_devis = getattr(doc_result, "DO_Piece", "")
                            logger.info(
                                f"📄 Numéro (via DocumentResult): {numero_devis}"
                            )
                    except Exception as e:
                        logger.warning(f"⚠️ DocumentResult non accessible: {e}")

                    if not numero_devis:
                        numero_devis = getattr(doc, "DO_Piece", "")
                        logger.info(f"📄 Numéro (via Document): {numero_devis}")

                    if not numero_devis:
                        raise RuntimeError("❌ Numéro devis vide après création")

                    # ===== COMMIT TRANSACTION =====
                    if transaction_active:
                        self.cial.CptaApplication.CommitTrans()
                        logger.info("✅ Transaction committée")

                    # ===== ATTENTE INDEXATION =====
                    logger.info("⏳ Attente indexation Sage (2s)...")
                    time.sleep(2)

                    # ===== RELECTURE COMPLÈTE =====
                    logger.info("🔍 Relecture complète du document...")
                    factory_doc = self.cial.FactoryDocumentVente
                    persist_reread = factory_doc.ReadPiece(0, numero_devis)

                    if not persist_reread:
                        logger.error(f"❌ Impossible de relire le devis {numero_devis}")
                        # Fallback: retourner les totaux calculés
                        total_calcule = sum(
                            l.get("montant_ligne_ht", 0) for l in devis_data["lignes"]
                        )
                        logger.warning(f"⚠️ Utilisation total calculé: {total_calcule}€")
                        return {
                            "numero_devis": numero_devis,
                            "total_ht": total_calcule,
                            "total_ttc": round(total_calcule * 1.20, 2),
                            "nb_lignes": len(devis_data["lignes"]),
                            "client_code": devis_data["client"]["code"],
                            "date_devis": str(date_obj.date()),
                        }

                    doc_final = win32com.client.CastTo(
                        persist_reread, "IBODocumentVente3"
                    )
                    doc_final.Read()

                    # ===== EXTRACTION TOTAUX =====
                    total_ht = float(getattr(doc_final, "DO_TotalHT", 0.0))
                    total_ttc = float(getattr(doc_final, "DO_TotalTTC", 0.0))
                    client_code_final = getattr(doc_final, "CT_Num", "")
                    date_finale = getattr(doc_final, "DO_Date", None)

                    logger.info(f"💰 Total HT: {total_ht}€")
                    logger.info(f"💰 Total TTC: {total_ttc}€")

                    # ===== DIAGNOSTIC EN CAS D'ANOMALIE =====
                    if total_ht == 0 and total_ttc > 0:
                        logger.warning("⚠️ Anomalie: Total HT = 0 mais Total TTC > 0")
                        logger.info("🔍 Lecture des lignes pour diagnostic...")

                        try:
                            factory_lignes_verif = doc_final.FactoryDocumentLigne
                        except:
                            factory_lignes_verif = doc_final.FactoryDocumentVenteLigne

                        index = 1
                        total_calcule = 0.0
                        while index <= 20:
                            try:
                                ligne_p = factory_lignes_verif.List(index)
                                if ligne_p is None:
                                    break

                                ligne_verif = win32com.client.CastTo(
                                    ligne_p, "IBODocumentLigne3"
                                )
                                ligne_verif.Read()

                                montant = float(
                                    getattr(ligne_verif, "DL_MontantHT", 0.0)
                                )
                                logger.info(
                                    f"   Ligne {index}: Montant HT = {montant}€"
                                )
                                total_calcule += montant

                                index += 1
                            except:
                                break

                        logger.info(f"📊 Total calculé manuellement: {total_calcule}€")

                        if total_calcule > 0:
                            total_ht = total_calcule
                            total_ttc = round(total_ht * 1.20, 2)
                            logger.info(
                                f"✅ Correction appliquée: HT={total_ht}€, TTC={total_ttc}€"
                            )

                    logger.info(
                        f"✅ ✅ ✅ DEVIS CRÉÉ: {numero_devis} - {total_ttc}€ TTC ✅ ✅ ✅"
                    )

                    return {
                        "numero_devis": numero_devis,
                        "total_ht": total_ht,
                        "total_ttc": total_ttc,
                        "nb_lignes": len(devis_data["lignes"]),
                        "client_code": client_code_final,
                        "date_devis": (
                            str(date_finale) if date_finale else str(date_obj.date())
                        ),
                    }

                except Exception as e:
                    if transaction_active:
                        try:
                            self.cial.CptaApplication.RollbackTrans()
                            logger.error("❌ Transaction annulée (rollback)")
                        except:
                            pass
                    raise

        except Exception as e:
            logger.error(f"❌ ❌ ❌ ERREUR CRÉATION DEVIS: {e}", exc_info=True)
            raise RuntimeError(f"Échec création devis: {str(e)}")

    # =========================================================================
    # LECTURE DEVIS
    # =========================================================================

    def lire_devis(self, numero_devis):
        """
        Lecture d'un devis (y compris brouillon)
        ✅ CORRIGÉ: Utilise .Client pour le client et .Article pour les lignes
        """
        if not self.cial:
            return None

        try:
            with self._com_context(), self._lock_com:
                factory = self.cial.FactoryDocumentVente

                # ✅ PRIORITÉ 1: Essayer ReadPiece (documents validés)
                persist = factory.ReadPiece(0, numero_devis)

                # ✅ PRIORITÉ 2: Rechercher dans la liste (brouillons)
                if not persist:
                    index = 1
                    while index < 10000:
                        try:
                            persist_test = factory.List(index)
                            if persist_test is None:
                                break

                            doc_test = win32com.client.CastTo(
                                persist_test, "IBODocumentVente3"
                            )
                            doc_test.Read()

                            if (
                                getattr(doc_test, "DO_Type", -1) == 0
                                and getattr(doc_test, "DO_Piece", "") == numero_devis
                            ):
                                persist = persist_test
                                break

                            index += 1
                        except:
                            index += 1

                if not persist:
                    logger.warning(f"Devis {numero_devis} introuvable")
                    return None

                doc = win32com.client.CastTo(persist, "IBODocumentVente3")
                doc.Read()

                # ✅ CHARGEMENT CLIENT VIA .Client
                client_code = ""
                client_intitule = ""

                try:
                    client_obj = getattr(doc, "Client", None)
                    if client_obj:
                        client_obj.Read()
                        client_code = getattr(client_obj, "CT_Num", "").strip()
                        client_intitule = getattr(client_obj, "CT_Intitule", "").strip()
                        logger.debug(
                            f"Client chargé via .Client: {client_code} - {client_intitule}"
                        )
                except Exception as e:
                    logger.debug(f"Erreur chargement client: {e}")

                    # Fallback sur cache si disponible
                    if client_code:
                        client_obj_cache = self.lire_client(client_code)
                        if client_obj_cache:
                            client_intitule = client_obj_cache.get("intitule", "")

                devis = {
                    "numero": getattr(doc, "DO_Piece", ""),
                    "date": str(getattr(doc, "DO_Date", "")),
                    "client_code": client_code,
                    "client_intitule": client_intitule,
                    "total_ht": float(getattr(doc, "DO_TotalHT", 0.0)),
                    "total_ttc": float(getattr(doc, "DO_TotalTTC", 0.0)),
                    "statut": getattr(doc, "DO_Statut", 0),
                    "lignes": [],
                }

                # Lecture des lignes
                try:
                    factory_lignes = doc.FactoryDocumentLigne
                except:
                    factory_lignes = doc.FactoryDocumentVenteLigne

                index = 1
                while True:
                    try:
                        ligne_persist = factory_lignes.List(index)
                        if ligne_persist is None:
                            break

                        ligne = win32com.client.CastTo(
                            ligne_persist, "IBODocumentLigne3"
                        )
                        ligne.Read()

                        # ✅✅✅ CHARGEMENT ARTICLE VIA .Article ✅✅✅
                        article_ref = ""

                        try:
                            # Méthode 1: Essayer AR_Ref direct (parfois disponible)
                            article_ref = getattr(ligne, "AR_Ref", "").strip()

                            # Méthode 2: Si vide, utiliser la propriété .Article
                            if not article_ref:
                                article_obj = getattr(ligne, "Article", None)
                                if article_obj:
                                    article_obj.Read()
                                    article_ref = getattr(
                                        article_obj, "AR_Ref", ""
                                    ).strip()
                                    logger.debug(
                                        f"Article chargé via .Article: {article_ref}"
                                    )
                        except Exception as e:
                            logger.debug(
                                f"Erreur chargement article ligne {index}: {e}"
                            )

                        devis["lignes"].append(
                            {
                                "article": article_ref,
                                "designation": getattr(ligne, "DL_Design", ""),
                                "quantite": float(getattr(ligne, "DL_Qte", 0.0)),
                                "prix_unitaire": float(
                                    getattr(ligne, "DL_PrixUnitaire", 0.0)
                                ),
                                "montant_ht": float(
                                    getattr(ligne, "DL_MontantHT", 0.0)
                                ),
                            }
                        )

                        index += 1
                    except Exception as e:
                        logger.debug(f"Erreur lecture ligne {index}: {e}")
                        break

                logger.info(
                    f"✅ Devis {numero_devis} lu: {len(devis['lignes'])} lignes, {devis['total_ttc']:.2f}€, client: {client_intitule}"
                )
                return devis

        except Exception as e:
            logger.error(f"❌ Erreur lecture devis {numero_devis}: {e}")
            return None

    def lire_document(self, numero, type_doc):
        """Lecture générique document (pour PDF)"""
        if type_doc == 0:
            return self.lire_devis(numero)

        try:
            with self._com_context(), self._lock_com:
                factory = self.cial.FactoryDocumentVente
                persist = factory.ReadPiece(type_doc, numero)

                if not persist:
                    return None

                doc = win32com.client.CastTo(persist, "IBODocumentVente3")
                doc.Read()

                # Lire lignes
                lignes = []
                try:
                    factory_lignes = doc.FactoryDocumentLigne
                except:
                    factory_lignes = doc.FactoryDocumentVenteLigne

                index = 1
                while True:
                    try:
                        ligne_p = factory_lignes.List(index)
                        if ligne_p is None:
                            break

                        ligne = win32com.client.CastTo(ligne_p, "IBODocumentLigne3")
                        ligne.Read()

                        lignes.append(
                            {
                                "designation": getattr(ligne, "DL_Design", ""),
                                "quantite": getattr(ligne, "DL_Qte", 0.0),
                                "prix_unitaire": getattr(ligne, "DL_PrixUnitaire", 0.0),
                                "montant_ht": getattr(ligne, "DL_MontantHT", 0.0),
                            }
                        )

                        index += 1
                    except:
                        break

                return {
                    "numero": getattr(doc, "DO_Piece", ""),
                    "date": str(getattr(doc, "DO_Date", "")),
                    "client_code": getattr(doc, "CT_Num", ""),
                    "client_intitule": getattr(doc, "CT_Intitule", ""),
                    "total_ht": getattr(doc, "DO_TotalHT", 0.0),
                    "total_ttc": getattr(doc, "DO_TotalTTC", 0.0),
                    "lignes": lignes,
                }
        except Exception as e:
            logger.error(f" Erreur lecture document: {e}")
            return None

    # =========================================================================
    # TRANSFORMATION (US-A2)
    # =========================================================================

    def transformer_document(self, numero_source, type_source, type_cible):
        """
        Transformation de document avec la méthode NATIVE de Sage

        CHANGEMENT MAJEUR:
        - Utilise TransformInto() au lieu de CreateProcess_Document()
        - Méthode officielle Sage pour les transformations
        - Gère automatiquement les numéros, statuts, et lignes

        Documentation Sage:
        IBODocumentVente3.TransformInto(DO_Type: int) -> IBODocumentVente3
        """
        if not self.cial:
            raise RuntimeError("Connexion Sage non etablie")

        # Convertir en int si enum
        type_source = int(type_source)
        type_cible = int(type_cible)

        logger.info(
            f"[TRANSFORM] Demande: {numero_source} "
            f"(type {type_source}) -> type {type_cible}"
        )

        # Validation des types
        types_valides = {0, 1, 2, 3, 4, 5}
        if type_source not in types_valides or type_cible not in types_valides:
            raise ValueError(
                f"Types invalides: source={type_source}, cible={type_cible}. "
                f"Valeurs valides: {types_valides}"
            )

        # Matrice de transformations Sage 100c
        transformations_autorisees = {
            (0, 3): "Devis -> Commande",
            (0, 1): "Devis -> Bon de livraison",
            (0, 5): "Devis -> Facture",  # Peut être supporté selon config
            (3, 1): "Commande -> Bon de livraison",
            (3, 4): "Commande -> Preparation",
            (3, 5): "Commande -> Facture",  # Direct si autorisé
            (1, 5): "Bon de livraison -> Facture",
            (4, 1): "Preparation -> Bon de livraison",
        }

        if (type_source, type_cible) not in transformations_autorisees:
            raise ValueError(
                f"Transformation non autorisee par Sage: "
                f"{type_source} -> {type_cible}. "
                f"Valides: "
                + ", ".join(
                    f"{k[0]}->{k[1]}" for k in transformations_autorisees.keys()
                )
            )

        try:
            with self._com_context(), self._lock_com:
                # ===== LECTURE SOURCE =====
                factory = self.cial.FactoryDocumentVente
                persist_source = factory.ReadPiece(type_source, numero_source)

                if not persist_source:
                    logger.warning(
                        f"[TRANSFORM] ReadPiece failed, searching in List()..."
                    )
                    persist_source = self._find_document_in_list(
                        numero_source, type_source
                    )

                    if not persist_source:
                        raise ValueError(
                            f"Document {numero_source} (type {type_source}) introuvable"
                        )

                doc_source = win32com.client.CastTo(persist_source, "IBODocumentVente3")
                doc_source.Read()

                # VÉRIFICATIONS STATUT
                statut_actuel = getattr(doc_source, "DO_Statut", 0)
                type_reel = getattr(doc_source, "DO_Type", -1)

                logger.info(
                    f"[TRANSFORM] Document source: type={type_reel}, "
                    f"statut={statut_actuel}, numero={numero_source}"
                )

                # Vérifier cohérence type
                if type_reel != type_source:
                    raise ValueError(
                        f"Incoherence: document {numero_source} est de type {type_reel}, "
                        f"pas de type {type_source}"
                    )

                # RÈGLES DE STATUT
                if statut_actuel == 5:
                    raise ValueError(
                        f"Document {numero_source} deja transforme (statut=5). "
                        f"Impossible de le transformer a nouveau."
                    )

                if statut_actuel == 6:
                    raise ValueError(
                        f"Document {numero_source} annule (statut=6). "
                        f"Impossible de le transformer."
                    )

                if statut_actuel in [3, 4]:
                    raise ValueError(
                        f"Document {numero_source} deja realise (statut={statut_actuel}). "
                        f"Ce document a deja ete transforme partiellement ou totalement."
                    )

                # Forcer statut "Accepté" si brouillon
                if type_source == 0 and statut_actuel == 0:
                    logger.warning(
                        f"[TRANSFORM] Devis en brouillon (statut=0), "
                        f"passage a 'Accepte' (statut=2)"
                    )
                    try:
                        doc_source.DO_Statut = 2
                        doc_source.Write()
                        logger.info(f"[TRANSFORM] Statut change: 0 -> 2")

                        # Re-lire
                        doc_source.Read()
                        nouveau_statut = getattr(doc_source, "DO_Statut", 0)
                        if nouveau_statut != 2:
                            raise RuntimeError(
                                f"Echec changement statut: toujours a {nouveau_statut}"
                            )
                    except Exception as e:
                        raise RuntimeError(f"Impossible de changer le statut: {e}")

                # ===== TRANSACTION =====
                transaction_active = False
                try:
                    self.cial.CptaApplication.BeginTrans()
                    transaction_active = True
                    logger.debug("[TRANSFORM] Transaction demarree")
                except AttributeError:
                    # BeginTrans n'existe pas sur cette version
                    logger.debug(
                        "[TRANSFORM] BeginTrans non disponible, continue sans transaction"
                    )
                except Exception as e:
                    logger.warning(f"[TRANSFORM] BeginTrans echoue: {e}")

                try:
                    # ✅✅✅ MÉTHODE NATIVE SAGE: TransformInto() ✅✅✅
                    logger.info(f"[TRANSFORM] Appel TransformInto({type_cible})...")

                    try:
                        # La méthode TransformInto() retourne le nouveau document
                        doc_cible = doc_source.TransformInto(type_cible)

                        if doc_cible is None:
                            raise RuntimeError(
                                "TransformInto() a retourne None. "
                                "Verifiez la configuration Sage et les autorisations."
                            )

                        logger.info("[TRANSFORM] TransformInto() execute avec succes")

                        # Cast vers le bon type
                        try:
                            doc_cible = win32com.client.CastTo(
                                doc_cible, "IBODocumentVente3"
                            )
                        except:
                            pass

                        # Lire le document cible
                        doc_cible.Read()

                        # Récupérer le numéro
                        numero_cible = getattr(doc_cible, "DO_Piece", "")

                        if not numero_cible:
                            raise RuntimeError(
                                "Numero document cible vide apres transformation"
                            )

                        # Compter les lignes
                        try:
                            factory_lignes = doc_cible.FactoryDocumentLigne
                        except:
                            factory_lignes = doc_cible.FactoryDocumentVenteLigne

                        nb_lignes = 0
                        index = 1
                        while index <= 1000:
                            try:
                                ligne_p = factory_lignes.List(index)
                                if ligne_p is None:
                                    break
                                nb_lignes += 1
                                index += 1
                            except:
                                break

                        logger.info(
                            f"[TRANSFORM] Document cible cree: {numero_cible} avec {nb_lignes} lignes"
                        )

                    except AttributeError as e:
                        # TransformInto() n'existe pas sur cette version de Sage
                        logger.error(f"[TRANSFORM] TransformInto() non disponible: {e}")
                        raise RuntimeError(
                            f"La methode TransformInto() n'est pas disponible sur votre version de Sage 100c. "
                            f"Vous devez soit: "
                            f"(1) Mettre a jour Sage, ou "
                            f"(2) Activer le module de gestion commerciale pour les commandes, ou "
                            f"(3) Utiliser l'interface Sage manuellement pour les transformations."
                        )

                    except Exception as e:
                        logger.error(f"[TRANSFORM] TransformInto() echoue: {e}")

                        # Essayer de déterminer la cause
                        if "Valeur invalide" in str(e):
                            raise RuntimeError(
                                f"Sage refuse la transformation vers le type {type_cible}. "
                                f"Causes possibles:\n"
                                f"1. Le module 'Commandes' n'est pas active dans votre licence Sage\n"
                                f"2. L'utilisateur n'a pas les droits sur ce type de document\n"
                                f"3. La configuration Sage bloque ce type de transformation\n"
                                f"4. Il manque des parametres obligatoires (depot, tarif, etc.)\n\n"
                                f"Verifiez dans Sage: Fichier > Autorisations > Gestion Commerciale"
                            )
                        elif "Acces refuse" in str(e) or "Access denied" in str(e):
                            raise RuntimeError(
                                f"Acces refuse pour creer une commande (type {type_cible}). "
                                f"Verifiez les droits utilisateur dans Sage: "
                                f"Fichier > Autorisations > Votre utilisateur"
                            )
                        else:
                            raise RuntimeError(
                                f"Erreur Sage lors de la transformation: {e}\n"
                                f"Consultez les logs Sage pour plus de details."
                            )

                    # Commit transaction
                    if transaction_active:
                        try:
                            self.cial.CptaApplication.CommitTrans()
                            logger.info("[TRANSFORM] Transaction committee")
                        except:
                            pass

                    # MAJ statut source -> Transformé
                    try:
                        doc_source.Read()  # Re-lire au cas où
                        doc_source.DO_Statut = 5
                        doc_source.Write()
                        logger.info(
                            f"[TRANSFORM] Statut source mis a jour: -> 5 (TRANSFORME)"
                        )
                    except Exception as e:
                        logger.warning(
                            f"[TRANSFORM] Impossible de MAJ statut source: {e}"
                        )

                    logger.info(
                        f"[TRANSFORM] SUCCES: "
                        f"{numero_source} ({type_source}) -> "
                        f"{numero_cible} ({type_cible}) - {nb_lignes} lignes"
                    )

                    return {
                        "success": True,
                        "document_source": numero_source,
                        "document_cible": numero_cible,
                        "nb_lignes": nb_lignes,
                    }

                except Exception as e:
                    if transaction_active:
                        try:
                            self.cial.CptaApplication.RollbackTrans()
                            logger.error("[TRANSFORM] Transaction annulee")
                        except:
                            pass
                    raise

        except Exception as e:
            logger.error(f"[TRANSFORM] Erreur: {e}", exc_info=True)
            raise RuntimeError(f"Echec transformation: {str(e)}")

    def _find_document_in_list(self, numero, type_doc):
        """Cherche un document dans List() si ReadPiece échoue"""
        try:
            factory = self.cial.FactoryDocumentVente
            index = 1

            while index < 10000:
                try:
                    persist = factory.List(index)
                    if persist is None:
                        break

                    doc = win32com.client.CastTo(persist, "IBODocumentVente3")
                    doc.Read()

                    if (
                        getattr(doc, "DO_Type", -1) == type_doc
                        and getattr(doc, "DO_Piece", "") == numero
                    ):
                        logger.info(f"[TRANSFORM] Document trouve a l'index {index}")
                        return persist

                    index += 1
                except:
                    index += 1
                    continue

            return None
        except Exception as e:
            logger.error(f"[TRANSFORM] Erreur recherche document: {e}")
            return None

    # =========================================================================
    # CHAMPS LIBRES (US-A3)
    # =========================================================================

    def mettre_a_jour_champ_libre(self, doc_id, type_doc, nom_champ, valeur):
        """Mise à jour champ libre pour Universign ID"""
        try:
            with self._com_context(), self._lock_com:
                factory = self.cial.FactoryDocumentVente
                persist = factory.ReadPiece(type_doc, doc_id)

                if persist:
                    doc = win32com.client.CastTo(persist, "IBODocumentVente3")
                    doc.Read()

                    try:
                        setattr(doc, f"DO_{nom_champ}", valeur)
                        doc.Write()
                        logger.debug(f"Champ libre {nom_champ} = {valeur} sur {doc_id}")
                        return True
                    except Exception as e:
                        logger.warning(f"Impossible de mettre à jour {nom_champ}: {e}")
        except Exception as e:
            logger.error(f"Erreur MAJ champ libre: {e}")

        return False

    def _lire_client_obj(self, code_client):
        """Retourne l'objet client Sage brut (pour remises)"""
        if not self.cial:
            return None

        try:
            with self._com_context(), self._lock_com:
                factory = self.cial.CptaApplication.FactoryClient
                persist = factory.ReadNumero(code_client)

                if persist:
                    return self._cast_client(persist)
        except:
            pass

        return None

    # =========================================================================
    # US-A6 - LECTURE CONTACTS
    # =========================================================================

    def lire_contact_principal_client(self, code_client):
        """
         NOUVEAU: Lecture contact principal d'un client

        Pour US-A6: relance devis via Universign
        Récupère l'email du contact principal pour l'envoi
        """
        if not self.cial:
            return None

        try:
            with self._com_context(), self._lock_com:
                factory_client = self.cial.CptaApplication.FactoryClient
                persist_client = factory_client.ReadNumero(code_client)

                if not persist_client:
                    return None

                client = self._cast_client(persist_client)
                if not client:
                    return None

                # Récupérer infos contact principal
                contact_info = {
                    "client_code": code_client,
                    "client_intitule": getattr(client, "CT_Intitule", ""),
                    "email": None,
                    "nom": None,
                    "telephone": None,
                }

                # Email principal depuis Telecom
                try:
                    telecom = getattr(client, "Telecom", None)
                    if telecom:
                        contact_info["email"] = getattr(telecom, "EMail", "")
                        contact_info["telephone"] = getattr(telecom, "Telephone", "")
                except:
                    pass

                # Nom du contact
                try:
                    contact_info["nom"] = (
                        getattr(client, "CT_Contact", "")
                        or contact_info["client_intitule"]
                    )
                except:
                    contact_info["nom"] = contact_info["client_intitule"]

                return contact_info

        except Exception as e:
            logger.error(f"Erreur lecture contact client {code_client}: {e}")
            return None

    # =========================================================================
    # US-A7 - MAJ CHAMP DERNIERE RELANCE
    # =========================================================================

    def mettre_a_jour_derniere_relance(self, doc_id, type_doc):
        """
         NOUVEAU: Met à jour le champ libre "Dernière relance"

        Pour US-A7: relance facture en un clic
        """
        date_relance = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        return self.mettre_a_jour_champ_libre(
            doc_id, type_doc, "DerniereRelance", date_relance
        )