#include "msdf_font_builder.h"

#include <msdfgen/msdfgen.h>

#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_OUTLINE_H

#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>

#include <fstream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <map>

namespace extra2d {
namespace tools {

using namespace msdfgen;

/**
 * @brief Freetype 轮廓转换上下文
 */
struct OutlineContext {
    Shape* shape;
    Contour* currentContour;
    Point2 lastPoint;
    bool hasLastPoint;
    std::map<char32_t, double> advanceMap;
};

/**
 * @brief MSDF 字体构建器实现
 */
struct MSDFFontBuilder::Impl {
    FT_Library ftLibrary = nullptr;
    FT_Face ftFace = nullptr;
    OutlineContext outlineCtx;
    
    struct GlyphBitmap {
        char32_t codepoint;
        Bitmap<float, 3> bitmap;
        double advance;
        double l, b, r, t;
        double pl, pb, pr, pt;
    };
    
    std::vector<GlyphBitmap> glyphBitmaps;
};

/**
 * @brief Freetype 移动到点回调函数
 */
static int ftMoveTo(const FT_Vector* to, void* user) {
    OutlineContext* ctx = static_cast<OutlineContext*>(user);
    ctx->currentContour = &ctx->shape->addContour();
    ctx->lastPoint = Point2(to->x / 64.0, to->y / 64.0);
    ctx->hasLastPoint = true;
    return 0;
}

/**
 * @brief Freetype 画线回调函数
 */
static int ftLineTo(const FT_Vector* to, void* user) {
    OutlineContext* ctx = static_cast<OutlineContext*>(user);
    if (ctx->currentContour && ctx->hasLastPoint) {
        Point2 endPoint(to->x / 64.0, to->y / 64.0);
        ctx->currentContour->addEdge(EdgeHolder(ctx->lastPoint, endPoint));
        ctx->lastPoint = endPoint;
    }
    return 0;
}

/**
 * @brief Freetype 二次贝塞尔曲线回调函数
 */
static int ftConicTo(const FT_Vector* control, const FT_Vector* to, void* user) {
    OutlineContext* ctx = static_cast<OutlineContext*>(user);
    if (ctx->currentContour && ctx->hasLastPoint) {
        Point2 controlPoint(control->x / 64.0, control->y / 64.0);
        Point2 endPoint(to->x / 64.0, to->y / 64.0);
        ctx->currentContour->addEdge(EdgeHolder(ctx->lastPoint, controlPoint, endPoint));
        ctx->lastPoint = endPoint;
    }
    return 0;
}

/**
 * @brief Freetype 三次贝塞尔曲线回调函数
 */
static int ftCubicTo(const FT_Vector* control1, const FT_Vector* control2, const FT_Vector* to, void* user) {
    OutlineContext* ctx = static_cast<OutlineContext*>(user);
    if (ctx->currentContour && ctx->hasLastPoint) {
        Point2 cp1(control1->x / 64.0, control1->y / 64.0);
        Point2 cp2(control2->x / 64.0, control2->y / 64.0);
        Point2 endPoint(to->x / 64.0, to->y / 64.0);
        ctx->currentContour->addEdge(EdgeHolder(ctx->lastPoint, cp1, cp2, endPoint));
        ctx->lastPoint = endPoint;
    }
    return 0;
}

MSDFFontBuilder::MSDFFontBuilder() : impl_(new Impl()) {
}

MSDFFontBuilder::~MSDFFontBuilder() {
    if (impl_) {
        if (impl_->ftFace) {
            FT_Done_Face(impl_->ftFace);
        }
        if (impl_->ftLibrary) {
            FT_Done_FreeType(impl_->ftLibrary);
        }
        delete impl_;
    }
}

void MSDFFontBuilder::setInputFont(const std::string& path) {
    inputFont_ = path;
}

void MSDFFontBuilder::setOutputPath(const std::string& path) {
    outputPath_ = path;
}

void MSDFFontBuilder::setCharset(const std::string& charset) {
    charset_ = charset;
}

void MSDFFontBuilder::setCharsetFile(const std::string& path) {
    charsetFile_ = path;
}

void MSDFFontBuilder::setFontSize(int size) {
    fontSize_ = size;
}

void MSDFFontBuilder::setPxRange(float range) {
    pxRange_ = range;
}

void MSDFFontBuilder::setAtlasSize(int width, int height) {
    atlasWidth_ = width;
    atlasHeight_ = height;
}

bool MSDFFontBuilder::build() {
    if (inputFont_.empty()) {
        error_ = "Input font path not set";
        return false;
    }

    if (outputPath_.empty()) {
        error_ = "Output path not set";
        return false;
    }

    if (!loadCharset()) {
        return false;
    }

    FT_Error error = FT_Init_FreeType(&impl_->ftLibrary);
    if (error) {
        error_ = "Failed to initialize FreeType";
        return false;
    }

    error = FT_New_Face(impl_->ftLibrary, inputFont_.c_str(), 0, &impl_->ftFace);
    if (error) {
        error_ = "Failed to load font: " + inputFont_;
        return false;
    }

    error = FT_Set_Char_Size(impl_->ftFace, fontSize_ * 64, fontSize_ * 64, 72, 72);
    if (error) {
        error_ = "Failed to set font size";
        return false;
    }

    if (!generateAllGlyphs()) {
        return false;
    }

    if (!packGlyphs()) {
        return false;
    }

    if (!savePngWithMetadata()) {
        return false;
    }

    return true;
}

bool MSDFFontBuilder::loadCharset() {
    if (!charsetFile_.empty()) {
        std::ifstream file(charsetFile_);
        if (!file) {
            error_ = "Failed to open charset file: " + charsetFile_;
            return false;
        }
        std::stringstream buffer;
        buffer << file.rdbuf();
        charset_ = buffer.str();
    }

    if (charset_.empty()) {
        charset_ = " !\"#$%&'()*+,-./0123456789:;<=>?@"
                   "ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`"
                   "abcdefghijklmnopqrstuvwxyz{|}~";
    }

    return true;
}

/**
 * @brief 从 Freetype 字形加载 msdfgen Shape
 */
static bool loadGlyphShape(FT_Face face, char32_t codepoint, Shape& shape, double& advance) {
    FT_UInt glyphIndex = FT_Get_Char_Index(face, codepoint);
    if (glyphIndex == 0) {
        return false;
    }

    FT_Error error = FT_Load_Glyph(face, glyphIndex, FT_LOAD_NO_SCALE);
    if (error) {
        return false;
    }

    advance = face->glyph->metrics.horiAdvance / 64.0;

    FT_Outline* outline = &face->glyph->outline;
    if (outline->n_contours == 0) {
        return false;
    }

    OutlineContext ctx;
    ctx.shape = &shape;
    ctx.currentContour = nullptr;
    ctx.hasLastPoint = false;

    FT_Outline_Funcs funcs;
    funcs.move_to = ftMoveTo;
    funcs.line_to = ftLineTo;
    funcs.conic_to = ftConicTo;
    funcs.cubic_to = ftCubicTo;
    funcs.shift = 0;
    funcs.delta = 0;

    error = FT_Outline_Decompose(outline, &funcs, &ctx);
    if (error) {
        return false;
    }

    return true;
}

bool MSDFFontBuilder::generateAllGlyphs() {
    impl_->glyphBitmaps.clear();

    double unitsPerEM = impl_->ftFace->units_per_EM;
    if (unitsPerEM == 0) {
        unitsPerEM = 1000.0;
    }
    double scale = fontSize_ / unitsPerEM;

    for (char c : charset_) {
        char32_t codepoint = static_cast<char32_t>(static_cast<unsigned char>(c));

        Shape shape;
        double glyphAdvance = 0.0;
        if (!loadGlyphShape(impl_->ftFace, codepoint, shape, glyphAdvance)) {
            continue;
        }

        shape.normalize();

        edgeColoringSimple(shape, 3.0);

        Shape::Bounds bounds = shape.getBounds();
        double l = bounds.l;
        double b = bounds.b;
        double r = bounds.r;
        double t = bounds.t;

        if (l >= r || b >= t) {
            continue;
        }

        double pl = l * scale;
        double pb = b * scale;
        double pr = r * scale;
        double pt = t * scale;

        double range = pxRange_ / scale;
        l -= range;
        b -= range;
        r += range;
        t += range;

        double width = (r - l) * scale;
        double height = (t - b) * scale;

        int w = static_cast<int>(std::ceil(width));
        int h = static_cast<int>(std::ceil(height));

        w = std::max(w, 1);
        h = std::max(h, 1);

        Impl::GlyphBitmap gb;
        gb.codepoint = codepoint;
        gb.advance = glyphAdvance * scale;
        gb.l = l;
        gb.b = b;
        gb.r = r;
        gb.t = t;
        gb.pl = pl;
        gb.pb = pb;
        gb.pr = pr;
        gb.pt = pt;

        gb.bitmap = Bitmap<float, 3>(w, h);

        MSDFGeneratorConfig config;
        config.overlapSupport = true;

        Projection projection(Vector2(scale, scale), Vector2(-l * scale, -b * scale));
        Range distanceRange(range * scale);
        generateMSDF(gb.bitmap, shape, projection, distanceRange, config);

        impl_->glyphBitmaps.push_back(std::move(gb));
    }

    return !impl_->glyphBitmaps.empty();
}

bool MSDFFontBuilder::packGlyphs() {
    std::vector<int> positions(impl_->glyphBitmaps.size() * 2, 0);

    std::vector<std::pair<int, int>> sizes;
    for (const auto& gb : impl_->glyphBitmaps) {
        sizes.emplace_back(gb.bitmap.width(), gb.bitmap.height());
    }

    std::vector<int> indices(sizes.size());
    for (size_t i = 0; i < indices.size(); ++i) {
        indices[i] = static_cast<int>(i);
    }

    std::sort(indices.begin(), indices.end(), [&](int a, int b) {
        return sizes[a].second > sizes[b].second;
    });

    int x = 0, y = 0;
    int rowHeight = 0;

    for (int idx : indices) {
        int w = sizes[idx].first;
        int h = sizes[idx].second;

        if (x + w > atlasWidth_) {
            x = 0;
            y += rowHeight;
            rowHeight = 0;
        }

        if (y + h > atlasHeight_) {
            error_ = "Atlas size too small for all glyphs";
            return false;
        }

        positions[idx * 2] = x;
        positions[idx * 2 + 1] = y;

        x += w;
        rowHeight = std::max(rowHeight, h);
    }

    Bitmap<float, 3> atlas(atlasWidth_, atlasHeight_);

    for (int py = 0; py < atlasHeight_; ++py) {
        for (int px = 0; px < atlasWidth_; ++px) {
            float* pixel = atlas(px, py);
            pixel[0] = 0.0f;
            pixel[1] = 0.0f;
            pixel[2] = 0.0f;
        }
    }

    for (size_t i = 0; i < impl_->glyphBitmaps.size(); ++i) {
        const auto& gb = impl_->glyphBitmaps[i];
        int px = positions[i * 2];
        int py = positions[i * 2 + 1];

        for (int gy = 0; gy < gb.bitmap.height(); ++gy) {
            for (int gx = 0; gx < gb.bitmap.width(); ++gx) {
                int targetY = atlasHeight_ - 1 - (py + gy);
                float* pixel = atlas(px + gx, targetY);
                const float* srcPixel = gb.bitmap(gx, gy);
                pixel[0] = srcPixel[0];
                pixel[1] = srcPixel[1];
                pixel[2] = srcPixel[2];
            }
        }

        GlyphData glyph;
        glyph.codepoint = gb.codepoint;
        glyph.advance = static_cast<float>(gb.advance);

        glyph.left = static_cast<double>(px);
        glyph.top = static_cast<double>(atlasHeight_ - py - gb.bitmap.height());
        glyph.right = static_cast<double>(px + gb.bitmap.width());
        glyph.bottom = static_cast<double>(atlasHeight_ - py);

        glyph.uvMin.x = static_cast<float>(glyph.left / atlasWidth_);
        glyph.uvMin.y = static_cast<float>(glyph.top / atlasHeight_);
        glyph.uvMax.x = static_cast<float>(glyph.right / atlasWidth_);
        glyph.uvMax.y = static_cast<float>(glyph.bottom / atlasHeight_);

        glyph.size.x = static_cast<float>(gb.pr - gb.pl);
        glyph.size.y = static_cast<float>(gb.pt - gb.pb);
        glyph.bearing.x = static_cast<float>(gb.pl);
        glyph.bearing.y = static_cast<float>(gb.pt);

        metadata_.glyphs.push_back(glyph);
    }

    metadata_.fontSize = fontSize_;
    metadata_.pxRange = pxRange_;
    metadata_.atlasWidth = atlasWidth_;
    metadata_.atlasHeight = atlasHeight_;
    metadata_.lineHeight = static_cast<int>(fontSize_ * 1.25);
    metadata_.baseline = static_cast<int>(fontSize_ * 0.25);

    impl_->glyphBitmaps.clear();
    impl_->glyphBitmaps.push_back({0, std::move(atlas), 0, 0, 0, 0, 0, 0, 0, 0, 0});

    return true;
}

bool MSDFFontBuilder::savePngWithMetadata() {
    if (impl_->glyphBitmaps.empty()) {
        error_ = "No atlas generated";
        return false;
    }

    const auto& atlas = impl_->glyphBitmaps[0].bitmap;

    std::vector<uint8_t> rgbaData(atlasWidth_ * atlasHeight_ * 4);
    for (int y = 0; y < atlasHeight_; ++y) {
        for (int x = 0; x < atlasWidth_; ++x) {
            const float* pixel = atlas(x, y);
            int idx = (y * atlasWidth_ + x) * 4;
            rgbaData[idx + 0] = static_cast<uint8_t>(std::clamp(pixel[0] * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f);
            rgbaData[idx + 1] = static_cast<uint8_t>(std::clamp(pixel[1] * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f);
            rgbaData[idx + 2] = static_cast<uint8_t>(std::clamp(pixel[2] * 0.5f + 0.5f, 0.0f, 1.0f) * 255.0f);
            rgbaData[idx + 3] = 255;
        }
    }

    std::string jsonStr = generateMetadataJson();
    std::vector<uint8_t> textChunk;

    std::string keyword = "msdf";
    textChunk.insert(textChunk.end(), keyword.begin(), keyword.end());
    textChunk.push_back(0);
    textChunk.insert(textChunk.end(), jsonStr.begin(), jsonStr.end());

    uint32_t length = static_cast<uint32_t>(textChunk.size());
    std::vector<uint8_t> lengthBytes(4);
    lengthBytes[0] = (length >> 24) & 0xFF;
    lengthBytes[1] = (length >> 16) & 0xFF;
    lengthBytes[2] = (length >> 8) & 0xFF;
    lengthBytes[3] = length & 0xFF;

    std::vector<uint8_t> crcData;
    crcData.insert(crcData.end(), {'t', 'E', 'X', 't'});
    crcData.insert(crcData.end(), textChunk.begin(), textChunk.end());

    uint32_t crc = 0xFFFFFFFF;
    for (uint8_t byte : crcData) {
        crc ^= byte;
        for (int i = 0; i < 8; ++i) {
            crc = (crc >> 1) ^ ((crc & 1) ? 0xEDB88320 : 0);
        }
    }
    crc ^= 0xFFFFFFFF;

    std::vector<uint8_t> crcBytes(4);
    crcBytes[0] = (crc >> 24) & 0xFF;
    crcBytes[1] = (crc >> 16) & 0xFF;
    crcBytes[2] = (crc >> 8) & 0xFF;
    crcBytes[3] = crc & 0xFF;

    std::string tempPng = outputPath_ + ".tmp.png";
    
    if (!stbi_write_png(tempPng.c_str(), atlasWidth_, atlasHeight_, 4, rgbaData.data(), atlasWidth_ * 4)) {
        error_ = "Failed to save PNG: " + tempPng;
        return false;
    }

    std::ifstream inputFile(tempPng, std::ios::binary);
    if (!inputFile) {
        error_ = "Failed to open temporary PNG file";
        return false;
    }

    std::vector<uint8_t> pngData((std::istreambuf_iterator<char>(inputFile)),
                                  std::istreambuf_iterator<char>());
    inputFile.close();

    std::vector<uint8_t> newPng;
    newPng.insert(newPng.end(), pngData.begin(), pngData.begin() + 8);

    size_t pos = 8;
    bool inserted = false;
    while (pos < pngData.size()) {
        if (pos + 8 > pngData.size()) break;

        std::string chunkType(pngData.begin() + pos + 4, pngData.begin() + pos + 8);

        if (!inserted && chunkType != "IHDR") {
            newPng.insert(newPng.end(), lengthBytes.begin(), lengthBytes.end());
            newPng.insert(newPng.end(), {'t', 'E', 'X', 't'});
            newPng.insert(newPng.end(), textChunk.begin(), textChunk.end());
            newPng.insert(newPng.end(), crcBytes.begin(), crcBytes.end());
            inserted = true;
        }

        uint32_t chunkLen = (static_cast<uint32_t>(pngData[pos]) << 24) |
                            (static_cast<uint32_t>(pngData[pos + 1]) << 16) |
                            (static_cast<uint32_t>(pngData[pos + 2]) << 8) |
                            static_cast<uint32_t>(pngData[pos + 3]);

        size_t chunkEnd = pos + 12 + chunkLen;
        newPng.insert(newPng.end(), pngData.begin() + pos, pngData.begin() + chunkEnd);
        pos = chunkEnd;
    }

    std::ofstream outputFile(outputPath_, std::ios::binary);
    if (!outputFile) {
        error_ = "Failed to write PNG file: " + outputPath_;
        return false;
    }
    outputFile.write(reinterpret_cast<const char*>(newPng.data()), newPng.size());

    std::remove(tempPng.c_str());

    return true;
}

std::string MSDFFontBuilder::generateMetadataJson() {
    nlohmann::json j;

    j["size"] = metadata_.fontSize;
    j["pxRange"] = metadata_.pxRange;
    j["lineHeight"] = metadata_.lineHeight;
    j["baseline"] = metadata_.baseline;

    j["atlas"]["width"] = metadata_.atlasWidth;
    j["atlas"]["height"] = metadata_.atlasHeight;

    for (const auto& glyph : metadata_.glyphs) {
        nlohmann::json glyphJson;
        glyphJson["unicode"] = static_cast<uint32_t>(glyph.codepoint);
        glyphJson["advance"] = glyph.advance;

        glyphJson["atlasBounds"]["left"] = glyph.left;
        glyphJson["atlasBounds"]["bottom"] = glyph.bottom;
        glyphJson["atlasBounds"]["right"] = glyph.right;
        glyphJson["atlasBounds"]["top"] = glyph.top;

        glyphJson["planeBounds"]["left"] = glyph.bearing.x;
        glyphJson["planeBounds"]["bottom"] = glyph.bearing.y - glyph.size.y;
        glyphJson["planeBounds"]["right"] = glyph.bearing.x + glyph.size.x;
        glyphJson["planeBounds"]["top"] = glyph.bearing.y;

        j["glyphs"].push_back(glyphJson);
    }

    return j.dump();
}

} // namespace tools
} // namespace extra2d