#include "ui/MainWindow.hpp"

#include "atlas/AtlasParser.hpp"
#include "conversion/ConversionJob.hpp"
#include "editor/SpineEditorLocator.hpp"
#include "editor/SpineVersionAvailability.hpp"
#include "scan/SpineDataVersionDetector.hpp"
#include "ui/SpinePreviewWidget.hpp"

#include <QComboBox>
#include <QCheckBox>
#include <QCoreApplication>
#include <QDir>
#include <QDirIterator>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QFileDialog>
#include <QFileInfo>
#include <QHBoxLayout>
#include <QLabel>
#include <QMimeData>
#include <QMessageBox>
#include <QPushButton>
#include <QSettings>
#include <QTimer>
#include <QUrl>
#include <QVBoxLayout>

#include <filesystem>

namespace dts {
namespace {

std::filesystem::path localPath(const QString& value) {
#if defined(_WIN32)
    return std::filesystem::path(value.toStdWString());
#else
    return std::filesystem::path(value.toStdString());
#endif
}

QString platformLibraryName(const QString& line) {
#if defined(_WIN32)
    return QStringLiteral("dts-runtime-%1.dll").arg(line);
#elif defined(__APPLE__)
    return QStringLiteral("libdts-runtime-%1.dylib").arg(line);
#else
    return QStringLiteral("libdts-runtime-%1.so").arg(line);
#endif
}

} // namespace

MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
    setupUi();
    setAcceptDrops(true);
    setWindowTitle(tr("DateToSpine"));
    resize(960, 680);
}

void MainWindow::openResourcePath(const QString& path) {
    addInput(path);
}

void MainWindow::setupUi() {
    auto* root = new QWidget;
    auto* layout = new QVBoxLayout(root);
    layout->setContentsMargins(28, 24, 28, 24);
    layout->setSpacing(16);

    auto* top = new QHBoxLayout;
    auto* title = new QLabel(tr("DateToSpine"));
    title->setObjectName(QStringLiteral("title"));
    availabilityLabel_ = new QLabel;
    availabilityLabel_->setAlignment(Qt::AlignCenter);
    availabilityLabel_->setMinimumWidth(190);
    availabilityLabel_->setVisible(false);
    resourceCombo_ = new QComboBox;
    resourceCombo_->setMinimumWidth(260);
    resourceCombo_->setVisible(false);
    auto* addButton = new QPushButton(tr("选择资源"));
    addButton->setObjectName(QStringLiteral("quietButton"));
    top->addWidget(title);
    top->addStretch();
    top->addWidget(availabilityLabel_);
    top->addStretch();
    top->addWidget(resourceCombo_);
    top->addWidget(addButton);
    layout->addLayout(top);

    previewWidget_ = new SpinePreviewWidget;
    previewWidget_->setObjectName(QStringLiteral("preview"));
    layout->addWidget(previewWidget_, 1);

    auto* controls = new QHBoxLayout;
    animationCombo_ = new QComboBox;
    animationCombo_->setMinimumWidth(220);
    animationCombo_->setEnabled(false);
    statusLabel_ = new QLabel;
    statusLabel_->setObjectName(QStringLiteral("status"));
    unpremultiplyCheck_ = new QCheckBox(tr("去除预乘 Alpha"));
    unpremultiplyCheck_->setToolTip(tr("由 Spine 官方纹理解包器转换为普通透明图片"));
    convertButton_ = new QPushButton(tr("一键转换为 .spine"));
    convertButton_->setObjectName(QStringLiteral("primaryButton"));
    convertButton_->setEnabled(false);
    controls->addWidget(new QLabel(tr("动画")));
    controls->addWidget(animationCombo_);
    controls->addWidget(statusLabel_, 1);
    controls->addWidget(unpremultiplyCheck_);
    controls->addWidget(convertButton_);
    layout->addLayout(controls);

    setCentralWidget(root);
    setStyleSheet(QStringLiteral(R"(
        QMainWindow, QWidget { background: #17191e; color: #f3f4f6; font-size: 14px; }
        QLabel#title { font-size: 22px; font-weight: 650; }
        QLabel#preview { background: #101217; border: 2px dashed #343944; border-radius: 14px; color: #a7adb8; }
        QLabel#status { color: #9299a5; padding-left: 8px; }
        QComboBox { background: #242832; border: 1px solid #3a404c; border-radius: 8px; padding: 8px 12px; }
        QPushButton { border-radius: 8px; padding: 9px 16px; }
        QPushButton#quietButton { background: #292d36; border: 1px solid #3d4350; }
        QPushButton#primaryButton { background: #6e5eea; border: none; font-weight: 650; padding: 11px 20px; }
        QPushButton#primaryButton:disabled { background: #343743; color: #777d89; }
        QCheckBox { spacing: 8px; color: #c9ced8; }
        QCheckBox::indicator { width: 18px; height: 18px; }
    )"));
    showEmptyState();

    connect(addButton, &QPushButton::clicked, this, &MainWindow::chooseResources);
    connect(resourceCombo_, &QComboBox::currentIndexChanged,
        this, &MainWindow::resourceChanged);
    connect(animationCombo_, &QComboBox::currentTextChanged,
        this, &MainWindow::animationChanged);
    connect(convertButton_, &QPushButton::clicked, this, &MainWindow::convertCurrent);
    previewTimer_ = new QTimer(this);
    previewTimer_->setInterval(16);
    connect(previewTimer_, &QTimer::timeout, this, &MainWindow::advancePreview);
}

void MainWindow::showEmptyState() {
    previewWidget_->resetViewport();
    previewWidget_->setMessage(
        tr("把 .json / .skel、.atlas 和图片拖到这里\n\n也可以拖入整个资源文件夹"));
    statusLabel_->clear();
}

void MainWindow::chooseResources() {
    const auto paths = QFileDialog::getOpenFileNames(this, tr("选择导出资源"), {},
        tr("Spine 资源 (*.json *.skel *.atlas *.png *.jpg *.jpeg *.webp);;所有文件 (*)"));
    for (const auto& path : paths) addInput(path);
}

void MainWindow::addInput(const QString& path) {
    const QFileInfo info(path);
    const auto scanDirectory = [this](const QString& directory, bool recursive) {
        QDirIterator iterator(directory, {"*.json", "*.skel"}, QDir::Files,
            recursive ? QDirIterator::Subdirectories : QDirIterator::NoIteratorFlags);
        while (iterator.hasNext()) addSkeleton(iterator.next());
    };
    if (info.isDir()) scanDirectory(path, true);
    else if (info.suffix().compare("json", Qt::CaseInsensitive) == 0
        || info.suffix().compare("skel", Qt::CaseInsensitive) == 0) addSkeleton(path);
    else scanDirectory(info.absolutePath(), false);
    scheduleAvailabilityCheck();
}

void MainWindow::addSkeleton(const QString& path) {
    const auto result = SpineDataVersionDetector{}.inspect(localPath(path));
    if (result.status != VersionDetectionStatus::Detected || skeletonPaths_.contains(path)) return;
    skeletonPaths_.append(path);
    resourceCombo_->addItem(QFileInfo(path).completeBaseName(), path);
    resourceCombo_->setVisible(true);
    resourceCombo_->setCurrentIndex(resourceCombo_->count() - 1);
}

QString MainWindow::findAtlas(const QString& skeletonPath) const {
    const QFileInfo skeleton(skeletonPath);
    QDir directory(skeleton.absolutePath());
    const QString base = skeleton.completeBaseName();
    for (const auto& name : {base + ".atlas", base + ".atlas.txt"}) {
        const auto candidate = directory.filePath(name);
        if (QFileInfo::exists(candidate)) return candidate;
    }
    const auto atlases = directory.entryInfoList({"*.atlas", "*.atlas.txt"}, QDir::Files);
    if (atlases.size() == 1) return atlases.front().absoluteFilePath();
    for (const auto& atlas : atlases) {
        if (base.startsWith(atlas.completeBaseName())
            || atlas.completeBaseName().startsWith(base)) return atlas.absoluteFilePath();
    }
    return {};
}

QString MainWindow::runtimeLibrary(const QString& versionLine) const {
    const QDir executableDirectory(QCoreApplication::applicationDirPath());
#if defined(__APPLE__)
    return QDir::cleanPath(executableDirectory.filePath(
        "../PlugIns/runtimes/" + platformLibraryName(versionLine)));
#else
    return executableDirectory.filePath("runtimes/" + platformLibraryName(versionLine));
#endif
}

void MainWindow::resourceChanged(int index) {
    if (index >= 0) {
        loadCurrentPreview();
        scheduleAvailabilityCheck();
    }
}

void MainWindow::loadCurrentPreview() {
    previewTimer_->stop();
    previewWidget_->resetViewport();
    animationCombo_->clear();
    animationCombo_->setEnabled(false);
    convertButton_->setEnabled(false);
    const QString skeletonPath = resourceCombo_->currentData().toString();
    const QString atlasPath = findAtlas(skeletonPath);
    const auto detection = SpineDataVersionDetector{}.inspect(localPath(skeletonPath));
    if (!detection.version || atlasPath.isEmpty()) {
        previewWidget_->setMessage(tr("没有找到与骨骼数据配套的 .atlas 文件"));
        statusLabel_->setText(tr("请把完整导出资源一起拖入"));
        return;
    }
    currentVersion_ = QString::fromStdString(detection.version->toString());
    std::string error;
    if (!runtime_.load(localPath(runtimeLibrary(
            QString::fromStdString(detection.version->line()))), error)) {
        previewWidget_->setMessage(tr("暂时无法加载这套资源"));
        statusLabel_->setText(QString::fromStdString(error));
        return;
    }
    const auto metadata = runtime_.loadSkeleton(
        localPath(skeletonPath), localPath(atlasPath), 1.0F, error);
    if (!metadata) {
        previewWidget_->setMessage(tr("此版本的预览模块仍在接入中"));
        statusLabel_->setText(tr("资源已识别，可以稍后转换"));
        return;
    }
    for (const auto& animation : metadata->animations)
        animationCombo_->addItem(QString::fromStdString(animation.name), animation.duration);
    animationCombo_->setEnabled(animationCombo_->count() > 0);
    statusLabel_->setText(tr("已识别 %1 个动画").arg(metadata->animations.size()));
    if (animationCombo_->count() > 0) {
        animationChanged(animationCombo_->itemText(0));
    } else {
        auto frame = runtime_.updatePreview(0.0F, error);
        if (frame) previewWidget_->setFrame(std::move(*frame));
        else previewWidget_->setMessage(tr("没有可播放的动画"));
    }
}

void MainWindow::animationChanged(const QString& name) {
    if (name.isEmpty()) return;
    std::string error;
    if (!runtime_.setAnimation(name.toStdString(), true, error)) {
        statusLabel_->setText(QString::fromStdString(error));
        return;
    }
    advancePreview();
    previewTimer_->start();
}

void MainWindow::advancePreview() {
    std::string error;
    auto frame = runtime_.updatePreview(0.016F, error);
    if (!frame) {
        previewTimer_->stop();
        previewWidget_->setMessage(tr("动画预览暂时不可用"));
        statusLabel_->setText(QString::fromStdString(error));
        return;
    }
    previewWidget_->setFrame(std::move(*frame));
}

QString MainWindow::resolveEditor() {
    QSettings settings;
    SpineEditorLocator locator;
    const auto saved = settings.value("spineEditorPath").toString();
    if (!saved.isEmpty()) {
        if (const auto normalized = locator.normalize(localPath(saved)))
            return QString::fromStdString(normalized->string());
    }
    const auto found = locator.discover();
    if (!found.empty()) return QString::fromStdString(found.front().string());
    return {};
}

void MainWindow::scheduleAvailabilityCheck() {
    if (availabilityCheckScheduled_) return;
    availabilityCheckScheduled_ = true;
    QTimer::singleShot(0, this, [this] {
        availabilityCheckScheduled_ = false;
        refreshAvailability();
    });
}

void MainWindow::showAvailability(const QString& text, const QString& color) {
    availabilityLabel_->setText(QStringLiteral("●  ") + text);
    availabilityLabel_->setStyleSheet(QStringLiteral(
        "QLabel { color: %1; background: #20242c; border: 1px solid #343a46; "
        "border-radius: 8px; padding: 7px 12px; font-weight: 600; }").arg(color));
    availabilityLabel_->setVisible(true);
}

void MainWindow::refreshAvailability() {
    availableVersions_.clear();
    currentEditorVersion_.clear();
    editorPath_ = resolveEditor();
    SpineVersionAvailability availability;
    for (const auto& path : skeletonPaths_) {
        const auto detection = SpineDataVersionDetector{}.inspect(localPath(path));
        if (!detection.version) continue;
        const auto line = QString::fromStdString(detection.version->line());
        if (const auto installed = availability.newestForLine(detection.version->line()))
            availableVersions_.insert(line, QString::fromStdString(installed->toString()));
    }
    const auto current = SpineDataVersionDetector{}.inspect(
        localPath(resourceCombo_->currentData().toString()));
    if (!current.version) return;
    const auto atlasPath = findAtlas(resourceCombo_->currentData().toString());
    if (atlasPath.isEmpty()) {
        showAvailability(tr("缺少配套 Atlas"), QStringLiteral("#ef6b73"));
        convertButton_->setText(tr("资源不完整"));
        convertButton_->setEnabled(false);
        return;
    }
    const auto atlas = AtlasParser{}.parseFile(localPath(atlasPath));
    if (!atlas.document) {
        showAvailability(tr("Atlas 无法识别"), QStringLiteral("#ef6b73"));
        convertButton_->setText(tr("资源不完整"));
        convertButton_->setEnabled(false);
        return;
    }
    const QDir atlasDirectory = QFileInfo(atlasPath).dir();
    for (const auto& page : atlas.document->pages) {
        const auto pagePath = QString::fromStdString(page.imagePath.string());
        if (!QFileInfo::exists(atlasDirectory.filePath(pagePath))) {
            showAvailability(tr("缺少纹理页 %1").arg(QFileInfo(pagePath).fileName()),
                QStringLiteral("#ef6b73"));
            convertButton_->setText(tr("资源不完整"));
            convertButton_->setEnabled(false);
            return;
        }
    }
    const auto line = QString::fromStdString(current.version->line());
    if (editorPath_.isEmpty()) {
        showAvailability(tr("未找到 Spine Editor"), QStringLiteral("#f2b84b"));
        convertButton_->setText(tr("指定 Spine 路径"));
        convertButton_->setEnabled(true);
        return;
    }
    currentEditorVersion_ = availableVersions_.value(line);
    if (currentEditorVersion_.isEmpty()) {
        showAvailability(tr("缺少 Spine %1").arg(line), QStringLiteral("#ef6b73"));
        convertButton_->setText(tr("指定 Spine %1 路径").arg(line));
        convertButton_->setEnabled(true);
        return;
    }
    showAvailability(tr("可转换 · Spine %1").arg(currentEditorVersion_),
        QStringLiteral("#55d68b"));
    convertButton_->setText(tr("一键转换为 .spine"));
    convertButton_->setEnabled(true);
}

bool MainWindow::chooseEditorPath() {
    const auto selected = QFileDialog::getOpenFileName(this,
        tr("指定 Spine 程序"), {}, tr("所有文件 (*)"));
    if (selected.isEmpty()) return false;
    SpineEditorLocator locator;
    const auto normalized = locator.normalize(localPath(selected));
    if (!normalized) {
        showAvailability(tr("选择的路径不是 Spine Editor"), QStringLiteral("#ef6b73"));
        return false;
    }
    QSettings{}.setValue("spineEditorPath", selected);
    editorPath_ = QString::fromStdString(normalized->string());
    refreshAvailability();
    return !currentEditorVersion_.isEmpty();
}

void MainWindow::convertCurrent() {
    if (editorPath_.isEmpty() || currentEditorVersion_.isEmpty())
        if (!chooseEditorPath()) return;
    const QString input = resourceCombo_->currentData().toString();
    const auto outputParent = QFileDialog::getExistingDirectory(this,
        tr("选择输出位置"), QFileInfo(input).absolutePath());
    if (outputParent.isEmpty()) return;
    const auto atlas = findAtlas(input);
    if (atlas.isEmpty()) {
        QMessageBox::critical(this, tr("转换失败"), tr("没有找到配套的 .atlas 文件。"));
        return;
    }
    ConversionRequest request{
        editorPath_, currentEditorVersion_, input, atlas, outputParent,
        QFileInfo(input).completeBaseName(), unpremultiplyCheck_->isChecked()};
    conversionJob_ = new ConversionJob(std::move(request), this);
    connect(conversionJob_, &ConversionJob::finished,
        this, &MainWindow::conversionFinished);
    setBusy(true);
    conversionJob_->start();
}

void MainWindow::setBusy(bool busy) {
    convertButton_->setEnabled(!busy);
    convertButton_->setText(busy ? tr("正在转换…") : tr("一键转换为 .spine"));
    if (busy) showAvailability(tr("正在使用 Spine %1 转换").arg(currentEditorVersion_),
        QStringLiteral("#72a7ff"));
}

void MainWindow::conversionFinished(bool success, const QString& outputDirectory,
    const QString& error) {
    conversionJob_->deleteLater();
    conversionJob_ = nullptr;
    setBusy(false);
    statusLabel_->setText(success ? tr("转换完成") : tr("转换失败"));
    statusLabel_->setToolTip(success ? outputDirectory : error);
    refreshAvailability();
    if (success) {
        QMessageBox::information(this, tr("转换完成"),
            tr("完整资源已生成：\n%1").arg(outputDirectory));
    } else {
        QMessageBox::critical(this, tr("转换失败"),
            error.isEmpty() ? tr("转换未完成，Spine Editor 未提供详细原因。") : error);
    }
}

void MainWindow::dragEnterEvent(QDragEnterEvent* event) {
    if (event->mimeData()->hasUrls()) event->acceptProposedAction();
}

void MainWindow::dropEvent(QDropEvent* event) {
    for (const auto& url : event->mimeData()->urls())
        if (url.isLocalFile()) addInput(url.toLocalFile());
    event->acceptProposedAction();
}

} // namespace dts