#include "glad/glad.h"
#include <algorithm>
#include <event/events.h>
#include <glm/gtc/type_ptr.hpp>
#include <renderer/renderer_module.h>
#include <utils/logger.h>

// SDL for window size query
#include <SDL.h>

namespace extra2d {

RendererModule::RendererModule() = default;

RendererModule::~RendererModule() = default;

RendererModule::RendererModule(RendererModule &&other) noexcept
    : materialPool_(std::move(other.materialPool_)),
      meshPool_(std::move(other.meshPool_)),
      texturePool_(std::move(other.texturePool_)),
      commandBuffer_(std::move(other.commandBuffer_)),
      commandCount_(other.commandCount_),
      uniformManager_(std::move(other.uniformManager_)),
      defaultMaterialHandle_(other.defaultMaterialHandle_),
      defaultQuadHandle_(other.defaultQuadHandle_),
      defaultTextureHandle_(other.defaultTextureHandle_),
      onRenderBeginListener_(std::move(other.onRenderBeginListener_)),
      onRenderSubmitListener_(std::move(other.onRenderSubmitListener_)),
      onRenderEndListener_(std::move(other.onRenderEndListener_)),
      onResizeListener_(std::move(other.onResizeListener_)),
      onShowListener_(std::move(other.onShowListener_)),
      glInitialized_(other.glInitialized_), stats_(other.stats_),
      viewportX_(other.viewportX_), viewportY_(other.viewportY_),
      viewportWidth_(other.viewportWidth_),
      viewportHeight_(other.viewportHeight_) {
  // 重置源对象状态
  other.commandCount_ = 0;
  other.defaultMaterialHandle_ = INVALID_MATERIAL_HANDLE;
  other.defaultQuadHandle_ = INVALID_MESH_HANDLE;
  other.defaultTextureHandle_ = INVALID_TEXTURE_HANDLE;
  other.glInitialized_ = false;
  other.stats_ = {};
  other.viewportX_ = 0;
  other.viewportY_ = 0;
  other.viewportWidth_ = 0;
  other.viewportHeight_ = 0;
}

RendererModule &RendererModule::operator=(RendererModule &&other) noexcept {
  if (this != &other) {
    // 清理当前资源
    if (glInitialized_) {
      destroyDefaultResources();
      uniformManager_.shutdown();
    }

    // 移动资源
    materialPool_ = std::move(other.materialPool_);
    meshPool_ = std::move(other.meshPool_);
    texturePool_ = std::move(other.texturePool_);
    commandBuffer_ = std::move(other.commandBuffer_);
    commandCount_ = other.commandCount_;
    uniformManager_ = std::move(other.uniformManager_);
    defaultMaterialHandle_ = other.defaultMaterialHandle_;
    defaultQuadHandle_ = other.defaultQuadHandle_;
    defaultTextureHandle_ = other.defaultTextureHandle_;
    onRenderBeginListener_ = std::move(other.onRenderBeginListener_);
    onRenderSubmitListener_ = std::move(other.onRenderSubmitListener_);
    onRenderEndListener_ = std::move(other.onRenderEndListener_);
    onResizeListener_ = std::move(other.onResizeListener_);
    onShowListener_ = std::move(other.onShowListener_);
    glInitialized_ = other.glInitialized_;
    stats_ = other.stats_;
    viewportX_ = other.viewportX_;
    viewportY_ = other.viewportY_;
    viewportWidth_ = other.viewportWidth_;
    viewportHeight_ = other.viewportHeight_;

    // 重置源对象状态
    other.commandCount_ = 0;
    other.defaultMaterialHandle_ = INVALID_MATERIAL_HANDLE;
    other.defaultQuadHandle_ = INVALID_MESH_HANDLE;
    other.defaultTextureHandle_ = INVALID_TEXTURE_HANDLE;
    other.glInitialized_ = false;
    other.stats_ = {};
    other.viewportX_ = 0;
    other.viewportY_ = 0;
    other.viewportWidth_ = 0;
    other.viewportHeight_ = 0;
  }
  return *this;
}

bool RendererModule::init() {
  E2D_LOG_INFO("Initializing RendererModule...");

  // 绑定事件监听器
  onRenderBeginListener_.bind([this]() { onRenderBegin(); });
  onRenderSubmitListener_.bind(
      [this](const RenderCommand &cmd) { onRenderSubmit(cmd); });
  onRenderSetCameraListener_.bind(
      [this](const Mat4 &viewProj) { onRenderSetCamera(viewProj); });
  onRenderEndListener_.bind([this]() { onRenderEnd(); });
  onResizeListener_.bind([this](int32_t w, int32_t h) { onResize(w, h); });

  // 延迟 GL 初始化到窗口显示时
  onShowListener_.bind([this]() { onWindowShow(); });

  E2D_LOG_INFO("RendererModule initialized (waiting for GL context)");
  return true;
}

void RendererModule::onWindowShow() {
  if (glInitialized_) {
    return;
  }

  E2D_LOG_INFO("Initializing OpenGL context...");

  // 初始化 UBO 管理器（需要 GL 上下文）
  if (!uniformManager_.initialize()) {
    E2D_LOG_ERROR("Failed to initialize UniformBufferManager");
    return;
  }

  // 创建默认资源（需要 GL 上下文）
  if (!createDefaultResources()) {
    E2D_LOG_ERROR("Failed to create default resources");
    return;
  }

  // 获取实际窗口大小并设置视口
  // 查询当前 SDL 窗口大小
  int windowWidth = 800, windowHeight = 600;
  SDL_Window *sdlWindow = SDL_GL_GetCurrentWindow();
  if (sdlWindow) {
    SDL_GetWindowSize(sdlWindow, &windowWidth, &windowHeight);
    E2D_LOG_INFO("Setting initial viewport to window size: {}x{}", windowWidth,
                 windowHeight);
  } else {
    E2D_LOG_WARN("Could not get SDL window, using default viewport 800x600");
  }
  setViewport(0, 0, static_cast<int32>(windowWidth),
              static_cast<int32>(windowHeight));

  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  glInitialized_ = true;
  E2D_LOG_INFO("OpenGL context initialized successfully");
}

void RendererModule::shutdown() {
  E2D_LOG_INFO("Shutting down RendererModule...");

  // 只有在 GL 初始化后才销毁 GL 相关资源
  if (glInitialized_) {
    // 销毁默认资源
    destroyDefaultResources();

    // 关闭 UBO 管理器
    uniformManager_.shutdown();
  }

  // 清理资源池
  materialPool_.slots.clear();
  while (!materialPool_.freeIndices.empty())
    materialPool_.freeIndices.pop();

  meshPool_.slots.clear();
  while (!meshPool_.freeIndices.empty())
    meshPool_.freeIndices.pop();

  texturePool_.slots.clear();
  while (!texturePool_.freeIndices.empty())
    texturePool_.freeIndices.pop();

  glInitialized_ = false;

  E2D_LOG_INFO("RendererModule shutdown complete");
}

MaterialHandle RendererModule::registerMaterial(Ptr<Material> material) {
  uint64_t handle = materialPool_.acquire();
  auto *slot = materialPool_.get(handle);
  if (slot) {
    slot->material = material;
  }
  return handle;
}

MeshHandle RendererModule::registerMesh(Ptr<Mesh> mesh) {
  uint64_t handle = meshPool_.acquire();
  auto *slot = meshPool_.get(handle);
  if (slot) {
    slot->mesh = mesh;
  }
  return handle;
}

TextureHandle RendererModule::registerTexture(Ptr<Texture> texture) {
  uint64_t handle = texturePool_.acquire();
  auto *slot = texturePool_.get(handle);
  if (slot) {
    slot->texture = texture;
  }
  return handle;
}

void RendererModule::unregisterMaterial(MaterialHandle handle) {
  materialPool_.release(handle);
}

void RendererModule::unregisterMesh(MeshHandle handle) {
  meshPool_.release(handle);
}

void RendererModule::unregisterTexture(TextureHandle handle) {
  texturePool_.release(handle);
}

Ptr<Material> RendererModule::getMaterial(MaterialHandle handle) {
  auto *slot = materialPool_.get(handle);
  return slot ? slot->material : nullptr;
}

Ptr<Mesh> RendererModule::getMesh(MeshHandle handle) {
  auto *slot = meshPool_.get(handle);
  return slot ? slot->mesh : nullptr;
}

Ptr<Texture> RendererModule::getTexture(TextureHandle handle) {
  auto *slot = texturePool_.get(handle);
  return slot ? slot->texture : nullptr;
}

void RendererModule::setViewport(int32 x, int32 y, int32 width, int32 height) {
  viewportX_ = x;
  viewportY_ = y;
  viewportWidth_ = width;
  viewportHeight_ = height;

  // 更新视口适配器
  viewportAdapter_.update(width, height);

  // 获取适配后的视口
  auto result = viewportAdapter_.getResult();
  glViewport(static_cast<GLint>(result.viewport.x),
             static_cast<GLint>(result.viewport.y),
             static_cast<GLsizei>(result.viewport.w),
             static_cast<GLsizei>(result.viewport.h));
}

void RendererModule::clear(const Color &color, uint32_t flags) {
  GLbitfield mask = 0;

  if (flags & CLEAR_COLOR_FLAG) {
    glClearColor(color.r, color.g, color.b, color.a);
    mask |= GL_COLOR_BUFFER_BIT;
  }

  if (flags & CLEAR_DEPTH_FLAG) {
    mask |= GL_DEPTH_BUFFER_BIT;
  }

  if (flags & CLEAR_STENCIL_FLAG) {
    mask |= GL_STENCIL_BUFFER_BIT;
  }

  if (mask != 0) {
    glClear(mask);
  }
}

void RendererModule::onRenderBegin() {
  // 如果 GL 未初始化，跳过渲染
  if (!glInitialized_) {
    return;
  }

  // 清除屏幕（黑色背景）
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glClear(GL_COLOR_BUFFER_BIT);

  // 清空命令缓冲区
  commandCount_ = 0;

  // 重置统计
  stats_ = {};

  // 重置 UBO 管理器
  uniformManager_.resetMaterialUBOs();
}

void RendererModule::onRenderSubmit(const RenderCommand &cmd) {
  // 如果 GL 未初始化，跳过提交
  if (!glInitialized_) {
    return;
  }

  // 检查缓冲区是否已满
  if (commandCount_ >= MAX_RENDER_COMMANDS) {
    E2D_LOG_WARN("Render command buffer full!");
    return;
  }

  // 直接存入预分配缓冲区（无动态分配）
  commandBuffer_[commandCount_++] = cmd;
  stats_.commandsSubmitted++;
}

void RendererModule::onRenderSetCamera(const Mat4 &viewProj) {
  // 如果 GL 未初始化，跳过
  if (!glInitialized_) {
    return;
  }

  // 保存视图投影矩阵
  viewProjectionMatrix_ = viewProj;

  // 更新全局 UBO 中的视图投影矩阵
  uniformManager_.updateGlobalUBO(&viewProj, sizeof(Mat4));
}

void RendererModule::onRenderEnd() {
  // 如果 GL 未初始化，跳过渲染
  if (!glInitialized_) {
    return;
  }

  // 排序命令
  sortCommands();

  // 批处理并绘制
  batchAndDraw();

  // 输出统计
  E2D_LOG_DEBUG("Render: {} commands, {} draw calls, {} batches",
                stats_.commandsExecuted, stats_.drawCalls, stats_.batches);
}

void RendererModule::onResize(int32 width, int32 height) {
  setViewport(0, 0, width, height);
}

void RendererModule::sortCommands() {
  // 使用 std::sort 对命令进行排序
  std::sort(commandBuffer_.begin(), commandBuffer_.begin() + commandCount_,
            [](const RenderCommand &a, const RenderCommand &b) {
              return a.sortKey < b.sortKey;
            });
}

void RendererModule::batchAndDraw() {
  MaterialHandle lastMaterial = INVALID_MATERIAL_HANDLE;
  MeshHandle lastMesh = INVALID_MESH_HANDLE;
  uint32_t batchStart = 0;
  uint32_t batchCount = 0;

  for (uint32_t i = 0; i < commandCount_; ++i) {
    const auto &cmd = commandBuffer_[i];

    if (cmd.type != RenderCommandType::DrawMesh) {
      // 处理非绘制命令
      if (batchCount > 0) {
        drawBatch(batchStart, batchCount, lastMaterial, lastMesh);
        stats_.batches++;
        batchCount = 0;
      }
      executeCommand(cmd);
      continue;
    }

    // 检查是否需要刷新批次
    if (cmd.drawMesh.material != lastMaterial ||
        cmd.drawMesh.mesh != lastMesh) {

      // 刷新上一批次
      if (batchCount > 0) {
        drawBatch(batchStart, batchCount, lastMaterial, lastMesh);
        stats_.batches++;
      }

      lastMaterial = cmd.drawMesh.material;
      lastMesh = cmd.drawMesh.mesh;
      batchStart = i;
      batchCount = 1;
    } else {
      ++batchCount;
    }

    stats_.commandsExecuted++;
  }

  // 刷新最后一批
  if (batchCount > 0) {
    drawBatch(batchStart, batchCount, lastMaterial, lastMesh);
    stats_.batches++;
  }
}

void RendererModule::drawBatch(uint32_t start, uint32_t count,
                               MaterialHandle materialHandle,
                               MeshHandle meshHandle) {
  auto material = getMaterial(materialHandle);
  // 如果材质无效，使用默认材质
  if (!material) {
    material = getMaterial(defaultMaterialHandle_);
  }

  auto mesh = getMesh(meshHandle);
  // 如果网格无效，使用默认四边形
  if (!mesh) {
    mesh = getMesh(defaultQuadHandle_);
  }

  if (!material || !mesh)
    return;

  // 获取着色器
  auto shader = material->getShader();
  if (!shader)
    return;

  // 绑定着色器
  shader->bind();

  // 设置视图投影矩阵
  shader->setMat4("uViewProjection", glm::value_ptr(viewProjectionMatrix_));

  // 设置材质参数
  // 注意：直接使用默认值，因为材质数据布局可能不匹配
  // tintColor 和 opacity 由着色器默认值处理
  shader->setVec4("uTintColor", 1.0f, 1.0f, 1.0f, 1.0f);
  shader->setFloat("uOpacity", 1.0f);

  // 绑定材质中的纹理
  const auto &textureSlots = material->getTextures();
  bool hasMaterialTexture = false;
  for (const auto &slot : textureSlots) {
    if (slot.handle != INVALID_TEXTURE_HANDLE) {
      auto texture = getTexture(slot.handle);
      if (texture) {
        texture->bind(slot.slot);
        // 设置采样器 uniform
        shader->setInt(slot.uniformName, static_cast<int>(slot.slot));
        hasMaterialTexture = true;
      }
    }
  }

  // 如果材质没有纹理，绑定默认纹理
  if (!hasMaterialTexture && defaultTextureHandle_ != INVALID_TEXTURE_HANDLE) {
    auto defaultTexture = getTexture(defaultTextureHandle_);
    if (defaultTexture) {
      defaultTexture->bind(0);
      shader->setInt("uTexture", 0);
    }
  }

  // 绑定网格
  mesh->bind();

  // 对每个实例单独绘制
  for (uint32_t i = 0; i < count; ++i) {
    Transform transform = commandBuffer_[start + i].getTransform();
    float matrix[16];
    transform.toMatrix(matrix);

    // 设置模型矩阵
    shader->setMat4("uModelMatrix", matrix);

    // 设置顶点颜色
    Color color = commandBuffer_[start + i].getColor();
    shader->setVec4("uColor", color.r, color.g, color.b, color.a);

    // 绘制
    mesh->draw();
    stats_.drawCalls++;
  }
}

void RendererModule::executeCommand(const RenderCommand &cmd) {
  switch (cmd.type) {
  case RenderCommandType::SetViewport:
    setViewport(cmd.viewport.x, cmd.viewport.y, cmd.viewport.width,
                cmd.viewport.height);
    break;

  case RenderCommandType::Clear:
    clear(cmd.clear.color, cmd.clear.flags);
    break;

  default:
    break;
  }
}

bool RendererModule::createDefaultResources() {
  // 创建默认着色器
  auto defaultShader = makePtr<Shader>();
  if (!defaultShader->loadFromFile("shader/default.vert",
                                   "shader/default.frag")) {
    E2D_LOG_ERROR("Failed to load default shader");
    return false;
  }

  // 创建默认材质布局
  auto defaultLayout = makePtr<MaterialLayout>();
  defaultLayout->addParam("tintColor", MaterialParamType::Color);
  defaultLayout->addParam("opacity", MaterialParamType::Float);
  defaultLayout->finalize();

  // 创建默认材质
  auto defaultMaterial = makePtr<Material>();
  defaultMaterial->setLayout(defaultLayout);
  defaultMaterial->setShader(defaultShader);
  defaultMaterial->setColor("tintColor", Color::White);
  defaultMaterial->setFloat("opacity", 1.0f);

  defaultMaterialHandle_ = registerMaterial(defaultMaterial);

  // 创建默认四边形
  auto defaultQuad = Mesh::createQuad(Vec2(1.0f, 1.0f));
  defaultQuadHandle_ = registerMesh(defaultQuad);

  // 创建默认纹理（1x1 白色）
  auto defaultTexture = makePtr<Texture>();
  uint8_t whitePixel[4] = {255, 255, 255, 255};
  defaultTexture->loadFromMemory(whitePixel, 1, 1, TextureFormat::RGBA8);
  defaultTextureHandle_ = registerTexture(defaultTexture);

  E2D_LOG_INFO("Default resources created");
  return true;
}

void RendererModule::destroyDefaultResources() {
  if (defaultMaterialHandle_ != INVALID_MATERIAL_HANDLE) {
    unregisterMaterial(defaultMaterialHandle_);
    defaultMaterialHandle_ = INVALID_MATERIAL_HANDLE;
  }

  if (defaultQuadHandle_ != INVALID_MESH_HANDLE) {
    unregisterMesh(defaultQuadHandle_);
    defaultQuadHandle_ = INVALID_MESH_HANDLE;
  }

  if (defaultTextureHandle_ != INVALID_TEXTURE_HANDLE) {
    unregisterTexture(defaultTextureHandle_);
    defaultTextureHandle_ = INVALID_TEXTURE_HANDLE;
  }
}

} // namespace extra2d