#include "TextureLoader.h"
#include "Asset/TextureAsset.h"
#include "Graphics/Graphics.h"
#include "Asset/AssetRegistry.h"
#include "Graphics/Vulkan/Enums.h"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wunused-variable"
#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>
#pragma GCC diagnostic pop
#include "ktx.h"

using namespace Seele;

TextureLoader::TextureLoader(Gfx::PGraphics graphics)
    : graphics(graphics)
{
    OTextureAsset placeholder = new TextureAsset();
    placeholderAsset = placeholder;
    import(TextureImportArgs{
        .filePath = std::filesystem::absolute("textures/placeholder.png"),
        .importPath = "",
        }, placeholderAsset);
    AssetRegistry::get().assetRoot->textures[""] = std::move(placeholder);
}

TextureLoader::~TextureLoader()
{
}

void TextureLoader::importAsset(TextureImportArgs args)
{
    std::filesystem::path assetPath = args.filePath.filename();
    assetPath.replace_extension("asset");
    
    OTextureAsset asset = new TextureAsset(args.importPath, assetPath.stem().string());
    PTextureAsset ref = asset;
    asset->setStatus(Asset::Status::Loading);
    AssetRegistry::get().registerTexture(std::move(asset));
    import(args, ref);
}

PTextureAsset TextureLoader::getPlaceholderTexture() 
{
    return placeholderAsset;
}

void TextureLoader::import(TextureImportArgs args, PTextureAsset textureAsset)
{
    int totalWidth = 0, totalHeight = 0, n = 0;
    unsigned char* data = stbi_load(args.filePath.string().c_str(), &totalWidth, &totalHeight, &n, 4);
    ktxTexture2* kTexture = nullptr;
    ktxTextureCreateInfo createInfo;
    createInfo.vkFormat = VK_FORMAT_R8G8B8A8_UNORM;
    createInfo.baseDepth = 1;
    createInfo.numLevels = 1;
    createInfo.numLayers = 1;
    createInfo.isArray = false;
    createInfo.generateMipmaps = false;

    if (args.type == TextureImportType::TEXTURE_CUBEMAP)
    {
        uint32 faceWidth = totalWidth / 4;
        // uint32 faceHeight = totalHeight / 3;
        // Cube map
        createInfo.baseWidth = totalWidth / 4;
        createInfo.baseHeight = totalHeight / 3;
        createInfo.numFaces = 6;
        createInfo.numDimensions = 2;

        ktxTexture2_Create(&createInfo,
            KTX_TEXTURE_CREATE_ALLOC_STORAGE,
            &kTexture);

        auto loadCubeFace = [&kTexture, &faceWidth, &totalWidth, &data](int xPos, int yPos, int faceName)
        {
            std::vector<unsigned char> vec(faceWidth * faceWidth * 4);
            for (uint32 y = 0; y < faceWidth; ++y)
            {
                for (uint32 x = 0; x < faceWidth; ++x)
                {
                    int imgX = x + (xPos * faceWidth);
                    int imgY = y + (yPos * faceWidth);
                    std::memcpy(&vec[(x + (faceWidth * y)) * 4], &data[(imgX + (totalWidth * imgY)) * 4], 4);
                }
            }
            ktxTexture_SetImageFromMemory(ktxTexture(kTexture),
                0, 0, faceName, vec.data(), vec.size());
        };
        loadCubeFace(2, 1, 0); // +X
        loadCubeFace(0, 1, 1); // -X
        loadCubeFace(1, 0, 2); // +Y
        loadCubeFace(1, 2, 3); // -Y
        loadCubeFace(1, 1, 4); // +Z
        loadCubeFace(3, 1, 5); // -Z
    }
    else
    {
        createInfo.baseWidth = totalWidth;
        createInfo.baseHeight = totalHeight;
        createInfo.numFaces = 1;
        createInfo.numDimensions = 1 + (totalHeight > 1);

        ktxTexture2_Create(&createInfo,
            KTX_TEXTURE_CREATE_ALLOC_STORAGE,
            &kTexture);

        ktxTexture_SetImageFromMemory(ktxTexture(kTexture),
            0, 0, 0, data, totalWidth * totalHeight * 4 * sizeof(unsigned char));
    }
    std::cout << "starting compression of " << textureAsset->getAssetIdentifier() << std::endl;

    ktxBasisParams params2 = {
        .structSize = sizeof(ktxBasisParams),
        .uastc = false,
        .threadCount = std::thread::hardware_concurrency(),
        .compressionLevel = 0,
        .qualityLevel = 0,
    };

    ktx_error_code_e error = ktxTexture2_CompressBasisEx(kTexture, &params2);
    assert(error == KTX_SUCCESS);

    ktx_uint8_t* dest;
    ktx_size_t size;
    ktxTexture_WriteToMemory(ktxTexture(kTexture), &dest, &size);

    Array<uint8> memory(size);
    std::memcpy(memory.data(), dest, size);
    free(dest);
    
    Array<uint8> rawPixels(totalWidth * totalHeight * 4);
    std::memcpy(rawPixels.data(), data, rawPixels.size());

    stbi_image_free(data);

    ArchiveBuffer temp(graphics);
    Serialization::save(temp, rawPixels);
    Serialization::save(temp, memory);
    temp.rewind();
    textureAsset->load(temp);
    if (textureAsset->getName().empty())
    {
        return;
    }
    auto stream = AssetRegistry::createWriteStream((std::filesystem::path(textureAsset->folderPath) / textureAsset->getName()).replace_extension("asset").string(), std::ios::binary);

    ArchiveBuffer archive;
    Serialization::save(archive, TextureAsset::IDENTIFIER);
    Serialization::save(archive, textureAsset->getName());
    Serialization::save(archive, textureAsset->getFolderPath());
    Serialization::save(archive, rawPixels);
    Serialization::save(archive, memory);
    archive.writeToStream(stream);


    ////co_return;
}