#include <algorithm>
#include <cstring>
#include <vector>
#include <renderer/command_queue.h>
#include <renderer/material.h>
#include <renderer/mesh.h>
#include <renderer/rhi_module.h>
#include <renderer/rhi/opengl/gl_command_list.h>
#include <renderer/rhi/opengl/gl_texture.h>
#include <types/math/transform.h>
#include <types/ptr/intrusive_ptr.h>
#include <utils/logger.h>

#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

namespace extra2d {

// ========================================
// CommandSorter 实现
// ========================================

CommandSorter::CommandSorter() {
  // 预分配初始容量
  commands_.reserve(INITIAL_CAPACITY);
  sortedIndices_.reserve(INITIAL_CAPACITY);
}

CommandSorter::~CommandSorter() = default;

CommandSorter::CommandSorter(CommandSorter&& other) noexcept
    : commands_(std::move(other.commands_)),
      sortedIndices_(std::move(other.sortedIndices_)),
      commandCount_(other.commandCount_) {
  other.commandCount_ = 0;
}

CommandSorter& CommandSorter::operator=(CommandSorter&& other) noexcept {
  if (this != &other) {
    commands_ = std::move(other.commands_);
    sortedIndices_ = std::move(other.sortedIndices_);
    commandCount_ = other.commandCount_;
    other.commandCount_ = 0;
  }
  return *this;
}

uint32_t CommandSorter::addCommand(const DrawCommand &cmd) {
  uint32_t index = commandCount_;

  // 如果缓冲区不够大，扩展它
  if (index >= commands_.size()) {
    commands_.push_back(cmd);
    sortedIndices_.push_back(index);
  } else {
    commands_[index] = cmd;
    sortedIndices_[index] = index;
  }

  commandCount_++;
  return index;
}

void CommandSorter::sort() {
  if (commandCount_ == 0) return;

  // 只排序有效范围的索引
  auto indicesBegin = sortedIndices_.begin();
  auto indicesEnd = sortedIndices_.begin() + commandCount_;

  // 使用稳定排序保持相同键的命令顺序
  std::stable_sort(indicesBegin, indicesEnd,
                   [this](uint32_t a, uint32_t b) {
                     return commands_[a].key < commands_[b].key;
                   });
}

void CommandSorter::clear() {
  // 重置计数器，保留内存
  commandCount_ = 0;
}

void CommandSorter::reserve(uint32_t capacity) {
  commands_.reserve(capacity);
  sortedIndices_.reserve(capacity);
}

// ========================================
// CommandBatcher 实现
// ========================================

void CommandBatcher::process(const CommandSorter &sorter) {
  clear();
  sorter_ = &sorter;

  if (sorter.getCount() == 0) {
    return;
  }

  CommandBatch currentBatch;
  currentBatch.startIndex = 0;
  currentBatch.count = 1;

  const auto &firstCmd = sorter.getCommand(0);
  currentBatch.pipeline = firstCmd.pipeline;
  currentBatch.textureCount = firstCmd.textureCount;
  for (uint32_t i = 0; i < firstCmd.textureCount; ++i) {
    currentBatch.textures[i] = firstCmd.textures[i];
  }

  // 遍历所有命令，合并兼容的命令
  for (uint32_t i = 1; i < sorter.getCount(); ++i) {
    const auto &cmd = sorter.getCommand(i);

    if (currentBatch.isCompatibleWith(cmd)) {
      // 兼容，加入当前批次
      currentBatch.count++;
    } else {
      // 不兼容，保存当前批次并创建新批次
      batches_.push_back(currentBatch);

      currentBatch.startIndex = i;
      currentBatch.count = 1;
      currentBatch.pipeline = cmd.pipeline;
      currentBatch.textureCount = cmd.textureCount;
      for (uint32_t j = 0; j < cmd.textureCount; ++j) {
        currentBatch.textures[j] = cmd.textures[j];
      }
    }
  }

  // 保存最后一个批次
  batches_.push_back(currentBatch);
}

const DrawCommand &CommandBatcher::getCommand(uint32_t batchIndex,
                                              uint32_t cmdIndex) const {
  const auto &batch = batches_[batchIndex];
  return sorter_->getCommand(batch.startIndex + cmdIndex);
}

void CommandBatcher::clear() {
  batches_.clear();
  sorter_ = nullptr;
}

// ========================================
// CommandQueue 实现
// ========================================

CommandQueue::CommandQueue() = default;

CommandQueue::~CommandQueue() { shutdown(); }

CommandQueue::CommandQueue(CommandQueue &&other) noexcept
    : sorter_(std::move(other.sorter_)), batcher_(std::move(other.batcher_)),
      context_(other.context_), commandList_(std::move(other.commandList_)),
      uboManager_(std::move(other.uboManager_)),
      globalUBOData_(other.globalUBOData_),
      materialUBOData_(std::move(other.materialUBOData_)),
      nextMaterialId_(other.nextMaterialId_),
      materialIds_(std::move(other.materialIds_)),
      currentMaterialUBO_(other.currentMaterialUBO_),
      materialUBOBufferOffset_(other.materialUBOBufferOffset_) {
  other.context_ = nullptr;
  other.globalUBOData_ = {};
  other.nextMaterialId_ = 1;
  other.currentMaterialUBO_ = nullptr;
  other.materialUBOBufferOffset_ = 0;
}

CommandQueue &CommandQueue::operator=(CommandQueue &&other) noexcept {
  if (this != &other) {
    shutdown();

    sorter_ = std::move(other.sorter_);
    batcher_ = std::move(other.batcher_);
    context_ = other.context_;
    commandList_ = std::move(other.commandList_);
    uboManager_ = std::move(other.uboManager_);
    globalUBOData_ = other.globalUBOData_;
    materialUBOData_ = std::move(other.materialUBOData_);
    nextMaterialId_ = other.nextMaterialId_;
    materialIds_ = std::move(other.materialIds_);
    currentMaterialUBO_ = other.currentMaterialUBO_;
    materialUBOBufferOffset_ = other.materialUBOBufferOffset_;

    other.context_ = nullptr;
    other.globalUBOData_ = {};
    other.nextMaterialId_ = 1;
    other.currentMaterialUBO_ = nullptr;
    other.materialUBOBufferOffset_ = 0;
  }
  return *this;
}

bool CommandQueue::initialize() {
  // 获取 RHI 模块
  auto *rhiModule = RHIModule::get();
  if (!rhiModule) {
    E2D_LOG_ERROR("RHIModule not available");
    return false;
  }

  auto *device = rhiModule->getDevice();
  if (!device) {
    E2D_LOG_ERROR("RHIDevice not available");
    return false;
  }

  context_ = rhiModule->getContext();
  if (!context_) {
    E2D_LOG_ERROR("RHIContext not available");
    return false;
  }

  // 创建命令列表
  commandList_ = device->createCommandList();
  if (!commandList_) {
    E2D_LOG_ERROR("Failed to create command list");
    return false;
  }

  // 初始化 UBO 管理器
  uboManager_ = std::make_unique<UniformBufferManager>();
  if (!uboManager_->initialize()) {
    E2D_LOG_ERROR("Failed to initialize UniformBufferManager");
    return false;
  }

  // 预分配材质 UBO 数据缓冲区
  materialUBOData_.reserve(1024 * 1024); // 1MB

  E2D_LOG_INFO("CommandQueue initialized");
  return true;
}

void CommandQueue::shutdown() {
  uboManager_.reset();
  commandList_.reset();
  context_ = nullptr;
  materialUBOData_.clear();
  E2D_LOG_INFO("CommandQueue shutdown");
}

void CommandQueue::beginFrame() {
  sorter_.clear();
  batcher_.clear();
  materialIds_.clear();
  nextMaterialId_ = 1;

  // 重置材质 UBO 缓冲区（保留容量，避免重新分配）
  materialUBOBufferOffset_ = 0;
  currentMaterialUBO_ = nullptr;

  // 重置 UBO 管理器的材质 UBO 池
  if (uboManager_) {
    uboManager_->resetMaterialUBOs();
  }

  // 重置统计
  stats_ = {};

  // 开始录制命令
  if (commandList_) {
    commandList_->begin();
  }
}

void CommandQueue::endFrame() {
  // 结束录制
  if (commandList_) {
    commandList_->end();
  }
}

uint32_t CommandQueue::getMaterialId(Material *material) {
  auto it = materialIds_.find(material);
  if (it != materialIds_.end()) {
    return it->second;
  }

  uint32_t id = nextMaterialId_++;
  materialIds_[material] = id;
  return id;
}

std::pair<UniformBuffer*, uint32_t> CommandQueue::allocateMaterialUBO(uint32_t size) {
  if (!uboManager_ || size == 0) {
    return {nullptr, 0};
  }

  // OpenGL 要求 UBO 偏移对齐到 GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT (通常是 256)
  static constexpr uint32_t UBO_ALIGNMENT = 256;

  // 使用批量更新机制：先分配到 CPU 缓冲区
  uint32_t offset = materialUBOBufferOffset_;
  // 对齐到 UBO_ALIGNMENT 字节
  offset = (offset + UBO_ALIGNMENT - 1) & ~(UBO_ALIGNMENT - 1);

  uint32_t alignedSize = (size + UBO_ALIGNMENT - 1) & ~(UBO_ALIGNMENT - 1);

  // 检查 CPU 缓冲区是否有足够空间
  if (offset + alignedSize > materialUBOData_.capacity()) {
    // 如果缓冲区已满，先刷新到 GPU
    flushMaterialUBOToGPU();
    offset = 0; // 重置偏移量
  }

  // 确保缓冲区足够大
  if (offset + alignedSize > materialUBOData_.size()) {
    materialUBOData_.resize(offset + alignedSize);
  }

  materialUBOBufferOffset_ = offset + alignedSize;

  return {nullptr, offset}; // 返回 nullptr 表示使用 CPU 缓冲区，offset 是 CPU 缓冲区偏移
}

void CommandQueue::flushMaterialUBOToGPU() {
  if (materialUBOBufferOffset_ == 0) {
    return;
  }

  // 获取一个足够大的 UBO
  currentMaterialUBO_ = uboManager_->acquireMaterialUBO(materialUBOBufferOffset_);
  if (!currentMaterialUBO_) {
    E2D_LOG_ERROR("Failed to acquire material UBO for flush");
    return;
  }

  // 批量更新到 GPU
  currentMaterialUBO_->update(materialUBOData_.data(), materialUBOBufferOffset_, 0);

  // 重置 CPU 缓冲区偏移
  materialUBOBufferOffset_ = 0;
}

UniformBuffer* CommandQueue::getCurrentMaterialUBO() const {
  return currentMaterialUBO_;
}

void CommandQueue::submitDraw(Ptr<Material> material, Ptr<Mesh> mesh,
                              const struct Transform &transform,
                              const Color &color) {
  if (!material || !mesh || !material->getShader()) {
    return;
  }

  DrawCommand cmd;

  // 构建排序键
  uint32_t materialId = getMaterialId(material.get());
  cmd.key = DrawKey::make(materialId, 0, 0);

  // 设置管线
  cmd.pipeline = material->getPipeline();

  // 设置网格数据
  cmd.vertexBuffer = mesh->getVertexBuffer();
  cmd.indexBuffer = mesh->getIndexBuffer();
  cmd.vertexCount = mesh->getVertexCount();
  cmd.indexCount = mesh->getIndexCount();

  // 设置变换和颜色
  float matrixData[16];
  transform.toMatrix(matrixData);
  cmd.modelMatrix = glm::make_mat4(matrixData);
  cmd.color = color;

  // 设置纹理
  const auto &textures = material->getTextures();
  cmd.textureCount =
      static_cast<uint32_t>(std::min(textures.size(), size_t(8)));
  for (uint32_t i = 0; i < cmd.textureCount; ++i) {
    if (textures[i].texture) {
      cmd.textures[i] = textures[i].texture->getHandle();
    }
  }

  // 分配材质 UBO 空间（使用 CPU 缓冲区）
  uint32_t materialDataSize = material->getDataSize();
  if (materialDataSize > 0) {
    auto [ubo, offset] = allocateMaterialUBO(materialDataSize);
    (void)ubo; // ubo 为 nullptr，使用 CPU 缓冲区

    // 复制材质数据到 CPU 缓冲区，并修改颜色
    if (offset + materialDataSize <= materialUBOData_.size()) {
      std::memcpy(materialUBOData_.data() + offset, material->getData(), materialDataSize);

      // 将实例颜色应用到 UBO 数据中的 uColor 参数
      auto layout = material->getLayout();
      if (layout) {
        const auto* param = layout->getParam("uColor");
        if (param && param->type == MaterialParamType::Color) {
          std::memcpy(materialUBOData_.data() + offset + param->offset, &color.r, sizeof(float) * 4);
        }
      }

      cmd.materialUBOOffset = offset;
      cmd.materialUBOSize = materialDataSize;
    }
  }

  sorter_.addCommand(cmd);
}

void CommandQueue::submitClear(const Color &color, uint32_t flags) {
  // 清除命令直接执行，不加入排序队列
  if (!commandList_) {
    return;
  }

  commandList_->clear(static_cast<ClearFlags>(flags), color, 1.0f, 0);
}

void CommandQueue::setViewport(int32_t x, int32_t y, int32_t width,
                               int32_t height) {
  if (!commandList_) {
    return;
  }

  Viewport viewport;
  viewport.x = static_cast<float>(x);
  viewport.y = static_cast<float>(y);
  viewport.width = static_cast<float>(width);
  viewport.height = static_cast<float>(height);
  viewport.minDepth = 0.0f;
  viewport.maxDepth = 1.0f;

  commandList_->setViewport(viewport);
}

void CommandQueue::updateGlobalUBO(const Mat4& viewProjection, float deltaTime,
                                   uint32_t screenWidth, uint32_t screenHeight, uint32_t frameIndex) {
  if (!uboManager_) {
    E2D_LOG_WARN("CommandQueue::updateGlobalUBO: uboManager is null");
    return;
  }

  // 填充全局 UBO 数据
  std::memcpy(globalUBOData_.viewProjection, glm::value_ptr(viewProjection), sizeof(float) * 16);
  globalUBOData_.cameraPosition[0] = 0.0f;
  globalUBOData_.cameraPosition[1] = 0.0f;
  globalUBOData_.cameraPosition[2] = 0.0f;
  globalUBOData_.cameraPosition[3] = 1.0f;
  globalUBOData_.time = 0.0f;  // TODO: 传递实际时间
  globalUBOData_.deltaTime = deltaTime;
  globalUBOData_.screenSize[0] = static_cast<float>(screenWidth);
  globalUBOData_.screenSize[1] = static_cast<float>(screenHeight);

  // 使用双缓冲更新 UBO
  uboManager_->updateGlobalUBO(&globalUBOData_, sizeof(globalUBOData_), frameIndex);
}

void CommandQueue::execute(uint32_t frameIndex) {
  if (!commandList_) {
    E2D_LOG_ERROR("CommandQueue::execute: commandList is null");
    return;
  }

  // 在排序前刷新材质 UBO 数据到 GPU
  flushMaterialUBOToGPU();

  // 排序命令
  sorter_.sort();

  // 批处理
  batcher_.process(sorter_);

  // 执行批次
  for (uint32_t i = 0; i < batcher_.getBatchCount(); ++i) {
    executeBatch(i, batcher_.getBatch(i), frameIndex);
  }

  // 提交命令到 GPU
  commandList_->submit();
}

void CommandQueue::executeBatch(uint32_t batchIndex, const CommandBatch &batch, uint32_t frameIndex) {
  if (!commandList_) {
    return;
  }

  // 绑定管线
  if (batch.pipeline.isValid()) {
    commandList_->setPipeline(batch.pipeline.get());
    stats_.pipelineBinds++;
  } else {
    E2D_LOG_WARN("Batch has no valid pipeline!");
  }

  // 绑定全局 UBO (binding = 0) - 使用双缓冲
  if (uboManager_) {
    UniformBuffer* globalUBO = uboManager_->getGlobalUBO(frameIndex);
    if (globalUBO) {
      commandList_->setUniformBuffer(0, globalUBO->getRHIBuffer());
      stats_.bufferBinds++;
    }
  }

  // 绑定纹理
  if (batch.textureCount > 0) {
    for (uint32_t i = 0; i < batch.textureCount; ++i) {
      if (batch.textures[i].isValid()) {
        commandList_->setTexture(i, batch.textures[i].get());
        stats_.textureBinds++;
      }
    }
  }

  // 执行批次中的所有命令
  for (uint32_t i = 0; i < batch.count; ++i) {
    const auto &cmd = batcher_.getCommand(batchIndex, i);

    // 绑定顶点缓冲区
    if (cmd.vertexBuffer.isValid()) {
      commandList_->setVertexBuffer(0, cmd.vertexBuffer.get(), 0);
      stats_.bufferBinds++;
    } else {
      E2D_LOG_WARN("Draw command has no valid vertex buffer!");
    }

    // 绑定索引缓冲区（如果有）
    if (cmd.isIndexed() && cmd.indexBuffer.isValid()) {
      commandList_->setIndexBuffer(cmd.indexBuffer.get(), IndexType::UInt16, 0);
      stats_.bufferBinds++;
    }

    // 绑定材质 UBO (binding = 1)
    if (cmd.materialUBOSize > 0 && currentMaterialUBO_) {
      commandList_->setUniformBuffer(1, currentMaterialUBO_->getRHIBuffer(), cmd.materialUBOOffset, cmd.materialUBOSize);
      stats_.bufferBinds++;
    }

    // 设置模型矩阵
    commandList_->setUniform("uModelMatrix", cmd.modelMatrix);

    // 绘制
    if (cmd.isIndexed()) {
      commandList_->drawIndexed(cmd.indexCount, 0, 0, 1, 0);
      stats_.drawCalls++;
      stats_.triangles += cmd.indexCount / 3;
    } else {
      commandList_->draw(cmd.vertexCount, 0, 1, 0);
      stats_.drawCalls++;
      stats_.triangles += cmd.vertexCount / 3;
    }
    stats_.vertices += cmd.vertexCount;
  }
}

} // namespace extra2d