// Copyright Citra Emulator Project / Azahar Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#include <unordered_map>
#include <QGraphicsOpacityEffect>
#include <QImage>
#include <QLabel>
#include <QPainter>
#include <QPixmap>
#include <QProgressBar>
#include <QPropertyAnimation>
#include <QString>
#include <QStyleOption>
#include <QTime>
#include <fmt/format.h>
#include "citra_qt/loading_screen.h"
#include "citra_qt/util/util.h"
#include "common/logging/log.h"
#include "core/loader/loader.h"
#include "core/loader/smdh.h"
#include "ui_loading_screen.h"
#include "video_core/rasterizer_interface.h"

constexpr char PROGRESSBAR_STYLE_PREPARE[] = R"(
QProgressBar {}
QProgressBar::chunk {})";

constexpr char PROGRESSBAR_STYLE_DECOMPILE[] = R"(
QProgressBar {
  background-color: black;
  border: 2px solid white;
  border-radius: 4px;
  padding: 2px;
}
QProgressBar::chunk {
  background-color: #fd8507;
  width: 1px;
})";

constexpr char PROGRESSBAR_STYLE_BUILD[] = R"(
QProgressBar {
  background-color: black;
  border: 2px solid white;
  border-radius: 4px;
  padding: 2px;
}
QProgressBar::chunk {
  background-color: #ffe402;
  width: 1px;
})";

constexpr char PROGRESSBAR_STYLE_COMPLETE[] = R"(
QProgressBar {
  background-color: #fd8507;
  border: 2px solid white;
  border-radius: 4px;
  padding: 2px;
}
QProgressBar::chunk {
  background-color: #ffe402;
})";

// Definitions for the differences in text and styling for each stage
const static std::unordered_map<VideoCore::LoadCallbackStage, const char*> stage_translations{
    {VideoCore::LoadCallbackStage::Prepare, QT_TRANSLATE_NOOP("LoadingScreen", "Loading...")},
    {VideoCore::LoadCallbackStage::Preload,
     QT_TRANSLATE_NOOP("LoadingScreen", "Preloading Textures %1 / %2")},
    {VideoCore::LoadCallbackStage::Decompile,
     QT_TRANSLATE_NOOP("LoadingScreen", "Preparing Shaders %1 / %2")},
    {VideoCore::LoadCallbackStage::Build,
     QT_TRANSLATE_NOOP("LoadingScreen", "Loading Shaders %1 / %2")},
    {VideoCore::LoadCallbackStage::Complete, QT_TRANSLATE_NOOP("LoadingScreen", "Launching...")},
};
const static std::unordered_map<VideoCore::LoadCallbackStage, const char*> progressbar_style{
    {VideoCore::LoadCallbackStage::Prepare, PROGRESSBAR_STYLE_PREPARE},
    {VideoCore::LoadCallbackStage::Preload, PROGRESSBAR_STYLE_BUILD},
    {VideoCore::LoadCallbackStage::Decompile, PROGRESSBAR_STYLE_DECOMPILE},
    {VideoCore::LoadCallbackStage::Build, PROGRESSBAR_STYLE_BUILD},
    {VideoCore::LoadCallbackStage::Complete, PROGRESSBAR_STYLE_COMPLETE},
};

LoadingScreen::LoadingScreen(QWidget* parent)
    : QWidget(parent), ui(std::make_unique<Ui::LoadingScreen>()),
      previous_stage(VideoCore::LoadCallbackStage::Complete) {
    ui->setupUi(this);
    setMinimumSize(400, 240);

    // Create a fade out effect to hide this loading screen widget.
    // When fading opacity, it will fade to the parent widgets background color, which is why we
    // create an internal widget named fade_widget that we use the effect on, while keeping the
    // loading screen widget's background color black. This way we can create a fade to black effect
    opacity_effect = new QGraphicsOpacityEffect(this);
    opacity_effect->setOpacity(1);
    ui->fade_parent->setGraphicsEffect(opacity_effect);
    fadeout_animation = std::make_unique<QPropertyAnimation>(opacity_effect, "opacity");
    fadeout_animation->setDuration(500);
    fadeout_animation->setStartValue(1);
    fadeout_animation->setEndValue(0);
    fadeout_animation->setEasingCurve(QEasingCurve::OutBack);

    // After the fade completes, hide the widget and reset the opacity
    connect(fadeout_animation.get(), &QPropertyAnimation::finished, [this] {
        hide();
        opacity_effect->setOpacity(1);
        emit Hidden();
    });
    connect(this, &LoadingScreen::LoadProgress, this, &LoadingScreen::OnLoadProgress,
            Qt::QueuedConnection);
    qRegisterMetaType<VideoCore::LoadCallbackStage>();
}

LoadingScreen::~LoadingScreen() = default;

void LoadingScreen::Prepare(Loader::AppLoader& loader) {
    std::vector<u8> buffer;
    // TODO when banner becomes supported, decode it and add it as a movie

    if (loader.ReadIcon(buffer) == Loader::ResultStatus::Success) {
        QPixmap icon = GetQPixmapFromSMDH(buffer);
        ui->icon->setPixmap(icon);
    } else {
        ui->icon->clear();
    }
    std::string title;
    if (loader.ReadTitle(title) != Loader::ResultStatus::Success) {
        u64 program_id;
        if (loader.ReadProgramId(program_id) == Loader::ResultStatus::Success) {
            title = fmt::format("{:016x}", program_id);
        }
    }
    ui->title->setText(tr("Now Loading\n%1").arg(QString::fromStdString(title)));
    eta_shown = false;
    OnLoadProgress(VideoCore::LoadCallbackStage::Prepare, 0, 0);
}

void LoadingScreen::OnLoadComplete() {
    fadeout_animation->start(QPropertyAnimation::KeepWhenStopped);
}

void LoadingScreen::OnLoadProgress(VideoCore::LoadCallbackStage stage, std::size_t value,
                                   std::size_t total) {
    using namespace std::chrono;
    const auto now = high_resolution_clock::now();
    // reset the timer if the stage changes
    if (stage != previous_stage) {
        ui->progress_bar->setStyleSheet(QString::fromUtf8(progressbar_style.at(stage)));
        // Hide the progress bar during the prepare stage
        if (stage == VideoCore::LoadCallbackStage::Prepare) {
            ui->progress_bar->hide();
        } else {
            ui->progress_bar->show();
        }
        previous_stage = stage;
    }
    // update the max of the progress bar if the number of shaders change
    if (total != previous_total) {
        ui->progress_bar->setMaximum(static_cast<int>(total));
        previous_total = total;
    }

    // calculate a simple rolling average after the first shader is loaded
    if (value > 0) {
        rolling_average -= rolling_average / NumberOfDataPoints;
        rolling_average += (now - previous_time) / NumberOfDataPoints;
    }

    QString estimate;

    // After 25 shader load times were put into the rolling average, determine if the ETA is long
    // enough to show it
    if (value > NumberOfDataPoints &&
        (eta_shown || rolling_average * (total - value) > ETABreakPoint)) {
        if (!eta_shown) {
            eta_shown = true;
        }
        const auto eta_mseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
            rolling_average * (total - value));
        const auto limited_mseconds = std::max<long>(eta_mseconds.count(), 1000);
        estimate = tr("Estimated Time %1")
                       .arg(QTime(0, 0, 0, 0)
                                .addMSecs(static_cast<int>(limited_mseconds))
                                .toString(QStringLiteral("mm:ss")));
    }

    // update labels and progress bar
    ui->stage->setText(GetStageTranslation(stage, value, total));
    ui->value->setText(estimate);
    ui->progress_bar->setValue(static_cast<int>(value));
    previous_time = now;
}

void LoadingScreen::paintEvent(QPaintEvent* event) {
    QStyleOption opt;
    opt.initFrom(this);
    QPainter p(this);
    style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
    QWidget::paintEvent(event);
}

QString LoadingScreen::GetStageTranslation(VideoCore::LoadCallbackStage stage, std::size_t value,
                                           std::size_t total) {
    const auto& stg = tr(stage_translations.at(stage));
    if (stage == VideoCore::LoadCallbackStage::Decompile ||
        stage == VideoCore::LoadCallbackStage::Build ||
        stage == VideoCore::LoadCallbackStage::Preload) {
        return stg.arg(value).arg(total);
    } else {
        return stg;
    }
}

void LoadingScreen::Clear() {}
