file_processor.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Dateiverarbeitungsfunktionen für das Sortierungsprogramm
"""

import os
import time
import re
from datetime import datetime
import threading
import tkinter as tk
from tkinter import ttk, messagebox

from config import NOT_ASSIGNABLE_FOLDER, POSSIBLE_YEARS, PERMANENT_CATEGORY
from ollama_manager import ollama_classify

# Globale Variablen
abort_flag = False

def get_content(file_path):
    """
    Extrahiert den Inhalt aus einer Datei
    
    Args:
        file_path: Pfad zur Datei
    
    Returns:
        Extrahierter Text oder Dateiinformationen bei Fehler
    """
    try:
        # Für PDF-Dateien
        if file_path.lower().endswith('.pdf'):
            try:
                # Versuch 1: PyPDF2
                try:
                    from PyPDF2 import PdfReader
                    with open(file_path, 'rb') as f:
                        reader = PdfReader(f)
                        content_list = []
                        for page in reader.pages:
                            text = page.extract_text() or ""
                            content_list.append(text)
                        return "\n".join(content_list)
                except Exception as pdf_error:
                    print(f"PyPDF2 konnte die Datei nicht lesen: {pdf_error}")
                    
                    # Versuch 2: pdfplumber (falls installiert)
                    try:
                        import pdfplumber
                        with pdfplumber.open(file_path) as pdf:
                            content_list = []
                            for page in pdf.pages:
                                text = page.extract_text() or ""
                                content_list.append(text)
                            return "\n".join(content_list)
                    except ImportError:
                        print("pdfplumber nicht installiert, verwende Dateiinformationen")
                    except Exception as plumber_error:
                        print(f"pdfplumber konnte die Datei nicht lesen: {plumber_error}")
                
                # Fallback: Dateiname und Metadaten verwenden
                file_name = os.path.basename(file_path)
                file_info = f"Dateiname: {file_name}\nDateipfad: {os.path.dirname(file_path)}"
                
                # Datum aus Dateinamen extrahieren (falls vorhanden)
                date_patterns = [
                    r'(\d{4})[_-]?(\d{2})[_-]?(\d{2})',  # YYYY-MM-DD oder YYYY_MM_DD
                    r'(\d{2})[_-]?(\d{2})[_-]?(\d{4})',  # DD-MM-YYYY oder DD_MM_YYYY
                ]
                
                for pattern in date_patterns:
                    match = re.search(pattern, file_name)
                    if match:
                        file_info += f"\nGefundenes Datum im Dateinamen: {match.group(0)}"
                        break
                
                return file_info
            
            except Exception as e:
                print(f"Fehler beim Lesen der PDF: {e}")
                return f"Dateiname: {os.path.basename(file_path)}"
                
        # Für Textdateien
        elif file_path.lower().endswith(('.txt', '.csv', '.md')):
            with open(file_path, 'r', encoding="utf-8", errors="replace") as f:
                return f.read()
                
        # Für andere Dateitypen
        else:
            # Metadaten extrahieren
            file_name = os.path.basename(file_path)
            file_size = os.path.getsize(file_path) / 1024  # KB
            file_date = time.strftime('%Y-%m-%d', time.localtime(os.path.getmtime(file_path)))
            
            return f"Dateiname: {file_name}\nGröße: {file_size:.1f} KB\nDatum: {file_date}"
            
    except Exception as e:
        print(f"Fehler beim Öffnen der Datei {os.path.basename(file_path)}: {e}")
        return f"Dateiname: {os.path.basename(file_path)} | Pfad: {os.path.dirname(file_path)}"

def enrich_document_content(file_path, content):
    """
    Reichert Dokumentinhalt mit Meta-Informationen an
    
    Args:
        file_path: Pfad zur Datei
        content: Rohinhalt der Datei
    
    Returns:
        Angereicherter Inhalt
    """
    enriched_content = []
    
    # 1. Metadaten extrahieren
    file_name = os.path.basename(file_path)
    file_ext = os.path.splitext(file_name)[1].lower()
    file_size = os.path.getsize(file_path) / 1024  # KB
    creation_time = datetime.fromtimestamp(os.path.getctime(file_path)).strftime('%Y-%m-%d')
    modified_time = datetime.fromtimestamp(os.path.getmtime(file_path)).strftime('%Y-%m-%d')
    
    # Metadaten am Anfang platzieren
    enriched_content.append("DOCUMENT METADATA:")
    enriched_content.append(f"Filename: {file_name}")
    enriched_content.append(f"File type: {file_ext}")
    enriched_content.append(f"Size: {file_size:.1f} KB")
    enriched_content.append(f"Created: {creation_time}")
    enriched_content.append(f"Modified: {modified_time}")
    
    # 2. Datumsanalyse im Dateinamen
    dates_in_filename = []
    
    # Verschiedene Datumsformate suchen
    date_patterns = [
        r'(\d{2})[.-/](\d{2})[.-/](\d{4})',  # DD.MM.YYYY
        r'(\d{4})[.-/](\d{2})[.-/](\d{2})',  # YYYY.MM.DD
        r'(\d{2})[-_]?(\d{2})[-_]?(\d{4})',  # DDMMYYYY mit optionalen Trennzeichen
        r'(\d{4})[-_]?(\d{2})[-_]?(\d{2})'   # YYYYMMDD mit optionalen Trennzeichen
    ]
    
    for pattern in date_patterns:
        matches = re.findall(pattern, file_name)
        if matches:
            dates_in_filename.extend(matches)
    
    if dates_in_filename:
        enriched_content.append("\nDATES IN FILENAME:")
        for date in dates_in_filename:
            date_str = '.'.join(date)
            enriched_content.append(f"- {date_str}")
    
    # 3. Schlüsselwörter im Inhalt identifizieren
    key_categories = {
        "Rechnung": ["rechnung", "invoice", "betrag", "zahlung", "zahlbar", "mwst", "ust-id", "umsatzsteuer",
                    "rechnungsnummer", "rechnungsdatum", "netto", "brutto", "skonto", "fällig"],
        "Bankkonto": ["kontoauszug", "konto", "überweisung", "bank", "sparkasse", "iban", "bic", "guthaben", 
                      "saldo", "einzahlung", "abbuchung", "lastschrift", "dauerauftrag"],
        "Steuer": ["steuer", "finanzamt", "einkommensteuer", "gewerbesteuer", "grundsteuer", "steuererklärung",
                  "steuerbescheid", "steuererstattung", "steuernummer", "steuer-id"],
        "Versicherung": ["versicherung", "police", "vertrag", "beitrag", "prämie", "schaden", "versicherungsschein",
                        "haftpflicht", "krankenversicherung", "kfz-versicherung", "hausrat"]
    }
    
    # Inhalt durchsuchen und gefundene Schlüsselwörter speichern
    found_keywords = {}
    content_lower = content.lower()
    
    for category, keywords in key_categories.items():
        found_in_category = []
        for keyword in keywords:
            if keyword in content_lower:
                found_in_category.append(keyword)
        
        if found_in_category:
            found_keywords[category] = found_in_category
    
    if found_keywords:
        enriched_content.append("\nIDENTIFIED KEYWORDS:")
        for category, keywords in found_keywords.items():
            enriched_content.append(f"{category}: {', '.join(keywords)}")
    
    # 4. Beträge suchen (Geldbeträge in verschiedenen Formaten)
    amounts = re.findall(r'(\d{1,3}(?:\.\d{3})*(?:,\d{2})|(?:\d+)(?:,\d{2}))\s*(?:€|EUR|Euro)', content, re.IGNORECASE)
    if amounts:
        enriched_content.append("\nIDENTIFIED AMOUNTS:")
        for amount in amounts:
            enriched_content.append(f"- {amount} EUR")
    
    # 5. Namen/Firmen identifizieren (Hinweis: einfache Heuristik)
    # Nach Absenderinformationen suchen
    sender_patterns = [
        r'(?:von|from|absender):\s*([A-Z][A-Za-z\s]+(?:GmbH|AG|KG|OHG|e\.V\.|Inc\.|Ltd\.))',
        r'(?:firma|company):\s*([A-Z][A-Za-z\s]+(?:GmbH|AG|KG|OHG|e\.V\.|Inc\.|Ltd\.))',
        r'(?:^|\n)([A-Z][A-Za-z\s]+(?:GmbH|AG|KG|OHG|e\.V\.|Inc\.|Ltd\.))(?:$|\n)'
    ]
    
    potential_senders = []
    for pattern in sender_patterns:
        matches = re.findall(pattern, content)
        if matches:
            potential_senders.extend(matches)
    
    if potential_senders:
        enriched_content.append("\nPOTENTIAL SENDERS/COMPANIES:")
        for sender in potential_senders:
            enriched_content.append(f"- {sender.strip()}")
    
    # 6. Original-Inhalt hinzufügen
    enriched_content.append("\n--- ORIGINAL CONTENT ---")
    enriched_content.append(content)
    
    return "\n".join(enriched_content)

def detect_year(file_content, ollama_params, config=None):
    """
    Erkennt das Jahr im Dateiinhalt
    
    Args:
        file_content: Inhalt der Datei
        ollama_params: Parameter für Ollama
        config: Konfiguration mit benutzerdefinierten Anweisungen
    
    Returns:
        Erkanntes Jahr
    """
    try:
        result = ollama_classify(file_content, POSSIBLE_YEARS, ollama_params, config)
        return result.get("result", "2023")
    except Exception as e:
        print(f"Fehler bei Jahreserkennung: {e}")
        return "2023"

def detect_category(file_content, custom_cats, ollama_params, config=None):
    """
    Erkennt die Kategorie im Dateiinhalt
    
    Args:
        file_content: Inhalt der Datei
        custom_cats: Liste der benutzerdefinierten Kategorien
        ollama_params: Parameter für Ollama
        config: Konfiguration mit benutzerdefinierten Anweisungen
    
    Returns:
        Erkannte Kategorie
    """
    try:
        # Filtere Jahre aus den Kategorien heraus
        cleaned_cats = []
        for cat in custom_cats:
            # Entferne Jahreszahlen am Anfang der Kategorie
            cleaned_cat = cat
            for year in POSSIBLE_YEARS:
                if cleaned_cat.startswith(year):
                    cleaned_cat = cleaned_cat[len(year):].strip()
            
            if cleaned_cat:
                cleaned_cats.append(cleaned_cat)
        
        result = ollama_classify(file_content, cleaned_cats, ollama_params, config)
        return result.get("result", "Sonstiges")
    except Exception as e:
        print(f"Fehler bei Kategorieerkennung: {e}")
        return "Sonstiges"

def final_label_for_file(file_content, custom_cats, ollama_params, config=None):
    """
    Erstellt das finale Label für eine Datei
    
    Args:
        file_content: Inhalt der Datei
        custom_cats: Liste der benutzerdefinierten Kategorien
        ollama_params: Parameter für Ollama
        config: Konfiguration mit benutzerdefinierten Anweisungen
    
    Returns:
        Finales Label (Jahr + Kategorie)
    """
    year_label = detect_year(file_content, ollama_params, config)
    cat_label = detect_category(file_content, custom_cats, ollama_params, config)
    
    # Vermeidet Doppelungen, falls die Kategorie bereits das Jahr enthält
    if any(year in cat_label for year in POSSIBLE_YEARS):
        return cat_label
    else:
        return f"{year_label} {cat_label}"

def preview_move_plan_with_year_structure(source_folder, target_folder, custom_cats, 
                                      ollama_params, config=None, log_callback=None,
                                      progress_callback=None, status_callback=None):
    """
    Zeigt eine Vorschau der Verschiebungen mit Jahr-Struktur in Tabellenform an
    
    Args:
        source_folder: Pfad zum Quellordner
        target_folder: Pfad zum Zielordner
        custom_cats: Liste der benutzerdefinierten Kategorien
        ollama_params: Parameter für Ollama
        config: Konfiguration
        log_callback: Funktion für Log-Meldungen
        progress_callback: Funktion für Fortschrittsanzeige
        status_callback: Funktion für Statusanzeige
    """
    global abort_flag
    abort_flag = False
    all_files = []
    
    # Hilfsfunktionen für Callbacks
    def log(msg, level="info"):
        if log_callback:
            log_callback(msg, level)
        else:
            print(f"[{level.upper()}] {msg}")
    
    def update_progress(value=None, maximum=None, text=None):
        if progress_callback:
            progress_callback(value, maximum, text)
    
    def update_status(text):
        if status_callback:
            status_callback(text)
    
    # Dateien sammeln
    log("Sammle Dateien für Vorschau...")
    update_status("Sammle Dateien...")
    
    for root_dir, dirs, files in os.walk(source_folder):
        for file in files:
            all_files.append(os.path.join(root_dir, file))
    
    update_status("")
    
    if not all_files:
        log("Keine Dateien im ausgewählten Ordner gefunden.", "warning")
        return []
    
    log(f"Insgesamt {len(all_files)} Dateien gefunden")
    update_progress(0, len(all_files))
    
    # Aktuelles Jahr für Validierung
    current_year = datetime.now().year
    
    # Verarbeitung der Dateien
    count = 0
    file_data = []
    
    for file_path in all_files:
        if abort_flag:
            log("Vorschau-Operation abgebrochen.", "warning")
            break
            
        try:
            # UI aktualisieren
            update_progress(count, len(all_files), f"Analysiere: {os.path.basename(file_path)}")
            
            # Inhalt analysieren
            content = get_content(file_path)
            content = enrich_document_content(file_path, content)   
            
            # Jahr und Kategorie erkennen
            year_label = detect_year(content, ollama_params, config)
            cat_label = detect_category(content, custom_cats, ollama_params, config)
            
            # Überprüfe, ob das Jahr in der Zukunft liegt
            try:
                detected_year = int(year_label)
                if detected_year > current_year:
                    year_label = str(current_year)
                    cat_label += " (korrigiertes Jahr)"
            except ValueError:
                pass
            
            # Zielverzeichnis bestimmen
            if cat_label in custom_cats:
                rel_path = os.path.join(year_label, cat_label)
            else:
                rel_path = NOT_ASSIGNABLE_FOLDER
            
            destination_dir = os.path.join(target_folder, rel_path)
            
            # Datensatz speichern
            file_data.append({
                "source_file": file_path,
                "filename": os.path.basename(file_path),
                "year": year_label,
                "category": cat_label,
                "destination": destination_dir
            })
            
        except Exception as e:
            log(f"Fehler bei Datei {os.path.basename(file_path)}: {e}", "error")
        
        count += 1
        update_progress(count, len(all_files))
    
    # Fertig
    update_progress(0, 0)
    log("Vorschau abgeschlossen - keine Dateien wurden verschoben.", "success")
    
    return file_data

def sort_files_by_year_and_category(source_folder, target_folder, custom_cats, 
                                   ollama_params, config=None, log_callback=None,
                                   progress_callback=None, status_callback=None):
    """
    Sortiert Dateien nach Jahr und Kategorie in einer strukturierten Verzeichnishierarchie
    
    Args:
        source_folder: Pfad zum Quellordner
        target_folder: Pfad zum Zielordner
        custom_cats: Liste der benutzerdefinierten Kategorien
        ollama_params: Parameter für Ollama
        config: Konfiguration
        log_callback: Funktion für Log-Meldungen
        progress_callback: Funktion für Fortschrittsanzeige
        status_callback: Funktion für Statusanzeige
        
    Returns:
        (moved_count, error_count) - Anzahl verschobener und fehlerhafter Dateien
    """
    global abort_flag
    abort_flag = False
    all_files = []
    
    # Hilfsfunktionen für Callbacks
    def log(msg, level="info"):
        if log_callback:
            log_callback(msg, level)
        else:
            print(f"[{level.upper()}] {msg}")
    
    def update_progress(value=None, maximum=None, text=None):
        if progress_callback:
            progress_callback(value, maximum, text)
    
    def update_status(text):
        if status_callback:
            status_callback(text)
    
    # Dateien sammeln
    log("Sammle Dateien für Sortierung...")
    update_status("Sammle Dateien...")
    
    for root_dir, dirs, files in os.walk(source_folder):
        for file in files:
            all_files.append(os.path.join(root_dir, file))
    
    update_status("")
    
    if not all_files:
        log("Keine Dateien im ausgewählten Quellordner gefunden.", "warning")
        return 0, 0
    
    log(f"Insgesamt {len(all_files)} Dateien gefunden")
    update_progress(0, len(all_files))
    
    # Aktuelles Jahr für Validierung
    current_year = datetime.now().year
    
    # Zielverzeichnis erstellen, falls es nicht existiert
    if not os.path.exists(target_folder):
        os.makedirs(target_folder)
        log(f"Zielverzeichnis erstellt: {target_folder}", "success")
    
    # Ordner für nicht zuordenbare Dokumente erstellen
    not_assignable_dir = os.path.join(target_folder, NOT_ASSIGNABLE_FOLDER)
    if not os.path.exists(not_assignable_dir):
        os.makedirs(not_assignable_dir)
    
    count = 0
    moved_count = 0
    error_count = 0
    
    for file_path in all_files:
        if abort_flag:
            log("Sortierungs-Operation abgebrochen.", "warning")
            break
        
        try:
            # UI aktualisieren
            update_progress(count, len(all_files), f"Verarbeite: {os.path.basename(file_path)}")
            
            # Inhalt analysieren
            content = get_content(file_path)
            content = enrich_document_content(file_path, content)   
            
            # Jahr und Kategorie erkennen
            year_label = detect_year(content, ollama_params, config)
            cat_label = detect_category(content, custom_cats, ollama_params, config)
            
            # Überprüfe, ob das Jahr in der Zukunft liegt
            try:
                detected_year = int(year_label)
                if detected_year > current_year:
                    log(f"Datei {os.path.basename(file_path)} hat ein zukünftiges Jahr ({year_label}). Verwende aktuelles Jahr.", "warning")
                    year_label = str(current_year)
            except ValueError:
                # Falls das Jahr nicht numerisch ist, ignorieren
                pass
            
            # Zielverzeichnisse erstellen
            year_dir = os.path.join(target_folder, year_label)
            if not os.path.exists(year_dir):
                os.makedirs(year_dir)
            
            # Zielordner für Kategorie bestimmen
            if cat_label in custom_cats:
                destination_dir = os.path.join(year_dir, cat_label)
            else:
                # Wenn keine Kategorie zugeordnet werden kann, in nicht_zuordenbar ablegen
                destination_dir = not_assignable_dir
                log(f"Keine passende Kategorie für {os.path.basename(file_path)} gefunden", "warning")
            
            # Zielordner erstellen, falls er nicht existiert
            if not os.path.exists(destination_dir):
                os.makedirs(destination_dir)
            
            # Datei verschieben
            destination_file = os.path.join(destination_dir, os.path.basename(file_path))
            
            # Falls Zieldatei bereits existiert, Namen anpassen
            if os.path.exists(destination_file):
                base, ext = os.path.splitext(os.path.basename(file_path))
                timestamp = time.strftime("%Y%m%d_%H%M%S")
                new_filename = f"{base}_{timestamp}{ext}"
                destination_file = os.path.join(destination_dir, new_filename)
                log(f"Zieldatei existiert bereits, verwende: {new_filename}", "warning")
            
            os.rename(file_path, destination_file)
            
            # Bestimmung des relativen Pfads zum Zielordner für übersichtlichere Logmeldungen
            rel_path = os.path.relpath(destination_dir, target_folder)
            log(f"Datei '{os.path.basename(file_path)}' ➔ '{rel_path}' verschoben", "success")
            moved_count += 1
            
        except Exception as e:
            log(f"Fehler bei Datei {os.path.basename(file_path)}: {e}", "error")
            error_count += 1
        
        count += 1
        update_progress(count, len(all_files))
    
    # Fertig
    update_progress(0, 0)
    log(f"Sortierung abgeschlossen: {moved_count} Dateien verschoben, {error_count} Fehler", 
       "success" if error_count == 0 else "warning")
    
    return moved_count, error_count