#include "mainwindow.h"
#include "clipboardresultdialog.h"
#include "clipboardurl.h"
#include "ui_mainwindow.h"
#include "yourlsclient.h"

#include <QAction>
#include <QApplication>
#include <QClipboard>
#include <QCloseEvent>
#include <QCoreApplication>
#include <QDialog>
#include <QDialogButtonBox>
#include <QGuiApplication>
#include <QLabel>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QSettings>
#include <QStatusBar>
#include <QStyle>
#include <QTimer>
#include <QVBoxLayout>

namespace {

    /**
   * @brief Builds a clickable HTML link for dialogs.
   * @param url URL to render.
   * @return Rich text string.
   */
    QString makeLinkHtml(const QUrl &url) {
        const QString urlText = url.toDisplayString();
        return QStringLiteral("<a href=\"%1\">%2</a>")
                .arg(url.toString(QUrl::FullyEncoded), urlText.toHtmlEscaped());
    }

    /**
   * @brief Returns the organization name used by QSettings.
   * @return Organization string.
   */
    QString settingsOrganization() {
        return QStringLiteral("deeaitch");
    }

    /**
   * @brief Returns the application name used by QSettings.
   * @return Application string.
   */
    QString settingsApplication() {
        return QStringLiteral("yourls-ui");
    }

}// namespace

/**
 * @brief Constructs the main window.
 * @param parent Parent widget.
 */
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent), ui(new Ui::MainWindow), m_trayIcon(nullptr), m_trayMenu(nullptr), m_cutUrlAction(nullptr), m_settingsAction(nullptr), m_helpAction(nullptr), m_aboutAction(nullptr), m_exitAction(nullptr), m_yourlsClient(new YourlsClient(this)) {
    ui->setupUi(this);
#ifndef QT_NO_DEBUG
    qDebug() << "[yourls-ui] debug build, executable:" << QCoreApplication::applicationFilePath()
             << "Qt:" << qVersion() << "platform:" << QGuiApplication::platformName();
#endif
    setWindowTitle(QStringLiteral("yourls-ui settings"));
    ui->apiKeyLineEdit->setEchoMode(QLineEdit::Password);
    statusBar()->showMessage(QStringLiteral("Configure YOURLS API settings and save."));

    setupMenuActions();
    setupTray();
    setupConnections();
    loadSettings();

    connect(m_yourlsClient, &YourlsClient::shortenSucceeded, this, &MainWindow::onShortenSucceeded);
    connect(m_yourlsClient, &YourlsClient::shortenFailed, this, &MainWindow::onShortenFailed);

    if (hasValidSettings()) {
        if (m_trayIcon != nullptr)
            m_trayIcon->show();
        QTimer::singleShot(0, this, &MainWindow::hideToTray);
    }
}

/**
 * @brief Destroys the main window.
 */
MainWindow::~MainWindow() {
    delete ui;
}

/**
 * @brief Handles close requests.
 * @param event Close event.
 */
void MainWindow::closeEvent(QCloseEvent *event) {
    if (hasValidSettings() && m_trayIcon != nullptr && m_trayIcon->isVisible()) {
        hideToTray();
        event->ignore();
        return;
    }

    QMainWindow::closeEvent(event);
}

/**
 * @brief Saves settings from the UI.
 */
void MainWindow::saveSettings() {
    const QString apiUrl = ui->urlLineEdit->text().trimmed();
    const QString apiKey = ui->apiKeyLineEdit->text().trimmed();

    if (apiUrl.isEmpty()) {
        QMessageBox::warning(this, QStringLiteral("Missing API URL"), QStringLiteral("Please enter the YOURLS API URL."));
        return;
    }

    if (apiKey.isEmpty()) {
        QMessageBox::warning(this, QStringLiteral("Missing API key"), QStringLiteral("Please enter the YOURLS API signature."));
        return;
    }

    const QUrl parsedApiUrl(apiUrl);
    if (!parsedApiUrl.isValid() || parsedApiUrl.scheme().isEmpty() || parsedApiUrl.host().isEmpty()) {
        QMessageBox::warning(this,
                             QStringLiteral("Invalid API URL"),
                             QStringLiteral("The configured API URL does not look valid."));
        return;
    }

    QSettings settings(settingsOrganization(), settingsApplication());
    settings.setValue(QStringLiteral("api/url"), apiUrl);
    settings.setValue(QStringLiteral("api/signature"), apiKey);
    settings.sync();

    if (m_trayIcon != nullptr)
        m_trayIcon->show();

    statusBar()->showMessage(QStringLiteral("Settings saved."), 2000);
    hideToTray();
}

/**
 * @brief Shows About text.
 */
void MainWindow::showAbout() {
    QMessageBox::about(this,
                       QStringLiteral("About yourls-ui"),
                       QStringLiteral("yourls-ui\n\n"
                                      "Small tray utility for shortening clipboard URLs with a YOURLS API.\n\n"
                                      "Creator: deeaitch\n"
                                      "Created: 2026-03-16"));
}

/**
 * @brief Shows Help text.
 */
void MainWindow::showHelp() {
    QMessageBox::information(this,
                             QStringLiteral("Help"),
                             QStringLiteral("1. Open Settings and enter the YOURLS API URL and signature.\n"
                                            "2. Save the settings. The application will stay in the tray.\n"
                                            "3. Copy a full URL to the clipboard.\n"
                                            "4. Right-click the tray icon and choose \"Cut URL\".\n"
                                            "5. The short URL will be copied back to the clipboard and shown in a popup.\n\n"
                                            "If something fails, the program shows detailed error information."));
}

/**
 * @brief Shows the settings window.
 */
void MainWindow::showSettingsWindow() {
    showNormal();
    raise();
    activateWindow();
}

/**
 * @brief Hides the settings window to tray when possible.
 */
void MainWindow::hideToTray() {
    if (!hasValidSettings() || m_trayIcon == nullptr || !QSystemTrayIcon::isSystemTrayAvailable() || !m_trayIcon->isVisible()) {
        showSettingsWindow();
        return;
    }

    hide();
    if (m_trayIcon != nullptr && m_trayIcon->isVisible()) {
        m_trayIcon->showMessage(QStringLiteral("yourls-ui"),
                                QStringLiteral("The application is running in the system tray."),
                                QSystemTrayIcon::Information,
                                2000);
    }
}

/**
 * @brief Exits the application.
 */
void MainWindow::exitApplication() {
    QApplication::quit();
}

/**
 * @brief Handles tray icon activation.
 * @param reason Activation reason.
 */
void MainWindow::onTrayIconActivated(QSystemTrayIcon::ActivationReason reason) {
    if (reason == QSystemTrayIcon::DoubleClick || reason == QSystemTrayIcon::Trigger)
        showSettingsWindow();
}

/**
 * @brief Reads a URL from the clipboard and shortens it.
 */
void MainWindow::cutUrlFromClipboard() {
    if (!hasValidSettings()) {
        QMessageBox::warning(this,
                             QStringLiteral("Settings required"),
                             QStringLiteral("Please configure the API URL and signature first."));
        showSettingsWindow();
        return;
    }

    QUrl longUrl;
    if (QGuiApplication::platformName().startsWith(QStringLiteral("wayland")) && !isActiveWindow()) {
        // Wayland delivers clipboard offers to clients with keyboard focus.
        // A tray menu belongs to the shell and does not focus our application.
        QDialog clipboardDialog(this);
        clipboardDialog.setWindowTitle(QStringLiteral("Read clipboard URL"));
        auto *layout = new QVBoxLayout(&clipboardDialog);
        layout->addWidget(new QLabel(
                QStringLiteral("Activate this window to read the URL from the clipboard."), &clipboardDialog));
        auto *buttons = new QDialogButtonBox(QDialogButtonBox::Cancel, &clipboardDialog);
        auto *readButton = buttons->addButton(QStringLiteral("Read clipboard"), QDialogButtonBox::AcceptRole);
        layout->addWidget(buttons);
        connect(buttons, &QDialogButtonBox::rejected, &clipboardDialog, &QDialog::reject);

        const auto readClipboard = [&]() {
            longUrl = ClipboardUrl::fromMimeData(QGuiApplication::clipboard()->mimeData());
            clipboardDialog.accept();
        };
        connect(readButton, &QPushButton::clicked, &clipboardDialog, readClipboard);

        // Wait for focus and the clipboard offer, without blocking the event loop.
        QTimer pollTimer(&clipboardDialog);
        int activePolls = 0;
        connect(&pollTimer, &QTimer::timeout, &clipboardDialog, [&]() {
            if (!clipboardDialog.isActiveWindow())
                return;
            const auto *mimeData = QGuiApplication::clipboard()->mimeData();
            if ((mimeData != nullptr && !mimeData->formats().isEmpty()) || ++activePolls >= 20)
                readClipboard();
        });
#ifndef QT_NO_DEBUG
        qDebug() << "[clipboard] Wayland: waiting for focused window and clipboard offer";
#endif
        pollTimer.start(100);
        if (clipboardDialog.exec() != QDialog::Accepted)
            return;
        pollTimer.stop();
    } else {
        longUrl = ClipboardUrl::fromMimeData(QGuiApplication::clipboard()->mimeData());
    }
#ifndef QT_NO_DEBUG
    qDebug() << "[clipboard] final URL:" << longUrl << "valid:" << longUrl.isValid();
#endif
    if (!longUrl.isValid()) {
#ifndef QT_NO_DEBUG
        qDebug() << "[clipboard] rejected locally; no YOURLS request sent";
#endif
        QMessageBox::warning(this,
                             QStringLiteral("Invalid clipboard content"),
                             QStringLiteral("The clipboard does not contain a valid URL."));
        return;
    }

    YourlsSettings settings;
    settings.apiUrl = ui->urlLineEdit->text().trimmed();
    settings.signature = ui->apiKeyLineEdit->text().trimmed();

    if (m_trayIcon != nullptr) {
        m_trayIcon->showMessage(QStringLiteral("yourls-ui"),
                                QStringLiteral("Requesting short URL..."),
                                QSystemTrayIcon::Information,
                                1200);
    }

    m_yourlsClient->shortenUrl(settings, longUrl);
}

/**
 * @brief Handles successful shortening.
 * @param shortUrl Generated short URL.
 */
void MainWindow::onShortenSucceeded(const QUrl &shortUrl) {
    showShortUrlPopup(shortUrl);
}

/**
 * @brief Handles shortening failure.
 * @param details Detailed error text.
 */
void MainWindow::onShortenFailed(const QString &details) {
    QMessageBox::critical(this, QStringLiteral("Failed to create short URL"), details);
}

/**
 * @brief Creates tray icon and tray menu.
 */
void MainWindow::setupTray() {
    if (!QSystemTrayIcon::isSystemTrayAvailable()) {
        QMessageBox::warning(this,
                             QStringLiteral("System tray unavailable"),
                             QStringLiteral("No system tray was detected. The application will stay as a normal window."));
        return;
    }

    m_trayIcon = new QSystemTrayIcon(this);
    m_trayIcon->setIcon(style()->standardIcon(QStyle::SP_DialogApplyButton));

    m_trayMenu = new QMenu(this);
    m_trayMenu->addAction(m_cutUrlAction);
    m_trayMenu->addSeparator();
    m_trayMenu->addAction(m_settingsAction);
    m_trayMenu->addAction(m_helpAction);
    m_trayMenu->addAction(m_aboutAction);
    m_trayMenu->addSeparator();
    m_trayMenu->addAction(m_exitAction);

    m_trayIcon->setContextMenu(m_trayMenu);
}

/**
 * @brief Connects UI signals to slots.
 */
void MainWindow::setupConnections() {
    connect(ui->saveBtn, &QPushButton::clicked, this, &MainWindow::saveSettings);

    connect(ui->actionHelp, &QAction::triggered, this, &MainWindow::showHelp);
    connect(ui->actionAbout, &QAction::triggered, this, &MainWindow::showAbout);
    connect(ui->actionExit, &QAction::triggered, this, &MainWindow::exitApplication);

    connect(m_cutUrlAction, &QAction::triggered, this, &MainWindow::cutUrlFromClipboard);
    connect(m_settingsAction, &QAction::triggered, this, &MainWindow::showSettingsWindow);
    connect(m_helpAction, &QAction::triggered, this, &MainWindow::showHelp);
    connect(m_aboutAction, &QAction::triggered, this, &MainWindow::showAbout);
    connect(m_exitAction, &QAction::triggered, this, &MainWindow::exitApplication);

    if (m_trayIcon != nullptr)
        connect(m_trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::onTrayIconActivated);
}

/**
 * @brief Loads persisted settings into the UI.
 */
void MainWindow::loadSettings() {
    QSettings settings(settingsOrganization(), settingsApplication());
    ui->urlLineEdit->setText(settings.value(QStringLiteral("api/url")).toString());
    ui->apiKeyLineEdit->setText(settings.value(QStringLiteral("api/signature")).toString());
}

/**
 * @brief Returns true when all required settings are present.
 * @return True when the application can work from the tray.
 */
bool MainWindow::hasValidSettings() const {
    return !ui->urlLineEdit->text().trimmed().isEmpty() && !ui->apiKeyLineEdit->text().trimmed().isEmpty();
}

/**
 * @brief Shows a popup with the generated short URL.
 * @param shortUrl Generated short URL.
 */
void MainWindow::showShortUrlPopup(const QUrl &shortUrl) {
    const bool wayland = QGuiApplication::platformName().startsWith(QStringLiteral("wayland"));
    ClipboardResultDialog dialog(shortUrl, wayland, this);
    dialog.setWindowTitle(QStringLiteral("Short URL created"));

    auto *layout = new QVBoxLayout(&dialog);
    auto *label = new QLabel(QStringLiteral("Generated short URL:<br>%1").arg(makeLinkHtml(shortUrl)), &dialog);
    label->setTextFormat(Qt::RichText);
    label->setTextInteractionFlags(Qt::TextBrowserInteraction);
    label->setOpenExternalLinks(true);
    layout->addWidget(label);
    layout->addWidget(dialog.copyStatusLabel());

    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Ok, &dialog);
    QObject::connect(buttons, &QDialogButtonBox::accepted, &dialog, [&dialog]() {
        // An OK click supplies focus/input even when automatic activation was denied.
        if (dialog.copyShortUrl())
            dialog.accept();
    });
    layout->addWidget(buttons);

    if (!wayland)
        dialog.copyShortUrl();
    dialog.exec();
}

/**
 * @brief Creates tray/menu actions.
 */
void MainWindow::setupMenuActions() {
    m_cutUrlAction = new QAction(QStringLiteral("Cut URL"), this);
    m_settingsAction = new QAction(QStringLiteral("Settings"), this);
    m_helpAction = new QAction(QStringLiteral("Help"), this);
    m_aboutAction = new QAction(QStringLiteral("About"), this);
    m_exitAction = new QAction(QStringLiteral("Exit"), this);
}