SQLiteViewer.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
SQLite Viewer - Vollständiger Datenbank-Browser
================================================

Features:
- Datenbank öffnen und durchsuchen
- Schema-Ansicht (CREATE TABLE Statements)
- CSV/Excel Export
- Volltext-Suche
- SQL-Editor mit Ausführung
- Sortierung und Filterung
"""

import os
import sys
import re
import json
import math
import base64
import csv
import sqlite3
from pathlib import Path
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from datetime import datetime
from typing import List, Tuple, Any
from translator import TranslationSystem
from export_atomic import atomic_export, database_files

APP_TITLE = "SQLite Viewer Pro"
APP_VERSION = "2.1.0"
DEFAULT_LIMIT = 1000
APP_ICON_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "SQLiteViewer.ico")
_CSV_FORMULA_PREFIXES = ("=", "+", "-", "@")
_CSV_IGNORABLE_PREFIX = "".join(chr(code) for code in range(0x21)) + "\ufeff"


def _csv_safe_value(value: Any):
    """Neutralisiert Stringwerte, die Tabellenkalkulationen als Formel deuten können."""
    if not isinstance(value, str):
        return value
    effective = value.lstrip(_CSV_IGNORABLE_PREFIX)
    if value.startswith(("\t", "\r")) or effective.startswith(_CSV_FORMULA_PREFIXES):
        return "'" + value
    return value


class ToolTip:
    """Barrierefreies, leichtgewichtiges Tooltip-Widget für Tkinter-Komponenten.
    Unterstützt Maus-Hover (<Enter>/<Leave>), Tastaturfokus (<FocusIn>/<FocusOut>),
    Schließen via <Escape> (WCAG 2.1 AA 1.4.13) und Statusleisten-Rückmeldung.
    """

    def __init__(self, widget: tk.Widget, text: str = "", app: Any = None, status_text: str | None = None):
        self.widget = widget
        self.text = text
        self.status_text = status_text if status_text is not None else text
        self.app = app
        self.tip_window: tk.Toplevel | None = None
        self.widget.bind("<Enter>", self.show_tip, add="+")
        self.widget.bind("<Leave>", self.hide_tip, add="+")
        self.widget.bind("<FocusIn>", self._on_focus_in, add="+")
        self.widget.bind("<FocusOut>", self._on_focus_out, add="+")
        self.widget.bind("<ButtonPress>", self.hide_tip, add="+")
        self.widget.bind("<Escape>", self.hide_tip, add="+")

    def set_text(self, text: str, status_text: str | None = None) -> None:
        self.text = text
        if status_text is not None:
            self.status_text = status_text
        if self.tip_window and self.tip_window.winfo_exists():
            for child in self.tip_window.winfo_children():
                if isinstance(child, tk.Label):
                    child.config(text=self.text)

    def _on_focus_in(self, event: Any = None) -> None:
        if self.app and hasattr(self.app, "_set_status") and self.status_text:
            self.app._set_status(self.status_text)
        self.show_tip(event)

    def _on_focus_out(self, event: Any = None) -> None:
        self.hide_tip(event)

    def show_tip(self, event: Any = None) -> None:
        if self.tip_window or not self.text:
            return
        try:
            x = self.widget.winfo_rootx() + 20
            y = self.widget.winfo_rooty() + self.widget.winfo_height() + 5
        except Exception:
            return

        try:
            self.tip_window = tw = tk.Toplevel(self.widget)
            tw.wm_overrideredirect(True)
            tw.wm_geometry(f"+{x}+{y}")
            tw.bind("<Escape>", self.hide_tip)
            try:
                tw.attributes("-topmost", True)
            except Exception:
                pass

            label = tk.Label(
                tw,
                text=self.text,
                justify=tk.LEFT,
                background="#2c3e50",
                foreground="#ffffff",
                relief=tk.SOLID,
                borderwidth=1,
                font=("Segoe UI" if os.name == "nt" else "Arial", 9),
                padx=8,
                pady=4,
            )
            label.pack(ipadx=1)
        except Exception:
            self.tip_window = None

    def hide_tip(self, event: Any = None) -> None:
        if self.tip_window:
            try:
                self.tip_window.destroy()
            except Exception:
                pass
            self.tip_window = None


class SqlViewer(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title(f"{APP_TITLE} v{APP_VERSION}")
        self.geometry("1200x800")
        self.minsize(800, 600)
        if os.path.exists(APP_ICON_PATH):
            try:
                self.iconbitmap(default=APP_ICON_PATH)
            except tk.TclError:
                pass

        # Settings & I18N
        self.settings = self._load_settings()
        saved_lang = self.settings.get("language")
        if not saved_lang or saved_lang not in TranslationSystem.SUPPORTED_LANGUAGES:
            saved_lang = self._detect_system_language()
        self.current_language = saved_lang
        self.translator = TranslationSystem(default_lang=self.current_language, app_dir=Path(__file__).parent)

        # State
        self.conn: sqlite3.Connection | None = None
        self.db_path: str | None = None
        self.current_columns: List[str] = []
        self.current_data: List[Tuple] = []
        self.export_context: dict[str, Any] = {}
        self.sql_result_columns: List[str] = []
        self.sql_result_data: List[Tuple] = []
        self.sql_result_export_context: dict[str, Any] = {}
        self.sort_column: str | None = None
        self.sort_reverse: bool = False
        self._tooltips: List[Tuple[Any, str, str]] = []

        # UI
        self._build_menu()
        self._build_toolbar()
        self._build_notebook()
        self._build_statusbar()

        # Styling
        self._setup_styles()
        self._update_export_actions()

        # BUG 4: Sauberes Schließen via WM_DELETE_WINDOW
        self.protocol("WM_DELETE_WINDOW", self._on_close)

    def _add_tooltip(self, widget: tk.Widget, text_key: str, status_key: str | None = None) -> ToolTip:
        """Erzeugt einen barrierefreien ToolTip und registriert ihn für dynamische Sprachaktualisierung."""
        s_key = status_key or text_key
        tip = ToolTip(widget, text=self.tr(text_key), app=self, status_text=self.tr(s_key))
        if not hasattr(self, "_tooltips"):
            self._tooltips = []
        self._tooltips.append((tip, text_key, s_key))
        return tip

    def _switch_tab(self, index: int):
        """Wechselt barrierefrei den Notebook-Reiter."""
        if hasattr(self, "notebook") and self.notebook:
            try:
                self.notebook.select(index)
            except Exception:
                pass

    def show_shortcuts_help(self):
        """Zeigt ein barrierefreies modales Dialogfenster mit allen Tastaturkürzeln und WCAG-Hinweisen."""
        title = self.tr("Tastaturkürzel & Barrierefreiheit")
        text = (
            f"{APP_TITLE} v{APP_VERSION} – {self.tr('Tastaturkürzel & Barrierefreiheit')}\n\n"
            f"{self.tr('Globale Tastaturkürzel')}:\n"
            f"• Strg + O        : {self.tr('Datenbank öffnen…')}\n"
            f"• Strg + W        : {self.tr('Datenbank schließen')}\n"
            f"• Strg + E        : {self.tr('Als CSV exportieren…')}\n"
            f"• Strg + Shift + E: {self.tr('Als JSON exportieren…')}\n"
            f"• Strg + F        : {self.tr('Suchen…')}\n"
            f"• Strg + A        : {self.tr('Alle auswählen')}\n"
            f"• F5              : {self.tr('Aktualisieren')}\n"
            f"• F9              : {self.tr('▶ Ausführen (F9)')}\n"
            f"• Strg + 1        : {self.tr('Daten-Tab')} (📊)\n"
            f"• Strg + 2        : {self.tr('Schema-Tab')} (🔧)\n"
            f"• Strg + 3        : {self.tr('SQL-Editor')} (💻)\n"
            f"• F1              : {self.tr('Tastaturkürzel & Barrierefreiheit…')}\n"
            f"• Shift + F1      : {self.tr('Über…')}\n"
            f"• Strg + Q        : {self.tr('Beenden')}\n\n"
            f"{self.tr('Tastaturnavigation & Screenreader (WCAG 2.1 AA)')}:\n"
            f"• Tab / Shift+Tab : {self.tr('Vorwärts / Rückwärts durch Steuerelemente springen')}\n"
            f"• Alt + Menütaste : {self.tr('Menüs direkt aufrufen (Alt+D Datei, Alt+B Bearbeiten, Alt+A Ansicht, Alt+H Hilfe)')}\n"
            f"• Escape          : {self.tr('Suche leeren oder Tooltip schließen')}\n"
            f"• Statusleiste    : {self.tr('Status- und Zähleranzeigen aktualisieren sich automatisch')}\n"
            f"• Tooltips        : {self.tr('Erscheinen bei Maus-Hover und Tastatur-Fokus')}"
        )
        messagebox.showinfo(title, text)

    def show_about_dialog(self):
        """Zeigt einen barrierefreien Informationsdialog über SQLite Viewer an."""
        title = self.tr("Über SQLite Viewer")
        text = (
            f"{APP_TITLE}\n"
            f"Version {APP_VERSION}\n\n"
            f"{self.tr('Vollständiger Datenbank-Browser für SQLite')}\n"
            f"{self.tr('Lokale Offline-Datenbankverwaltung ohne externe Datenübertragung (Zero-Egress).')}\n\n"
            f"{self.tr('Kernfunktionen')}:\n"
            f"• {self.tr('Datenbanken öffnen, prüfen und durchsuchen')}\n"
            f"• {self.tr('CREATE TABLE Schemata und Indizes analysieren')}\n"
            f"• {self.tr('SQL-Editor mit Syntax-Highlighting und Ausführung (F9)')}\n"
            f"• {self.tr('Atomarer CSV- und JSON-Export mit Schutzrechten')}\n"
            f"• {self.tr('Mehrsprachige Oberfläche (6 Sprachen: DE, EN, ES, ZH, JA, RU)')}\n"
            f"• {self.tr('Barrierefreie Tastaturnavigation & Tooltips (WCAG 2.1 AA)')}\n\n"
            f"Lizenz: MIT\n"
            f"© 2026 lukisch & doc-bricks / file-bricks"
        )
        messagebox.showinfo(title, text)

    def _show_about(self):
        self.show_about_dialog()

    @staticmethod
    def _get_settings_path() -> Path:
        """Ermittelt den Pfad zur sqliteviewer_settings.json im Benutzerprofil (AppData / XDG)."""
        if sys.platform == "win32":
            base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
            cfg_dir = Path(base) / "SQLiteViewer"
        else:
            base = os.environ.get("XDG_CONFIG_HOME") or os.path.expanduser("~/.config")
            cfg_dir = Path(base) / "sqliteviewer"
        try:
            cfg_dir.mkdir(parents=True, exist_ok=True)
        except OSError:
            pass
        return cfg_dir / "sqliteviewer_settings.json"

    def _load_settings(self) -> dict:
        try:
            p = self._get_settings_path()
            if p.exists():
                with open(p, "r", encoding="utf-8") as f:
                    return json.load(f)
        except Exception:
            pass
        return {}

    def _save_settings(self):
        try:
            p = self._get_settings_path()
            p.parent.mkdir(parents=True, exist_ok=True)
            settings = {"language": getattr(self, "current_language", "de")}
            temp_p = p.with_suffix(".tmp")
            with open(temp_p, "w", encoding="utf-8") as f:
                json.dump(settings, f, indent=2)
                f.flush()
                os.fsync(f.fileno())
            os.replace(temp_p, p)
        except Exception:
            pass

    @staticmethod
    def _detect_system_language() -> str:
        """Erkennt die Systemsprache und mappt sie auf unterstützte Codes (de, en, es, zh, ja, ru)."""
        import locale
        try:
            loc = locale.getlocale()[0] or os.environ.get("LANG", "") or ""
            loc = loc.lower()
            if loc.startswith("de"):
                return "de"
            elif loc.startswith("es"):
                return "es"
            elif loc.startswith("zh"):
                return "zh"
            elif loc.startswith("ja"):
                return "ja"
            elif loc.startswith("ru"):
                return "ru"
            elif loc.startswith("en"):
                return "en"
        except Exception:
            pass
        return "de"

    def tr(self, key: str) -> str:
        """Uebersetzt einen Key via TranslationSystem mit sicherem Fallback."""
        tr_sys = getattr(self, "translator", None)
        if tr_sys is not None and hasattr(tr_sys, "t"):
            return tr_sys.t(key)
        return key

    def change_language(self, lang_code: str):
        """Wechselt die aktive Sprache, persistiert sie und aktualisiert die UI."""
        if hasattr(self, "translator") and self.translator and lang_code in TranslationSystem.SUPPORTED_LANGUAGES:
            self.current_language = lang_code
            self.translator.set_language(lang_code)
            if hasattr(self, "lang_var") and self.lang_var:
                self.lang_var.set(lang_code)
            self._save_settings()
            self.retranslate_ui()
            self._set_status(f"{self.tr('Sprache geändert')}: {lang_code.upper()}")

    def retranslate_ui(self):
        """Aktualisiert alle UI-Texte dynamisch zur Laufzeit ohne Neustart."""
        # 1. Fenstertitel
        try:
            self.title(f"{APP_TITLE} v{APP_VERSION}")
        except Exception:
            pass

        # 2. Menüleiste
        if hasattr(self, "menubar") and self.menubar:
            try:
                self.menubar.entryconfigure(1, label=self.tr("Datei"))
                self.menubar.entryconfigure(2, label=self.tr("Bearbeiten"))
                self.menubar.entryconfigure(3, label=self.tr("Ansicht"))
                self.menubar.entryconfigure(4, label=self.tr("Hilfe"))
            except Exception:
                pass

        # Datei-Menü
        if hasattr(self, "file_menu") and self.file_menu:
            try:
                self.file_menu.entryconfigure(0, label=self.tr("Datenbank öffnen…"))
                self.file_menu.entryconfigure(1, label=self.tr("Datenbank schließen"))
                self.file_menu.entryconfigure(6, label=self.tr("Beenden"))
            except Exception:
                pass

        # Bearbeiten-Menü
        if hasattr(self, "edit_menu") and self.edit_menu:
            try:
                self.edit_menu.entryconfigure(0, label=self.tr("Suchen…"))
                self.edit_menu.entryconfigure(1, label=self.tr("Alle auswählen"))
                self.edit_menu.entryconfigure(3, label=self.tr("Aktualisieren"))
            except Exception:
                pass

        # Ansicht-Menü
        if hasattr(self, "view_menu") and self.view_menu:
            try:
                self.view_menu.entryconfigure(0, label=self.tr("Daten-Tab"))
                self.view_menu.entryconfigure(1, label=self.tr("Schema-Tab"))
                self.view_menu.entryconfigure(2, label=self.tr("SQL-Editor"))
                self.view_menu.entryconfigure(4, label=self.tr("Sprache"))
            except Exception:
                pass

        # Hilfe-Menü
        if hasattr(self, "help_menu") and self.help_menu:
            try:
                self.help_menu.entryconfigure(0, label=self.tr("Über…"))
                self.help_menu.entryconfigure(1, label=self.tr("Tastaturkürzel & Barrierefreiheit…"))
            except Exception:
                pass

        # 3. Toolbar
        if hasattr(self, "table_label") and self.table_label:
            try:
                self.table_label.configure(text=self.tr("Tabelle:"))
            except Exception:
                pass
        if hasattr(self, "limit_label") and self.limit_label:
            try:
                self.limit_label.configure(text=self.tr("Limit:"))
            except Exception:
                pass
        if hasattr(self, "search_label") and self.search_label:
            try:
                self.search_label.configure(text=self.tr("Suche:"))
            except Exception:
                pass
        if hasattr(self, "refresh_button") and self.refresh_button:
            try:
                self.refresh_button.configure(text=self.tr("⟳ Aktualisieren"))
            except Exception:
                pass

        # Export Button & Menu
        try:
            self._update_export_actions()
        except Exception:
            pass

        # 4. Tabs (Notebook)
        if hasattr(self, "notebook") and self.notebook:
            try:
                self.notebook.tab(0, text=self.tr("📊 Daten"))
                self.notebook.tab(1, text=self.tr("🔧 Schema"))
                self.notebook.tab(2, text=self.tr("💻 SQL-Editor"))
            except Exception:
                pass

        # 5. Schema Tab
        if hasattr(self, "schema_table_label") and self.schema_table_label:
            try:
                self.schema_table_label.configure(text=self.tr("Tabelle:"))
            except Exception:
                pass
        if hasattr(self, "schema_all_btn") and self.schema_all_btn:
            try:
                self.schema_all_btn.configure(text=self.tr("Alle Schemas anzeigen"))
            except Exception:
                pass

        # 6. SQL Editor Tab
        if hasattr(self, "sql_input_frame") and self.sql_input_frame:
            try:
                self.sql_input_frame.configure(text=self.tr("SQL-Query"))
            except Exception:
                pass
        if hasattr(self, "sql_run_btn") and self.sql_run_btn:
            try:
                self.sql_run_btn.configure(text=self.tr("▶ Ausführen (F9)"))
            except Exception:
                pass
        if hasattr(self, "sql_clear_btn") and self.sql_clear_btn:
            try:
                self.sql_clear_btn.configure(text=self.tr("🗑 Leeren"))
            except Exception:
                pass
        if hasattr(self, "sql_result_frame") and self.sql_result_frame:
            try:
                self.sql_result_frame.configure(text=self.tr("Ergebnis"))
            except Exception:
                pass

        # 7. Statusbar
        if hasattr(self, "status_var") and self.status_var:
            try:
                curr = self.status_var.get()
                if curr in ["Bereit", "Ready", "Listo", "就绪", "準備完了", "Готово"]:
                    self.status_var.set(self.tr("Bereit"))
            except Exception:
                pass

        # 8. Tooltips dynamisch aktualisieren
        if hasattr(self, "_tooltips") and self._tooltips:
            for tip, text_key, s_key in self._tooltips:
                try:
                    tip.set_text(self.tr(text_key), self.tr(s_key))
                except Exception:
                    pass

    def _setup_styles(self):
        """Konfiguriere ttk Styles."""
        style = ttk.Style()
        style.configure("Treeview", rowheight=24)
        style.configure("Treeview.Heading", font=('Segoe UI', 9, 'bold'))

    # ==================== MENU ====================
    def _build_menu(self):
        menubar = tk.Menu(self)

        # Datei-Menü (Alt+D)
        self.file_menu = tk.Menu(menubar, tearoff=False)
        self.file_menu.add_command(label=self.tr("Datenbank öffnen…"), command=self.open_db, accelerator="Ctrl+O", underline=0)
        self.file_menu.add_command(label=self.tr("Datenbank schließen"), command=self.close_db, accelerator="Ctrl+W", underline=10)
        self.file_menu.add_separator()
        self.file_menu.add_command(label=self.tr("Als CSV exportieren…"), command=self.export_csv, accelerator="Ctrl+E", underline=4)
        self.export_csv_menu_index = self.file_menu.index("end")
        self.file_menu.add_command(label=self.tr("Als JSON exportieren…"), command=self.export_json, accelerator="Ctrl+Shift+E", underline=4)
        self.export_json_menu_index = self.file_menu.index("end")
        self.file_menu.add_separator()
        self.file_menu.add_command(label=self.tr("Beenden"), command=self._on_close, accelerator="Ctrl+Q", underline=0)
        menubar.add_cascade(label=self.tr("Datei"), menu=self.file_menu, underline=0)

        # Bearbeiten-Menü (Alt+B)
        self.edit_menu = tk.Menu(menubar, tearoff=False)
        self.edit_menu.add_command(label=self.tr("Suchen…"), command=self._focus_search, accelerator="Ctrl+F", underline=0)
        self.edit_menu.add_command(label=self.tr("Alle auswählen"), command=self._select_all, accelerator="Ctrl+A", underline=0)
        self.edit_menu.add_separator()
        self.edit_menu.add_command(label=self.tr("Aktualisieren"), command=self.load_selected_table, accelerator="F5", underline=0)
        menubar.add_cascade(label=self.tr("Bearbeiten"), menu=self.edit_menu, underline=0)

        # Ansicht-Menü (Alt+A)
        self.view_menu = tk.Menu(menubar, tearoff=False)
        self.view_menu.add_command(label=self.tr("Daten-Tab"), command=lambda: self._switch_tab(0), accelerator="Ctrl+1", underline=0)
        self.view_menu.add_command(label=self.tr("Schema-Tab"), command=lambda: self._switch_tab(1), accelerator="Ctrl+2", underline=0)
        self.view_menu.add_command(label=self.tr("SQL-Editor"), command=lambda: self._switch_tab(2), accelerator="Ctrl+3", underline=0)
        self.view_menu.add_separator()

        # Sprach-Untermenü
        self.lang_menu = tk.Menu(self.view_menu, tearoff=False)
        self.lang_var = tk.StringVar(value=getattr(self, "current_language", "de"))
        for code in TranslationSystem.SUPPORTED_LANGUAGES:
            label_text = {
                "de": "Deutsch (DE)",
                "en": "English (EN)",
                "es": "Español (ES)",
                "zh": "中文 (ZH)",
                "ja": "日本語 (JA)",
                "ru": "Русский (RU)",
            }.get(code, code)
            self.lang_menu.add_radiobutton(
                label=label_text,
                variable=self.lang_var,
                value=code,
                command=lambda c=code: self.change_language(c),
            )
        self.view_menu.add_cascade(label=self.tr("Sprache"), menu=self.lang_menu, underline=0)
        menubar.add_cascade(label=self.tr("Ansicht"), menu=self.view_menu, underline=0)

        # Hilfe-Menü (Alt+H)
        self.help_menu = tk.Menu(menubar, tearoff=False)
        self.help_menu.add_command(label=self.tr("Über…"), command=self.show_about_dialog, accelerator="Shift+F1", underline=0)
        self.help_menu.add_command(label=self.tr("Tastaturkürzel & Barrierefreiheit…"), command=self.show_shortcuts_help, accelerator="F1", underline=0)
        menubar.add_cascade(label=self.tr("Hilfe"), menu=self.help_menu, underline=0)

        self.menubar = menubar
        self.config(menu=menubar)

        # Shortcuts
        self.bind_all("<Control-o>", lambda e: self.open_db())
        self.bind_all("<Control-w>", lambda e: self.close_db())
        self.bind_all("<Control-q>", lambda e: self._on_close())
        self.bind_all("<Control-e>", lambda e: self.export_csv())
        self.bind_all("<Control-E>", lambda e: self.export_json())
        self.bind_all("<Control-Shift-E>", lambda e: self.export_json())
        self.bind_all("<Control-Shift-e>", lambda e: self.export_json())
        self.bind_all("<Control-f>", lambda e: self._focus_search())
        self.bind_all("<Control-a>", lambda e: self._select_all())
        self.bind_all("<F5>", lambda e: self.load_selected_table())
        self.bind_all("<F1>", lambda e: self.show_shortcuts_help())
        self.bind_all("<Shift-F1>", lambda e: self.show_about_dialog())
        self.bind_all("<Control-1>", lambda e: self._switch_tab(0))
        self.bind_all("<Control-2>", lambda e: self._switch_tab(1))
        self.bind_all("<Control-3>", lambda e: self._switch_tab(2))

    # ==================== TOOLBAR ====================
    def _build_toolbar(self):
        tr = getattr(self, "tr", lambda k: k)
        add_tip = getattr(self, "_add_tooltip", lambda *args, **kwargs: None)
        bar = ttk.Frame(self, padding=(8, 6))
        bar.pack(side=tk.TOP, fill=tk.X)

        # DB-Pfad
        self.db_label = ttk.Label(bar, text="DB: –", width=40, anchor="w")
        self.db_label.pack(side=tk.LEFT, padx=(0, 10))

        # Tabellen-Auswahl
        self.table_label = ttk.Label(bar, text=tr("Tabelle:"))
        self.table_label.pack(side=tk.LEFT)
        self.table_var = tk.StringVar()
        self.table_combo = ttk.Combobox(bar, textvariable=self.table_var, state="readonly", width=25)
        self.table_combo.pack(side=tk.LEFT, padx=6)
        self.table_combo.bind("<<ComboboxSelected>>", lambda e: self.load_selected_table())
        add_tip(self.table_combo, "Tabelle auswählen")

        # Limit
        self.limit_label = ttk.Label(bar, text=tr("Limit:"))
        self.limit_label.pack(side=tk.LEFT, padx=(10, 0))
        self.limit_var = tk.IntVar(value=DEFAULT_LIMIT)
        self.limit_entry = ttk.Spinbox(bar, from_=1, to=1_000_000, increment=100,
                                        textvariable=self.limit_var, width=8)
        self.limit_entry.pack(side=tk.LEFT, padx=6)
        add_tip(self.limit_entry, "Maximale Zeilenanzahl festlegen (1 bis 1.000.000)")

        # Suchfeld
        self.search_label = ttk.Label(bar, text=tr("Suche:"))
        self.search_label.pack(side=tk.LEFT, padx=(15, 0))
        self.search_var = tk.StringVar()
        self.search_entry = ttk.Entry(bar, textvariable=self.search_var, width=20)
        self.search_entry.pack(side=tk.LEFT, padx=4)
        self.search_entry.bind("<Return>", lambda e: self._search_data())
        self.search_entry.bind("<KeyRelease>", lambda e: self._search_data())
        self.search_entry.bind("<Escape>", self._clear_search)
        add_tip(self.search_entry, "Volltextsuche in aktiver Tabelle (Eingabe / Escape zum Leeren)")

        # Buttons
        self.refresh_button = ttk.Button(bar, text=tr("⟳ Aktualisieren"), command=self.load_selected_table, width=13)
        self.refresh_button.pack(side=tk.LEFT, padx=4)
        add_tip(self.refresh_button, "Tabelle und Daten neu laden (F5)")

        self.export_button = ttk.Button(bar, text=tr("📋 Export"), command=self.export_csv)
        self.export_button.pack(side=tk.LEFT, padx=4)
        add_tip(self.export_button, "Aktive Daten exportieren (Strg+E / Menü)")

    # ==================== NOTEBOOK (Tabs) ====================
    def _build_notebook(self):
        self.notebook = ttk.Notebook(self)
        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
        self.notebook.bind("<<NotebookTabChanged>>", lambda _event: self._update_export_actions())

        # Tab 1: Daten
        self.data_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.data_frame, text="📊 Daten")
        self._build_data_tab()

        # Tab 2: Schema
        self.schema_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.schema_frame, text="🔧 Schema")
        self._build_schema_tab()

        # Tab 3: SQL-Editor
        self.sql_frame = ttk.Frame(self.notebook)
        self.notebook.add(self.sql_frame, text="💻 SQL-Editor")
        self._build_sql_tab()

    def _build_data_tab(self):
        """Daten-Tab mit Treeview."""
        container = ttk.Frame(self.data_frame)
        container.pack(fill=tk.BOTH, expand=True)

        # Treeview
        self.tree = ttk.Treeview(container, show="headings", selectmode="extended")
        self.tree["columns"] = ()

        # Scrollbars
        vsb = ttk.Scrollbar(container, orient="vertical", command=self.tree.yview)
        hsb = ttk.Scrollbar(container, orient="horizontal", command=self.tree.xview)
        self.tree.configure(yscrollcommand=vsb.set, xscrollcommand=hsb.set)

        # Layout
        self.tree.grid(row=0, column=0, sticky="nsew")
        vsb.grid(row=0, column=1, sticky="ns")
        hsb.grid(row=1, column=0, sticky="ew")
        container.grid_rowconfigure(0, weight=1)
        container.grid_columnconfigure(0, weight=1)

    def _build_schema_tab(self):
        """Schema-Tab mit CREATE TABLE Statements."""
        # Toolbar
        tr = getattr(self, "tr", lambda k: k)
        add_tip = getattr(self, "_add_tooltip", lambda *args, **kwargs: None)
        toolbar = ttk.Frame(self.schema_frame, padding=5)
        toolbar.pack(fill=tk.X)

        self.schema_table_label = ttk.Label(toolbar, text=tr("Tabelle:"))
        self.schema_table_label.pack(side=tk.LEFT)
        self.schema_table_var = tk.StringVar()
        self.schema_combo = ttk.Combobox(toolbar, textvariable=self.schema_table_var,
                                          state="readonly", width=30)
        self.schema_combo.pack(side=tk.LEFT, padx=6)
        self.schema_combo.bind("<<ComboboxSelected>>", lambda e: self._load_schema())
        add_tip(self.schema_combo, "Tabelle für Schema-Definition wählen")

        self.schema_all_btn = ttk.Button(toolbar, text=tr("Alle Schemas anzeigen"), command=self._load_all_schemas)
        self.schema_all_btn.pack(side=tk.LEFT, padx=10)
        add_tip(self.schema_all_btn, "Alle CREATE TABLE Schemata anzeigen")

        # Text-Widget für Schema
        text_frame = ttk.Frame(self.schema_frame)
        text_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        self.schema_text = tk.Text(text_frame, wrap=tk.NONE, font=("Consolas", 10),
                                    bg="#1e1e1e", fg="#d4d4d4", insertbackground="white")
        schema_vsb = ttk.Scrollbar(text_frame, orient="vertical", command=self.schema_text.yview)
        schema_hsb = ttk.Scrollbar(text_frame, orient="horizontal", command=self.schema_text.xview)
        self.schema_text.configure(yscrollcommand=schema_vsb.set, xscrollcommand=schema_hsb.set)

        self.schema_text.grid(row=0, column=0, sticky="nsew")
        schema_vsb.grid(row=0, column=1, sticky="ns")
        schema_hsb.grid(row=1, column=0, sticky="ew")
        text_frame.grid_rowconfigure(0, weight=1)
        text_frame.grid_columnconfigure(0, weight=1)

        # Syntax Highlighting Tags
        self.schema_text.tag_configure("keyword", foreground="#569cd6")
        self.schema_text.tag_configure("type", foreground="#4ec9b0")
        self.schema_text.tag_configure("string", foreground="#ce9178")
        self.schema_text.tag_configure("comment", foreground="#6a9955")

    def _build_sql_tab(self):
        """SQL-Editor Tab."""
        # Splitter
        paned = ttk.PanedWindow(self.sql_frame, orient=tk.VERTICAL)
        paned.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        # SQL-Eingabe
        tr = getattr(self, "tr", lambda k: k)
        add_tip = getattr(self, "_add_tooltip", lambda *args, **kwargs: None)
        self.sql_input_frame = ttk.LabelFrame(paned, text=tr("SQL-Query"), padding=5)
        paned.add(self.sql_input_frame, weight=1)

        self.sql_text = tk.Text(self.sql_input_frame, wrap=tk.NONE, font=("Consolas", 11),
                                 bg="#1e1e1e", fg="#d4d4d4", insertbackground="white", height=8)
        sql_vsb = ttk.Scrollbar(self.sql_input_frame, orient="vertical", command=self.sql_text.yview)
        self.sql_text.configure(yscrollcommand=sql_vsb.set)

        self.sql_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        sql_vsb.pack(side=tk.RIGHT, fill=tk.Y)

        # SQL Tags
        self.sql_text.tag_configure("keyword", foreground="#569cd6")
        self.sql_text.bind("<KeyRelease>", self._highlight_sql)

        # Buttons
        btn_frame = ttk.Frame(self.sql_frame, padding=5)
        btn_frame.pack(fill=tk.X)

        self.sql_run_btn = ttk.Button(btn_frame, text=tr("▶ Ausführen (F9)"), command=self.execute_sql)
        self.sql_run_btn.pack(side=tk.LEFT, padx=5)
        add_tip(self.sql_run_btn, "SQL-Abfrage ausführen (F9)")

        self.sql_clear_btn = ttk.Button(btn_frame, text=tr("🗑 Leeren"), command=lambda: self.sql_text.delete("1.0", tk.END))
        self.sql_clear_btn.pack(side=tk.LEFT)
        add_tip(self.sql_clear_btn, "SQL-Eingabe leeren")

        self.sql_status = ttk.Label(btn_frame, text="")
        self.sql_status.pack(side=tk.RIGHT, padx=10)

        self.bind_all("<F9>", lambda e: self.execute_sql())

        # Ergebnis
        self.sql_result_frame = ttk.LabelFrame(paned, text=tr("Ergebnis"), padding=5)
        paned.add(self.sql_result_frame, weight=2)

        self.sql_result_tree = ttk.Treeview(self.sql_result_frame, show="headings")
        result_vsb = ttk.Scrollbar(self.sql_result_frame, orient="vertical", command=self.sql_result_tree.yview)
        result_hsb = ttk.Scrollbar(self.sql_result_frame, orient="horizontal", command=self.sql_result_tree.xview)
        self.sql_result_tree.configure(yscrollcommand=result_vsb.set, xscrollcommand=result_hsb.set)

        self.sql_result_tree.grid(row=0, column=0, sticky="nsew")
        result_vsb.grid(row=0, column=1, sticky="ns")
        result_hsb.grid(row=1, column=0, sticky="ew")
        self.sql_result_frame.grid_rowconfigure(0, weight=1)
        self.sql_result_frame.grid_columnconfigure(0, weight=1)

    def _build_statusbar(self):
        """Status-Leiste unten."""
        self.statusbar = ttk.Frame(self, padding=(5, 2))
        self.statusbar.pack(side=tk.BOTTOM, fill=tk.X)

        self.status_var = tk.StringVar(value=self.tr("Bereit"))
        ttk.Label(self.statusbar, textvariable=self.status_var, anchor="w").pack(side=tk.LEFT, fill=tk.X, expand=True)

        self.row_count_var = tk.StringVar(value="")
        ttk.Label(self.statusbar, textvariable=self.row_count_var, anchor="e").pack(side=tk.RIGHT)

    # ==================== DATABASE OPERATIONS ====================
    def open_db(self):
        path = filedialog.askopenfilename(
            title="SQLite-Datenbank öffnen",
            filetypes=[("SQLite DB", "*.db *.sqlite *.sqlite3"), ("Alle Dateien", "*.*")]
        )
        if not path:
            return
        self.open_db_path(path)

    def open_db_path(self, path: str):
        if not path:
            return

        try:
            # Path wird als echtes file://-URI kodiert, damit Sonderzeichen wie
            # "#" oder Leerzeichen nicht als URI-Markup fehlinterpretiert werden.
            conn = sqlite3.connect(f"{Path(path).resolve().as_uri()}?mode=ro", uri=True)
            conn.row_factory = sqlite3.Row
            self.close_db()
            self.conn = conn
            self.db_path = path
            self.db_label.config(text=f"DB: {os.path.basename(path)}")
            self._set_status(f"Verbunden: {path}")
            self._load_tables()
        except Exception as e:
            messagebox.showerror("Fehler beim Öffnen", str(e))
            self._set_status("Fehler")

    def close_db(self):
        if self.conn is not None:
            try:
                self.conn.close()
            except sqlite3.Error:
                pass
            self.conn = None
            self.db_path = None
            self.db_label.config(text="DB: –")
            self.current_columns = []
            self.current_data = []
            self.export_context = {}
            self.sql_result_columns = []
            self.sql_result_data = []
            self.sql_result_export_context = {}
            self.sort_column = None
            self.sort_reverse = False
            if hasattr(self, "search_var"):
                self.search_var.set("")
            if hasattr(self, "table_var"):
                self.table_var.set("")
            if hasattr(self, "schema_table_var"):
                self.schema_table_var.set("")
            if hasattr(self, "row_count_var"):
                self.row_count_var.set("")
            if hasattr(self, "sql_status"):
                self.sql_status.config(text="")
            self._clear_tree()
            self._clear_sql_result()
            self._clear_schema_text()
            self.table_combo["values"] = []
            self.schema_combo["values"] = []
            SqlViewer._update_export_actions(self)
            self._set_status("Datenbank geschlossen")

    def _load_tables(self, selected_table: str | None = None):
        if not self.conn:
            return
        try:
            cur = self.conn.execute(
                "SELECT name FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name"
            )
            tables = [r[0] for r in cur.fetchall()]
            self.table_combo["values"] = tables
            self.schema_combo["values"] = tables

            if tables:
                target_table = selected_table if selected_table in tables else tables[0]
                self.table_combo.set(target_table)
                self.schema_combo.set(target_table)
                self.load_selected_table()
                self._load_schema()
            else:
                self.table_combo.set("")
                self.schema_combo.set("")
                if hasattr(self, "schema_table_var"):
                    self.schema_table_var.set("")
                self.current_columns = []
                self.current_data = []
                self.export_context = {}
                self.sort_column = None
                self.sort_reverse = False
                if hasattr(self, "row_count_var"):
                    self.row_count_var.set("")
                self._clear_tree()
                self._clear_schema_text()
                self._update_export_actions()
                self._set_status("Keine Tabellen gefunden")
        except Exception as e:
            messagebox.showerror("Fehler", f"Tabellen konnten nicht geladen werden:\n{e}")

    def load_selected_table(self):
        table = self.table_var.get()
        if not table or not self.conn:
            return

        try:
            limit = max(1, int(self.limit_var.get()))
        except (ValueError, TypeError, tk.TclError):  # Bugsweep 23: leere/ungueltige Spinbox -> TclError
            limit = DEFAULT_LIMIT

        try:
            # Spalten bestimmen
            cur = self.conn.execute(f"PRAGMA table_info({self._ident(table)})")
            cols = [row[1] for row in cur.fetchall()]
            if not cols:
                self._clear_tree()
                self._set_status("Tabelle hat keine Spalten")
                return

            # Sortierung
            if self.sort_column and self.sort_column not in cols:
                self.sort_column = None
                self.sort_reverse = False

            order_clause = ""
            if self.sort_column and self.sort_column in cols:
                direction = "DESC" if self.sort_reverse else "ASC"
                order_clause = f" ORDER BY {self._ident(self.sort_column)} {direction}"

            # Daten holen
            query = f"SELECT * FROM {self._ident(table)}{order_clause} LIMIT ?"
            cur = self.conn.execute(query, (limit,))
            rows = cur.fetchall()
            self._set_current_view_data(cols, rows)
            self._set_export_context(
                view="table",
                table=table,
                query=None,
                row_limit=limit,
                search_term=None,
                sort_column=self.sort_column,
                sort_descending=self.sort_reverse,
            )

            self._populate_tree(cols, rows)
            self._update_export_actions()

            # Zähle Gesamtzeilen
            count_cur = self.conn.execute(f"SELECT COUNT(*) FROM {self._ident(table)}")
            total = count_cur.fetchone()[0]

            self._set_status(f"Tabelle: {table}")
            self.row_count_var.set(f"Zeilen: {len(rows)} / {total}")

        except Exception as e:
            messagebox.showerror("Fehler beim Laden", str(e))

    # ==================== SCHEMA ====================
    def _load_schema(self):
        table = self.schema_table_var.get()
        if not table or not self.conn:
            return

        try:
            cur = self.conn.execute(
                "SELECT sql FROM sqlite_master WHERE type IN ('table', 'view') AND name=?", (table,)
            )
            result = cur.fetchone()
            if result and result[0]:
                self.schema_text.config(state=tk.NORMAL)
                self.schema_text.delete("1.0", tk.END)
                self.schema_text.insert("1.0", result[0])
                self._highlight_schema()
                self.schema_text.config(state=tk.DISABLED)

                # Zusätzliche Infos
                info = self._get_table_info(table)
                self.schema_text.config(state=tk.NORMAL)
                self.schema_text.insert(tk.END, f"\n\n-- Tabellen-Info --\n{info}")
                self.schema_text.config(state=tk.DISABLED)

        except Exception as e:
            messagebox.showerror("Fehler", str(e))

    def _load_all_schemas(self):
        if not self.conn:
            return

        try:
            cur = self.conn.execute(
                "SELECT name, sql FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name"
            )
            schemas = cur.fetchall()

            self.schema_text.config(state=tk.NORMAL)
            self.schema_text.delete("1.0", tk.END)

            for name, sql in schemas:
                if sql:
                    self.schema_text.insert(tk.END, f"-- {name} --\n{sql};\n\n")

            self._highlight_schema()
            self.schema_text.config(state=tk.DISABLED)

        except Exception as e:
            messagebox.showerror("Fehler", str(e))

    def _get_table_info(self, table: str) -> str:
        """Holt zusätzliche Tabelleninformationen."""
        info_parts = []
        if not self.conn:
            return ""

        # Spalteninfo
        try:
            cur = self.conn.execute(f"PRAGMA table_info({self._ident(table)})")
            try:
                columns = cur.fetchall()
                info_parts.append(f"Spalten: {len(columns)}")
            finally:
                cur.close()
        except Exception:
            pass

        # Zeilenanzahl
        try:
            cur = self.conn.execute(f"SELECT COUNT(*) FROM {self._ident(table)}")
            try:
                count = cur.fetchone()[0]
                info_parts.append(f"Zeilen: {count}")
            finally:
                cur.close()
        except Exception:
            pass

        # Indizes
        try:
            cur = self.conn.execute(f"PRAGMA index_list({self._ident(table)})")
            try:
                indexes = cur.fetchall()
                if indexes:
                    info_parts.append(f"Indizes: {len(indexes)}")
            finally:
                cur.close()
        except Exception:
            pass

        # Foreign Keys
        try:
            cur = self.conn.execute(f"PRAGMA foreign_key_list({self._ident(table)})")
            try:
                fks = cur.fetchall()
                if fks:
                    info_parts.append(f"Foreign Keys: {len(fks)}")
            finally:
                cur.close()
        except Exception:
            pass

        return "\n".join(info_parts)

    def _highlight_schema(self):
        """Syntax-Highlighting für Schema."""
        keywords = ["CREATE", "TABLE", "PRIMARY", "KEY", "NOT", "NULL", "UNIQUE",
                    "DEFAULT", "FOREIGN", "REFERENCES", "INDEX", "ON", "IF", "EXISTS",
                    "AUTOINCREMENT", "CHECK", "CONSTRAINT"]
        types = ["INTEGER", "TEXT", "REAL", "BLOB", "VARCHAR", "CHAR", "BOOLEAN",
                 "DATE", "DATETIME", "TIMESTAMP", "NUMERIC", "FLOAT", "DOUBLE"]

        for keyword in keywords:
            self._highlight_word(self.schema_text, keyword, "keyword")

        for dtype in types:
            self._highlight_word(self.schema_text, dtype, "type")

    def _highlight_word(self, widget, word, tag):
        """Hebt ein Wort im Text-Widget hervor."""
        start = "1.0"
        while True:
            pos = widget.search(r'\m' + word + r'\M', start, tk.END, regexp=True, nocase=True)
            if not pos:
                break
            end = f"{pos}+{len(word)}c"
            widget.tag_add(tag, pos, end)
            start = end

    # ==================== SQL EDITOR ====================
    def execute_sql(self):
        if not self.conn:
            messagebox.showwarning("Warnung", "Keine Datenbank geöffnet.")
            return

        sql = ""
        if hasattr(self.sql_text, "tag_ranges"):
            try:
                if self.sql_text.tag_ranges(tk.SEL):
                    sql = self.sql_text.get(tk.SEL_FIRST, tk.SEL_LAST).strip()
            except (tk.TclError, AttributeError):
                pass
        if not sql:
            sql = self.sql_text.get("1.0", tk.END).strip()
        if not sql:
            return

        try:
            start_time = datetime.now()
            cur = self.conn.execute(sql)

            # sqlite3 signalisiert ergebnisliefernde Statements über description.
            # Das ist robuster als ein Prefix-Check und fängt auch Kommentare
            # vor SELECT/WITH/PRAGMA/EXPLAIN korrekt ab.
            if cur.description is not None:
                rows = cur.fetchall()
                cols = [desc[0] for desc in cur.description]
                SqlViewer._set_sql_result_state(
                    self,
                    cols,
                    rows,
                    view="query",
                    table=self.table_var.get() or None,
                    query=sql,
                    row_limit=None,
                    search_term=None,
                    sort_column=None,
                    sort_descending=None,
                )
                self._populate_sql_result(cols, rows)
                SqlViewer._update_export_actions(self)
                elapsed = (datetime.now() - start_time).total_seconds()
                if rows:
                    self.sql_status.config(text=f"✓ {len(rows)} Zeilen in {elapsed:.3f}s")
                else:
                    self.sql_status.config(text="✓ Keine Ergebnisse")
            else:
                current_table = self.table_var.get()
                self.conn.commit()
                affected = cur.rowcount
                SqlViewer._clear_sql_result_state(self)
                self._clear_sql_result()
                SqlViewer._update_export_actions(self)
                self.sql_status.config(text=f"✓ {affected} Zeilen betroffen")
                self._load_tables(current_table)  # Tabellenliste + aktuelle Auswahl neu laden

        except Exception as e:
            self.sql_status.config(text="✗ Fehler")
            messagebox.showerror("SQL-Fehler", str(e))

    def _populate_sql_result(self, columns: List[str], rows: List[Tuple]):
        """Füllt das SQL-Ergebnis-Treeview."""
        self.sql_result_tree.delete(*self.sql_result_tree.get_children())
        self.sql_result_tree["columns"] = columns

        for c in columns:
            self.sql_result_tree.heading(c, text=c)
            self.sql_result_tree.column(c, width=120, anchor="w")

        for row in rows:
            values = [self._format_value(v) for v in row]
            self.sql_result_tree.insert("", tk.END, values=values)

    def _set_current_view_data(self, columns: List[str], rows: List[Any]):
        """Merkt sich die aktuell sichtbaren Daten fuer Export und Folgeaktionen."""
        self.current_columns = list(columns)
        self.current_data = [tuple(row) for row in rows]

    def _set_export_context(self, **kwargs):
        """Merkt sich Metadaten der aktuellen Ansicht für Export-Companions."""
        self.export_context = dict(kwargs)

    def _set_sql_result_state(self, columns: List[str], rows: List[Any], **kwargs):
        """Merkt sich SQL-Ergebnisse getrennt vom Daten-Tab-Zustand."""
        self.sql_result_columns = list(columns)
        self.sql_result_data = [tuple(row) for row in rows]
        self.sql_result_export_context = dict(kwargs)

    def _clear_sql_result_state(self):
        self.sql_result_columns = []
        self.sql_result_data = []
        self.sql_result_export_context = {}

    def _sql_tab_selected(self) -> bool:
        notebook = getattr(self, "notebook", None)
        if notebook is not None:
            try:
                return notebook.index(notebook.select()) == 2
            except Exception:
                pass

        return bool(getattr(self, "sql_result_columns", [])) and bool(
            getattr(self, "sql_result_export_context", {})
        )

    def _get_export_state(self) -> tuple[list[str], list[tuple], dict[str, Any]]:
        if SqlViewer._sql_tab_selected(self):
            sql_columns = list(getattr(self, "sql_result_columns", []))
            if sql_columns:
                return (
                    sql_columns,
                    list(getattr(self, "sql_result_data", [])),
                    dict(getattr(self, "sql_result_export_context", {}) or {}),
                )

        return (
            list(getattr(self, "current_columns", [])),
            list(getattr(self, "current_data", [])),
            dict(getattr(self, "export_context", {}) or {}),
        )

    def _get_export_action_state(self) -> dict[str, Any]:
        columns, _rows, context = SqlViewer._get_export_state(self)
        has_data = bool(columns)
        source_view = context.get("view") if has_data else None

        if source_view == "query":
            return {
                "enabled": True,
                "button_label": "📋 SQL exportieren",
                "csv_label": "SQL-Ergebnis als CSV exportieren…",
                "json_label": "SQL-Ergebnis als JSON exportieren…",
                "empty_message": "Keine Tabellen- oder SQL-Daten zum Exportieren.",
            }

        if source_view == "table" or has_data:
            return {
                "enabled": True,
                "button_label": "📋 Tabelle exportieren",
                "csv_label": "Tabelle als CSV exportieren…",
                "json_label": "Tabelle als JSON exportieren…",
                "empty_message": "Keine Tabellen- oder SQL-Daten zum Exportieren.",
            }

        return {
            "enabled": False,
            "button_label": "📋 Export",
            "csv_label": "Als CSV exportieren…",
            "json_label": "Als JSON exportieren…",
            "empty_message": "Keine Tabellen- oder SQL-Daten zum Exportieren.",
        }

    def _update_export_actions(self):
        action_state = SqlViewer._get_export_action_state(self)
        button = getattr(self, "export_button", None)
        if button is not None:
            button.configure(
                text=self.tr(action_state["button_label"]),
                state=tk.NORMAL if action_state["enabled"] else tk.DISABLED,
            )

        file_menu = getattr(self, "file_menu", None)
        csv_index = getattr(self, "export_csv_menu_index", None)
        json_index = getattr(self, "export_json_menu_index", None)
        if file_menu is not None and csv_index is not None:
            file_menu.entryconfigure(
                csv_index,
                label=self.tr(action_state["csv_label"]),
                state=tk.NORMAL if action_state["enabled"] else tk.DISABLED,
            )
        if file_menu is not None and json_index is not None:
            file_menu.entryconfigure(
                json_index,
                label=self.tr(action_state["json_label"]),
                state=tk.NORMAL if action_state["enabled"] else tk.DISABLED,
            )

    def _clear_sql_result(self):
        self.sql_result_tree.delete(*self.sql_result_tree.get_children())
        self.sql_result_tree["columns"] = ()

    def _clear_schema_text(self):
        if not hasattr(self, "schema_text"):
            return

        self.schema_text.config(state=tk.NORMAL)
        self.schema_text.delete("1.0", tk.END)
        self.schema_text.config(state=tk.DISABLED)

    def _highlight_sql(self, event=None):
        """Einfaches SQL-Highlighting."""
        keywords = ["SELECT", "FROM", "WHERE", "AND", "OR", "INSERT", "UPDATE",
                    "DELETE", "CREATE", "DROP", "ALTER", "TABLE", "INTO", "VALUES",
                    "SET", "ORDER", "BY", "GROUP", "HAVING", "JOIN", "LEFT", "RIGHT",
                    "INNER", "OUTER", "ON", "AS", "DISTINCT", "LIMIT", "OFFSET",
                    "UNION", "EXCEPT", "INTERSECT", "NULL", "NOT", "IN", "LIKE",
                    "BETWEEN", "EXISTS", "CASE", "WHEN", "THEN", "ELSE", "END"]

        # Entferne alte Tags
        self.sql_text.tag_remove("keyword", "1.0", tk.END)

        for keyword in keywords:
            self._highlight_word(self.sql_text, keyword, "keyword")

    # ==================== EXPORT ====================
    def export_csv(self):
        action_state = SqlViewer._get_export_action_state(self)
        columns, rows, export_context = SqlViewer._get_export_state(self)
        if not action_state["enabled"]:
            messagebox.showwarning("Export", action_state["empty_message"])
            return

        try:
            protected = database_files(self)
        except Exception as e:
            messagebox.showerror("Export-Fehler", str(e))
            return

        table = export_context.get("table") or self.table_var.get() or export_context.get("view") or "export"
        safe_table = re.sub(r'[\\/*?:"<>|]', '_', str(table)).strip(' .') or "export"
        default_name = f"{safe_table}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"

        path = filedialog.asksaveasfilename(
            title="Als CSV exportieren",
            defaultextension=".csv",
            initialfile=default_name,
            filetypes=[("CSV-Dateien", "*.csv"), ("Alle Dateien", "*.*")]
        )

        if not path:
            return

        try:
            protected |= database_files(self)
            with atomic_export(path, protected, newline="", encoding="utf-8-sig",
                               refresh_sources=lambda: database_files(self)) as f:
                writer = csv.writer(f, delimiter=";", quoting=csv.QUOTE_MINIMAL)
                writer.writerow(_csv_safe_value(column) for column in columns)
                # Bugsweep 23: BLOB/bytes base64-kodieren, sonst landet ein b'...'-Rohliteral in der
                # CSV (konsistent mit dem JSON-Export, der BLOBs ebenfalls base64-kodiert).
                writer.writerows(
                    [
                        [
                            (
                                base64.b64encode(v).decode("ascii") if isinstance(v, bytes) else
                                (base64.b64encode(bytes(v)).decode("ascii") if isinstance(v, (bytearray, memoryview)) else _csv_safe_value(v))
                            )
                            for v in row
                        ]
                        for row in rows
                    ]
                )

            self._set_status(f"Exportiert: {os.path.basename(path)}")
            messagebox.showinfo("Export", f"Erfolgreich exportiert:\n{path}\n\n{len(rows)} Zeilen")

        except Exception as e:
            messagebox.showerror("Export-Fehler", str(e))

    def _serialize_export_value(self, value: Any):
        """Konvertiert SQLite-Werte in ein stabiles JSON-kompatibles Format."""
        # Bugsweep 23: nicht-finite Floats (NaN/Inf) -> String. json.dump schreibt sie sonst als
        # NaN/Infinity-Literale, die kein gueltiges JSON sind (RFC 8259) und von vielen Parsern
        # (z.B. JS JSON.parse) abgelehnt werden.
        if isinstance(value, float) and not math.isfinite(value):
            return str(value)
        if value is None or isinstance(value, (str, int, float, bool)):
            return value
        if isinstance(value, (bytes, bytearray, memoryview)):
            raw_bytes = bytes(value)
            return {
                "type": "blob",
                "encoding": "base64",
                "size_bytes": len(raw_bytes),
                "data": base64.b64encode(raw_bytes).decode("ascii"),
            }
        return str(value)

    def _build_export_payload(self) -> dict[str, Any]:
        """Erzeugt den Companion-Export für Web/PWA- oder Review-Workflows."""
        columns, rows, context = SqlViewer._get_export_state(self)
        database_path = self.db_path
        database_name = os.path.basename(database_path) if database_path else None
        result_rows = []

        for row in rows:
            row_dict = {}
            seen_cols: dict[str, int] = {}
            for index, column in enumerate(columns):
                count = seen_cols.get(column, 0)
                seen_cols[column] = count + 1
                col_key = column if count == 0 else f"{column}_{count + 1}"
                val = row[index] if index < len(row) else None
                row_dict[col_key] = SqlViewer._serialize_export_value(self, val)
            result_rows.append(row_dict)

        return {
            "schema_version": "sqliteviewer-export-v1",
            "app_name": APP_TITLE,
            "app_version": APP_VERSION,
            "exported_at": datetime.now().astimezone().isoformat(timespec="seconds"),
            "source": {
                "database_path": database_path,
                "database_name": database_name,
                "view": context.get("view") or "unknown",
                "table": context.get("table"),
                "query": context.get("query"),
                "row_limit": context.get("row_limit"),
                "search_term": context.get("search_term"),
                "sort_column": context.get("sort_column"),
                "sort_descending": context.get("sort_descending"),
            },
            "columns": list(columns),
            "row_count": len(result_rows),
            "result_rows": result_rows,
        }

    def export_json(self):
        action_state = SqlViewer._get_export_action_state(self)
        columns, _rows, export_context = SqlViewer._get_export_state(self)
        if not action_state["enabled"]:
            messagebox.showwarning("Export", action_state["empty_message"])
            return

        try:
            protected = database_files(self)
            payload = self._build_export_payload()
        except Exception as e:
            messagebox.showerror("Export-Fehler", str(e))
            return

        table = export_context.get("table") or self.table_var.get() or export_context.get("view") or "export"
        safe_table = re.sub(r'[\\/*?:"<>|]', '_', str(table)).strip(' .') or "export"
        default_name = f"{safe_table}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        path = filedialog.asksaveasfilename(
            title="Als JSON exportieren",
            defaultextension=".json",
            initialfile=default_name,
            filetypes=[("JSON-Dateien", "*.json"), ("Alle Dateien", "*.*")],
        )

        if not path:
            return

        try:
            protected |= database_files(self)
            with atomic_export(path, protected, encoding="utf-8",
                               refresh_sources=lambda: database_files(self)) as handle:
                json.dump(payload, handle, indent=2, ensure_ascii=False)

            self._set_status(f"Exportiert: {os.path.basename(path)}")
            messagebox.showinfo("Export", f"Erfolgreich exportiert:\n{path}\n\n{payload['row_count']} Zeilen")
        except Exception as e:
            messagebox.showerror("Export-Fehler", str(e))

    # ==================== SEARCH ====================
    def _escape_like_pattern(self, value: str) -> str:
        """Escaped wildcards for LIKE-based search."""
        return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")

    def _search_data(self):
        """Filtert die Daten basierend auf dem Suchbegriff."""
        search_term = (self.search_var.get() or "").strip() if hasattr(self, "search_var") and self.search_var is not None else ""

        if not search_term:
            # Zeige alle Daten
            self.load_selected_table()
            return

        if not self.conn:
            return

        table = self.table_var.get()
        if not table:
            return

        # Suche in allen Spalten
        try:
            try:
                limit = max(1, int(self.limit_var.get()))
            except (ValueError, TypeError, tk.TclError):  # Bugsweep 23: leere/ungueltige Spinbox -> TclError
                limit = DEFAULT_LIMIT

            # Spalten immer per PRAGMA aus der Tabelle holen. self.current_columns kann
            # nach execute_sql() auf Query-Ergebnisspalten zeigen, die nicht in der
            # Tabelle existieren → "no such column"-Fehler (Bugsweep 2026-06-27).
            cur_info = self.conn.execute(f"PRAGMA table_info({self._ident(table)})")
            cols = [row[1] for row in cur_info.fetchall()]
            if not cols:
                return

            conditions = " OR ".join([f"{self._ident(col)} LIKE ? ESCAPE '\\'" for col in cols])
            order_clause = ""
            if self.sort_column and self.sort_column in cols:
                direction = "DESC" if self.sort_reverse else "ASC"
                order_clause = f" ORDER BY {self._ident(self.sort_column)} {direction}"
            query = f"SELECT * FROM {self._ident(table)} WHERE {conditions}{order_clause} LIMIT ?"
            escaped_term = self._escape_like_pattern(search_term)
            params = [f"%{escaped_term}%" for _ in cols]
            params.append(limit)

            cur = self.conn.execute(query, params)
            rows = cur.fetchall()

            self._set_current_view_data(cols, rows)
            self._set_export_context(
                view="table_search",
                table=table,
                query=None,
                row_limit=limit,
                search_term=search_term,
                sort_column=self.sort_column,
                sort_descending=self.sort_reverse,
            )
            self._clear_tree()
            self.tree["columns"] = cols
            for c in cols:
                indicator = ""
                if c == self.sort_column:
                    indicator = " ↓" if self.sort_reverse else " ↑"
                self.tree.heading(c, text=c + indicator, command=lambda col=c: self._sort_by_column(col))
                self.tree.column(c, width=120, anchor="w")

            for row in rows:
                if isinstance(row, sqlite3.Row):
                    values = [self._format_value(row[i]) for i in range(len(cols))]
                elif isinstance(row, (tuple, list)):
                    values = [self._format_value(row[i] if i < len(row) else None) for i in range(len(cols))]
                else:
                    values = [self._format_value(v) for v in row]
                self.tree.insert("", tk.END, values=values)

            if hasattr(self, "_update_export_actions"):
                self._update_export_actions()

            self.row_count_var.set(f"Gefunden: {len(rows)}")

        except Exception as e:
            self._set_status(f"Suchfehler: {e}")

    def _focus_search(self):
        self.search_entry.focus_set()
        self.search_entry.select_range(0, tk.END)

    def _clear_search(self, _event=None):
        """Leert den aktiven Suchfilter, behält den Fokus und lädt die Tabelle neu."""
        if not hasattr(self, "search_var") or self.search_var is None:
            return "break"

        had_search = bool((self.search_var.get() or "").strip())
        self.search_var.set("")

        if hasattr(self, "search_entry") and self.search_entry is not None:
            self.search_entry.focus_set()
            self.search_entry.select_range(0, tk.END)

        if had_search and hasattr(self, "table_var") and (self.table_var.get() or "").strip():
            self.load_selected_table()

        return "break"

    # ==================== SORTING ====================
    def _sort_by_column(self, column: str):
        """Sortiert die Tabelle nach einer Spalte."""
        if self.sort_column == column:
            self.sort_reverse = not self.sort_reverse
        else:
            self.sort_column = column
            self.sort_reverse = False

        search_term = ""
        if hasattr(self, "search_var") and self.search_var is not None:
            search_term = (self.search_var.get() or "").strip()

        if search_term:
            self._search_data()
        else:
            self.load_selected_table()

    # ==================== TREE HELPERS ====================
    def _clear_tree(self):
        self.tree.delete(*self.tree.get_children())
        self.tree["columns"] = ()

    def _populate_tree(self, columns: List[str], rows: List):
        self._clear_tree()

        self.tree["columns"] = columns
        for c in columns:
            # Sortierindikator
            indicator = ""
            if c == self.sort_column:
                indicator = " ↓" if self.sort_reverse else " ↑"

            self.tree.heading(c, text=c + indicator, command=lambda col=c: self._sort_by_column(col))
            self.tree.column(c, width=120, anchor="w")

        for row in rows:
            if isinstance(row, sqlite3.Row):
                values = [self._format_value(row[i]) for i in range(len(columns))]
            elif isinstance(row, (tuple, list)):
                values = [self._format_value(row[i] if i < len(row) else None) for i in range(len(columns))]
            else:
                values = [self._format_value(v) for v in row]
            self.tree.insert("", tk.END, values=values)

    def _format_value(self, value: Any) -> str:
        """Formatiert einen Wert für die Anzeige."""
        if value is None:
            return "NULL"
        if isinstance(value, (bytes, bytearray, memoryview)):
            return f"[BLOB {len(value)} bytes]"
        return str(value)

    def _select_all(self):
        """Wählt alle Zeilen im Treeview aus."""
        self.tree.selection_set(self.tree.get_children())

    # ==================== UTILS ====================
    _SQLITE_KEYWORDS = {
        "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND",
        "AS", "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN",
        "BY", "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN",
        "COMMIT", "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
        "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
        "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
        "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
        "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING",
        "IF", "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY",
        "INNER", "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL",
        "JOIN", "KEY", "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO",
        "NOT", "NOTNULL", "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER",
        "PLAN", "PRAGMA", "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES",
        "REGEXP", "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT",
        "RIGHT", "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE",
        "TEMP", "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION",
        "UNIQUE", "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL",
        "WHEN", "WHERE", "WITH", "WITHOUT"
    }

    def _ident(self, name: str) -> str:
        """Gibt einen sicheren SQLite-Identifier zurück."""
        if not name:
            raise ValueError("Identifier darf nicht leer sein.")

        is_simple = re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", name) is not None
        is_keyword = name.upper() in self._SQLITE_KEYWORDS

        if not is_simple or is_keyword:
            safe_name = name.replace('"', '""')
            return f'"{safe_name}"'

        return name

    def _set_status(self, text: str):
        self.status_var.set(text)

    def _on_close(self):
        """Sauberes Schließen: DB schließen, dann Fenster zerstören."""
        self.close_db()
        self.destroy()

    def _show_about(self):
        messagebox.showinfo(
            "Über SQLite Viewer",
            f"{APP_TITLE}\nVersion {APP_VERSION}\n\n"
            "Features:\n"
            "• Datenbank durchsuchen\n"
            "• Schema-Ansicht\n"
            "• SQL-Editor\n"
            "• CSV-/JSON-Export\n"
            "• Volltext-Suche\n"
            "• Sortierung\n\n"
            "© 2026 lukisch"
        )


if __name__ == "__main__":
    app = SqlViewer()
    if len(sys.argv) > 1:
        app.after(100, lambda: app.open_db_path(sys.argv[1]))
    app.mainloop()