#!/usr/bin/env python3
"""
🤖 AI Shopping Schema Generator - Intelectra
Erzeugt KI-optimierte JSON-LD Schemas für bessere AI-Findbarkeit

SICHER: Läuft komplett isoliert, keine Live-Shop Auswirkungen!
"""

import json
import sys
import re
from datetime import datetime
import os

class AIShoppingSchemaGenerator:
    def __init__(self):
        self.base_url = "https://intelectra.de"
        self.safety_icon_base = "/themes/theme2/media/images/safety/"

    def generate_schema(self, item_data):
        """Erzeugt KI-optimiertes Schema für einen Artikel"""
        try:
            schema = {
                "@context": "https://schema.org",
                "@type": "Product",
                "name": item_data.get('name', ''),
                "identifier": f"intelectra-{item_data.get('item_id', '')}",
                "category": "Elektro-Ersatzteil",
                "url": f"{self.base_url}/artikel/{item_data.get('item_id', '')}",

                # Timestamp für Monitoring
                "_meta": {
                    "generated": datetime.now().isoformat(),
                    "generator": "AI Shopping Schema v1.0",
                    "source": "intelectra_live_shop"
                }
            }

            # Sicherheitshinweise hinzufügen (wenn vorhanden)
            if item_data.get('warnings'):
                schema["safetyConsiderations"] = self.build_safety_schema(item_data['warnings'])

            # Problem-Solution-Mapping (Smart Feature!)
            schema["solves"] = self.build_problem_solutions(item_data)

            # Kompatibilitäts-Informationen
            if item_data.get('attributes'):
                schema["compatibleWith"] = self.build_compatibility_schema(item_data['attributes'])

            # Installations-Hinweise
            schema["installationHints"] = self.generate_installation_hints(item_data)

            return schema

        except Exception as e:
            self.log_error(f"Schema generation failed: {str(e)}")
            return None

    def build_safety_schema(self, warnings):
        """Konvertiert Sicherheitshinweise in KI-optimiertes Format"""
        safety_considerations = []

        for warning in warnings:
            consideration = {
                "@type": "SafetyConsideration",
                "name": warning.get('name', ''),
                "description": warning.get('beschreibung', ''),
                "warningLevel": self.detect_warning_level(warning.get('name', '')),
                "iconPath": f"{self.safety_icon_base}{warning.get('image_filename', '')}"
            }

            # Intelligente Kategorisierung
            if "elektrisch" in warning.get('name', '').lower():
                consideration["category"] = "electrical_hazard"
                consideration["preventiveMeasures"] = ["Netzstecker ziehen", "Spannungsfreiheit prüfen"]
            elif "quetsch" in warning.get('name', '').lower():
                consideration["category"] = "mechanical_hazard"
                consideration["preventiveMeasures"] = ["Schutzhandschuhe tragen", "Vorsichtig arbeiten"]

            safety_considerations.append(consideration)

        return safety_considerations

    def build_problem_solutions(self, item_data):
        """🚀 UNIVERSAL PROBLEM-SOLUTION ENGINE - Der komplette Motor!"""
        name = item_data.get('name', '').lower()
        solutions = []

        # 🚰 WASSERSYSTEM - Pumpen, Schläuche, Ventile
        if any(word in name for word in ['pumpe', 'pump', 'ablaufpumpe', 'laugenpumpe']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Wasser läuft nicht ab / Pumpe defekt",
                "symptoms": ["Gerät pumpt nicht", "Wasser steht", "Ablauf verstopft", "Pumpe brummt", "E20 Fehler", "E03 Fehler", "F03 Fehler", "OE Fehler", "5E Fehler"],
                "urgencyLevel": "HIGH",
                "repairComplexity": "MEDIUM",
                "problemKeywords": ["pumpe defekt", "wasser läuft nicht ab", "ablauf verstopft", "e20 fehler", "pumpe brummt", "f03 fehler"]
            })

        if any(word in name for word in ['schlauch', 'aquastop', 'zulaufschlauch', 'ablaufschlauch']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Wasserschlauch defekt / Undichtigkeit",
                "symptoms": ["Wasser tropft", "Schlauch porös", "Undichtigkeit", "Aquastop löst aus", "E10 Fehler", "F17 Fehler"],
                "urgencyLevel": "HIGH",
                "repairComplexity": "EASY",
                "problemKeywords": ["schlauch kaputt", "wasser tropft", "undicht", "aquastop piepst", "e10 fehler"]
            })

        # 🔥 HEIZSYSTEM - Heizstäbe, Thermostate, NTC
        if any(word in name for word in ['heizstab', 'heizung', 'thermostat', 'ntc', 'temperaturfühler']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Gerät heizt nicht / Temperaturproblem",
                "symptoms": ["Kein warmes Wasser", "Geschirr bleibt kalt", "Heizung defekt", "E15 Fehler", "F25 Fehler", "E01 Fehler"],
                "urgencyLevel": "MEDIUM",
                "repairComplexity": "MEDIUM",
                "problemKeywords": ["heizt nicht", "kein warmes wasser", "heizstab defekt", "e15 fehler", "f25 fehler"]
            })

        # ⚡ MOTOREN - Antriebsmotoren, Umwälzpumpen
        if any(word in name for word in ['motor', 'antrieb', 'antriebsmotor', 'umwälzpumpe']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Motor dreht nicht / Antrieb defekt",
                "symptoms": ["Trommel dreht nicht", "Motor brummt", "Gerät startet nicht", "F21 Fehler", "E02 Fehler", "F34 Fehler"],
                "urgencyLevel": "HIGH",
                "repairComplexity": "HARD",
                "problemKeywords": ["motor defekt", "trommel dreht nicht", "motor brummt", "f21 fehler", "antrieb kaputt"]
            })

        # 🚪 TÜRSYSTEM - Türschloss, Türdichtung, Türgriff
        if any(word in name for word in ['türschloss', 'türgriff', 'türdichtung', 'door lock', 'handle']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Tür schließt nicht / Türproblem",
                "symptoms": ["Tür geht nicht zu", "Türschloss defekt", "Wasser tropft aus Tür", "E01 Fehler", "F16 Fehler"],
                "urgencyLevel": "MEDIUM",
                "repairComplexity": "EASY",
                "problemKeywords": ["tür geht nicht zu", "türschloss defekt", "türgriff kaputt", "e01 fehler"]
            })

        # ⚙️ MECHANIK - Stoßdämpfer, Federn, Lager, Riemen
        if any(word in name for word in ['stoßdämpfer', 'feder', 'lager', 'riemen', 'keilriemen']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Mechanik defekt / Geräusche beim Betrieb",
                "symptoms": ["Komische Geräusche", "Gerät wackelt", "Vibrationen", "Quietschen", "Schleifen"],
                "urgencyLevel": "MEDIUM",
                "repairComplexity": "MEDIUM",
                "problemKeywords": ["komische geräusche", "gerät wackelt", "quietscht", "schleift", "vibriert"]
            })

        # 🔌 ELEKTRONIK - Platinen, Sensoren, Timer
        if any(word in name for word in ['platine', 'steuerung', 'elektronik', 'sensor', 'timer', 'display']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Elektronik defekt / Steuerungsproblem",
                "symptoms": ["Display zeigt Fehler", "Programm startet nicht", "Tasten reagieren nicht", "F-Fehler", "E-Fehler"],
                "urgencyLevel": "HIGH",
                "repairComplexity": "HARD",
                "problemKeywords": ["display defekt", "steuerung kaputt", "f fehler", "e fehler", "platine defekt"]
            })

        # 🧽 FILTER & REINIGUNG
        if any(word in name for word in ['filter', 'sieb', 'flusensieb', 'wasserfilter']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Filter verstopft / Reinigungsproblem",
                "symptoms": ["Schlechte Waschleistung", "Filter verstopft", "Geruch", "Wasser trüb"],
                "urgencyLevel": "LOW",
                "repairComplexity": "EASY",
                "problemKeywords": ["filter verstopft", "schlechte waschleistung", "geruch", "flusensieb"]
            })

        # 💡 BELEUCHTUNG - Lampen, LEDs
        if any(word in name for word in ['lampe', 'led', 'birne', 'leuchte', 'beleuchtung']):
            solutions.append({
                "@type": "ProblemSolution",
                "problem": "Beleuchtung defekt / Licht geht nicht",
                "symptoms": ["Licht geht nicht an", "LED defekt", "Birne kaputt", "Dunkel im Gerät"],
                "urgencyLevel": "LOW",
                "repairComplexity": "EASY",
                "problemKeywords": ["licht geht nicht", "led defekt", "birne kaputt", "beleuchtung aus"]
            })

        return solutions

    def build_compatibility_schema(self, attributes):
        """Extrahiert Kompatibilitäts-Informationen aus Attributen"""
        compatible_brands = []

        # Pattern für bekannte Marken (Intelectra-optimiert)
        brand_patterns = {
            'bsh': ['siemens', 'bosch', 'neff', 'gaggenau', 'constructa'],
            'whirlpool': ['whirlpool', 'bauknecht', 'privileg', 'ignis'],
            'electrolux': ['electrolux', 'aeg', 'zanussi'],
            'miele': ['miele'],
            'liebherr': ['liebherr'],
            'amica': ['amica', 'hansa']
        }

        # Suche nach Marken in Attributen
        for attr_key, attr_value in attributes.items():
            if isinstance(attr_value, str):
                for brand_group, brands in brand_patterns.items():
                    if any(brand in attr_value.lower() for brand in brands):
                        compatible_brands.extend(brands)

        return {
            "brands": list(set(compatible_brands)),
            "applianceTypes": self.detect_appliance_types(attributes)
        }

    def detect_appliance_types(self, attributes):
        """Erkennt Gerätetypen aus Attributen"""
        types = []

        # Pattern Recognition für Gerätetypen
        type_keywords = {
            "Waschmaschine": ["waschmaschine", "washing", "wäsche"],
            "Geschirrspüler": ["geschirrspüler", "dishwasher", "spülmaschine"],
            "Kühlschrank": ["kühlschrank", "refrigerator", "kühl"],
            "Backofen": ["backofen", "oven", "herd"],
            "Trockner": ["trockner", "wäschetrockner", "dryer"]
        }

        for attr_value in attributes.values():
            if isinstance(attr_value, str):
                for appliance, keywords in type_keywords.items():
                    if any(keyword in attr_value.lower() for keyword in keywords):
                        types.append(appliance)

        return list(set(types))

    def generate_installation_hints(self, item_data):
        """Generiert intelligente Installations-Hinweise"""
        name = item_data.get('name', '').lower()

        if 'schlauch' in name:
            return {
                "difficulty": "Einfach - ohne Fachmann machbar",
                "timeRequired": "5-10 Minuten",
                "toolsNeeded": ["Zange", "Schraubendreher"],
                "safetyNote": "Wasser abstellen vor Montage"
            }
        elif 'pumpe' in name:
            return {
                "difficulty": "Mittel - handwerkliches Geschick nötig",
                "timeRequired": "30-45 Minuten",
                "toolsNeeded": ["Schraubendreher", "Zange", "Multimeter"],
                "safetyNote": "Strom abstellen! Gerät vom Netz trennen"
            }
        elif 'heizstab' in name:
            return {
                "difficulty": "Schwer - Fachmann empfohlen",
                "timeRequired": "60-90 Minuten",
                "toolsNeeded": ["Multimeter", "Spezialwerkzeug"],
                "safetyNote": "⚠️ HOCHSPANNUNG! Strom komplett abschalten"
            }

        return {
            "difficulty": "Mittlere Schwierigkeit",
            "timeRequired": "15-30 Minuten",
            "safetyNote": "Sicherheitshinweise beachten"
        }

    def detect_warning_level(self, warning_name):
        """Intelligente Warnstufen-Erkennung"""
        name_lower = warning_name.lower()

        if any(word in name_lower for word in ['elektrisch', 'strom', 'spannung']):
            return "CRITICAL"
        elif any(word in name_lower for word in ['heiß', 'temperatur', 'verbrennung']):
            return "HIGH"
        elif any(word in name_lower for word in ['quetsch', 'verletzung']):
            return "MEDIUM"
        else:
            return "LOW"

    def save_schema(self, schema, item_id):
        """Speichert Schema für späteren Abruf (optional)"""
        try:
            schema_dir = "/var/www/vhosts/intelectra.de/httpdocs/core/python/logs"
            os.makedirs(schema_dir, exist_ok=True)
            schema_file = f"{schema_dir}/schema_{item_id}.json"

            with open(schema_file, 'w', encoding='utf-8') as f:
                json.dump(schema, f, indent=2, ensure_ascii=False)

            return True
        except Exception as e:
            self.log_error(f"Schema save failed: {str(e)}")
            return False

    def log_error(self, message):
        """Fehler-Logging"""
        try:
            log_dir = "/var/www/vhosts/intelectra.de/httpdocs/core/python/logs"
            os.makedirs(log_dir, exist_ok=True)
            log_file = f"{log_dir}/ai_schema.log"
            timestamp = datetime.now().isoformat()
            with open(log_file, 'a', encoding='utf-8') as f:
                f.write(f"{timestamp} ERROR: {message}\n")
        except:
            pass  # Silent fail für Live-Shop

def main():
    """Hauptfunktion - wird von PHP aufgerufen"""
    if len(sys.argv) < 2:
        print(json.dumps({"error": "No input data provided"}))
        sys.exit(1)

    try:
        # Input von PHP parsen
        input_data = json.loads(sys.argv[1])

        # Schema Generator initialisieren
        generator = AIShoppingSchemaGenerator()

        # Schema erzeugen
        schema = generator.generate_schema(input_data)

        if schema:
            # Optional: Schema speichern
            generator.save_schema(schema, input_data.get('item_id', 'unknown'))

            # Erfolg zurückgeben
            result = {
                "success": True,
                "schema_generated": True,
                "item_id": input_data.get('item_id'),
                "timestamp": datetime.now().isoformat()
            }
        else:
            result = {"success": False, "error": "Schema generation failed"}

        print(json.dumps(result))

    except Exception as e:
        error_result = {"success": False, "error": str(e)}
        print(json.dumps(error_result))
        sys.exit(1)

if __name__ == "__main__":
    main()