# tools/orthography_tool.py
import os
from pathlib import Path
from typing import Dict, List, Optional, Any
from tools.readability_tool import calculate_readability_score as _readability_score

# Pfade zu den Orthographie-Wissensdateien
ORTHOGRAPHY_BASE_PATH = Path(__file__).parent.parent / "knowledge" / "orthography"
GETRENNT_ZUSAMMEN_PATH = ORTHOGRAPHY_BASE_PATH / "getrennt_zusammenschreibung.txt"
BINDESTRICH_PATH = ORTHOGRAPHY_BASE_PATH / "bindestrich.txt"
GROSS_KLEIN_PATH = ORTHOGRAPHY_BASE_PATH / "gross_kleinschreibung.txt"
ZEICHENSETZUNG_PATH = ORTHOGRAPHY_BASE_PATH / "zeichensetzung.txt"
WORTTRENNUNG_PATH = ORTHOGRAPHY_BASE_PATH / "worttrennung.txt"

# Cache für die geladenen Daten
orthography_data = {
    "getrennt_zusammen": [],
    "bindestrich": [],
    "gross_klein": [],
    "zeichensetzung": [],
    "worttrennung": [],
}

def load_orthography_file(file_path: Path, data_key: str) -> bool:
    """
    Lädt Orthographie-Daten aus einer TXT-Datei.
    
    Args:
        file_path: Pfad zur Datei
        data_key: Schlüssel für das orthography_data Dictionary
    
    Returns:
        bool: True, wenn das Laden erfolgreich war, sonst False
    """
    if not file_path.is_file():
        print(f"Info: Orthographie-Datei noch nicht vorhanden oder leer: {file_path}")
        return False
    
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            # Datei ist leer oder hat noch keine Daten - das ist in Ordnung
            content = f.read().strip()
            if not content:
                print(f"Info: Orthographie-Datei {file_path.name} ist leer. Bereit zum Befüllen durch Benutzer.")
                return False
            
            # Speichere den gesamten Inhalt als Liste von Zeilen
            orthography_data[data_key] = [line.strip() for line in content.split('\n') 
                                         if line.strip() and not line.strip().startswith('#')]
            
            print(f"Orthographie-Daten für {data_key} erfolgreich geladen: {len(orthography_data[data_key])} Regeln/Einträge.")
            return True
    
    except Exception as e:
        print(f"Fehler beim Laden der Orthographie-Datei {file_path}: {e}")
        return False

def load_all_orthography_data() -> Dict[str, bool]:
    """
    Lädt alle Orthographie-Datendateien.
    
    Returns:
        Dict[str, bool]: Dictionary mit Status für jede Datei
    """
    load_status = {}
    
    load_status["getrennt_zusammen"] = load_orthography_file(GETRENNT_ZUSAMMEN_PATH, "getrennt_zusammen")
    load_status["bindestrich"] = load_orthography_file(BINDESTRICH_PATH, "bindestrich")
    load_status["gross_klein"] = load_orthography_file(GROSS_KLEIN_PATH, "gross_klein")
    load_status["zeichensetzung"] = load_orthography_file(ZEICHENSETZUNG_PATH, "zeichensetzung")
    load_status["worttrennung"] = load_orthography_file(WORTTRENNUNG_PATH, "worttrennung")
    
    return load_status

# Beim Import des Moduls alle Daten laden
load_status = load_all_orthography_data()

def reload_orthography_data() -> Dict[str, bool]:
    """
    Lädt alle Orthographie-Daten neu (für den Fall, dass die Dateien aktualisiert wurden).
    
    Returns:
        Dict[str, bool]: Status des Ladens für jede Datei
    """
    global load_status
    load_status = load_all_orthography_data()
    return load_status

def get_getrennt_zusammen_rules() -> List[str]:
    """
    Gibt alle Regeln zur Getrennt- und Zusammenschreibung zurück.
    
    Returns:
        List[str]: Liste von Regeln oder leere Liste, wenn keine Daten verfügbar
    """
    return orthography_data["getrennt_zusammen"]

def get_bindestrich_rules() -> List[str]:
    """
    Gibt alle Regeln zur Schreibung mit Bindestrich zurück.
    
    Returns:
        List[str]: Liste von Regeln oder leere Liste, wenn keine Daten verfügbar
    """
    return orthography_data["bindestrich"]

def get_gross_klein_rules() -> List[str]:
    """
    Gibt alle Regeln zur Groß- und Kleinschreibung zurück.
    
    Returns:
        List[str]: Liste von Regeln oder leere Liste, wenn keine Daten verfügbar
    """
    return orthography_data["gross_klein"]

def get_zeichensetzung_rules() -> List[str]:
    """
    Gibt alle Regeln zur Zeichensetzung zurück.
    
    Returns:
        List[str]: Liste von Regeln oder leere Liste, wenn keine Daten verfügbar
    """
    return orthography_data["zeichensetzung"]

def get_worttrennung_rules() -> List[str]:
    """
    Gibt alle Regeln zur Worttrennung am Zeilenende zurück.
    
    Returns:
        List[str]: Liste von Regeln oder leere Liste, wenn keine Daten verfügbar
    """
    return orthography_data["worttrennung"]

def check_getrennt_zusammen(text: str) -> Dict:
    """
    Überprüft einen Text auf potenzielle Probleme mit Getrennt- und Zusammenschreibung.
    
    Args:
        text (str): Der zu analysierende Text
    
    Returns:
        Dict: Ergebnis der Analyse
    """
    if not load_status["getrennt_zusammen"]:
        return {
            "status": "Keine Daten verfügbar",
            "message": "Keine Regeln zur Getrennt- und Zusammenschreibung verfügbar. Bitte befüllen Sie die Datei."
        }
    
    # Implementierung der Logik zur Überprüfung
    # Diese einfache Version gibt nur zurück, dass die Analyse durchgeführt wurde
    return {
        "status": "Analyse durchgeführt",
        "rules_count": len(orthography_data["getrennt_zusammen"]),
        "message": "Die Analyse wurde mit den verfügbaren Regeln durchgeführt."
    }

def check_bindestrich(text: str) -> Dict:
    """
    Überprüft einen Text auf potenzielle Probleme mit Bindestrich-Schreibung.
    
    Args:
        text (str): Der zu analysierende Text
    
    Returns:
        Dict: Ergebnis der Analyse
    """
    if not load_status["bindestrich"]:
        return {
            "status": "Keine Daten verfügbar",
            "message": "Keine Regeln zur Bindestrich-Schreibung verfügbar. Bitte befüllen Sie die Datei."
        }
    
    # Implementierung der Logik zur Überprüfung
    # Diese einfache Version gibt nur zurück, dass die Analyse durchgeführt wurde
    return {
        "status": "Analyse durchgeführt",
        "rules_count": len(orthography_data["bindestrich"]),
        "message": "Die Analyse wurde mit den verfügbaren Regeln durchgeführt."
    }

def check_gross_klein(text: str) -> Dict:
    """
    Überprüft einen Text auf potenzielle Probleme mit Groß- und Kleinschreibung.
    
    Args:
        text (str): Der zu analysierende Text
    
    Returns:
        Dict: Ergebnis der Analyse
    """
    if not load_status["gross_klein"]:
        return {
            "status": "Keine Daten verfügbar",
            "message": "Keine Regeln zur Groß- und Kleinschreibung verfügbar. Bitte befüllen Sie die Datei."
        }
    
    # Implementierung der Logik zur Überprüfung
    # Diese einfache Version gibt nur zurück, dass die Analyse durchgeführt wurde
    return {
        "status": "Analyse durchgeführt",
        "rules_count": len(orthography_data["gross_klein"]),
        "message": "Die Analyse wurde mit den verfügbaren Regeln durchgeführt."
    }

def check_zeichensetzung(text: str) -> Dict:
    """
    Überprüft einen Text auf potenzielle Probleme mit Zeichensetzung.
    
    Args:
        text (str): Der zu analysierende Text
    
    Returns:
        Dict: Ergebnis der Analyse
    """
    if not load_status["zeichensetzung"]:
        return {
            "status": "Keine Daten verfügbar",
            "message": "Keine Regeln zur Zeichensetzung verfügbar. Bitte befüllen Sie die Datei."
        }
    
    # Implementierung der Logik zur Überprüfung
    # Diese einfache Version gibt nur zurück, dass die Analyse durchgeführt wurde
    return {
        "status": "Analyse durchgeführt",
        "rules_count": len(orthography_data["zeichensetzung"]),
        "message": "Die Analyse wurde mit den verfügbaren Regeln durchgeführt."
    }

def check_worttrennung(text: str) -> Dict:
    """
    Überprüft einen Text auf potenzielle Probleme mit Worttrennung am Zeilenende.
    
    Args:
        text (str): Der zu analysierende Text
    
    Returns:
        Dict: Ergebnis der Analyse
    """
    if not load_status["worttrennung"]:
        return {
            "status": "Keine Daten verfügbar",
            "message": "Keine Regeln zur Worttrennung verfügbar. Bitte befüllen Sie die Datei."
        }
    
    # Implementierung der Logik zur Überprüfung
    # Diese einfache Version gibt nur zurück, dass die Analyse durchgeführt wurde
    return {
        "status": "Analyse durchgeführt",
        "rules_count": len(orthography_data["worttrennung"]),
        "message": "Die Analyse wurde mit den verfügbaren Regeln durchgeführt."
    }

def get_all_orthography_rules() -> Dict:
    """
    Gibt alle verfügbaren Orthographie-Regeln zurück.
    
    Returns:
        Dict: Dictionary mit allen Regeln, kategorisiert
    """
    return {
        "getrennt_zusammen": orthography_data["getrennt_zusammen"],
        "bindestrich": orthography_data["bindestrich"],
        "gross_klein": orthography_data["gross_klein"],
        "zeichensetzung": orthography_data["zeichensetzung"],
        "worttrennung": orthography_data["worttrennung"],
        "load_status": load_status
    } 

# Lesbarkeitsbewertung: Delegiert an tools.readability_tool.calculate_readability_score
def calculate_readability_score(text: str) -> Dict[str, Any]:
    """
    Delegiert an tools.readability_tool.calculate_readability_score.
    """
    return _readability_score(text)