#include "boo/IWindow.hpp"
#include "boo/IGraphicsContext.hpp"
#include "logvisor/logvisor.hpp"
#include "boo/graphicsdev/NX.hpp"

#include <switch.h>

namespace boo {

std::unique_ptr<IGraphicsCommandQueue> _NewNXCommandQueue(NXContext* ctx, IGraphicsContext* parent);
std::unique_ptr<IGraphicsDataFactory> _NewNXDataFactory(IGraphicsContext* parent, NXContext* ctx);

struct GraphicsContextNX : IGraphicsContext {
  NXContext* m_nxCtx;
  std::unique_ptr<IGraphicsDataFactory> m_dataFactory;
  std::unique_ptr<IGraphicsCommandQueue> m_commandQueue;

public:
  explicit GraphicsContextNX(NXContext* nxCtx) : m_nxCtx(nxCtx) {
    m_dataFactory = _NewNXDataFactory(this, nxCtx);
    m_commandQueue = _NewNXCommandQueue(nxCtx, this);
  }

  EGraphicsAPI getAPI() const { return EGraphicsAPI::NX; }
  EPixelFormat getPixelFormat() const { return EPixelFormat::RGBA8; }
  void setPixelFormat(EPixelFormat pf) {}
  bool initializeContext(void* handle) { return m_nxCtx->initialize(); }
  void makeCurrent() {}
  void postInit() {}
  void present() {}

  IGraphicsCommandQueue* getCommandQueue() { return m_commandQueue.get(); }
  IGraphicsDataFactory* getDataFactory() { return m_dataFactory.get(); }
  IGraphicsDataFactory* getMainContextDataFactory() { return m_dataFactory.get(); }
  IGraphicsDataFactory* getLoadContextDataFactory() { return m_dataFactory.get(); }
};

class WindowNX : public IWindow {
  std::string m_title;
  std::unique_ptr<GraphicsContextNX> m_gfxCtx;
  IWindowCallback* m_callback = nullptr;

public:
  WindowNX(std::string_view title, NXContext* nxCtx) : m_title(title), m_gfxCtx(new GraphicsContextNX(nxCtx)) {
    m_gfxCtx->initializeContext(nullptr);
  }

  void setCallback(IWindowCallback* cb) { m_callback = cb; }

  void closeWindow() {}
  void showWindow() {}
  void hideWindow() {}

  SystemString getTitle() { return m_title; }
  void setTitle(SystemStringView title) { m_title = title; }

  void setCursor(EMouseCursor cursor) {}
  void setWaitCursor(bool wait) {}

  void setWindowFrameDefault() {}
  void getWindowFrame(float& xOut, float& yOut, float& wOut, float& hOut) const {
    u32 width, height;
    gfxGetFramebufferResolution(&width, &height);
    xOut = 0;
    yOut = 0;
    wOut = width;
    hOut = height;
  }
  void getWindowFrame(int& xOut, int& yOut, int& wOut, int& hOut) const {
    u32 width, height;
    gfxGetFramebufferResolution(&width, &height);
    xOut = 0;
    yOut = 0;
    wOut = width;
    hOut = height;
  }
  void setWindowFrame(float x, float y, float w, float h) {}
  void setWindowFrame(int x, int y, int w, int h) {}
  float getVirtualPixelFactor() const { return 1.f; }

  bool isFullscreen() const { return true; }
  void setFullscreen(bool fs) {}

  void claimKeyboardFocus(const int coord[2]) {}
  bool clipboardCopy(EClipboardType type, const uint8_t* data, size_t sz) { return false; }
  std::unique_ptr<uint8_t[]> clipboardPaste(EClipboardType type, size_t& sz) { return {}; }

  void waitForRetrace() {}

  uintptr_t getPlatformHandle() const { return 0; }
  bool _incomingEvent(void* event) {
    (void)event;
    return false;
  }
  void _cleanup() {}

  ETouchType getTouchType() const { return ETouchType::Display; }

  void setStyle(EWindowStyle style) {}
  EWindowStyle getStyle() const { return EWindowStyle::None; }

  void setTouchBarProvider(void*) {}

  IGraphicsCommandQueue* getCommandQueue() { return m_gfxCtx->getCommandQueue(); }
  IGraphicsDataFactory* getDataFactory() { return m_gfxCtx->getDataFactory(); }
  IGraphicsDataFactory* getMainContextDataFactory() { return m_gfxCtx->getMainContextDataFactory(); }
  IGraphicsDataFactory* getLoadContextDataFactory() { return m_gfxCtx->getLoadContextDataFactory(); }
};

std::shared_ptr<IWindow> _WindowNXNew(std::string_view title, NXContext* nxCtx) {
  std::shared_ptr<IWindow> ret = std::make_shared<WindowNX>(title, nxCtx);
  return ret;
}

} // namespace boo