mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "imagemodel.h"
#include "imageview.h"
#include "histogramdialog.h"

#include <QFileDialog>
#include <QMessageBox>
#include <QMenu>
#include <QWidgetAction>
#include <QSlider>
#include <QToolBar>
#include <QToolButton>
#include <QInputDialog>
#include <QFileInfo>
#include <QPixmap>
#include <QDir>
#include <QPushButton>
#include <QDebug>
#include <QSettings>
#include <QStyle>
#include <QIcon>
#include <utility>
#include <cmath>
#include <QScreen>
#include <QGuiApplication>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLabel>

// Konstruktor: Hier wird die Benutzeroberfläche aufgebaut und die Logik verknüpft.
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , m_model(new ImageModel(this)) // Das Datenmodell initialisieren
{
    ui->setupUi(this);
    this->setMinimumSize(550, 400);
    resize(1000,600);

    // -----------------------------------------------------------
    // 1. ACTIONS ERSTELLEN
    // Actions sind abstrahierte Benutzerbefehle. Sie können gleichzeitig
    // in Menüs UND in der Toolbar verwendet werden.
    // -----------------------------------------------------------

    // --- Undo / Redo ---
    m_actionUndo = new QAction(style()->standardIcon(QStyle::SP_ArrowBack), "Rückgängig", this);
    m_actionUndo->setShortcut(QKeySequence::Undo); // Standard-Shortcut (Strg+Z)

    m_actionRedo = new QAction(style()->standardIcon(QStyle::SP_ArrowForward), "Wiederherstellen", this);
    m_actionRedo->setShortcut(QKeySequence::Redo); // Standard-Shortcut (Strg+Y / Strg+Shift+Z)

    // --- Standard Actions (Dateioperationen) ---
    // Wir nutzen Standard-Icons vom Betriebssystem (sieht nativer aus)
    ui->menubar_Datei_Oeffnen->setIcon(style()->standardIcon(QStyle::SP_DialogOpenButton));
    ui->menubar_Datei_Speichern->setIcon(style()->standardIcon(QStyle::SP_DialogSaveButton));
    ui->menubar_Datei_SpeichernAls->setIcon(style()->standardIcon(QStyle::SP_DialogSaveButton));
    ui->menubar_Datei_Beenden->setIcon(style()->standardIcon(QStyle::SP_DialogCloseButton));

    // --- Bildbearbeitungs-Actions ---
    m_actionSpiegeln = new QAction("Spiegeln", this);
    m_actionSpiegeln->setIcon(QIcon(":/icons/mirror.svg"));

    m_actionDrehen = new QAction("Drehen", this);
    m_actionDrehen->setIcon(QIcon(":/icons/rotate.svg"));

    m_actionGraustufen = new QAction("Graustufen", this);
    m_actionGraustufen->setCheckable(true); // Dieser Button rastet ein (An/Aus)
    m_actionGraustufen->setIcon(QIcon(":/icons/greyscale.svg"));

    m_actionResize = new QAction("Größe ändern (Dialog)", this);
    m_actionResize->setIcon(QIcon(":/icons/resize.svg"));

    m_actionScale = new QAction("Skalieren (%)", this);
    m_actionScale->setIcon(QIcon(":/icons/scale.svg"));

    m_actionCrop = new QAction("Zuschneiden", this);
    m_actionCrop->setCheckable(true);   // Modus aktivieren/deaktivieren
    m_actionCrop->setIcon(QIcon(":/icons/crop.svg"));

    m_actionHistogram = new QAction("Histogramm", this);
    m_actionHistogram->setIcon(QIcon(":/icons/histogram.svg"));

    m_actionFreeTransform = new QAction("Größe ändern (Frei)", this);
    m_actionFreeTransform->setIcon(QIcon(":/icons/resizeFree.svg"));
    m_actionFreeTransform->setCheckable(true);

    // Tastenkürzel zuweisen
    ui->menubar_Datei_Oeffnen->setShortcut(QKeySequence::Open);
    ui->menubar_Datei_Speichern->setShortcut(QKeySequence::Save);
    ui->menubar_Datei_SpeichernAls->setShortcut(QKeySequence::SaveAs);
    ui->menubar_Datei_Beenden->setShortcut(QKeySequence::Quit);

    m_actionSpiegeln->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_M));
    m_actionDrehen->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_R));
    m_actionGraustufen->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_G));
    m_actionResize->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_E));
    m_actionScale->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_K));
    m_actionFreeTransform->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_T));
    m_actionCrop->setShortcut(Qt::Key_C);
    m_actionHistogram->setShortcut(Qt::Key_H);

    // Tooltips für alle Actions setzen (zeigt den Shortcut beim Hovern an)
    QList<QAction*> allActions = {
        m_actionSpiegeln, m_actionDrehen, m_actionGraustufen,
        m_actionResize, m_actionScale, m_actionCrop, m_actionHistogram,
        m_actionFreeTransform,
        ui->menubar_Datei_Oeffnen, ui->menubar_Datei_Speichern
    };
    for (QAction *action : std::as_const(allActions)) {
        if (!action->shortcut().isEmpty()) {
            action->setToolTip(action->text() + " (" + action->shortcut().toString(QKeySequence::NativeText) + ")");
        }
    }

    // -----------------------------------------------------------
    // 2. MENÜS SETUP
    // -----------------------------------------------------------

    // Menü "Bearbeiten" dynamisch erstellen und Undo/Redo hinzufügen
    QMenu *menuBearbeiten = new QMenu("Bearbeiten", this);
    ui->menubar->addMenu(menuBearbeiten); // Einfach hinten anhängen (Sicher!)
    menuBearbeiten->addAction(m_actionUndo);
    menuBearbeiten->addAction(m_actionRedo);

    // --- Komplexe Widgets in Menüs einbauen ---
    // Qt erlaubt es nicht direkt, Slider in Menüs zu packen.
    // Trick: Wir bauen einen Container (QWidgetAction), packen den Slider da rein
    // und fügen den Container ins Menü ein.

    // Helligkeit
    m_actionHelligkeit = new QAction("Helligkeit", this);
    m_actionHelligkeit->setIcon(QIcon(":/icons/brightness.svg"));
    QMenu *helligkeitMenu = new QMenu(this);
    QWidget *hContainer = new QWidget(this);
    QVBoxLayout *hLayout = new QVBoxLayout(hContainer);
    hLayout->setContentsMargins(5, 5, 5, 5); hLayout->setSpacing(2);
    m_helligkeitSlider = new QSlider(Qt::Horizontal, this);
    m_helligkeitSlider->setRange(-100, 100);
    m_helligkeitSlider->setValue(0);
    m_helligkeitSlider->setMinimumWidth(200);
    QPushButton *btnAutoH = new QPushButton("Automatisch anpassen", this);
    btnAutoH->setCursor(Qt::PointingHandCursor);
    hLayout->addWidget(m_helligkeitSlider);
    hLayout->addWidget(btnAutoH);
    QWidgetAction *hWidgetAction = new QWidgetAction(this);
    hWidgetAction->setDefaultWidget(hContainer);
    helligkeitMenu->addAction(hWidgetAction);
    m_actionHelligkeit->setMenu(helligkeitMenu);

    // URL laden Action
    m_actionOpenUrl = new QAction("Von URL öffnen...", this);
    m_actionOpenUrl->setIcon(style()->standardIcon(QStyle::SP_ComputerIcon));
    m_actionOpenUrl->setShortcut(QKeySequence(Qt::CTRL | Qt::Key_U));

    // Action ins Menü "Datei" einfügen (z.B. vor Speichern)
    ui->menuDatei->insertAction(ui->menubar_Datei_Speichern, m_actionOpenUrl);

    // Network Manager initialisieren (für Web-Downloads)
    m_netManager = new QNetworkAccessManager(this);
    connect(m_netManager, &QNetworkAccessManager::finished, this, &MainWindow::onImageDownloaded);
    connect(m_actionOpenUrl, &QAction::triggered, this, &MainWindow::onOpenUrlClicked);

    // Kontrast
    m_actionKontrast = new QAction("Kontrast", this);
    m_actionKontrast->setIcon(QIcon(":/icons/contrast.svg"));
    QMenu *kontrastMenu = new QMenu(this);
    m_kontrastSlider = new QSlider(Qt::Horizontal, this);
    m_kontrastSlider->setRange(0, 100);
    m_kontrastSlider->setValue(50);
    m_kontrastSlider->setMinimumWidth(200);
    QWidgetAction *kWidgetAction = new QWidgetAction(this);
    kWidgetAction->setDefaultWidget(m_kontrastSlider);
    kontrastMenu->addAction(kWidgetAction);
    m_actionKontrast->setMenu(kontrastMenu);

    // Color Splash
    m_actionColorSplash = new QAction("Color Splash", this);
    m_actionColorSplash->setIcon(QIcon(":/icons/colorsplash.svg"));
    m_actionColorSplash->setCheckable(true);

    QMenu *splashMenu = new QMenu(this);
    QWidget *sContainer = new QWidget(this);
    QVBoxLayout *sLayout = new QVBoxLayout(sContainer);
    QLabel *lblInfo = new QLabel("1. Aktivieren\n2. Ins Bild klicken", sContainer);
    lblInfo->setStyleSheet("font-size: 9pt; color: gray;");
    QSlider *splashSlider = new QSlider(Qt::Horizontal, this);
    splashSlider->setRange(1, 200);
    splashSlider->setValue(40);
    sLayout->addWidget(lblInfo);
    sLayout->addWidget(splashSlider);
    QWidgetAction *sWidgetAction = new QWidgetAction(this);
    sWidgetAction->setDefaultWidget(sContainer);
    splashMenu->addAction(sWidgetAction);
    m_actionColorSplash->setMenu(splashMenu);

    // Filter Menü (Untermenü)
    m_actionFilterMenu = new QAction(QIcon(":/icons/filter.svg"), "Filter", this);
    QMenu *filterMenu = new QMenu(this);

    m_actionComicFilter = new QAction("Comic-Look", this);
    m_actionComicFilter->setCheckable(true); // FIX: Häkchen aktivieren!
    filterMenu->addAction(m_actionComicFilter);

    QAction *invertAction = new QAction("Invertieren", this);
    invertAction->setCheckable(true); // FIX: Häkchen aktivieren!
    filterMenu->addAction(invertAction);

    QAction *sepiaAction = new QAction("Sepia", this);
    sepiaAction->setCheckable(true); // FIX: Häkchen aktivieren!
    filterMenu->addAction(sepiaAction);

    QAction *sharpenAction = new QAction("Schärfen", this);
    sharpenAction->setCheckable(true); // FIX: Häkchen aktivieren!
    filterMenu->addAction(sharpenAction);

    m_actionFilterMenu->setMenu(filterMenu);

    // -----------------------------------------------------------
    // 3. TOOLBAR BEFÜLLEN
    // Die Toolbar bietet schnellen Zugriff auf die wichtigsten Funktionen.
    // -----------------------------------------------------------
    ui->toolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);

    ui->toolBar->addAction(m_actionHelligkeit);
    ui->toolBar->addAction(m_actionKontrast);
    ui->toolBar->addAction(m_actionHistogram);
    ui->toolBar->addSeparator();
    ui->toolBar->addAction(m_actionSpiegeln);
    ui->toolBar->addAction(m_actionDrehen);
    ui->toolBar->addSeparator();
    ui->toolBar->addAction(m_actionCrop);
    ui->toolBar->addAction(m_actionResize);
    ui->toolBar->addAction(m_actionScale);
    ui->toolBar->addAction(m_actionFreeTransform);
    ui->toolBar->addSeparator();
    ui->toolBar->addAction(m_actionColorSplash);
    ui->toolBar->addAction(m_actionFilterMenu);
    ui->toolBar->addAction(m_actionGraustufen);

    // Konfiguration der Dropdown-Buttons in der Toolbar
    // InstantPopup sorgt dafür, dass sofort das Menü (mit dem Slider) aufgeht.
    if (auto* btn = qobject_cast<QToolButton*>(ui->toolBar->widgetForAction(m_actionHelligkeit))) btn->setPopupMode(QToolButton::InstantPopup);
    if (auto* btn = qobject_cast<QToolButton*>(ui->toolBar->widgetForAction(m_actionKontrast))) btn->setPopupMode(QToolButton::InstantPopup);
    if (auto* btn = qobject_cast<QToolButton*>(ui->toolBar->widgetForAction(m_actionFilterMenu))) btn->setPopupMode(QToolButton::InstantPopup);
    // MenuButtonPopup teilt den Button: Klick links -> Aktion, Klick rechts -> Menü
    if (auto* btn = qobject_cast<QToolButton*>(ui->toolBar->widgetForAction(m_actionColorSplash))) btn->setPopupMode(QToolButton::MenuButtonPopup);

    // Recent Files (Zuletzt geöffnet)
    m_recentFilesMenu = new QMenu("Zuletzt geöffnet", this);
    ui->menuDatei->insertMenu(ui->menubar_Datei_Beenden, m_recentFilesMenu);
    ui->menuDatei->insertSeparator(ui->menubar_Datei_Beenden);

    // -----------------------------------------------------------
    // 4. CONNECTIONS (Signale und Slots verbinden)
    // Das Herzstück von Qt: Wenn A passiert, führe Funktion B aus.
    // -----------------------------------------------------------

    // Undo / Redo
    connect(m_actionUndo, &QAction::triggered, this, &MainWindow::onUndoClicked);
    connect(m_actionRedo, &QAction::triggered, this, &MainWindow::onRedoClicked);

    // Wenn sich die History ändert (neuer Schritt), müssen die Buttons aktiviert/deaktiviert werden
    connect(m_model, &ImageModel::historyChanged, this, &MainWindow::updateHistoryButtons);

    // Datei-Menü
    connect(ui->menubar_Datei_Oeffnen, &QAction::triggered, this, &MainWindow::onFileOpen);
    connect(ui->menubar_Datei_Speichern, &QAction::triggered, this, &MainWindow::onFileSave);
    connect(ui->menubar_Datei_SpeichernAls, &QAction::triggered, this, &MainWindow::onFileSaveAs);
    connect(ui->menubar_Datei_Beenden, &QAction::triggered, this, &QMainWindow::close);

    // Bild-Operationen
    connect(m_actionSpiegeln, &QAction::triggered, this, &MainWindow::onSpiegelnClicked);
    connect(m_actionDrehen, &QAction::triggered, this, &MainWindow::onDrehenClicked);
    connect(m_actionGraustufen, &QAction::toggled, this, &MainWindow::onGraustufenToggled);
    connect(m_actionResize, &QAction::triggered, this, &MainWindow::onResizeClicked);
    connect(m_actionScale, &QAction::triggered, this, &MainWindow::onScaleClicked);
    connect(m_actionHistogram, &QAction::triggered, this, &MainWindow::onHistogramClicked);
    connect(m_actionCrop, &QAction::toggled, this, &MainWindow::onCropToggled);

    // Sliders
    connect(m_helligkeitSlider, &QSlider::valueChanged, this, &MainWindow::onHelligkeitChanged);
    connect(m_kontrastSlider, &QSlider::valueChanged, this, &MainWindow::onKontrastChanged);
    connect(btnAutoH, &QPushButton::clicked, this, &MainWindow::onAutoHelligkeitClicked);

    // --- Performance Optimierung (Preview Mode) ---
    // Wenn der Slider gedrückt wird, schalten wir auf eine schnelle Vorschau um.
    // Wenn er losgelassen wird, berechnen wir das Bild in voller Qualität.
    connect(m_helligkeitSlider, &QSlider::sliderPressed, this, [this](){
        m_model->pushUndoState();// Zustand sichern, BEVOR man schiebt
        m_model->setPreviewMode(true);
    });
    connect(m_helligkeitSlider, &QSlider::sliderReleased, this, [this](){
        m_model->setPreviewMode(false);
    });
    connect(m_kontrastSlider, &QSlider::sliderPressed, this, [this](){
        m_model->pushUndoState();
        m_model->setPreviewMode(true);
    });
    connect(m_kontrastSlider, &QSlider::sliderReleased, this, [this](){
        m_model->setPreviewMode(false);
    });

    // Filter Trigger
    connect(m_actionComicFilter, &QAction::triggered, this, &MainWindow::onComicFilterTriggered);

    // Lambda-Funktionen für kurze Filter-Aufrufe
    connect(invertAction, &QAction::triggered, this, [this](){
        if (!m_model->isNull()) { m_model->applyInvert(); updateImageDisplay(); }
    });
    connect(sepiaAction, &QAction::triggered, this, [this](){
        if (!m_model->isNull()) { m_model->applySepia(); updateImageDisplay(); }
    });
    connect(sharpenAction, &QAction::triggered, this, [this](){
        if (!m_model->isNull()) { m_model->applySharpen(); updateImageDisplay(); }
    });

    // Model -> View Updates: Wenn das Model fertig gerechnet hat, zeige das Bild an
    connect(m_model, &ImageModel::imageUpdated, this, &MainWindow::updateImageDisplay);
    connect(ui->statusbar, &QStatusBar::messageChanged, this, &MainWindow::onStatusMessageChanged);

    // --- ImageView (Das Widget, das das Bild anzeigt) ---
    m_imageView = new ImageView(this);
    m_imageView->setAlignment(Qt::AlignCenter);
    m_imageView->setText("Bitte öffnen Sie eine Bilddatei...");
    m_imageView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    // Altes Platzhalter-Label aus dem UI-Designer entfernen und durch ImageView ersetzen
    if (ui->label_Bild != nullptr) {
        ui->verticalLayout->removeWidget(ui->label_Bild);
        delete ui->label_Bild;
        ui->label_Bild = nullptr;
    }
    ui->verticalLayout->addWidget(m_imageView);

    connect(m_imageView, &ImageView::selectionFinished, this, &MainWindow::onSelectionFinished);

    // Logik für "Freies Transformieren" (Ecken ziehen)
    connect(m_actionFreeTransform, &QAction::toggled, this, [this](bool checked){
        if(checked) {
            // Konfliktvermeidung: Crop und Transform können nicht gleichzeitig an sein
            if(m_actionCrop->isChecked()) m_actionCrop->setChecked(false);
            m_imageView->setPickColorMode(false);
        }

        m_imageView->setResizeMode(checked);

        if(checked) ui->statusbar->showMessage("Ziehen Sie an den Ecken, um die Größe zu ändern.");
        else ui->statusbar->clearMessage();
    });

    // Zoom-Feedback in der Statusleiste
    connect(m_imageView, &ImageView::zoomChanged, this, [this](double scale){
        int percent = std::round(scale * 100);
        ui->statusbar->showMessage(QString("Zoom: %1%").arg(percent), 2000);
    });

    // Wenn ImageView das Resizing beendet hat, Daten ans Model senden
    connect(m_imageView, &ImageView::imageResized, this, [this](int w, int h){
        m_model->resizeImage(w, h);
        m_actionFreeTransform->setChecked(false);
        ui->statusbar->showMessage(QString("Größe geändert auf: %1 x %2").arg(w).arg(h), 3000);
    });
    // Logik für Crop (Zuschneiden)
    connect(m_actionCrop, &QAction::toggled, this, [this](bool checked){
        if(checked) {
            // Free Transform ausmachen
            if(m_actionFreeTransform->isChecked()) m_actionFreeTransform->setChecked(false);

            // FIX: Color Splash Effekt anlassen, nur Picker ausmachen
            m_imageView->setPickColorMode(false);
        }
        m_imageView->setCropMode(checked);

        if(checked) ui->statusbar->showMessage("Zuschneiden aktiv: Ziehen Sie einen Rahmen.");
        else ui->statusbar->clearMessage();
    });

    // Logik für Color Splash
    connect(m_actionColorSplash, &QAction::toggled, this, [this](bool checked){
        if (m_model->isNull()) return;
        if (checked) {
            // Andere Modi deaktivieren
            m_actionCrop->setChecked(false);
            m_actionFreeTransform->setChecked(false);
            // Picker aktivieren
            m_imageView->setPickColorMode(true);
            ui->statusbar->showMessage("Klicken Sie auf eine Farbe im Bild!");
        } else {
            m_imageView->setPickColorMode(false);
            if (m_model->isColorSplashActive()) m_model->applyColorSplash();
            updateImageDisplay();
        }
    });

    // Slider für Color Splash Toleranz
    connect(splashSlider, &QSlider::valueChanged, this, [this](int val){
        m_model->setSplashTolerance(val);
        updateImageDisplay();
    });
    // Wenn eine Farbe im Bild angeklickt wurde
    connect(m_imageView, &ImageView::colorPicked, this, [this](const QColor &c){
        m_model->setSplashColor(c);
        if (!m_model->isColorSplashActive()) {
            m_model->applyColorSplash();
        }
        updateImageDisplay();
        ui->statusbar->showMessage(QString("Farbe gewählt: %1").arg(c.name()), 3000);
    });

    loadSettings(); // Zuletzt geöffnete Dateien laden
    setControlsEnabled(false);  // UI deaktivieren, bis ein Bild geladen ist
    updateHistoryButtons();
}

MainWindow::~MainWindow()
{
    delete ui;
}

// --------------------------------------------------------------------------------
// DATEI OPERATIONEN
// --------------------------------------------------------------------------------

void MainWindow::onFileOpen()
{
    QString filter = "Bilddateien (*.png *.jpg *.bmp *.jpeg)";
    QString fileName = QFileDialog::getOpenFileName(this, "Bild öffnen", QDir::homePath(), filter);
    if (fileName.isEmpty()) return;

    if (!m_model->loadFromFile(fileName)) {
        QMessageBox::warning(this, "Fehler", "Bild konnte nicht geladen werden.");
        setControlsEnabled(false);
        m_permanenteStatusNachricht.clear();
        ui->statusbar->clearMessage();
    } else {
        m_permanenteStatusNachricht = fileName;
        ui->statusbar->showMessage(m_permanenteStatusNachricht);
        setWindowTitle(QFileInfo(fileName).fileName() + " | OnePic");
        addToRecentFiles(fileName);
        // UI-Elemente zurücksetzen
        m_helligkeitSlider->setValue(0);
        m_kontrastSlider->setValue(50);
        m_actionGraustufen->setChecked(false);
        m_mausCropAktiv = false;
        m_actionCrop->setChecked(false);
        m_actionFreeTransform->setChecked(false);
        m_actionColorSplash->setChecked(false);
        setControlsEnabled(true);
        updateImageDisplay();
    }
}

void MainWindow::onFileSave()
{
    if (m_model->isNull()) return;

    // Unterscheidung: Haben wir eine echte lokale Datei oder eine URL/neues Bild?
    // Wenn URL (http...) -> "Speichern unter" aufrufen
    if (m_permanenteStatusNachricht.isEmpty() || m_permanenteStatusNachricht.startsWith("http")) {
        onFileSaveAs();
    } else {
        // Normale Datei -> Überschreiben
        if (m_model->saveToFile(m_permanenteStatusNachricht))
            ui->statusbar->showMessage("Bild erfolgreich gespeichert", 5000);
        else
            QMessageBox::warning(this, "Speicherfehler", "Konnte nicht speichern.");
    }
}

void MainWindow::onFileSaveAs()
{
    if (m_model->isNull()) return;
    QString filter = "PNG-Datei (*.png);;JPEG-Datei (*.jpg *.jpeg);;BMP-Datei (*.bmp)";
    QString fileName = QFileDialog::getSaveFileName(this, "Speichern unter...", QDir::homePath() + "/Unbenannt.png", filter);
    if (fileName.isEmpty()) return;
    if (m_model->saveToFile(fileName)) {
        m_permanenteStatusNachricht = fileName;
        setWindowTitle(QFileInfo(fileName).fileName() + " | OnePic");
        ui->statusbar->showMessage("Gespeichert: " + fileName, 5000);
        addToRecentFiles(fileName);
    } else QMessageBox::warning(this, "Speicherfehler", "Konnte nicht speichern.");
}

// --------------------------------------------------------------------------------
// RECENT FILES (Zuletzt geöffnet)
// Nutzt QSettings für Persistenz (Speichern über Neustarts hinweg)
// --------------------------------------------------------------------------------
void MainWindow::addToRecentFiles(const QString &fileName)
{
    m_recentFilesList.removeAll(fileName);  // Doppelte Einträge vermeiden
    m_recentFilesList.prepend(fileName);    // Nach oben schieben
    while (m_recentFilesList.size() > MAX_RECENT_FILES) m_recentFilesList.removeLast();

    QSettings settings("TH-Koeln", "OnePic");
    settings.setValue("recentFiles", m_recentFilesList);
    updateRecentFileActions();
}

void MainWindow::updateRecentFileActions()
{
    m_recentFilesMenu->clear();
    if (m_recentFilesList.isEmpty()) { m_recentFilesMenu->addAction("Keine Einträge")->setEnabled(false); return; }
    for (const QString &fileName : std::as_const(m_recentFilesList)) {
        QFileInfo info(fileName);
        QAction *action = new QAction(info.fileName(), this);
        action->setData(fileName);  // Den vollen Pfad als unsichtbare Daten anhängen
        action->setToolTip(fileName);
        connect(action, &QAction::triggered, this, &MainWindow::onRecentFileTriggered);
        m_recentFilesMenu->addAction(action);
    }
    m_recentFilesMenu->addSeparator();
    QAction *clearAction = new QAction("Verlauf leeren", this);
    connect(clearAction, &QAction::triggered, this, &MainWindow::onClearRecentFiles);
    m_recentFilesMenu->addAction(clearAction);
}

void MainWindow::onClearRecentFiles()
{
    m_recentFilesList.clear();
    QSettings settings("TH-Koeln", "OnePic");
    settings.setValue("recentFiles", m_recentFilesList);
    updateRecentFileActions();
}

void MainWindow::loadSettings()
{
    QSettings settings("TH-Koeln", "OnePic");
    m_recentFilesList = settings.value("recentFiles").toStringList();
    updateRecentFileActions();
}

void MainWindow::onRecentFileTriggered()
{
    QAction *action = qobject_cast<QAction *>(sender());
    if (!action) return;
    QString fileName = action->data().toString();
    if (!QFile::exists(fileName)) {
        QMessageBox::warning(this, "Fehler", "Datei existiert nicht mehr.");
        m_recentFilesList.removeAll(fileName);
        updateRecentFileActions();
        return;
    }
    // Ladelogik ähnlich wie onFileOpen
    if (m_model->loadFromFile(fileName)) {
        m_permanenteStatusNachricht = fileName;
        ui->statusbar->showMessage(fileName);
        setWindowTitle(QFileInfo(fileName).fileName() + " | OnePic");
        addToRecentFiles(fileName);
        m_helligkeitSlider->setValue(0);
        m_kontrastSlider->setValue(50);
        m_actionGraustufen->setChecked(false);
        m_mausCropAktiv = false;
        m_actionCrop->setChecked(false);
        m_actionFreeTransform->setChecked(false);
        m_actionColorSplash->setChecked(false);
        setControlsEnabled(true);
        updateImageDisplay();
    }
}

// --------------------------------------------------------------------------------
// BILD OPERATIONEN (Weiterleitung an das Model)
// --------------------------------------------------------------------------------

void MainWindow::onSpiegelnClicked() { m_model->flip(); }
void MainWindow::onDrehenClicked() { m_model->rotate(); }
void MainWindow::onHelligkeitChanged(int value) { m_model->setHelligkeit(value); }
void MainWindow::onKontrastChanged(int value) { m_model->setKontrast(value); }
void MainWindow::onGraustufenToggled(bool checked) { m_model->setGrayscale(checked); }

void MainWindow::onResizeClicked()
{
    if (m_model->isNull()) return;
    QSize currentSize = m_model->getCurrentSize();
    bool ok_w = false, ok_h = false;
    int w = QInputDialog::getInt(this, "Größe ändern", "Neue Breite (Pixel):", currentSize.width(), 1, 20000, 1, &ok_w);
    if (!ok_w) return;
    int h = QInputDialog::getInt(this, "Größe ändern", "Neue Höhe (Pixel):", currentSize.height(), 1, 20000, 1, &ok_h);
    if (!ok_h) return;
    m_model->resizeImage(w, h);
}

void MainWindow::onScaleClicked()
{
    if (m_model->isNull()) return;
    bool ok;
    double faktor = QInputDialog::getDouble(this, "Skalieren", "Faktor (%):", 100.0, 1.0, 5000.0, 1, &ok);
    if (ok) m_model->scaleImage(faktor / 100.0);
}

void MainWindow::onHistogramClicked()
{
    if (m_model->isNull()) return;
    QVector<int> histData = m_model->getHistogram();

    // Falls ein altes Fenster noch offen ist, schließen
    if (m_histogramDialog) { m_histogramDialog->close(); delete m_histogramDialog; m_histogramDialog = nullptr; }
    m_histogramDialog = new HistogramDialog(histData, this);
    // Das Fenster löscht sich selbst aus dem Speicher beim Schließen (wichtig gegen Memory Leaks)
    m_histogramDialog->setAttribute(Qt::WA_DeleteOnClose);
    connect(m_histogramDialog, &QDialog::destroyed, this, [this](){ m_histogramDialog = nullptr; });
    m_histogramDialog->show();
}

void MainWindow::onCropToggled(bool checked)
{
    if (m_model->isNull()) { if (checked) m_actionCrop->setChecked(false); return; }
    m_mausCropAktiv = checked;
    m_imageView->setCropMode(checked);
    if (checked) {
        m_actionFreeTransform->setChecked(false);
        m_actionColorSplash->setChecked(false);
        ui->statusbar->showMessage("Zuschneiden aktiv: Ziehen Sie einen Rahmen.");
    }
    else ui->statusbar->clearMessage();
}

void MainWindow::onCropClicked() {}

void MainWindow::onSelectionFinished(const QRect &rect)
{
    if (!m_mausCropAktiv || m_model->isNull()) return;
    m_actionCrop->setChecked(false);    // Modus beenden nach Auswahl
    if (rect.isValid() && rect.width() > 0 && rect.height() > 0) {
        m_model->cropImage(rect);
        ui->statusbar->showMessage("Zugeschnitten.");
    } else ui->statusbar->showMessage("Ungültige Auswahl.");
}

void MainWindow::onComicFilterTriggered()
{
    if (m_model->isNull()) { QMessageBox::warning(this, "Filter", "Bitte laden Sie zuerst ein Bild."); return; }
    QGuiApplication::setOverrideCursor(Qt::WaitCursor); // Sanduhr anzeigen, da Berechnung dauern kann
    m_model->applyComicFilter();
    updateImageDisplay();
    QGuiApplication::restoreOverrideCursor();
    ui->statusbar->showMessage("Comic-Filter angewendet.", 3000);
}

// --------------------------------------------------------------------------------
// UI UPDATES
// Diese Funktion synchronisiert das GUI mit dem internen Datenzustand.
// --------------------------------------------------------------------------------

void MainWindow::updateImageDisplay()
{
    if (m_model->isNull()) {
        m_imageView->clear();
        m_imageView->setText("Bitte öffnen Sie eine Bilddatei...");
        m_imageView->setImage(QImage());
        return;
    }

    m_imageView->setText("");
    m_imageView->setImage(m_model->getProcessedImage());

    // --- GUI ELEMENTE SYNCHRONISIEREN ---
    // Wir nutzen blockSignals(true), um zu verhindern, dass das Setzen eines Checkbox-Status
    // wieder ein Signal auslöst, das die Funktion erneut aufruft (Endlosschleife).

    // 1. Graustufen Button
    if (m_actionGraustufen) {
        // Blockieren verhindert, dass setChecked() wieder onGraustufenToggled aufruft
        const bool wasBlocked = m_actionGraustufen->blockSignals(true);
        m_actionGraustufen->setChecked(m_model->isGrayscale());
        m_actionGraustufen->blockSignals(wasBlocked);
    }

    // 2. Comic Filter Button
    if (m_actionComicFilter) {
        const bool wasBlocked = m_actionComicFilter->blockSignals(true);
        m_actionComicFilter->setChecked(m_model->isComicFilterActive());
        m_actionComicFilter->blockSignals(wasBlocked);
    }

    // 3. Color Splash Button
    if (m_actionColorSplash) {
        m_actionColorSplash->setChecked(m_model->isColorSplashActive());
    }

    // 4. Filter Menü Checkboxen (Invert, Sepia, etc.)
    QMenu* filterMenu = m_actionFilterMenu->menu();
    if (filterMenu) {
        for (QAction* action : filterMenu->actions()) {
            bool oldState = action->blockSignals(true);

            QString text = action->text();
            if (text.contains("Invertieren")) action->setChecked(m_model->isInvertActive());
            else if (text.contains("Sepia")) action->setChecked(m_model->isSepiaActive());
            else if (text.contains("Schärfen")) action->setChecked(m_model->isSharpenActive());

            action->blockSignals(oldState);
        }
    }
}

void MainWindow::onStatusMessageChanged(const QString &message)
{
    // Stellt sicher, dass der Dateiname wieder erscheint, wenn eine temporäre Nachricht (z.B. Zoom) verschwindet
    if (message.isEmpty() && !m_permanenteStatusNachricht.isEmpty()) ui->statusbar->showMessage(m_permanenteStatusNachricht);
}

void MainWindow::setControlsEnabled(bool enabled)
{
    // Alle Buttons aktivieren/deaktivieren (je nachdem ob Bild geladen ist)
    m_actionHelligkeit->setEnabled(enabled);
    m_actionKontrast->setEnabled(enabled);
    ui->menubar_Datei_Speichern->setEnabled(enabled);
    ui->menubar_Datei_SpeichernAls->setEnabled(enabled);
    m_actionFilterMenu->setEnabled(enabled);
    m_actionSpiegeln->setEnabled(enabled);
    m_actionDrehen->setEnabled(enabled);
    m_actionGraustufen->setEnabled(enabled);
    m_actionResize->setEnabled(enabled);
    m_actionScale->setEnabled(enabled);
    m_actionCrop->setEnabled(enabled);
    m_actionHistogram->setEnabled(enabled);
    m_actionFreeTransform->setEnabled(enabled);
    m_actionColorSplash->setEnabled(enabled);
    m_actionUndo->setEnabled(enabled && m_model->canUndo());
    m_actionRedo->setEnabled(enabled && m_model->canRedo());
}

void MainWindow::updateView() { if (!m_model->isNull()) m_imageView->setImage(m_model->getProcessedImage()); }

// Iterativer Algorithmus zur automatischen Helligkeitskorrektur
void MainWindow::onAutoHelligkeitClicked()
{
    if (m_model->isNull()) return;
    m_model->pushUndoState();
    const int targetMean = 128; // Ziel: Mittleres Grau
    const int tolerance = 3;
    const int maxIterations = 5;
    for (int k = 0; k < maxIterations; ++k) {
        QVector<int> hist = m_model->getHistogram();
        double sumPixels = 0; double sumWeighted = 0;
        for (int i = 0; i < hist.size(); ++i) { sumWeighted += i * hist[i]; sumPixels += hist[i]; }
        if (sumPixels == 0) return;
        int currentMean = static_cast<int>(sumWeighted / sumPixels);
        int diff = targetMean - currentMean;
        if (std::abs(diff) <= tolerance) { ui->statusbar->showMessage(QString("Auto-Helligkeit: Optimiert (Mittelwert: %1)").arg(currentMean), 3000); break; }
        int currentSliderVal = m_helligkeitSlider->value();
        int newSliderVal = currentSliderVal + diff;
        if (newSliderVal > 100) newSliderVal = 100; if (newSliderVal < -100) newSliderVal = -100;
        if (newSliderVal == currentSliderVal) break;
        m_helligkeitSlider->setValue(newSliderVal);
        QCoreApplication::processEvents();  // UI responsive halten
    }
}

// --------------------------------------------------------------------------------
// UNDO / REDO
// --------------------------------------------------------------------------------

void MainWindow::onUndoClicked() {
    m_model->undo();
    updateImageDisplay();
}

void MainWindow::onRedoClicked() {
    m_model->redo();
    updateImageDisplay();
}

void MainWindow::updateHistoryButtons() {
    m_actionUndo->setEnabled(m_model->canUndo());
    m_actionRedo->setEnabled(m_model->canRedo());
}

// --------------------------------------------------------------------------------
// NETZWERK / URL LADEN
// --------------------------------------------------------------------------------

void MainWindow::onOpenUrlClicked()
{
    bool ok;
    QString text = QInputDialog::getText(this, "Bild von URL laden",
                                         "URL eingeben:", QLineEdit::Normal,
                                         "https://", &ok);
    if (ok && !text.isEmpty()) {
        ui->statusbar->showMessage("Lade Bild herunter: " + text);
        QNetworkRequest request{QUrl(text)};

        // Wichtig: User-Agent setzen, damit Server wissen, wer anfragt (verhindert Blockierung)
        request.setHeader(QNetworkRequest::UserAgentHeader, "OnePicClient/1.0");
        // Startet den Download asynchron. Das Programm friert nicht ein.
        m_netManager->get(request);
    }
}
// Slot, der aufgerufen wird, wenn der Download fertig ist (Signal: finished)
void MainWindow::onImageDownloaded(QNetworkReply *reply)
{
    if (reply->error() != QNetworkReply::NoError) {
        QMessageBox::warning(this, "Download Fehler", "Fehler beim Laden: " + reply->errorString());
        ui->statusbar->clearMessage();
        reply->deleteLater();   // Speicher freigeben
        return;
    }

    QByteArray data = reply->readAll();
    QImage img;
    // Versuchen, die Rohdaten als Bild zu interpretieren
    if (img.loadFromData(data)) {
        m_model->loadFromImage(img);

        QString url = reply->url().toString();
        m_permanenteStatusNachricht = url;
        ui->statusbar->showMessage("Geladen von: " + url);
        setWindowTitle("Web-Bild | OnePic");

        // Controls aktivieren (gleicher Block wie bei FileOpen)
        m_helligkeitSlider->setValue(0);
        m_kontrastSlider->setValue(50);
        m_actionGraustufen->setChecked(false);
        m_mausCropAktiv = false;
        m_actionCrop->setChecked(false);
        m_actionFreeTransform->setChecked(false);
        m_actionColorSplash->setChecked(false);
        setControlsEnabled(true);
        updateImageDisplay();

    } else {
        QMessageBox::warning(this, "Fehler", "Die heruntergeladenen Daten sind kein unterstütztes Bildformat.");
        ui->statusbar->clearMessage();
    }

    reply->deleteLater();   // Wichtig: Reply-Objekt löschen, sonst Memory Leak
}