/*
 * Copyright 2026 Rive
 */

#include "rive/decoders/bitmap_decoder.hpp"
#include "rive/gpu_texture_format.hpp"

// bc7decomp provides BC7 software decompression.
// rgbcx provides BC1/BC2/BC3 software decompression.
#include "bc7decomp.h"
#include "rgbcx.h"

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <memory>

std::unique_ptr<Bitmap> decode_bc_texture(
    const uint8_t* blocks,
    size_t /*byteCount*/,
    uint32_t width,
    uint32_t height,
    rive::GPUTextureFormat format)
{
  // All BCn formats use 4x4 pixel blocks.
  const uint32_t blocksX = (width + 3) / 4;
  const uint32_t blocksY = (height + 3) / 4;

  const size_t pixelCount = static_cast<size_t>(width) * height;
  auto pixels = std::make_unique<uint8_t[]>(pixelCount * 4);
  memset(pixels.get(), 0, pixelCount * 4);

  const uint8_t* src = blocks;

  for (uint32_t by = 0; by < blocksY; by++)
  {
    for (uint32_t bx = 0; bx < blocksX; bx++)
    {
      // Decode one 4x4 block into a temporary 16-pixel RGBA buffer.
      // uint32_t storage gives the bc7decomp/rgbcx union casts proper
      // alignment (required on ARM) and lets the copy below move one
      // pixel per assignment.
      uint32_t blockPixels[16] = {};

      switch (format)
      {
        case rive::GPUTextureFormat::bc7:
          bc7decomp::unpack_bc7(
              src,
              reinterpret_cast<bc7decomp::color_rgba*>(blockPixels));
          src += 16;
          break;

        case rive::GPUTextureFormat::bc1:
          rgbcx::unpack_bc1(
              src,
              reinterpret_cast<rgbcx::color32*>(blockPixels),
              true);
          src += 8;
          break;

        case rive::GPUTextureFormat::bc3:
          rgbcx::unpack_bc3(
              src,
              reinterpret_cast<rgbcx::color32*>(blockPixels));
          src += 16;
          break;

        default:
          fprintf(
              stderr,
              "DecodeBcTexture - unsupported BC format %u\n",
              static_cast<unsigned>(format));
          return nullptr;
      }

      // Copy decoded pixels into the output image. The last block
      // row/column may extend past the image edge — clamp via a
      // precomputed pixel count so each loop has a single exit.
      uint32_t* dst32 = reinterpret_cast<uint32_t*>(pixels.get());
      const uint32_t copyW = std::min<uint32_t>(4u, width - bx * 4);
      const uint32_t copyH = std::min<uint32_t>(4u, height - by * 4);
      for (uint32_t py = 0; py < copyH; py++)
      {
        const uint32_t dstY = by * 4 + py;
        for (uint32_t px = 0; px < copyW; px++)
        {
          const uint32_t dstX = bx * 4 + px;
          dst32[dstY * width + dstX] = blockPixels[py * 4 + px];
        }
      }
    }
  }

  const size_t numBytes = static_cast<size_t>(width) * height * 4;
  return std::make_unique<Bitmap>(
      width,
      height,
      numBytes,
      Bitmap::PixelFormat::RGBA,
      std::move(pixels));
}