#pragma once
#include <ParallelRDPWrapper.hpp>
#include <QVulkanWindow>
#include <QMainWindow>
#include <QThread>

struct InputSettings;

namespace n64 {
struct Core;
}
class QtPrdpWindowInfo;
class QtWSIPlatform;

struct QtInstanceFactory : Vulkan::InstanceFactory {
    VkInstance create_instance(const VkInstanceCreateInfo *info) override {
        handle.setApiVersion({1, 3, 0});
        QByteArrayList exts;
        for (int i = 0; i < info->enabledExtensionCount; i++) {
            exts.push_back(QByteArray::fromStdString(info->ppEnabledExtensionNames[i]));
        }
        QByteArrayList layers;
        for (int i = 0; i < info->enabledLayerCount; i++) {
            layers.push_back(QByteArray::fromStdString(info->ppEnabledLayerNames[i]));
        }
        handle.setExtensions(exts);
        handle.setLayers(layers);
        handle.create();

        return handle.vkInstance();
    }

    QVulkanInstance handle;
};

class RenderWidget final : public QWidget {
    Q_OBJECT
    QVulkanInstance inst;

  public:
    explicit RenderWidget();

    QPaintEngine *paintEngine() const override { return nullptr; }

    std::unique_ptr<QtInstanceFactory> qtVkInstanceFactory;
    std::shared_ptr<ParallelRDP::WindowInfo> windowInfo;
    std::shared_ptr<QtWSIPlatform> wsiPlatform;
};


class QtPrdpWindowInfo final : public ParallelRDP::WindowInfo {
  public:
    explicit QtPrdpWindowInfo(QWindow *window) : window(window) {}
    CoordinatePair get_window_size() override {
        return CoordinatePair{static_cast<float>(window->width()), static_cast<float>(window->height())};
    }

  private:
    QWindow *window{};
};

class QtWSIPlatform final : public Vulkan::WSIPlatform {
  public:
    explicit QtWSIPlatform(QWindow *window) : window(window) {}
    ~QtWSIPlatform() = default;

    std::vector<const char *> get_instance_extensions() override {
        auto vec = std::vector<const char *>();
        auto extensions = window->vulkanInstance()->extensions();

        vec.resize(extensions.size());

        for (u32 i = 0; i < extensions.size(); i++) {
            vec[i] = extensions[i];
        }

        return vec;
    }

    VkSurfaceKHR create_surface(VkInstance instance, VkPhysicalDevice pDevice) override {
        return QVulkanInstance::surfaceForWindow(window);
    }

    void destroy_surface(VkInstance instance, VkSurfaceKHR surface) override {}

    uint32_t get_surface_width() override { return 640; }

    uint32_t get_surface_height() override { return 480; }

    bool alive(Vulkan::WSI &) override { return true; }

    void poll_input() override {}
    void poll_input_async(Granite::InputTrackerHandler *handler) override {}

    void event_frame_tick(double frame, double elapsed) override {}

    const VkApplicationInfo *get_application_info() override { return &appInfo; }

    VkApplicationInfo appInfo{.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .apiVersion = VK_API_VERSION_1_3};

    QWindow *window{};

  private:
    bool gamepadConnected = false;
};