Gestion des données produits unifiée

@prefix : <http://product.example.org/ontology#> .
@prefix schema: <https://schema.org/> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .

# Classes principales
:Produit a owl:Class ;
    rdfs:subClassOf schema:Product .

:Catégorie a owl:Class ;
    rdfs:subClassOf skos:Concept .

:Attribut a owl:Class .
:ValeurAttribut a owl:Class .
:Fournisseur a owl:Class .
:Marque a owl:Class .
:Accessoire a owl:Class ; rdfs:subClassOf :Produit .

# Relations
:appartientÀCatégorie a owl:ObjectProperty ;
    rdfs:domain :Produit ;
    rdfs:range :Catégorie .

:aPourAttribut a owl:ObjectProperty ;
    rdfs:domain :Produit ;
    rdfs:range :Attribut .

:estCompatibleAvec a owl:ObjectProperty ;
    rdfs:domain :Produit ;
    rdfs:range :Produit ;
    owl:symmetric true .

:estSubstitutDe a owl:ObjectProperty ;
    rdfs:domain :Produit ;
    rdfs:range :Produit .

:estAccessoireDe a owl:ObjectProperty ;
    rdfs:domain :Accessoire ;
    rdfs:range :Produit .

:estFourniPar a owl:ObjectProperty ;
    rdfs:domain :Produit ;
    rdfs:range :Fournisseur .

# Règle : Compatibilité transitive
[ (:estCompatibleAvec ?a ?b), (:estCompatibleAvec ?b ?c) -> (:estCompatibleAvec ?a ?c) ]

# Règle : Si produit compatible, ses accessoires le sont aussi
[ (:estAccessoireDe ?a ?p), (:estCompatibleAvec ?p ?q) -> (:estCompatibleAvec ?a ?q) ]

class ProductKnowledgeGraph:
    def __init__(self, kg, llm, embedding_model):
        self.kg = kg
        self.llm = llm
        self.embedder = embedding_model
    
    def integrate_product(self, source_data, source_type):
        """Intègre un produit depuis n'importe quelle source"""
        
        # 1. Normalisation et nettoyage
        normalized = self.normalize(source_data, source_type)
        
        # 2. Recherche de correspondance (déduplication)
        existing = self.find_matching_product(normalized)
        
        if existing:
            # Fusion avec données existantes
            product_id = existing['id']
            self.merge_product(product_id, normalized)
        else:
            # Création nouveau produit
            product_id = self.create_product(normalized)
        
        # 3. Enrichissement automatique
        self.enrich_product(product_id)
        
        # 4. Détection des relations
        self.discover_relations(product_id)
        
        return product_id
    
    def normalize(self, data, source_type):
        """Normalisation selon source"""
        mapping = {
            'erp': self.map_erp_to_ontology,
            'pim': self.map_pim_to_ontology,
            'excel': self.map_excel_to_ontology,
            'supplier': self.map_supplier_to_ontology
        }
        return mapping[source_type](data)
    
    def find_matching_product(self, product):
        """Détection de doublons par similarité sémantique + règles"""
        # Recherche par identifiant unique (EAN, SKU)
        if product.get('ean'):
            existing = self.kg.query(f"""
                SELECT ?p WHERE {{
                    ?p :aPourEAN "{product['ean']}" .
                }}
            """)
            if existing:
                return existing[0]
        
        # Recherche par similarité du nom
        product_embedding = self.embedder.encode(product['name'])
        candidates = self.vector_db.similarity_search(product_embedding, k=5)
        
        for candidate in candidates:
            score = self.calculate_match_score(product, candidate)
            if score > 0.85:
                return candidate
        
        return None
    
    def enrich_product(self, product_id):
        """Enrichissement via LLM et sources externes"""
        product = self.kg.get_product(product_id)
        
        # Génération de description SEO
        seo_desc = self.llm.generate(f"""
            Génère une description SEO pour ce produit (150-160 caractères):
            Nom: {product['name']}
            Catégorie: {product['category']}
            Attributs: {product['attributes']}
        """)
        
        # Classification automatique dans catégories
        categories = self.llm.classify(product['name'], self.kg.get_categories())
        
        # Mise à jour du graphe
        self.kg.insert(f"""
            :{product_id} :aPourDescriptionSEO "{seo_desc}" ;
                :appartientÀCatégorie :{categories[0]} .
        """)
    
    def discover_relations(self, product_id):
        """Détection automatique des relations produits"""
        product = self.kg.get_product(product_id)
        
        # Compatibilité technique (via attributs)
        compatible = self.kg.query(f"""
            SELECT ?other WHERE {{
                ?other a :Produit .
                ?other :aPourAttribut ?attr .
                FILTER(?attr IN ({product['technical_attrs']}))
                FILTER(?other != :{product_id})
            }}
        """)
        
        for comp in compatible:
            self.kg.insert(f":{product_id} :estCompatibleAvec :{comp['id']}")
        
        # Accessoires suggérés
        accessories = self.llm.suggest_accessories(product['name'], product['category'])
        for acc in accessories:
            self.kg.insert(f":{acc} :estAccessoireDe :{product_id}")