#include "ostc45_icon.h"


//OSTC45_Icon::OSTC45_Icon() {}


#pragma pack(push, 1)
struct BMPFileHeader
{
    uint16_t bfType;
    uint32_t bfSize;
    uint16_t bfReserved1;
    uint16_t bfReserved2;
    uint32_t bfOffBits;
};

struct BMPInfoHeader
{
    uint32_t biSize;
    int32_t  biWidth;
    int32_t  biHeight;
    uint16_t biPlanes;
    uint16_t biBitCount;
    uint32_t biCompression;
    uint32_t biSizeImage;
    int32_t  biXPelsPerMeter;
    int32_t  biYPelsPerMeter;
    uint32_t biClrUsed;
    uint32_t biClrImportant;
};
#pragma pack(pop)

BmpToArray::BmpToArray(const QString& filename)
{
    loadBMP(filename);
}

void BmpToArray::loadBMP(const QString& filename)
{
    QFile file(filename);
    int dstY;
    QByteArray rowBuffer;
    bool topDown = false;
    BMPFileHeader fileHeader;
    BMPInfoHeader infoHeader;

    if (!file.open(QIODevice::ReadOnly))
        throw std::runtime_error("Cannot open BMP file");

    if (file.read(reinterpret_cast<char*>(&fileHeader),
                  sizeof(BMPFileHeader)) != sizeof(BMPFileHeader))
        throw std::runtime_error("Failed to read BMP file header");

    if (file.read(reinterpret_cast<char*>(&infoHeader),
                  sizeof(BMPInfoHeader)) != sizeof(BMPInfoHeader))
        throw std::runtime_error("Failed to read BMP info header");

    if (fileHeader.bfType != 0x4D42)
        throw std::runtime_error("Not a valid BMP file");

    if (infoHeader.biBitCount != 8)
        throw std::runtime_error("Only 8-bit BMP supported");
    if (infoHeader.biCompression != 0)
        throw std::runtime_error("Compressed BMP not supported");

    if(infoHeader.biWidth > 800)
        throw std::runtime_error("Only BMP with 800 or less horizontal pixels supported");

    if(infoHeader.biHeight > 480)
        throw std::runtime_error("Only BMP with 480 or less vertical pixels supported");

    // Width / Height
    width = infoHeader.biWidth;
    height = infoHeader.biHeight;

    if ((int32_t)height < 0) {
        height = -((int32_t)height);
        topDown = true;
    }

    // Palette
    uint32_t colorCount = infoHeader.biClrUsed;
    if (colorCount == 0) colorCount = 256;
    if (colorCount > 256) colorCount = 256;

    clut.resize(colorCount);

    for (uint32_t i = 0; i < colorCount; ++i)
        file.read(reinterpret_cast<char*>(&clut[i]), 4);

    // CLUT in 32-Bit transform 0x00RRGGBB
    clut32.resize(255, 0);

    for (uint32_t i = 0; i < colorCount && i < 255; ++i)
    {
        clut32[i] =
            (clut[i].r << 16) |
            (clut[i].g << 8) |
            (clut[i].b);
    }

    // Pixel-Data
    if (!file.seek(fileHeader.bfOffBits))
        throw std::runtime_error("Failed to seek to pixel data");

    pixelData.resize(width * height);

    size_t rowSize = (width + 3) & ~3; // 4-Byte alignment

    rowBuffer.resize(rowSize);

    for (int y = 0; y < height; ++y)
    {
        if (file.read(rowBuffer.data(), rowSize) != rowSize)
            throw std::runtime_error("Failed to read BMP pixel row");

        if (topDown)
        {
            dstY = height - 1 - y;
        }
        else
        {
            dstY = y;
        }

        for (int x = 0; x < width; ++x)
        {
            pixelData[x * height + dstY] =
                static_cast<uint8_t>(rowBuffer[x]);
        }
    }


}
QByteArray BmpToArray::getTransferBytes() const
{
    QByteArray out;

    out.reserve(clut32.size() * 4 + pixelData.size());

    // CLUT (32 Bit, Little Endian)
    for (uint32_t color : clut32)
    {
        out.append(static_cast<char>( color        & 0xFF));
        out.append(static_cast<char>((color >> 8)  & 0xFF));
        out.append(static_cast<char>((color >> 16) & 0xFF));
        out.append(static_cast<char>((color >> 24) & 0xFF));
    }

    // Pixel (8 Bit)
    out.append(reinterpret_cast<const char*>(pixelData.data()),
               pixelData.size());

    return out;
}

void BmpToArray::getImageXY(uint32_t* x, uint32_t* y)
{
    *x = width;
    *y = height;
}