main_window.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""CodeBox Hauptfenster"""

from pathlib import Path
from PySide6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QSplitter,
    QStatusBar, QLabel, QComboBox, QToolBar, QFileDialog,
    QMessageBox, QTabWidget
)
from PySide6.QtCore import Qt, Signal

from core.tabs import TabWidget
from core.output import OutputPanel
from features.terminal import TerminalWidget
from features.project_view import ProjectView
from languages import get_provider_for_extension, get_provider_by_name, get_all_providers
from features.lsp_client import LSPManager
from version import format_window_title
from config import load_settings, save_settings


class MainWindow(QMainWindow):
    """CodeBox Hauptfenster"""

    lspDiagnosticsReceived = Signal(object, list)
    lspCompletionsReceived = Signal(object, list)

    def __init__(self):
        super().__init__()
        self._settings = load_settings()
        self.setWindowTitle(format_window_title())
        self.setGeometry(100, 100, 1200, 800)
        self._lsp_manager = LSPManager()
        self._lsp_tabs_by_uri = {}
        self.lspDiagnosticsReceived.connect(self._apply_lsp_diagnostics)
        self.lspCompletionsReceived.connect(self._apply_lsp_completions)

        self.setup_ui()
        self.setup_shortcuts()
        self._apply_settings()
        self.new_file()

    def setup_ui(self):
        # ---- Menüleiste ----
        menubar = self.menuBar()

        file_menu = menubar.addMenu("Datei")
        file_menu.addAction("Neu", self.new_file, "Ctrl+N")
        file_menu.addAction("Öffnen...", self.open_file, "Ctrl+O")
        file_menu.addAction("Speichern", self.save_file, "Ctrl+S")
        file_menu.addSeparator()
        file_menu.addAction("Beenden", self.close, "Ctrl+Q")

        edit_menu = menubar.addMenu("Bearbeiten")
        edit_menu.addAction("Rückgängig", self._undo, "Ctrl+Z")
        edit_menu.addAction("Wiederherstellen", self._redo, "Ctrl+Y")
        edit_menu.addSeparator()
        edit_menu.addAction("Suchen", self._find, "Ctrl+F")
        edit_menu.addAction("Gehe zu Zeile", self._goto_line, "Ctrl+G")
        edit_menu.addSeparator()
        edit_menu.addAction("Einstellungen...", self.open_settings_dialog, "Ctrl+,")


        run_menu = menubar.addMenu("Ausführen")
        run_menu.addAction("Ausführen", self.run_current, "F5")
        run_menu.addAction("Stoppen", self._stop_run, "Shift+F5")

        # ---- Toolbar ----
        toolbar = QToolBar("Hauptleiste")
        self.addToolBar(toolbar)
        toolbar.addAction("Neu", self.new_file)
        toolbar.addAction("Öffnen", self.open_file)
        toolbar.addAction("Speichern", self.save_file)
        toolbar.addSeparator()
        toolbar.addAction("Ausführen", self.run_current)

        # Sprach-Auswahl in Toolbar
        self.lang_combo = QComboBox()
        self.lang_combo.addItem("(Auto)")
        for p in get_all_providers():
            self.lang_combo.addItem(p.get_name())
        self.lang_combo.currentTextChanged.connect(self._on_language_changed)
        toolbar.addWidget(QLabel("  Sprache: "))
        toolbar.addWidget(self.lang_combo)

        # ---- Ansicht-Menü ----
        view_menu = menubar.addMenu("Ansicht")
        self._toggle_project_action = view_menu.addAction(
            "Projektbaum", self._toggle_project_view, "Ctrl+B"
        )
        self._toggle_terminal_action = view_menu.addAction(
            "Terminal", self._toggle_terminal, "Ctrl+`"
        )

        # Theme-Submenü
        from features.theme_manager import get_available_themes, apply_theme
        theme_menu = view_menu.addMenu("Theme")
        for theme_name in get_available_themes():
            theme_menu.addAction(
                theme_name.capitalize(),
                lambda checked=False, t=theme_name: apply_theme(QApplication.instance(), t)
            )

        # ---- Central Widget ----
        central = QWidget()
        self.setCentralWidget(central)
        layout = QVBoxLayout(central)
        layout.setContentsMargins(0, 0, 0, 0)

        # Horizontaler Splitter: ProjectView | Editor+Output
        self.h_splitter = QSplitter(Qt.Orientation.Horizontal)

        # Linke Seite: Project-View (Dateibaum)
        self.project_view = ProjectView()
        self.project_view.fileDoubleClicked.connect(self._open_file_from_project)
        self.h_splitter.addWidget(self.project_view)

        # Rechte Seite: Vertikaler Splitter (Editor oben, Output/Terminal unten)
        self.v_splitter = QSplitter(Qt.Orientation.Vertical)

        # Tab-Widget (Editor)
        self.tab_widget = TabWidget()
        self.tab_widget.currentFileChanged.connect(self._on_file_changed)
        self.v_splitter.addWidget(self.tab_widget)

        # Unteres Panel: Tabs mit Output und Terminal
        self.bottom_tabs = QTabWidget()
        self.output = OutputPanel()
        self.output.run_btn.clicked.connect(self.run_current)
        self.bottom_tabs.addTab(self.output, "Ausgabe")

        self.terminal = TerminalWidget()
        self.bottom_tabs.addTab(self.terminal, "Terminal")

        self.v_splitter.addWidget(self.bottom_tabs)
        self.v_splitter.setSizes([600, 200])

        self.h_splitter.addWidget(self.v_splitter)
        self.h_splitter.setSizes([220, 980])

        layout.addWidget(self.h_splitter)

        # ---- Statusbar ----
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.pos_label = QLabel("Zeile 1, Spalte 1")
        self.lang_label = QLabel("Keine Sprache")
        self.enc_label = QLabel("UTF-8")
        self.status_bar.addPermanentWidget(self.pos_label)
        self.status_bar.addPermanentWidget(self.lang_label)
        self.status_bar.addPermanentWidget(self.enc_label)

    def setup_shortcuts(self):
        pass  # Shortcuts sind bereits über die Menüleiste definiert

    # ---- Datei-Aktionen ----

    def new_file(self):
        tab = self.tab_widget.new_tab()
        self.output.run_btn.setEnabled(False)
        self._connect_cursor(tab)
        if hasattr(self, '_settings') and self._settings and tab and tab.editor:
            font_family = self._settings.get("font_family", "Consolas")
            font_size = int(self._settings.get("font_size", 10))
            tab_size = int(self._settings.get("tab_size", 4))
            tab.editor.apply_editor_settings(font_family, font_size, tab_size)

    def open_file(self):
        path, _ = QFileDialog.getOpenFileName(
            self, "Datei öffnen", "",
            "Alle Dateien (*);;Python (*.py);;JavaScript (*.js);;C++ (*.cpp *.h)"
        )
        if path:
            self.open_path(Path(path))

    def open_path(self, file_path: Path):
        """Öffnet einen konkreten Pfad ohne Dateidialog."""
        path = Path(file_path)
        if not path.exists():
            QMessageBox.warning(self, "Datei öffnen", f"Datei nicht gefunden:\n{path}")
            return None

        tab = self.tab_widget.open_file(path)
        if tab and tab.editor and hasattr(self, '_settings') and self._settings:
            font_family = self._settings.get("font_family", "Consolas")
            font_size = int(self._settings.get("font_size", 10))
            tab_size = int(self._settings.get("tab_size", 4))
            tab.editor.apply_editor_settings(font_family, font_size, tab_size)
        if tab and tab.provider:
            self.lang_label.setText(tab.provider.get_name())
            self.output.run_btn.setEnabled(True)
            self._connect_lsp(tab, path)
        self._connect_cursor(tab)
        return tab

    def _connect_lsp(self, tab, file_path: Path):
        """Verbindet den Tab mit dem LSP-Server für die Sprache."""
        if not tab or not tab.provider or not file_path:
            return
        lang_name = tab.provider.get_name()
        client = self._lsp_manager.get_client(lang_name)
        if not client:
            return

        uri = file_path.resolve().as_uri()
        lang_id = lang_name.lower()
        text = tab.editor.toPlainText()
        if getattr(tab, "_lsp_client", None) is client and getattr(tab, "_lsp_uri", None) == uri:
            return

        self._lsp_tabs_by_uri[uri] = tab
        client.on_diagnostics = self._dispatch_lsp_diagnostics

        old_text_changed = getattr(tab, "_lsp_text_changed_slot", None)
        if old_text_changed:
            try:
                tab.editor.textChanged.disconnect(old_text_changed)
            except (TypeError, RuntimeError):
                pass

        old_completion_slot = getattr(tab, "_lsp_completion_slot", None)
        if old_completion_slot:
            try:
                tab.editor.completionRequested.disconnect(old_completion_slot)
            except (TypeError, RuntimeError):
                pass

        tab._lsp_uri = uri
        tab._lsp_client = client
        tab._lsp_version = 1

        client.did_open(uri, lang_id, text)

        def on_text_changed():
            tab._lsp_version += 1
            client.did_change(uri, tab.editor.toPlainText(), tab._lsp_version)
        tab.editor.textChanged.connect(on_text_changed)
        tab._lsp_text_changed_slot = on_text_changed

        def on_completion_requested(line, character, _prefix):
            self._request_lsp_completion(tab, line, character)
        tab.editor.completionRequested.connect(on_completion_requested)
        tab._lsp_completion_slot = on_completion_requested

    def _dispatch_lsp_diagnostics(self, params):
        """Leitet LSP-Diagnostics aus dem Reader-Thread in den UI-Thread."""
        tab = self._lsp_tabs_by_uri.get(params.get("uri"))
        if not tab:
            return
        severity_map = {1: "error", 2: "warning", 3: "info", 4: "hint"}
        errors = []
        for diagnostic in params.get("diagnostics", []):
            start = diagnostic.get("range", {}).get("start", {})
            errors.append({
                "line": start.get("line", 0) + 1,
                "col": start.get("character", 0),
                "message": diagnostic.get("message", ""),
                "severity": severity_map.get(diagnostic.get("severity", 1), "error"),
            })
        self.lspDiagnosticsReceived.emit(tab, errors)

    def _request_lsp_completion(self, tab, line: int, character: int):
        if not self._is_live_tab(tab):
            return
        client = getattr(tab, "_lsp_client", None)
        uri = getattr(tab, "_lsp_uri", None)
        if not client or not uri:
            return

        def on_completion(result):
            words = self._extract_lsp_completion_words(result)
            if words:
                self.lspCompletionsReceived.emit(tab, words)

        client.request_completion(uri, line, character, callback=on_completion)

    def _apply_lsp_diagnostics(self, tab, errors):
        if self._is_live_tab(tab):
            tab.editor.set_linter_errors(errors)

    def _apply_lsp_completions(self, tab, words):
        if not self._is_live_tab(tab):
            return
        tab.editor.set_completer_words(words)
        completer = tab.editor.completer
        prefix = tab.editor.text_under_cursor()
        if not completer or len(prefix) < 2 or not tab.editor.hasFocus():
            return
        completer.setCompletionPrefix(prefix)
        completer.popup().setCurrentIndex(completer.completionModel().index(0, 0))
        cursor_rect = tab.editor.cursorRect()
        cursor_rect.setWidth(
            completer.popup().sizeHintForColumn(0) +
            completer.popup().verticalScrollBar().sizeHint().width()
        )
        completer.complete(cursor_rect)

    @staticmethod
    def _extract_lsp_completion_words(result) -> list:
        if isinstance(result, dict):
            items = result.get("items", [])
        else:
            items = result or []
        words = []
        for item in items:
            if isinstance(item, dict):
                label = item.get("label")
            else:
                label = str(item)
            if label:
                words.append(label)
        return sorted(set(words))

    def _is_live_tab(self, tab) -> bool:
        return any(self.tab_widget.tabs.get(idx) is tab for idx in range(self.tab_widget.count()))

    def save_file(self):
        tab = self.tab_widget.current_tab()
        if not tab:
            return
        assigned_new_path = False
        original_file_path = tab.file_path
        original_provider = tab.provider
        original_lang_label = self.lang_label.text()
        original_run_enabled = self.output.run_btn.isEnabled()
        if not tab.file_path:
            path, _ = QFileDialog.getSaveFileName(
                self, "Speichern unter", "",
                "Alle Dateien (*);;Python (*.py);;JavaScript (*.js);;C++ (*.cpp)"
            )
            if path:
                assigned_new_path = True
                tab.file_path = Path(path)
                # Provider setzen basierend auf neuer Extension
                ext = tab.file_path.suffix.lstrip('.')
                provider = get_provider_for_extension(ext)
                if provider:
                    tab.provider = provider
                    tab.highlighter.set_provider(provider)
                    tab.editor.set_provider(provider)
                    self.lang_label.setText(provider.get_name())
            else:
                return
        if not tab.save():
            if assigned_new_path:
                tab.file_path = original_file_path
                tab.provider = original_provider
                tab.highlighter.set_provider(original_provider)
                tab.editor.set_provider(original_provider)
                self.lang_label.setText(original_lang_label)
                self.output.run_btn.setEnabled(original_run_enabled)
            return
        self.tab_widget._update_tab_title(tab)
        self.setWindowTitle(format_window_title(tab.file_path))
        self.output.run_btn.setEnabled(bool(tab.provider))
        if tab.file_path and tab.provider and not getattr(tab, "_lsp_client", None):
            self._connect_lsp(tab, tab.file_path)
        # LSP: didSave melden
        if hasattr(tab, '_lsp_client') and tab._lsp_client:
            tab._lsp_client.did_save(tab._lsp_uri, tab.editor.toPlainText())

    # ---- Bearbeiten-Aktionen ----

    def _undo(self):
        tab = self.tab_widget.current_tab()
        if tab:
            tab.editor.undo()

    def _redo(self):
        tab = self.tab_widget.current_tab()
        if tab:
            tab.editor.redo()

    def _find(self):
        from PySide6.QtWidgets import QInputDialog
        text, ok = QInputDialog.getText(self, "Suchen", "Suchbegriff:")
        if ok and text:
            tab = self.tab_widget.current_tab()
            if tab:
                count = tab.editor.highlightSearchResults(text)
                self.status_bar.showMessage(f"{count} Treffer gefunden", 3000)

    def _goto_line(self):
        from PySide6.QtWidgets import QInputDialog
        from PySide6.QtGui import QTextCursor
        tab = self.tab_widget.current_tab()
        if not tab:
            return
        line, ok = QInputDialog.getInt(
            self, "Gehe zu Zeile", "Zeile:", 1, 1, tab.editor.blockCount()
        )
        if ok:
            cursor = tab.editor.textCursor()
            cursor.movePosition(QTextCursor.Start)
            tab.editor.setTextCursor(cursor)
            tab.editor.centerCursor()

    def open_settings_dialog(self):
        """Öffnet den Einstellungsdialog und übernimmt geänderte Optionen."""
        from ui.settings_dialog import SettingsDialog
        dialog = SettingsDialog(self)
        if dialog.exec():
            self._settings = dialog.get_settings()
            self._apply_settings()

    def _apply_settings(self):
        """Wendet geladene oder geänderte Einstellungen auf Hauptfenster, Theme und Tabs an."""
        if not hasattr(self, '_settings') or not self._settings:
            return

        font_family = self._settings.get("font_family", "Consolas")
        font_size = int(self._settings.get("font_size", 10))
        tab_size = int(self._settings.get("tab_size", 4))
        theme = self._settings.get("theme", "dark")

        # Theme anwenden
        from features.theme_manager import apply_theme
        apply_theme(QApplication.instance(), theme)

        # Editor-Einstellungen auf alle offenen Tabs anwenden
        for idx in range(self.tab_widget.count()):
            tab = self.tab_widget.tabs.get(idx)
            if tab and tab.editor:
                tab.editor.apply_editor_settings(font_family, font_size, tab_size)

    # ---- Ausführen ----

    def run_current(self):
        tab = self.tab_widget.current_tab()
        if not tab or not tab.file_path:
            QMessageBox.warning(self, "Ausführen", "Bitte zuerst eine Datei speichern.")
            return
        # Automatisch speichern vor dem Ausführen
        if not tab.save():
            return
        if tab.provider:
            cmd = tab.provider.get_run_command(str(tab.file_path))
            self.output.run_command(cmd)
        else:
            QMessageBox.warning(self, "Ausführen",
                                "Keine Sprachunterstützung für diese Datei.")

    def _stop_run(self):
        self.output.stop_process()

    # ---- Events ----

    def _on_file_changed(self, file_path):
        if file_path:
            self.setWindowTitle(format_window_title(file_path))
            tab = self.tab_widget.current_tab()
            if tab and tab.provider:
                self.lang_label.setText(tab.provider.get_name())
                self.output.run_btn.setEnabled(True)
                self._connect_lsp(tab, file_path)
            else:
                self.lang_label.setText("Keine Sprache")
                self.output.run_btn.setEnabled(False)
            self._connect_cursor(tab)
            # ProjectView und Terminal auf Projektordner setzen
            project_dir = file_path.parent
            if self.project_view._root_path != project_dir:
                self.project_view.set_root(str(project_dir))
            self.terminal.set_working_dir(str(project_dir))
        else:
            self.setWindowTitle(format_window_title())
            self.lang_label.setText("Keine Sprache")
            self.output.run_btn.setEnabled(False)
            tab = self.tab_widget.current_tab()
            if tab:
                self._connect_cursor(tab)

    def _on_language_changed(self, lang_name):
        if lang_name == "(Auto)":
            return
        tab = self.tab_widget.current_tab()
        if tab:
            provider = get_provider_by_name(lang_name)
            if provider:
                tab.provider = provider
                tab.highlighter.set_provider(provider)
                tab.editor.set_provider(provider)
                self.lang_label.setText(provider.get_name())
                self.output.run_btn.setEnabled(True)
                if tab.file_path:
                    self._connect_lsp(tab, tab.file_path)

    def _connect_cursor(self, tab):
        if tab:
            old_slot = getattr(tab, "_cursor_slot", None)
            if old_slot is not None:
                try:
                    tab.editor.cursorPositionInfo.disconnect(old_slot)
                except (TypeError, RuntimeError):
                    pass

            def _slot(line, col):
                self.pos_label.setText(f"Zeile {line}, Spalte {col}")

            tab._cursor_slot = _slot
            tab.editor.cursorPositionInfo.connect(_slot)

    def _open_file_from_project(self, file_path):
        """Öffnet eine Datei aus dem Projektbaum."""
        self.open_path(file_path)

    def _toggle_project_view(self):
        """Blendet den Projektbaum ein/aus."""
        self.project_view.setVisible(not self.project_view.isVisible())

    def _toggle_terminal(self):
        """Blendet das untere Panel ein/aus und wechselt zum Terminal-Tab."""
        if self.bottom_tabs.isVisible() and self.bottom_tabs.currentWidget() == self.terminal:
            self.bottom_tabs.hide()
        else:
            self.bottom_tabs.show()
            self.bottom_tabs.setCurrentWidget(self.terminal)
            self.terminal.input.setFocus()

    def closeEvent(self, event):
        # Alle Tabs auf ungespeicherte Änderungen prüfen
        unsaved = []
        for idx in range(self.tab_widget.count()):
            tab = self.tab_widget.tabs.get(idx)
            if tab and tab.is_modified:
                unsaved.append(self.tab_widget.tabText(idx))
        if unsaved:
            names = "\n".join(f"  - {n}" for n in unsaved)
            reply = QMessageBox.question(
                self, "Beenden",
                f"Es gibt ungespeicherte Änderungen in:\n{names}\n\nTrotzdem beenden?",
                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
            )
            if reply == QMessageBox.StandardButton.No:
                event.ignore()
                return
        # Terminal-Prozess sauber beenden
        if hasattr(self, 'terminal'):
            self.terminal.close()
        # LSP-Server stoppen
        self._lsp_manager.stop_all()
        event.accept()