#include "engine_instance.h"

#include <QDebug>
#include <QLibrary>
#include <QOpenGLFunctions>
#include <QSurface>

static QOpenGLContext* currentOpenglContext = nullptr;
extern "C" void* getProcAddress(const char* fn) {
  if (!currentOpenglContext)
    return nullptr;
  else
    return reinterpret_cast<void*>(currentOpenglContext->getProcAddress(fn));
}

EngineInstance::EngineInstance(const QString& libraryPath, const QString&dataPath, QObject* parent)
    : QObject(parent), m_instance{nullptr, nullptr} {
  QLibrary hwlib(libraryPath);

  if (!hwlib.load())
    qWarning() << "Engine library not found" << hwlib.errorString();

  hedgewars_engine_protocol_version =
      reinterpret_cast<Engine::hedgewars_engine_protocol_version_t*>(
          hwlib.resolve("hedgewars_engine_protocol_version"));
  start_engine =
      reinterpret_cast<Engine::start_engine_t*>(hwlib.resolve("start_engine"));
  generate_preview = reinterpret_cast<Engine::generate_preview_t*>(
      hwlib.resolve("generate_preview"));
  dispose_preview = reinterpret_cast<Engine::dispose_preview_t*>(
      hwlib.resolve("dispose_preview"));
  cleanup = reinterpret_cast<Engine::cleanup_t*>(hwlib.resolve("cleanup"));

  send_ipc = reinterpret_cast<Engine::send_ipc_t*>(hwlib.resolve("send_ipc"));
  read_ipc = reinterpret_cast<Engine::read_ipc_t*>(hwlib.resolve("read_ipc"));

  setup_current_gl_context =
      reinterpret_cast<Engine::setup_current_gl_context_t*>(
          hwlib.resolve("setup_current_gl_context"));
  render_frame =
      reinterpret_cast<Engine::render_frame_t*>(hwlib.resolve("render_frame"));
  advance_simulation = reinterpret_cast<Engine::advance_simulation_t*>(
      hwlib.resolve("advance_simulation"));
  move_camera =
      reinterpret_cast<Engine::move_camera_t*>(hwlib.resolve("move_camera"));
  simple_event =
      reinterpret_cast<Engine::simple_event_t*>(hwlib.resolve("simple_event"));
  long_event =
      reinterpret_cast<Engine::long_event_t*>(hwlib.resolve("long_event"));
  positioned_event = reinterpret_cast<Engine::positioned_event_t*>(
      hwlib.resolve("positioned_event"));

  m_isValid = hedgewars_engine_protocol_version && start_engine &&
              generate_preview && dispose_preview && cleanup && send_ipc &&
              read_ipc && setup_current_gl_context && render_frame &&
              advance_simulation && move_camera && simple_event && long_event &&
              positioned_event;

  emit isValidChanged(m_isValid);

  if (isValid()) {
    qDebug() << "Loaded engine library with protocol version"
             << hedgewars_engine_protocol_version();

    m_instance = std::unique_ptr<Engine::EngineInstance, Engine::cleanup_t*>(
        start_engine(reinterpret_cast<const int8_t*>(dataPath.toUtf8().data())),
        cleanup);
  } else {
    qDebug("Engine library load failed");
  }
}

EngineInstance::~EngineInstance() = default;

void EngineInstance::sendConfig(const GameConfig& config) {
  for (auto b : config.config()) {
    send_ipc(m_instance.get(), reinterpret_cast<uint8_t*>(b.data()),
             static_cast<size_t>(b.size()));
  }
}

void EngineInstance::advance(quint32 ticks) {
  advance_simulation(m_instance.get(), ticks);
}

void EngineInstance::moveCamera(const QPoint& delta) {
  move_camera(m_instance.get(), delta.x(), delta.y());
}

void EngineInstance::simpleEvent(Engine::SimpleEventType event_type) {
  simple_event(m_instance.get(),
               static_cast<hwengine::SimpleEventType>(event_type));
}

void EngineInstance::longEvent(Engine::LongEventType event_type,
                               Engine::LongEventState state) {
  long_event(m_instance.get(), static_cast<hwengine::LongEventType>(event_type),
             static_cast<hwengine::LongEventState>(state));
}

void EngineInstance::positionedEvent(Engine::PositionedEventType event_type,
                                     qint32 x, qint32 y) {
  positioned_event(m_instance.get(),
                   static_cast<hwengine::PositionedEventType>(event_type), x,
                   y);
}

void EngineInstance::renderFrame() { render_frame(m_instance.get()); }

void EngineInstance::setOpenGLContext(QOpenGLContext* context) {
  currentOpenglContext = context;

  auto size = context->surface()->size();
  setup_current_gl_context(m_instance.get(), static_cast<quint16>(size.width()),
                           static_cast<quint16>(size.height()),
                           &getProcAddress);
}

QImage EngineInstance::generatePreview() {
  Engine::PreviewInfo pinfo;

  generate_preview(m_instance.get(), &pinfo);

  QVector<QRgb> colorTable;
  colorTable.resize(256);
  for (int i = 0; i < 256; ++i) colorTable[i] = qRgba(255, 255, 0, i);

  QImage previewImage(pinfo.land, static_cast<int>(pinfo.width),
                      static_cast<int>(pinfo.height), QImage::Format_Indexed8);
  previewImage.setColorTable(colorTable);

  // Cannot use it here, since QImage refers to original bytes
  // dispose_preview(m_instance.get());

  return previewImage;
}

bool EngineInstance::isValid() const { return m_isValid; }