/*
 * 86Box	A hypervisor and IBM PC system emulator that specializes in
 *		running old operating systems and software designed for IBM
 *		PC systems and compatibles from 1981 through fairly recent
 *		system designs based on the PCI bus.
 *
 *		This file is part of the 86Box distribution.
 *
 *		Program settings UI module.
 *
 *
 *
 * Authors: Joakim L. Gilje <jgilje@jgilje.net>
 *          Cacodemon345
 *          Teemu Korhonen
 *
 *      Copyright 2021 Joakim L. Gilje
 *      Copyright 2021-2021 Teemu Korhonen
 *      Copyright 2021-2022 Cacodemon345
 */
#include "qt_rendererstack.hpp"
#include "ui_qt_rendererstack.h"

#include "qt_hardwarerenderer.hpp"
#include "qt_openglrenderer.hpp"
#include "qt_softwarerenderer.hpp"
#include "qt_vulkanwindowrenderer.hpp"
#ifdef Q_OS_WIN
#include "qt_d3d9renderer.hpp"
#endif

#include "qt_mainwindow.hpp"
#include "qt_util.hpp"

#include "evdev_mouse.hpp"

#include <atomic>
#include <stdexcept>

#include <QScreen>
#include <QMessageBox>

#ifdef __APPLE__
#    include <CoreGraphics/CoreGraphics.h>
#endif

extern "C" {
#include <86box/86box.h>
#include <86box/mouse.h>
#include <86box/plat.h>
#include <86box/video.h>

double mouse_sensitivity = 1.0;
}

struct mouseinputdata {
    atomic_int deltax, deltay, deltaz;
    atomic_int mousebuttons;
};
static mouseinputdata mousedata;

extern "C" void macos_poll_mouse();
extern MainWindow *main_window;
RendererStack::RendererStack(QWidget *parent, int monitor_index)
    : QStackedWidget(parent)
    , ui(new Ui::RendererStack)
{
    ui->setupUi(this);

    m_monitor_index = monitor_index;
#if defined __unix__ && !defined __HAIKU__
    char *mouse_type = getenv("EMU86BOX_MOUSE"), auto_mouse_type[16];
    if (!mouse_type || (mouse_type[0] == '\0') || !stricmp(mouse_type, "auto")) {
        if (QApplication::platformName().contains("wayland"))
            strcpy(auto_mouse_type, "wayland");
        else if (QApplication::platformName() == "eglfs" || QApplication::platformName() == "xcb")
            strcpy(auto_mouse_type, "evdev");
        else
            auto_mouse_type[0] = '\0';
        mouse_type = auto_mouse_type;
    }

#    ifdef WAYLAND
    if (!stricmp(mouse_type, "wayland")) {
        wl_init();
        this->mouse_poll_func = wl_mouse_poll;
        this->mouse_capture_func = wl_mouse_capture;
        this->mouse_uncapture_func = wl_mouse_uncapture;
    }
#    endif
#    ifdef EVDEV_INPUT
    if (!stricmp(mouse_type, "evdev")) {
        evdev_init();
        this->mouse_poll_func = evdev_mouse_poll;
    }
#    endif
#endif
#ifdef __APPLE__
    this->mouse_poll_func = macos_poll_mouse;
#endif
}

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

void
qt_mouse_capture(int on)
{
    if (!on) {
        mouse_capture = 0;
        QApplication::setOverrideCursor(Qt::ArrowCursor);
#ifdef __APPLE__
        CGAssociateMouseAndMouseCursorPosition(true);
#endif
        return;
    }
    mouse_capture = 1;
    QApplication::setOverrideCursor(Qt::BlankCursor);
#ifdef __APPLE__
    CGAssociateMouseAndMouseCursorPosition(false);
#endif
    return;
}

void
RendererStack::mousePoll()
{
#ifndef __APPLE__
    mouse_x          = mousedata.deltax;
    mouse_y          = mousedata.deltay;
    mouse_z          = mousedata.deltaz;
    mousedata.deltax = mousedata.deltay = mousedata.deltaz = 0;
    mouse_buttons    = mousedata.mousebuttons;

    if (this->mouse_poll_func)
#endif
        this->mouse_poll_func();

    mouse_x *= mouse_sensitivity;
    mouse_y *= mouse_sensitivity;
}

int ignoreNextMouseEvent = 1;
void
RendererStack::mouseReleaseEvent(QMouseEvent *event)
{
    if (this->geometry().contains(event->pos()) && event->button() == Qt::LeftButton && !mouse_capture && (isMouseDown & 1) && mouse_get_buttons() != 0) {
        plat_mouse_capture(1);
        this->setCursor(Qt::BlankCursor);
        if (!ignoreNextMouseEvent)
            ignoreNextMouseEvent++; // Avoid jumping cursor when moved.
        isMouseDown &= ~1;
        return;
    }
    if (mouse_capture && event->button() == Qt::MiddleButton && mouse_get_buttons() < 3) {
        plat_mouse_capture(0);
        this->setCursor(Qt::ArrowCursor);
        isMouseDown &= ~1;
        return;
    }
    if (mouse_capture) {
        mousedata.mousebuttons &= ~event->button();
    }
    isMouseDown &= ~1;
}

void
RendererStack::mousePressEvent(QMouseEvent *event)
{
    isMouseDown |= 1;
    if (mouse_capture) {
        mousedata.mousebuttons |= event->button();
    }
    event->accept();
}

void
RendererStack::wheelEvent(QWheelEvent *event)
{
    if (mouse_capture) {
        mousedata.deltaz += event->pixelDelta().y();
    }
}

void
RendererStack::mouseMoveEvent(QMouseEvent *event)
{
    if (QApplication::platformName().contains("wayland")) {
        event->accept();
        return;
    }
    if (!mouse_capture) {
        event->ignore();
        return;
    }
#if defined __APPLE__ || defined _WIN32
    event->accept();
    return;
#else
    static QPoint oldPos = QCursor::pos();
    if (ignoreNextMouseEvent) {
        oldPos = event->pos();
        ignoreNextMouseEvent--;
        event->accept();
        return;
    }
    mousedata.deltax += event->pos().x() - oldPos.x();
    mousedata.deltay += event->pos().y() - oldPos.y();
    if (QApplication::platformName() == "eglfs") {
        leaveEvent((QEvent *) event);
        ignoreNextMouseEvent--;
    }
    QCursor::setPos(mapToGlobal(QPoint(width() / 2, height() / 2)));
    ignoreNextMouseEvent = 2;
    oldPos               = event->pos();
#endif
}

void
RendererStack::leaveEvent(QEvent *event)
{
    if (QApplication::platformName().contains("wayland")) {
        event->accept();
        return;
    }
    if (!mouse_capture)
        return;
    QCursor::setPos(mapToGlobal(QPoint(width() / 2, height() / 2)));
    ignoreNextMouseEvent = 2;
    event->accept();
}

void
RendererStack::switchRenderer(Renderer renderer)
{
    startblit();
    if (current) {
        if ((current_vid_api == Renderer::Direct3D9 && renderer != Renderer::Direct3D9)
        || (current_vid_api != Renderer::Direct3D9 && renderer == Renderer::Direct3D9)) {
            rendererWindow->finalize();
            if (rendererWindow->hasBlitFunc()) {
                while (directBlitting) {}
                connect(this, &RendererStack::blit, this, &RendererStack::blitDummy, Qt::DirectConnection);
                disconnect(this, &RendererStack::blit, this, &RendererStack::blitRenderer);
            } else {
                connect(this, &RendererStack::blit, this, &RendererStack::blitDummy, Qt::DirectConnection);
                disconnect(this, &RendererStack::blit, this, &RendererStack::blitCommon);
            }

            removeWidget(current.get());
            disconnect(this, &RendererStack::blitToRenderer, nullptr, nullptr);

            /* Create new renderer only after previous is destroyed! */
            connect(current.get(), &QObject::destroyed, [this, renderer](QObject *) {
                createRenderer(renderer);
                disconnect(this, &RendererStack::blit, this, &RendererStack::blitDummy);
                blitDummied = false;
                QTimer::singleShot(1000, this, [this]() { this->blitDummied = false; } );
            });

            rendererWindow->hasBlitFunc() ? current.reset() : current.release()->deleteLater();
        } else {
            rendererWindow->finalize();
            removeWidget(current.get());
            disconnect(this, &RendererStack::blitToRenderer, nullptr, nullptr);

            /* Create new renderer only after previous is destroyed! */
            connect(current.get(), &QObject::destroyed, [this, renderer](QObject *) { createRenderer(renderer); });

            current.release()->deleteLater();
        }
    } else {
        createRenderer(renderer);
    }
}

void
RendererStack::createRenderer(Renderer renderer)
{
    current_vid_api = renderer;
    switch (renderer) {
        default:
        case Renderer::Software:
            {
                auto sw        = new SoftwareRenderer(this);
                rendererWindow = sw;
                connect(this, &RendererStack::blitToRenderer, sw, &SoftwareRenderer::onBlit, Qt::QueuedConnection);
#ifdef __HAIKU__
                current.reset(sw);
#else
                current.reset(this->createWindowContainer(sw, this));
#endif
            }
            break;
        case Renderer::OpenGL:
            {
                this->createWinId();
                auto hw        = new HardwareRenderer(this);
                rendererWindow = hw;
                connect(this, &RendererStack::blitToRenderer, hw, &HardwareRenderer::onBlit, Qt::QueuedConnection);
                current.reset(this->createWindowContainer(hw, this));
                break;
            }
        case Renderer::OpenGLES:
            {
                this->createWinId();
                auto hw        = new HardwareRenderer(this, HardwareRenderer::RenderType::OpenGLES);
                rendererWindow = hw;
                connect(this, &RendererStack::blitToRenderer, hw, &HardwareRenderer::onBlit, Qt::QueuedConnection);
                current.reset(this->createWindowContainer(hw, this));
                break;
            }
        case Renderer::OpenGL3:
            {
                this->createWinId();
                auto hw        = new OpenGLRenderer(this);
                rendererWindow = hw;
                connect(this, &RendererStack::blitToRenderer, hw, &OpenGLRenderer::onBlit, Qt::QueuedConnection);
                connect(hw, &OpenGLRenderer::initialized, [=]() {
                    /* Buffers are available only after initialization. */
                    imagebufs = rendererWindow->getBuffers();
                    endblit();
                    emit rendererChanged();
                });
                connect(hw, &OpenGLRenderer::errorInitializing, [=]() {
                    /* Renderer not could initialize, fallback to software. */
                    imagebufs = {};
                    QTimer::singleShot(0, this, [this]() { switchRenderer(Renderer::Software); });
                });
                current.reset(this->createWindowContainer(hw, this));
                break;
            }
#ifdef Q_OS_WIN
        case Renderer::Direct3D9:
        {
            this->createWinId();
            auto hw = new D3D9Renderer(this, m_monitor_index);
            rendererWindow = hw;
            connect(hw, &D3D9Renderer::error, this, [this](QString str)
            {
                auto msgBox = new QMessageBox(QMessageBox::Critical, "86Box", QString("Failed to initialize D3D9 renderer. Falling back to software rendering.\n\n") + str, QMessageBox::Ok);
                msgBox->setAttribute(Qt::WA_DeleteOnClose);
                msgBox->show();
                imagebufs = {};
                QTimer::singleShot(0, this, [this]() { switchRenderer(Renderer::Software); });
            });
            connect(hw, &D3D9Renderer::initialized, this, [this]()
            {
                endblit();
                emit rendererChanged();
            });
            current.reset(hw);
            break;
        }
#endif
#if QT_CONFIG(vulkan)
        case Renderer::Vulkan:
        {
            this->createWinId();
            VulkanWindowRenderer *hw = nullptr;
            try {
                hw        = new VulkanWindowRenderer(this);
            } catch(std::runtime_error& e) {
                auto msgBox = new QMessageBox(QMessageBox::Critical, "86Box", e.what() + QString("\nFalling back to software rendering."), QMessageBox::Ok);
                msgBox->setAttribute(Qt::WA_DeleteOnClose);
                msgBox->show();
                imagebufs = {};
                QTimer::singleShot(0, this, [this]() { switchRenderer(Renderer::Software); });
                current.reset(nullptr);
                break;
            };
            rendererWindow = hw;
            connect(this, &RendererStack::blitToRenderer, hw, &VulkanWindowRenderer::onBlit, Qt::QueuedConnection);
            connect(hw, &VulkanWindowRenderer::rendererInitialized, [=]() {
                /* Buffers are available only after initialization. */
                imagebufs = rendererWindow->getBuffers();
                endblit();
                emit rendererChanged();
            });
            connect(hw, &VulkanWindowRenderer::errorInitializing, [=]() {
                /* Renderer could not initialize, fallback to software. */
                auto msgBox = new QMessageBox(QMessageBox::Critical, "86Box", QString("Failed to initialize Vulkan renderer.\nFalling back to software rendering."), QMessageBox::Ok);
                msgBox->setAttribute(Qt::WA_DeleteOnClose);
                msgBox->show();
                imagebufs = {};
                QTimer::singleShot(0, this, [this]() { switchRenderer(Renderer::Software); });
            });
            current.reset(this->createWindowContainer(hw, this));
            break;
        }
#endif
    }
    if (current.get() == nullptr) return;
    current->setFocusPolicy(Qt::NoFocus);
    current->setFocusProxy(this);
    addWidget(current.get());

    this->setStyleSheet("background-color: black");

    currentBuf = 0;

    if (rendererWindow->hasBlitFunc()) {
        connect(this, &RendererStack::blit, this, &RendererStack::blitRenderer, Qt::DirectConnection);
    }
    else {
        connect(this, &RendererStack::blit, this, &RendererStack::blitCommon, Qt::DirectConnection);
    }

    if (renderer != Renderer::OpenGL3 && renderer != Renderer::Vulkan && renderer != Renderer::Direct3D9) {
        imagebufs = rendererWindow->getBuffers();
        endblit();
        emit rendererChanged();
    }
}

void
RendererStack::blitDummy(int x, int y, int w, int h)
{
    video_blit_complete_monitor(m_monitor_index);
    blitDummied = true;
}

void
RendererStack::blitRenderer(int x, int y, int w, int h)
{
    if (blitDummied) { blitDummied = false; video_blit_complete_monitor(m_monitor_index); return; }
    directBlitting = true;
    rendererWindow->blit(x, y, w, h);
    directBlitting = false;
}

// called from blitter thread
void
RendererStack::blitCommon(int x, int y, int w, int h)
{
    if (blitDummied || (x < 0) || (y < 0) || (w <= 0) || (h <= 0) || (w > 2048) || (h > 2048) || (monitors[m_monitor_index].target_buffer == NULL) || imagebufs.empty() || std::get<std::atomic_flag *>(imagebufs[currentBuf])->test_and_set()) {
        video_blit_complete_monitor(m_monitor_index);
        return;
    }
    sx = x;
    sy = y;
    sw = this->w = w;
    sh = this->h       = h;
    uint8_t *imagebits = std::get<uint8_t *>(imagebufs[currentBuf]);
    for (int y1 = y; y1 < (y + h); y1++) {
        auto scanline = imagebits + (y1 * rendererWindow->getBytesPerRow()) + (x * 4);
        video_copy(scanline, &(monitors[m_monitor_index].target_buffer->line[y1][x]), w * 4);
    }

    if (monitors[m_monitor_index].mon_screenshots) {
        video_screenshot_monitor((uint32_t *) imagebits, x, y, 2048, m_monitor_index);
    }
    video_blit_complete_monitor(m_monitor_index);
    emit blitToRenderer(currentBuf, sx, sy, sw, sh);
    currentBuf = (currentBuf + 1) % imagebufs.size();
}

void RendererStack::closeEvent(QCloseEvent* event)
{
    if (cpu_thread_run == 0 || is_quit == 0) {
        event->accept();
        show_second_monitors = 0; // TODO: This isn't actually the right fix, so fix this properly.
        return;
    }
    event->ignore();
    main_window->close();
}