/*
   Copyright (C) 2015, SiPlus, Chasseur de bots.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "ktx.h"

#include <string.h>

#include "bytestreamutils.h"
#include "etclib.h"
#include "ifilesystem.h"
#include "imagelib.h"


const int KTX_TYPE_UNSIGNED_BYTE = 0x1401;
const int KTX_TYPE_UNSIGNED_SHORT_4_4_4_4 = 0x8033;
const int KTX_TYPE_UNSIGNED_SHORT_5_5_5_1 = 0x8034;
const int KTX_TYPE_UNSIGNED_SHORT_5_6_5 = 0x8363;

const int KTX_FORMAT_ALPHA = 0x1906;
const int KTX_FORMAT_RGB = 0x1907;
const int KTX_FORMAT_RGBA = 0x1908;
const int KTX_FORMAT_LUMINANCE = 0x1909;
const int KTX_FORMAT_LUMINANCE_ALPHA = 0x190A;
const int KTX_FORMAT_BGR = 0x80E0;
const int KTX_FORMAT_BGRA = 0x80E1;

const int KTX_FORMAT_ETC1_RGB8 = 0x8D64;

class KTX_Decoder {
public:
    virtual ~KTX_Decoder() = default;

    virtual void Decode(PointerInputStream &istream, byte *out) = 0;

    virtual unsigned int GetPixelSize() = 0;
};

class KTX_Decoder_A8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        out[0] = out[1] = out[2] = 0;
        out[3] = istream_read_byte(istream);
    }

    virtual unsigned int GetPixelSize()
    {
        return 1;
    }
};

class KTX_Decoder_RGB8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        istream.read(out, 3);
        out[3] = 255;
    }

    virtual unsigned int GetPixelSize()
    {
        return 3;
    }
};

class KTX_Decoder_RGBA8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        istream.read(out, 4);
    }

    virtual unsigned int GetPixelSize()
    {
        return 4;
    }
};

class KTX_Decoder_L8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        byte l = istream_read_byte(istream);
        out[0] = out[1] = out[2] = l;
        out[3] = 255;
    }

    virtual unsigned int GetPixelSize()
    {
        return 1;
    }
};

class KTX_Decoder_LA8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        byte la[2];
        istream.read(la, 2);
        out[0] = out[1] = out[2] = la[0];
        out[3] = la[1];
    }

    virtual unsigned int GetPixelSize()
    {
        return 2;
    }
};

class KTX_Decoder_BGR8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        byte bgr[3];
        istream.read(bgr, 3);
        out[0] = bgr[2];
        out[1] = bgr[1];
        out[2] = bgr[0];
        out[3] = 255;
    }

    virtual unsigned int GetPixelSize()
    {
        return 3;
    }
};

class KTX_Decoder_BGRA8 : public KTX_Decoder {
public:
    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        byte bgra[4];
        istream.read(bgra, 4);
        out[0] = bgra[2];
        out[1] = bgra[1];
        out[2] = bgra[0];
        out[3] = bgra[3];
    }

    virtual unsigned int GetPixelSize()
    {
        return 4;
    }
};

class KTX_Decoder_RGBA4 : public KTX_Decoder {
protected:
    bool m_bigEndian;
public:
    KTX_Decoder_RGBA4(bool bigEndian) : m_bigEndian(bigEndian)
    {}

    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        uint16_t rgba;
        if (m_bigEndian) {
            rgba = istream_read_uint16_be(istream);
        } else {
            rgba = istream_read_uint16_le(istream);
        }
        int r = (rgba >> 12) & 0xf;
        int g = (rgba >> 8) & 0xf;
        int b = (rgba >> 4) & 0xf;
        int a = rgba & 0xf;
        out[0] = (r << 4) | r;
        out[1] = (g << 4) | g;
        out[2] = (b << 4) | b;
        out[3] = (a << 4) | a;
    }

    virtual unsigned int GetPixelSize()
    {
        return 2;
    }
};

class KTX_Decoder_RGBA5 : public KTX_Decoder {
protected:
    bool m_bigEndian;
public:
    KTX_Decoder_RGBA5(bool bigEndian) : m_bigEndian(bigEndian)
    {}

    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        uint16_t rgba;
        if (m_bigEndian) {
            rgba = istream_read_uint16_be(istream);
        } else {
            rgba = istream_read_uint16_le(istream);
        }
        int r = (rgba >> 11) & 0x1f;
        int g = (rgba >> 6) & 0x1f;
        int b = (rgba >> 1) & 0x1f;
        out[0] = (r << 3) | (r >> 2);
        out[1] = (g << 3) | (g >> 2);
        out[2] = (b << 3) | (b >> 2);
        out[3] = (rgba & 1) * 255;
    }

    virtual unsigned int GetPixelSize()
    {
        return 2;
    }
};

class KTX_Decoder_RGB5 : public KTX_Decoder {
protected:
    bool m_bigEndian;
public:
    KTX_Decoder_RGB5(bool bigEndian) : m_bigEndian(bigEndian)
    {}

    virtual void Decode(PointerInputStream &istream, byte *out)
    {
        uint16_t rgb;
        if (m_bigEndian) {
            rgb = istream_read_uint16_be(istream);
        } else {
            rgb = istream_read_uint16_le(istream);
        }
        int r = (rgb >> 11) & 0x1f;
        int g = (rgb >> 5) & 0x3f;
        int b = rgb & 0x1f;
        out[0] = (r << 3) | (r >> 2);
        out[1] = (g << 2) | (g >> 4);
        out[2] = (b << 3) | (b >> 2);
        out[3] = 255;
    }

    virtual unsigned int GetPixelSize()
    {
        return 2;
    }
};

static void KTX_DecodeETC1(PointerInputStream &istream, Image &image)
{
    unsigned int width = image.getWidth(), height = image.getHeight();
    unsigned int stride = width * 4;
    byte *pixbuf = image.getRGBAPixels();
    byte etc[8], rgba[64];

    for (unsigned int y = 0; y < height; y += 4, pixbuf += stride * 4) {
        unsigned int blockrows = height - y;
        if (blockrows > 4) {
            blockrows = 4;
        }

        byte *p = pixbuf;
        for (unsigned int x = 0; x < width; x += 4, p += 16) {
            istream.read(etc, 8);
            ETC_DecodeETC1Block(etc, rgba, qtrue);

            unsigned int blockrowsize = width - x;
            if (blockrowsize > 4) {
                blockrowsize = 4;
            }
            blockrowsize *= 4;
            for (unsigned int blockrow = 0; blockrow < blockrows; blockrow++) {
                memcpy(p + blockrow * stride, rgba + blockrow * 16, blockrowsize);
            }
        }
    }
}

Image *LoadKTXBuff(PointerInputStream &istream)
{
    byte identifier[12];
    istream.read(identifier, 12);
    if (memcmp(identifier, "\xABKTX 11\xBB\r\n\x1A\n", 12)) {
        globalErrorStream() << "LoadKTX: Image has the wrong identifier\n";
        return 0;
    }

    bool bigEndian = (istream_read_uint32_le(istream) == 0x01020304);

    unsigned int type;
    if (bigEndian) {
        type = istream_read_uint32_be(istream);
    } else {
        type = istream_read_uint32_le(istream);
    }

    // For compressed textures, the format is in glInternalFormat.
    // For uncompressed textures, it's in glBaseInternalFormat.
    istream.seek((type ? 3 : 2) * sizeof(uint32_t));
    unsigned int format;
    if (bigEndian) {
        format = istream_read_uint32_be(istream);
    } else {
        format = istream_read_uint32_le(istream);
    }
    if (!type) {
        istream.seek(sizeof(uint32_t));
    }

    unsigned int width, height;
    if (bigEndian) {
        width = istream_read_uint32_be(istream);
        height = istream_read_uint32_be(istream);
    } else {
        width = istream_read_uint32_le(istream);
        height = istream_read_uint32_le(istream);
    }
    if (!width) {
        globalErrorStream() << "LoadKTX: Image has zero width\n";
        return 0;
    }
    if (!height) {
        height = 1;
    }

    // Skip the key/values and load the first 2D image in the texture.
    // Since KTXorientation is only a hint and has no effect on the texture data and coordinates, it must be ignored.
    istream.seek(4 * sizeof(uint32_t));
    unsigned int bytesOfKeyValueData;
    if (bigEndian) {
        bytesOfKeyValueData = istream_read_uint32_be(istream);
    } else {
        bytesOfKeyValueData = istream_read_uint32_le(istream);
    }
    istream.seek(bytesOfKeyValueData + sizeof(uint32_t));

    RGBAImage *image = new RGBAImage(width, height);

    if (type) {
        KTX_Decoder *decoder = NULL;
        switch (type) {
            case KTX_TYPE_UNSIGNED_BYTE:
                switch (format) {
                    case KTX_FORMAT_ALPHA:
                        decoder = new KTX_Decoder_A8();
                        break;
                    case KTX_FORMAT_RGB:
                        decoder = new KTX_Decoder_RGB8();
                        break;
                    case KTX_FORMAT_RGBA:
                        decoder = new KTX_Decoder_RGBA8();
                        break;
                    case KTX_FORMAT_LUMINANCE:
                        decoder = new KTX_Decoder_L8();
                        break;
                    case KTX_FORMAT_LUMINANCE_ALPHA:
                        decoder = new KTX_Decoder_LA8();
                        break;
                    case KTX_FORMAT_BGR:
                        decoder = new KTX_Decoder_BGR8();
                        break;
                    case KTX_FORMAT_BGRA:
                        decoder = new KTX_Decoder_BGRA8();
                        break;
                }
                break;
            case KTX_TYPE_UNSIGNED_SHORT_4_4_4_4:
                if (format == KTX_FORMAT_RGBA) {
                    decoder = new KTX_Decoder_RGBA4(bigEndian);
                }
                break;
            case KTX_TYPE_UNSIGNED_SHORT_5_5_5_1:
                if (format == KTX_FORMAT_RGBA) {
                    decoder = new KTX_Decoder_RGBA5(bigEndian);
                }
                break;
            case KTX_TYPE_UNSIGNED_SHORT_5_6_5:
                if (format == KTX_FORMAT_RGB) {
                    decoder = new KTX_Decoder_RGB5(bigEndian);
                }
                break;
        }

        if (!decoder) {
            globalErrorStream() << "LoadKTX: Image has an unsupported pixel type " << type << " or format " << format
                                << "\n";
            image->release();
            return 0;
        }

        unsigned int inRowLength = width * decoder->GetPixelSize();
        unsigned int inPadding = ((inRowLength + 3) & ~3) - inRowLength;
        byte *out = image->getRGBAPixels();
        for (unsigned int y = 0; y < height; y++) {
            for (unsigned int x = 0; x < width; x++, out += 4) {
                decoder->Decode(istream, out);
            }

            if (inPadding) {
                istream.seek(inPadding);
            }
        }

        delete decoder;
    } else {
        switch (format) {
            case KTX_FORMAT_ETC1_RGB8:
                KTX_DecodeETC1(istream, *image);
                break;
            default:
                globalErrorStream() << "LoadKTX: Image has an unsupported compressed format " << format << "\n";
                image->release();
                return 0;
        }
    }

    return image;
}

Image *LoadKTX(ArchiveFile &file)
{
    ScopedArchiveBuffer buffer(file);
    PointerInputStream istream(buffer.buffer);
    return LoadKTXBuff(istream);
}