mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "globalkeyinterceptor.h"
#include "hotkeymanager.h"
#include "windowoverlay.h"

#include <QDir>
#include <QFile>
#include <QFileDialog>
#include <QCoreApplication>
#include <QLineEdit>
#include <QMetaObject>
#include <QMenu>
#include <QComboBox>
#include <QTabWidget>
#include <QTabBar>
#include <QStyle>
#include <QStyleOptionTab>
#include <QStylePainter>
#include <QGraphicsOpacityEffect>
#include <QFontMetrics>
#include <QCheckBox>
#include <QColor>
#include <QColorDialog>
#include <QSignalBlocker>
#include <QAction>
#include <QSystemTrayIcon>
#include <QIcon>
#include <QCloseEvent>
#include <QApplication>
#include <QMessageBox>
#include <QRegularExpression>
#include <QStandardPaths>
#include <QTimer>
#include <QtEndian>

#include <cstring>

#include <QMediaDevices>
#include <QAudioDevice>

#include <windows.h>

QPointer<MainWindow> MainWindow::instance = nullptr;

class ServiceTabBar : public QTabBar {
public:
    explicit ServiceTabBar(QWidget *parent = nullptr)
        : QTabBar(parent) {}

    QSize tabSizeHint(int index) const override {
        QStyleOptionTab opt;
        initStyleOption(&opt, index);
        QFontMetrics fm = opt.fontMetrics;
        QSize textSize = fm.size(Qt::TextShowMnemonic, opt.text);
        QSize iconSize = opt.icon.isNull() ? QSize(0, 0) : opt.iconSize;

        const int hspace = style()->pixelMetric(QStyle::PM_TabBarTabHSpace, &opt, this);
        const int vspace = style()->pixelMetric(QStyle::PM_TabBarTabVSpace, &opt, this);
        int width = textSize.width() + iconSize.width();
        if (!opt.icon.isNull() && !opt.text.isEmpty())
            width += fm.horizontalAdvance(QLatin1Char(' '));
        width += hspace;
        int height = qMax(textSize.height(), iconSize.height()) + vspace;
        return QSize(width, height);
    }

protected:
    void paintEvent(QPaintEvent *event) override {
        Q_UNUSED(event);
        QStylePainter painter(this);
        QStyleOptionTab opt;
        for (int i = 0; i < count(); ++i) {
            initStyleOption(&opt, i);
            painter.drawControl(QStyle::CE_TabBarTabShape, opt);

            QRect textRect = opt.rect;
            int hspace = style()->pixelMetric(QStyle::PM_TabBarTabHSpace, &opt, this) / 2;
            int vspace = style()->pixelMetric(QStyle::PM_TabBarTabVSpace, &opt, this) / 2;
            textRect.adjust(hspace, vspace, -hspace, -vspace);

            if (!opt.icon.isNull()) {
                QSize iconSize = opt.iconSize.isValid() ? opt.iconSize : QSize(16, 16);
                QRect iconRect = textRect;
                iconRect.setWidth(iconSize.width());
                iconRect.setHeight(iconSize.height());
                iconRect.moveTop(textRect.top() + (textRect.height() - iconSize.height()) / 2);
                QIcon::Mode iconMode = (opt.state & QStyle::State_Enabled) ? QIcon::Normal : QIcon::Disabled;
                QIcon::State iconState = (opt.state & QStyle::State_Selected) ? QIcon::On : QIcon::Off;
                painter.drawItemPixmap(iconRect, Qt::AlignLeft | Qt::AlignVCenter,
                                       opt.icon.pixmap(iconSize, iconMode, iconState));
                textRect.setLeft(iconRect.right() + 4);
            }

            style()->drawItemText(&painter, textRect, Qt::AlignVCenter | Qt::AlignLeft,
                                  opt.palette, opt.state & QStyle::State_Enabled,
                                  opt.text, QPalette::WindowText);
        }
    }
};

class ServiceTabWidget : public QTabWidget {
public:
    explicit ServiceTabWidget(QWidget *parent = nullptr)
        : QTabWidget(parent) {
        setTabBar(new ServiceTabBar(this));
    }
};

namespace {
/// Default overlay color fallback (matches ConfigStore default #EC46FF)
const QColor DEFAULT_OVERLAY_COLOR(236, 70, 255);
/// Audio level meter update interval (ms)
constexpr int LEVEL_DECAY_INTERVAL_MS = 50;
/// Prewarm delay after window initialization (ms)
constexpr int PREWARM_DELAY_MS = 500;
/// Audio level smoothing factor (0-1, higher = more smoothing)
constexpr qreal LEVEL_SMOOTHING_FACTOR = 0.85;
/// Audio level decay rate per tick
constexpr qreal LEVEL_DECAY_RATE = 0.04;
/// Minimum elapsed time before level decay starts (ms)
constexpr qint64 LEVEL_DECAY_THRESHOLD_MS = 120;
/// Allowed range for Soniox endpoint delay in milliseconds.
constexpr int SONIOX_MIN_ENDPOINT_DELAY_MS = 500;
constexpr int SONIOX_MAX_ENDPOINT_DELAY_MS = 3000;
/// Allowed range for Yandex endpoint delay hint in milliseconds.
constexpr int YANDEX_MIN_ENDPOINT_DELAY_MS = 0;
constexpr int YANDEX_MAX_ENDPOINT_DELAY_MS = 5000;
/// Opacity for disabled delay controls to make inactive state visible without overriding native style.
constexpr qreal DISABLED_DELAY_SPINBOX_OPACITY = 0.55;
constexpr qreal ENABLED_DELAY_SPINBOX_OPACITY = 1.0;

bool hasLanguageHints(const QString &value) {
    const QStringList parts = value.split(QRegularExpression("[,;]"),
                                          Qt::SkipEmptyParts);
    for (const auto &raw : parts) {
        if (!raw.trimmed().isEmpty())
            return true;
    }
    return false;
}

QColor parseColorValue(const QString &value, const QColor &fallback) {
    const QColor color(value.trimmed());
    if (!color.isValid())
        return fallback;
    return QColor(color.red(), color.green(), color.blue());
}

QString normalizeColorText(const QString &value, const QColor &fallback) {
    return parseColorValue(value, fallback).name(QColor::HexRgb);
}

void setDelaySpinBoxState(QSpinBox *spinBox, const bool enabled) {
    if (!spinBox)
        return;

    spinBox->setEnabled(enabled);
    auto *effect = qobject_cast<QGraphicsOpacityEffect *>(spinBox->graphicsEffect());
    if (!effect) {
        effect = new QGraphicsOpacityEffect(spinBox);
        spinBox->setGraphicsEffect(effect);
    }
    effect->setOpacity(enabled ? ENABLED_DELAY_SPINBOX_OPACITY : DISABLED_DELAY_SPINBOX_OPACITY);
}
} // namespace

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , hotkeyManager(new HotkeyManager(this))
    , overlayWindow(new WindowOverlay(this))
    , dictationController(new DictationController(this))
    , levelCapture(new AudioCapture(this))
    , levelDecayTimer(new QTimer(this)) {
    instance = this;
    ui->setupUi(this);
    // Include application name in the window title
    setWindowTitle(QCoreApplication::applicationName() + " - " + tr("Settings"));
    {
        auto *oldTabs = ui->servicesTabWidget;
        auto *newTabs = new ServiceTabWidget(ui->tabServices);
        newTabs->setObjectName(oldTabs->objectName());
        while (oldTabs->count() > 0) {
            QWidget *page = oldTabs->widget(0);
            QString title = oldTabs->tabText(0);
            oldTabs->removeTab(0);
            newTabs->addTab(page, title);
        }
        int tabsIndex = ui->verticalLayoutServices->indexOf(oldTabs);
        ui->verticalLayoutServices->removeWidget(oldTabs);
        if (tabsIndex < 0)
            ui->verticalLayoutServices->addWidget(newTabs);
        else
            ui->verticalLayoutServices->insertWidget(tabsIndex, newTabs);
        oldTabs->deleteLater();
        ui->servicesTabWidget = newTabs;
    }
    ui->servicesTabWidget->setTabPosition(QTabWidget::West);
    ui->servicesTabWidget->tabBar()->setExpanding(false);
    connect(ui->lineEditHotkey, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditFinalizationHotkey, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->comboProvider, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, [this](int) {
                syncServiceTabs(currentProviderId());
                saveConfig();
            });
    connect(ui->comboInputDevice, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, [this](int) {
                restartInputLevelCapture();
                saveConfig();
            });
    connect(ui->lineEditSonioxEndpoint, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditSonioxApiKey, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditSonioxModel, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditSonioxLanguageHints, &QLineEdit::textChanged, this,
            [this](const QString &value) {
                updateLanguageHintsStrictEnabled(value);
                saveConfig();
            });
    connect(ui->checkBoxSonioxLanguageHintsStrict, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->lineEditSonioxContext, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditSonioxProxy, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->checkBoxSonioxEndpointDetection, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->checkBoxSonioxUseMaxEndpointDelay, &QCheckBox::toggled, this, [this](const bool checked) {
        setDelaySpinBoxState(ui->spinBoxSonioxMaxEndpointDelayMs, checked);
        saveConfig();
    });
    connect(ui->spinBoxSonioxMaxEndpointDelayMs, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MainWindow::saveConfig);
    connect(ui->checkBoxSonioxKeepConnection, &QCheckBox::toggled, this, &MainWindow::saveConfig);

    connect(ui->lineEditAzureEndpoint, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditAzureProxy, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditAzureApiKey, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditAzureEndpointId, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditAzureLanguage, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditAzureLanguageHints, &QLineEdit::textChanged, this,
            [this](const QString &value) {
                updateAzureLanguageHintsStrictEnabled(value);
                saveConfig();
            });
    connect(ui->checkBoxAzureLanguageHintsStrict, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->lineEditAzurePhraseHints, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->checkBoxAzureKeepConnection, &QCheckBox::toggled, this, &MainWindow::saveConfig);

    connect(ui->lineEditDeepgramEndpoint, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditDeepgramProxy, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditDeepgramApiKey, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditDeepgramModel, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditDeepgramLanguage, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->checkBoxDeepgramPunctuate, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->checkBoxDeepgramInterimResults, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->checkBoxDeepgramSmartFormat, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->checkBoxDeepgramKeepConnection, &QCheckBox::toggled, this, &MainWindow::saveConfig);

    connect(ui->lineEditYandexEndpoint, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->checkBoxYandexUseApiKey, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->lineEditYandexApiKey, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditYandexFolderId, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditYandexModel, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditYandexLanguage, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->checkBoxYandexTextNormalization, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->checkBoxYandexLiteratureText, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->checkBoxYandexUseMaxPauseBetweenWordsHint, &QCheckBox::toggled, this, [this](const bool checked) {
        setDelaySpinBoxState(ui->spinBoxYandexMaxPauseBetweenWordsHintMs, checked);
        saveConfig();
    });
    connect(ui->spinBoxYandexMaxPauseBetweenWordsHintMs, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MainWindow::saveConfig);
    connect(ui->checkBoxYandexProfanityFilter, &QCheckBox::toggled, this, &MainWindow::saveConfig);

    setDelaySpinBoxState(ui->spinBoxSonioxMaxEndpointDelayMs, ui->checkBoxSonioxUseMaxEndpointDelay->isChecked());
    setDelaySpinBoxState(ui->spinBoxYandexMaxPauseBetweenWordsHintMs,
                         ui->checkBoxYandexUseMaxPauseBetweenWordsHint->isChecked());

    connect(ui->lineEditOverlayBorderColor, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->lineEditOverlayGlowColor, &QLineEdit::textChanged, this, &MainWindow::saveConfig);
    connect(ui->doubleSpinOverlayPulseSpeed, QOverload<double>::of(&QDoubleSpinBox::valueChanged),
            this, &MainWindow::saveConfig);
    connect(ui->spinOverlayGlowSize, QOverload<int>::of(&QSpinBox::valueChanged),
            this, &MainWindow::saveConfig);
    connect(ui->checkBoxOverlayShowRec, &QCheckBox::toggled, this, [this](bool checked) {
        updateRecBlinkEnabled(checked);
        saveConfig();
    });
    connect(ui->checkBoxOverlayBlinkDot, &QCheckBox::toggled, this, &MainWindow::saveConfig);
    connect(ui->pushButtonOverlayPreview, &QPushButton::toggled, this,
            [this](bool checked) { setOverlayPreviewEnabled(checked); });

    const AppConfig defaultConfig = ConfigStore::defaultConfig();
    const QColor defaultBorder = parseColorValue(defaultConfig.visualStyle.borderColor, DEFAULT_OVERLAY_COLOR);
    const QColor defaultGlow = parseColorValue(defaultConfig.visualStyle.glowColor, DEFAULT_OVERLAY_COLOR);
    auto pickColor = [this](QLineEdit *lineEdit, const QColor &fallback) {
        const QColor current = parseColorValue(lineEdit->text(), fallback);
        const QColor chosen = QColorDialog::getColor(current, this, tr("Select color"));
        if (!chosen.isValid())
            return;
        lineEdit->setText(chosen.name(QColor::HexRgb));
    };
    connect(ui->pushButtonOverlayBorderColorPick, &QPushButton::clicked, this, [pickColor, this, defaultBorder]() {
        pickColor(ui->lineEditOverlayBorderColor, defaultBorder);
    });
    connect(ui->pushButtonOverlayGlowColorPick, &QPushButton::clicked, this, [pickColor, this, defaultGlow]() {
        pickColor(ui->lineEditOverlayGlowColor, defaultGlow);
    });

    levelDecayTimer->setInterval(LEVEL_DECAY_INTERVAL_MS);
    connect(levelDecayTimer, &QTimer::timeout, this, &MainWindow::decayInputLevel);
    connect(levelCapture, &AudioCapture::audioDataReady, this, &MainWindow::handleInputLevelData);
    connect(levelCapture, &AudioCapture::errorOccurred, this, [this](const QString &) {
        stopInputLevelCapture();
    });

    connect(ui->pushButtonExportSettings, &QPushButton::clicked,
            this, &MainWindow::exportSettings);
    connect(ui->pushButtonImportSettings, &QPushButton::clicked,
            this, &MainWindow::importSettings);

    ui->lineEditHotkey->installEventFilter(this);
    ui->lineEditFinalizationHotkey->installEventFilter(this);

    createTrayIcon();

    connect(dictationController, &DictationController::errorOccurred, this, [this](const QString &message) {
        if (overlayWindow)
            overlayWindow->hideOverlay();
        restartInputLevelCapture();
        if (hotkeyManager)
            hotkeyManager->setEouEnabled(false);
        if (trayIcon) {
            trayIcon->showMessage(QCoreApplication::applicationName(),
                                  message,
                                  QSystemTrayIcon::Warning);
        }
    });

    connect(hotkeyManager, &HotkeyManager::hotkeyPressed,
            this, &MainWindow::handleGlobalHotkeyPressed);
    connect(hotkeyManager, &HotkeyManager::eouPressed, this, [this]() {
        if (dictationController)
            dictationController->sendEou();
    });

    populateServiceProviders();
    populateInputDevices();

    connect(ui->tabWidget, &QTabWidget::currentChanged, this, [this](int index) {
        if (index < 0)
            return;
        if (ui->tabWidget->widget(index) != ui->tabServices)
            return;
        syncServiceTabs(currentProviderId());
    });

    loadConfig();
    restartInputLevelCapture();
    static_cast<void>(hotkeyManager->registerHotkey(ui->lineEditHotkey->text()));
    
    // Initialize connections on startup (program starts minimized to tray)
    QTimer::singleShot(PREWARM_DELAY_MS, this, [this]() {
        if (dictationController) {
            const AppConfig config = buildConfigFromUi();
            dictationController->prewarm(config);
        }
    });
}

MainWindow::~MainWindow() {
    GlobalKeyInterceptor::stop();
    if (dictationController)
        dictationController->stop();
    delete ui;
    instance = nullptr;
}

bool MainWindow::eventFilter(QObject *obj, QEvent *ev) {
    if (obj == ui->lineEditHotkey) {
        if (ev->type() == QEvent::FocusIn) {
            prevHotkey = ui->lineEditHotkey->text();
            hotkeyCaptured = false;
            GlobalKeyInterceptor::capturing = true;
            GlobalKeyInterceptor::captureTarget = GlobalKeyInterceptor::TARGET_MAIN_HOTKEY;
            GlobalKeyInterceptor::start();
        } else if (ev->type() == QEvent::FocusOut) {
            GlobalKeyInterceptor::capturing = false;
            GlobalKeyInterceptor::captureTarget = GlobalKeyInterceptor::TARGET_NONE;
            if (!hotkeyCaptured)
                ui->lineEditHotkey->setText(prevHotkey);
        }
    } else if (obj == ui->lineEditFinalizationHotkey) {
        if (ev->type() == QEvent::FocusIn) {
            prevFinalizationHotkey = ui->lineEditFinalizationHotkey->text();
            finalizationHotkeyCaptured = false;
            GlobalKeyInterceptor::capturing = true;
            GlobalKeyInterceptor::captureTarget = GlobalKeyInterceptor::TARGET_FINALIZATION_HOTKEY;
            GlobalKeyInterceptor::start();
        } else if (ev->type() == QEvent::FocusOut) {
            GlobalKeyInterceptor::capturing = false;
            GlobalKeyInterceptor::captureTarget = GlobalKeyInterceptor::TARGET_NONE;
            if (!finalizationHotkeyCaptured)
                ui->lineEditFinalizationHotkey->setText(prevFinalizationHotkey);
        }
    }
    return QMainWindow::eventFilter(obj, ev);
}

void MainWindow::closeEvent(QCloseEvent *event) {
    event->ignore();
    if (ui->pushButtonOverlayPreview->isChecked()) {
        const QSignalBlocker blocker(ui->pushButtonOverlayPreview);
        ui->pushButtonOverlayPreview->setChecked(false);
        setOverlayPreviewEnabled(false);
    }
    stopInputLevelCapture();
    hide();
}

void MainWindow::showEvent(QShowEvent *event) {
    QMainWindow::showEvent(event);
    restartInputLevelCapture();
}

void MainWindow::hideEvent(QHideEvent *event) {
    QMainWindow::hideEvent(event);
    stopInputLevelCapture();
    
    // Reconnect services when settings window is closed
    if (dictationController) {
        const AppConfig config = buildConfigFromUi();
        dictationController->prewarm(config);
    }
    
    // Re-enable hotkey when settings window is closed
    hotkeyManager->setEnabled(true);
}

void MainWindow::changeEvent(QEvent *event) {
    QMainWindow::changeEvent(event);
    
    if (event->type() == QEvent::WindowStateChange) {
        // Skip if minimized - hideEvent will handle it
        return;
    }
    
    if (event->type() == QEvent::ActivationChange) {
        if (isActiveWindow()) {
            // Window gained focus - disable services
            if (dictationController) {
                dictationController->disconnectService();
            }
            hotkeyManager->setEnabled(false);
        } else {
            // Window lost focus - enable services
            if (dictationController) {
                const AppConfig config = buildConfigFromUi();
                dictationController->prewarm(config);
            }
            hotkeyManager->setEnabled(true);
        }
    }
}

void MainWindow::setHotkeyText(const QString &text) {
    ui->lineEditHotkey->setText(text);
    hotkeyCaptured = true;
    saveConfig();
}

void MainWindow::setFinalizationHotkeyText(const QString &text) {
    ui->lineEditFinalizationHotkey->setText(text);
    finalizationHotkeyCaptured = true;
    saveConfig();
}

void MainWindow::applyDefaultSettings() {
    applyConfig(ConfigStore::defaultConfig());
}

void MainWindow::loadConfig() {
    const QString path = ConfigStore::configFilePath();
    if (!QFile::exists(path)) {
        loadingConfig = true;
        applyDefaultSettings();
        loadingConfig = false;
        saveConfig();
        return;
    }

    AppConfig config;
    if (!ConfigStore::loadFromFile(path, &config))
        return;

    loadingConfig = true;
    applyConfig(config);
    loadingConfig = false;
}

void MainWindow::saveConfig() {
    if (loadingConfig)
        return;

    const AppConfig config = buildConfigFromUi();
    static_cast<void>(ConfigStore::saveToFile(ConfigStore::configFilePath(), config));

    static_cast<void>(hotkeyManager->registerHotkey(config.settings.hotkey));
    static_cast<void>(hotkeyManager->setEouSequence(config.settings.finalizationHotkey));
    updateOverlayStyle(config.visualStyle);
}

QString MainWindow::suggestedSettingsPath() const {
    QString baseDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
    if (baseDir.isEmpty())
        baseDir = QDir::homePath();
    return QDir(baseDir).filePath("VoiceToKeys_settings.json");
}

void MainWindow::exportSettings() {
    const QString filter = tr("JSON Files (*.json)");
    const QString path = QFileDialog::getSaveFileName(
        this,
        tr("Export Settings"),
        suggestedSettingsPath(),
        filter
    );
    if (path.isEmpty())
        return;

    const AppConfig config = buildConfigFromUi();
    if (!ConfigStore::saveToFile(path, config)) {
        QMessageBox::warning(this, tr("Export Settings"),
                             tr("Failed to export settings."));
    }
}

void MainWindow::importSettings() {
    const QString filter = tr("JSON Files (*.json);;All Files (*)");
    const QString path = QFileDialog::getOpenFileName(
        this,
        tr("Import Settings"),
        QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation),
        filter
    );
    if (path.isEmpty())
        return;

    AppConfig config;
    if (!ConfigStore::loadFromFile(path, &config)) {
        QMessageBox::warning(this, tr("Import Settings"),
                             tr("Failed to import settings."));
        return;
    }

    loadingConfig = true;
    applyConfig(config);
    loadingConfig = false;
    saveConfig();
}

void MainWindow::applyConfig(const AppConfig &config) {
    {
        const QSignalBlocker blocker(ui->comboProvider);
        bool matched = false;
        for (int i = 0; i < ui->comboProvider->count(); ++i) {
            if (ui->comboProvider->itemData(i).toString() == config.settings.providerId) {
                ui->comboProvider->setCurrentIndex(i);
                matched = true;
                break;
            }
        }
        if (!matched && ui->comboProvider->count() > 0)
            ui->comboProvider->setCurrentIndex(0);
    }

    syncServiceTabs(config.settings.providerId);
    ui->lineEditHotkey->setText(config.settings.hotkey);
    ui->lineEditFinalizationHotkey->setText(config.settings.finalizationHotkey);

    {
        const QSignalBlocker blocker(ui->comboInputDevice);
        int selectedIndex = 0;
        for (int i = 0; i < ui->comboInputDevice->count(); ++i) {
            if (ui->comboInputDevice->itemData(i).toString() == config.settings.inputDeviceId) {
                selectedIndex = i;
                break;
            }
        }
        ui->comboInputDevice->setCurrentIndex(selectedIndex);
    }

    ui->lineEditSonioxEndpoint->setText(config.soniox.endpoint);
    ui->lineEditSonioxApiKey->setText(config.soniox.apiKey);
    ui->lineEditSonioxModel->setText(config.soniox.model);
    ui->lineEditSonioxLanguageHints->setText(config.soniox.languageHints);
    ui->checkBoxSonioxLanguageHintsStrict->setChecked(config.soniox.languageHintsStrict);
    ui->lineEditSonioxContext->setText(config.soniox.context);
    ui->lineEditSonioxProxy->setText(config.soniox.proxy);
    ui->checkBoxSonioxEndpointDetection->setChecked(config.soniox.endpointDetection);
    ui->spinBoxSonioxMaxEndpointDelayMs->setRange(SONIOX_MIN_ENDPOINT_DELAY_MS, SONIOX_MAX_ENDPOINT_DELAY_MS);
    ui->checkBoxSonioxUseMaxEndpointDelay->setChecked(config.soniox.useMaxEndpointDelay);
    ui->spinBoxSonioxMaxEndpointDelayMs->setValue(config.soniox.maxEndpointDelayMs);
    setDelaySpinBoxState(ui->spinBoxSonioxMaxEndpointDelayMs, config.soniox.useMaxEndpointDelay);
    ui->checkBoxSonioxKeepConnection->setChecked(config.soniox.keepConnection);
    updateLanguageHintsStrictEnabled(config.soniox.languageHints);

    ui->lineEditAzureEndpoint->setText(config.azure.endpoint);
    ui->lineEditAzureProxy->setText(config.azure.proxy);
    ui->lineEditAzureApiKey->setText(config.azure.apiKey);
    ui->lineEditAzureEndpointId->setText(config.azure.endpointId);
    ui->lineEditAzureLanguage->setText(config.azure.language);
    ui->lineEditAzureLanguageHints->setText(config.azure.languageHints);
    ui->checkBoxAzureLanguageHintsStrict->setChecked(config.azure.languageHintsStrict);
    ui->lineEditAzurePhraseHints->setText(config.azure.phraseHints);
    ui->checkBoxAzureKeepConnection->setChecked(config.azure.keepConnection);
    updateAzureLanguageHintsStrictEnabled(config.azure.languageHints);

    ui->lineEditDeepgramEndpoint->setText(config.deepgram.endpoint);
    ui->lineEditDeepgramProxy->setText(config.deepgram.proxy);
    ui->lineEditDeepgramApiKey->setText(config.deepgram.apiKey);
    ui->lineEditDeepgramModel->setText(config.deepgram.model);
    ui->lineEditDeepgramLanguage->setText(config.deepgram.language);
    ui->checkBoxDeepgramPunctuate->setChecked(config.deepgram.punctuate);
    ui->checkBoxDeepgramInterimResults->setChecked(config.deepgram.interimResults);
    ui->checkBoxDeepgramSmartFormat->setChecked(config.deepgram.smartFormat);
    ui->checkBoxDeepgramKeepConnection->setChecked(config.deepgram.keepConnection);

    ui->lineEditYandexEndpoint->setText(config.yandex.endpoint);
    ui->checkBoxYandexUseApiKey->setChecked(config.yandex.useApiKey);
    ui->lineEditYandexApiKey->setText(config.yandex.apiKey);
    ui->lineEditYandexFolderId->setText(config.yandex.folderId);
    ui->lineEditYandexModel->setText(config.yandex.model);
    ui->lineEditYandexLanguage->setText(config.yandex.language);
    ui->checkBoxYandexTextNormalization->setChecked(config.yandex.textNormalization);
    ui->checkBoxYandexLiteratureText->setChecked(config.yandex.literatureText);
    ui->spinBoxYandexMaxPauseBetweenWordsHintMs->setRange(YANDEX_MIN_ENDPOINT_DELAY_MS,
                                                           YANDEX_MAX_ENDPOINT_DELAY_MS);
    ui->checkBoxYandexUseMaxPauseBetweenWordsHint->setChecked(config.yandex.useMaxPauseBetweenWordsHint);
    ui->spinBoxYandexMaxPauseBetweenWordsHintMs->setValue(config.yandex.maxPauseBetweenWordsHintMs);
    setDelaySpinBoxState(ui->spinBoxYandexMaxPauseBetweenWordsHintMs, config.yandex.useMaxPauseBetweenWordsHint);
    ui->checkBoxYandexProfanityFilter->setChecked(config.yandex.profanityFilter);

    ui->lineEditOverlayBorderColor->setText(config.visualStyle.borderColor);
    ui->lineEditOverlayGlowColor->setText(config.visualStyle.glowColor);
    ui->doubleSpinOverlayPulseSpeed->setValue(config.visualStyle.pulseSpeedHz);
    ui->spinOverlayGlowSize->setValue(config.visualStyle.glowSizePx);
    ui->checkBoxOverlayShowRec->setChecked(config.visualStyle.showRecBadge);
    ui->checkBoxOverlayBlinkDot->setChecked(config.visualStyle.blinkRecDot);
    updateRecBlinkEnabled(config.visualStyle.showRecBadge);
    updateOverlayStyle(config.visualStyle);
    if (hotkeyManager)
        static_cast<void>(hotkeyManager->setEouSequence(config.settings.finalizationHotkey));
}

AppConfig MainWindow::buildConfigFromUi() const {
    AppConfig config;
    const AppConfig defaults = ConfigStore::defaultConfig();
    const QColor defaultBorder = parseColorValue(defaults.visualStyle.borderColor, DEFAULT_OVERLAY_COLOR);
    const QColor defaultGlow = parseColorValue(defaults.visualStyle.glowColor, DEFAULT_OVERLAY_COLOR);
    config.settings.providerId = currentProviderId();
    config.settings.hotkey = ui->lineEditHotkey->text();
    config.settings.finalizationHotkey = ui->lineEditFinalizationHotkey->text();
    config.settings.inputDeviceId = ui->comboInputDevice->currentData().toString();

    config.soniox.endpoint = ui->lineEditSonioxEndpoint->text();
    config.soniox.apiKey = ui->lineEditSonioxApiKey->text();
    config.soniox.model = ui->lineEditSonioxModel->text();
    config.soniox.languageHints = ui->lineEditSonioxLanguageHints->text();
    config.soniox.languageHintsStrict = ui->checkBoxSonioxLanguageHintsStrict->isChecked();
    config.soniox.context = ui->lineEditSonioxContext->text();
    config.soniox.proxy = ui->lineEditSonioxProxy->text();
    config.soniox.endpointDetection = ui->checkBoxSonioxEndpointDetection->isChecked();
    config.soniox.useMaxEndpointDelay = ui->checkBoxSonioxUseMaxEndpointDelay->isChecked();
    config.soniox.maxEndpointDelayMs = ui->spinBoxSonioxMaxEndpointDelayMs->value();
    config.soniox.keepConnection = ui->checkBoxSonioxKeepConnection->isChecked();

    config.azure.endpoint = ui->lineEditAzureEndpoint->text();
    config.azure.proxy = ui->lineEditAzureProxy->text();
    config.azure.apiKey = ui->lineEditAzureApiKey->text();
    config.azure.endpointId = ui->lineEditAzureEndpointId->text();
    config.azure.language = ui->lineEditAzureLanguage->text();
    config.azure.languageHints = ui->lineEditAzureLanguageHints->text();
    config.azure.languageHintsStrict = ui->checkBoxAzureLanguageHintsStrict->isChecked();
    config.azure.phraseHints = ui->lineEditAzurePhraseHints->text();
    config.azure.keepConnection = ui->checkBoxAzureKeepConnection->isChecked();

    config.deepgram.endpoint = ui->lineEditDeepgramEndpoint->text();
    config.deepgram.proxy = ui->lineEditDeepgramProxy->text();
    config.deepgram.apiKey = ui->lineEditDeepgramApiKey->text();
    config.deepgram.model = ui->lineEditDeepgramModel->text();
    config.deepgram.language = ui->lineEditDeepgramLanguage->text();
    config.deepgram.punctuate = ui->checkBoxDeepgramPunctuate->isChecked();
    config.deepgram.interimResults = ui->checkBoxDeepgramInterimResults->isChecked();
    config.deepgram.smartFormat = ui->checkBoxDeepgramSmartFormat->isChecked();
    config.deepgram.keepConnection = ui->checkBoxDeepgramKeepConnection->isChecked();

    config.yandex.endpoint = ui->lineEditYandexEndpoint->text();
    config.yandex.useApiKey = ui->checkBoxYandexUseApiKey->isChecked();
    config.yandex.apiKey = ui->lineEditYandexApiKey->text();
    config.yandex.folderId = ui->lineEditYandexFolderId->text();
    config.yandex.model = ui->lineEditYandexModel->text();
    config.yandex.language = ui->lineEditYandexLanguage->text();
    config.yandex.textNormalization = ui->checkBoxYandexTextNormalization->isChecked();
    config.yandex.literatureText = ui->checkBoxYandexLiteratureText->isChecked();
    config.yandex.useMaxPauseBetweenWordsHint = ui->checkBoxYandexUseMaxPauseBetweenWordsHint->isChecked();
    config.yandex.maxPauseBetweenWordsHintMs = ui->spinBoxYandexMaxPauseBetweenWordsHintMs->value();
    config.yandex.profanityFilter = ui->checkBoxYandexProfanityFilter->isChecked();

    config.visualStyle.borderColor = normalizeColorText(ui->lineEditOverlayBorderColor->text(), defaultBorder);
    config.visualStyle.glowColor = normalizeColorText(ui->lineEditOverlayGlowColor->text(), defaultGlow);
    config.visualStyle.pulseSpeedHz = ui->doubleSpinOverlayPulseSpeed->value();
    config.visualStyle.glowSizePx = ui->spinOverlayGlowSize->value();
    config.visualStyle.showRecBadge = ui->checkBoxOverlayShowRec->isChecked();
    config.visualStyle.blinkRecDot = ui->checkBoxOverlayBlinkDot->isChecked();
    return config;
}

void MainWindow::handleGlobalHotkeyPressed() {
    if (!dictationController)
        return;

    if (dictationController->isActive()) {
        if (overlayWindow)
            overlayWindow->hideOverlay();
        dictationController->stop();
        if (hotkeyManager)
            hotkeyManager->setEouEnabled(false);
        if (isVisible())
            restartInputLevelCapture();
        return;
    }

    if (ui->pushButtonOverlayPreview->isChecked())
        ui->pushButtonOverlayPreview->setChecked(false);

    stopInputLevelCapture();
    if (overlayWindow)
        overlayWindow->showForActiveWindow();
    dictationController->start(buildConfigFromUi());
    if (hotkeyManager) {
        const AppConfig config = buildConfigFromUi();
        const bool supportsManualFinalization =
            config.settings.providerId.compare("yandex", Qt::CaseInsensitive) == 0
            || config.settings.providerId.compare("soniox", Qt::CaseInsensitive) == 0;
        hotkeyManager->setEouEnabled(supportsManualFinalization);
    }
}

void MainWindow::createTrayIcon() {
    QMenu *trayMenu = new QMenu(this);
    QAction *restoreAction = trayMenu->addAction(tr("Settings"));
    QAction *quitAction = trayMenu->addAction(tr("Exit"));

    connect(restoreAction, &QAction::triggered, this, [this]() {
        showNormal();
        raise();
        activateWindow();
    });
    connect(quitAction, &QAction::triggered, qApp, &QApplication::quit);

    trayIcon = new QSystemTrayIcon(this);
    trayIcon->setIcon(QIcon(":/icons/app.png"));
    trayIcon->setToolTip(QCoreApplication::applicationName());
    trayIcon->setContextMenu(trayMenu);
    connect(trayIcon, &QSystemTrayIcon::activated,
            this, &MainWindow::onTrayIconActivated);
    trayIcon->show();
}

void MainWindow::onTrayIconActivated(QSystemTrayIcon::ActivationReason reason) {
    if (reason == QSystemTrayIcon::Trigger ||
        reason == QSystemTrayIcon::DoubleClick) {
        showNormal();
        raise();
        activateWindow();
    }
}

void MainWindow::populateServiceProviders() {
    const QSignalBlocker comboBlocker(ui->comboProvider);
    const QSignalBlocker tabBlocker(ui->servicesTabWidget);

    ui->comboProvider->clear();

    ui->comboProvider->addItem(tr("Soniox"), "soniox");
    int sonioxIndex = ui->servicesTabWidget->indexOf(ui->pageSoniox);
    if (sonioxIndex < 0)
        sonioxIndex = ui->servicesTabWidget->addTab(ui->pageSoniox, tr("Soniox"));
    ui->servicesTabWidget->setTabText(sonioxIndex, tr("Soniox"));
    ui->servicesTabWidget->tabBar()->setTabData(sonioxIndex, "soniox");
    ui->servicesTabWidget->setCurrentIndex(sonioxIndex);

    ui->comboProvider->addItem(tr("Azure"), "azure");
    int azureIndex = ui->servicesTabWidget->indexOf(ui->pageAzure);
    if (azureIndex < 0)
        azureIndex = ui->servicesTabWidget->addTab(ui->pageAzure, tr("Azure"));
    ui->servicesTabWidget->setTabText(azureIndex, tr("Azure"));
    ui->servicesTabWidget->tabBar()->setTabData(azureIndex, "azure");

    ui->comboProvider->addItem(tr("Deepgram"), "deepgram");
    int deepgramIndex = ui->servicesTabWidget->indexOf(ui->pageDeepgram);
    if (deepgramIndex < 0)
        deepgramIndex = ui->servicesTabWidget->addTab(ui->pageDeepgram, tr("Deepgram"));
    ui->servicesTabWidget->setTabText(deepgramIndex, tr("Deepgram"));
    ui->servicesTabWidget->tabBar()->setTabData(deepgramIndex, "deepgram");

    ui->comboProvider->addItem(tr("Yandex"), "yandex");
    int yandexIndex = ui->servicesTabWidget->indexOf(ui->pageYandex);
    if (yandexIndex < 0)
        yandexIndex = ui->servicesTabWidget->addTab(ui->pageYandex, tr("Yandex"));
    ui->servicesTabWidget->setTabText(yandexIndex, tr("Yandex"));
    ui->servicesTabWidget->tabBar()->setTabData(yandexIndex, "yandex");
}

void MainWindow::populateInputDevices() {
    const QSignalBlocker blocker(ui->comboInputDevice);

    ui->comboInputDevice->clear();
    ui->comboInputDevice->addItem(tr("Default"), "");

    const auto devices = QMediaDevices::audioInputs();
    for (const auto &device : devices) {
        ui->comboInputDevice->addItem(device.description(),
                                      QString::fromLatin1(device.id().toHex()));
    }
}

void MainWindow::syncServiceTabs(const QString &providerId) {
    const QString id = providerId.trimmed();
    if (id.isEmpty())
        return;

    QTabBar *bar = ui->servicesTabWidget->tabBar();
    if (!bar)
        return;

    const QSignalBlocker blocker(ui->servicesTabWidget);
    for (int i = 0; i < bar->count(); ++i) {
        if (bar->tabData(i).toString() == id) {
            ui->servicesTabWidget->setCurrentIndex(i);
            return;
        }
    }
}

QString MainWindow::currentProviderId() const {
    const QString id = ui->comboProvider->currentData().toString();
    if (!id.isEmpty())
        return id;
    return ui->comboProvider->currentText().trimmed().toLower();
}

void MainWindow::updateLanguageHintsStrictEnabled(const QString &value) {
    const bool enabled = hasLanguageHints(value);
    if (!enabled) {
        const QSignalBlocker blocker(ui->checkBoxSonioxLanguageHintsStrict);
        ui->checkBoxSonioxLanguageHintsStrict->setChecked(false);
    }
    ui->checkBoxSonioxLanguageHintsStrict->setEnabled(enabled);
    ui->labelSonioxLanguageHintsStrict->setEnabled(enabled);
    ui->labelSonioxLanguageHintsStrictHelp->setEnabled(enabled);
}

void MainWindow::updateAzureLanguageHintsStrictEnabled(const QString &value) {
    const bool enabled = hasLanguageHints(value);
    if (!enabled) {
        const QSignalBlocker blocker(ui->checkBoxAzureLanguageHintsStrict);
        ui->checkBoxAzureLanguageHintsStrict->setChecked(false);
    }
    ui->checkBoxAzureLanguageHintsStrict->setEnabled(enabled);
    ui->labelAzureLanguageHintsStrict->setEnabled(enabled);
    ui->labelAzureLanguageHintsStrictHelp->setEnabled(enabled);
}

void MainWindow::updateOverlayStyle(const VisualStyleSettings &settings) {
    if (!overlayWindow)
        return;

    const AppConfig defaults = ConfigStore::defaultConfig();
    const QColor defaultBorder = parseColorValue(defaults.visualStyle.borderColor, DEFAULT_OVERLAY_COLOR);
    const QColor defaultGlow = parseColorValue(defaults.visualStyle.glowColor, DEFAULT_OVERLAY_COLOR);

    OverlayVisualStyle style;
    style.borderColor = parseColorValue(settings.borderColor, defaultBorder);
    style.glowColor = parseColorValue(settings.glowColor, defaultGlow);
    style.pulseSpeedHz = settings.pulseSpeedHz;
    style.glowSizePx = settings.glowSizePx;
    style.showRecBadge = settings.showRecBadge;
    style.blinkRecDot = settings.blinkRecDot;
    overlayWindow->setVisualStyle(style);
}

void MainWindow::updateRecBlinkEnabled(bool showRec) {
    ui->checkBoxOverlayBlinkDot->setEnabled(showRec);
    ui->labelOverlayBlinkDot->setEnabled(showRec);
}

void MainWindow::setOverlayPreviewEnabled(bool enabled) {
    if (!overlayWindow)
        return;

    if (enabled) {
        WId windowId = winId();
        overlayWindow->showForWindow(windowId);
    } else {
        overlayWindow->clearPreviewWindow();
        overlayWindow->hideOverlay();
    }
}

void MainWindow::restartInputLevelCapture() {
    if (dictationController && dictationController->isActive())
        return;
    stopInputLevelCapture();
    startInputLevelCapture();
}

void MainWindow::startInputLevelCapture() {
    if (!levelCapture || !isVisible())
        return;

    const QString deviceId = ui->comboInputDevice->currentData().toString();
    if (!levelCapture->prepare(deviceId)) {
        ui->progressInputLevel->setValue(0);
        return;
    }

    if (!levelCapture->start()) {
        ui->progressInputLevel->setValue(0);
        return;
    }

    levelValue = 0.0;
    levelClock.restart();
    levelDecayTimer->start();
}

void MainWindow::stopInputLevelCapture() {
    if (levelCapture)
        levelCapture->stop();
    levelDecayTimer->stop();
    levelValue = 0.0;
    ui->progressInputLevel->setValue(0);
}

void MainWindow::handleInputLevelData(const QByteArray &data) {
    if (!levelCapture || data.isEmpty())
        return;

    const qreal level = computeAudioLevel(data, levelCapture->format());
    if (level <= 0.0)
        return;

    const qreal smoothed = qMax(level, levelValue * LEVEL_SMOOTHING_FACTOR);
    levelValue = qBound(0.0, smoothed, 1.0);
    levelClock.restart();
    ui->progressInputLevel->setValue(static_cast<int>(levelValue * 100.0));
}

void MainWindow::decayInputLevel() {
    if (!levelClock.isValid())
        return;

    if (levelClock.elapsed() > LEVEL_DECAY_THRESHOLD_MS) {
        levelValue = qMax(0.0, levelValue - LEVEL_DECAY_RATE);
        ui->progressInputLevel->setValue(static_cast<int>(levelValue * 100.0));
    }
}

qreal MainWindow::computeAudioLevel(const QByteArray &data, const QAudioFormat &format) const {
    if (data.isEmpty())
        return 0.0;

    switch (format.sampleFormat()) {
        case QAudioFormat::UInt8: {
            const int bytesPerSample = 1;
            const int sampleCount = data.size() / bytesPerSample;
            int peak = 0;
            for (int i = 0; i < sampleCount; ++i) {
                const int sample = static_cast<int>(static_cast<quint8>(data[i])) - 128;
                peak = qMax(peak, qAbs(sample));
            }
            return static_cast<qreal>(peak) / 128.0;
        }
        case QAudioFormat::Int16: {
            const int bytesPerSample = 2;
            const int sampleCount = data.size() / bytesPerSample;
            int peak = 0;
            const uchar *raw = reinterpret_cast<const uchar *>(data.constData());
            for (int i = 0; i < sampleCount; ++i) {
                const int offset = i * bytesPerSample;
                qint16 value = qFromLittleEndian<qint16>(raw + offset);
                peak = qMax(peak, qAbs(static_cast<int>(value)));
            }
            return static_cast<qreal>(peak) / 32768.0;
        }
        case QAudioFormat::Int32: {
            const int bytesPerSample = 4;
            const int sampleCount = data.size() / bytesPerSample;
            qint64 peak = 0;
            const uchar *raw = reinterpret_cast<const uchar *>(data.constData());
            for (int i = 0; i < sampleCount; ++i) {
                const int offset = i * bytesPerSample;
                qint32 value = qFromLittleEndian<qint32>(raw + offset);
                peak = qMax(peak, static_cast<qint64>(qAbs(value)));
            }
            return static_cast<qreal>(peak) / 2147483648.0;
        }
        case QAudioFormat::Float: {
            const int bytesPerSample = 4;
            const int sampleCount = data.size() / bytesPerSample;
            qreal peak = 0.0;
            const uchar *raw = reinterpret_cast<const uchar *>(data.constData());
            for (int i = 0; i < sampleCount; ++i) {
                const int offset = i * bytesPerSample;
                float value = 0.0f;
                memcpy(&value, raw + offset, sizeof(float));
                peak = qMax(peak, static_cast<qreal>(qAbs(value)));
            }
            return qMin(1.0, peak);
        }
        default:
            break;
    }
    return 0.0;
}