#include "parser/pdfium_internal.hpp"

namespace pdfengine::parser {

std::expected<void, EngineError> PdfiumDocument::applyOp_replaceText(const nlohmann::json& op, int pageIndex) {
#ifdef PDFENGINE_WITH_PDFIUM
                std::vector<int> objectIndices;
                std::string newText = "";
                std::string internalFontId = "";
                double fontSize = -1.0;
                bool disableJustify = false;

                if (op.contains("data") && op["data"].is_object()) {
                    auto data = op["data"];
                    if (data.contains("objectIndices") && data["objectIndices"].is_array()) {
                        for (auto& idx : data["objectIndices"]) {
                            objectIndices.push_back(idx.get<int>());
                        }
                    }
                    newText = data.value("text", "");
                    internalFontId = data.value("internalFontId", "");
                    if (data.contains("fontSize")) {
                        fontSize = data["fontSize"].get<double>();
                    }
                    disableJustify = data.value("disableJustify", false);
                } else {
                    if (op.contains("objectIndices") && op["objectIndices"].is_array()) {
                        for (auto& idx : op["objectIndices"]) {
                            objectIndices.push_back(idx.get<int>());
                        }
                    }
                    newText = op.value("text", "");
                    internalFontId = op.value("internalFontId", "");
                    if (op.contains("fontSize")) {
                        fontSize = op["fontSize"].get<double>();
                    }
                }

                if (objectIndices.empty()) {
                    spdlog::warn("replace_text has empty objectIndices, nothing to replace");
                    return {};
                }

                FPDF_PAGE page = FPDF_LoadPage(doc_, pageIndex);
                if (!page) {
                    spdlog::error("Failed to load page index {} for replace_text", pageIndex);
                    return std::unexpected(EngineError::Unknown);
                }

                std::sort(objectIndices.begin(), objectIndices.end(), std::greater<int>());
                
                int minIndex = objectIndices.back();
                
                FPDF_PAGEOBJECT origObj = FPDFPage_GetObject(page, minIndex);
                if (!origObj) {
                    spdlog::error("Failed to get original text object at index {}", minIndex);
                    FPDF_ClosePage(page);
                    return std::unexpected(EngineError::Unknown);
                }
                
                double a = 1.0, b = 0.0, c = 0.0, d = 1.0, e = 0.0, f = 0.0;
                FS_MATRIX matrix;
                if (FPDFPageObj_GetMatrix(origObj, &matrix)) {
                    a = matrix.a;
                    b = matrix.b;
                    c = matrix.c;
                    d = matrix.d;
                    e = matrix.e;
                    f = matrix.f;
                }
                
                unsigned int r = 0, g = 0, b_color = 0, a_color = 255;
                FPDFPageObj_GetFillColor(origObj, &r, &g, &b_color, &a_color);

                if (fontSize < 0.0) {
                    float sizeVal = 12.0f;
                    if (FPDFTextObj_GetFontSize(origObj, &sizeVal)) {
                        fontSize = sizeVal;
                    } else {
                        fontSize = 12.0;
                    }
                }

                FPDF_TEXT_RENDERMODE renderMode = static_cast<FPDF_TEXT_RENDERMODE>(FPDFTextObj_GetTextRenderMode(origObj));

                std::string fontName = "Helvetica";
                std::string origFontName = "";
                bool bold = false;
                bool italic = false;
                FPDF_FONT origFont = FPDFTextObj_GetFont(origObj);
                if (origFont) {
                    size_t nameLen = FPDFFont_GetBaseFontName(origFont, nullptr, 0);
                    if (nameLen > 0) {
                        std::vector<char> nameBuf(nameLen);
                        if (FPDFFont_GetBaseFontName(origFont, nameBuf.data(), nameLen) > 0) {
                            origFontName = nameBuf.data();
                            std::string baseName(nameBuf.data());
                            std::string lowerName = baseName;
                            std::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](unsigned char c) {
                                return static_cast<char>(std::tolower(c));
                            });
                            
                            bold = (lowerName.find("bold") != std::string::npos);
                            italic = (lowerName.find("italic") != std::string::npos || lowerName.find("oblique") != std::string::npos);
                            
                            if (lowerName.find("times") != std::string::npos) {
                                if (bold && italic) fontName = "Times-BoldItalic";
                                else if (bold) fontName = "Times-Bold";
                                else if (italic) fontName = "Times-Italic";
                                else fontName = "Times-Roman";
                            } else if (lowerName.find("courier") != std::string::npos) {
                                if (bold && italic) fontName = "Courier-BoldOblique";
                                else if (bold) fontName = "Courier-Bold";
                                else if (italic) fontName = "Courier-Oblique";
                                else fontName = "Courier";
                            } else {
                                if (bold && italic) fontName = "Helvetica-BoldOblique";
                                else if (bold) fontName = "Helvetica-Bold";
                                else if (italic) fontName = "Helvetica-Oblique";
                                else fontName = "Helvetica";
                            }
                        }
                    }
                }

                if (!internalFontId.empty()) {
                    std::string lowerId = internalFontId;
                    std::transform(lowerId.begin(), lowerId.end(), lowerId.begin(), [](unsigned char c) {
                        return static_cast<char>(std::tolower(c));
                    });
                    if (lowerId.find("bolditalic") != std::string::npos) { bold = true; italic = true; }
                    else if (lowerId.find("bold") != std::string::npos) { bold = true; }
                    else if (lowerId.find("italic") != std::string::npos) { italic = true; }
                    else if (lowerId.find("oblique") != std::string::npos) { italic = true; }

                    if (lowerId.find("times") != std::string::npos) {
                        if (bold && italic) fontName = "Times-BoldItalic";
                        else if (bold) fontName = "Times-Bold";
                        else if (italic) fontName = "Times-Italic";
                        else fontName = "Times-Roman";
                    } else if (lowerId.find("courier") != std::string::npos) {
                        if (bold && italic) fontName = "Courier-BoldOblique";
                        else if (bold) fontName = "Courier-Bold";
                        else if (italic) fontName = "Courier-Oblique";
                        else fontName = "Courier";
                    } else if (lowerId.find("helvetica") != std::string::npos) {
                        if (bold && italic) fontName = "Helvetica-BoldOblique";
                        else if (bold) fontName = "Helvetica-Bold";
                        else if (italic) fontName = "Helvetica-Oblique";
                        else fontName = "Helvetica";
                    }
                }

                std::optional<FontInfo> matchedFontInfo;
                auto fontsRes = getFonts(pageIndex, pageIndex);
                if (fontsRes.has_value()) {
                    for (const auto& fontInfoEntry : *fontsRes) {
                        if ((!internalFontId.empty() && fontInfoEntry.internalFontId == internalFontId) ||
                            (!origFontName.empty() && fontInfoEntry.fontName == origFontName)) {
                            matchedFontInfo = fontInfoEntry;
                            break;
                        }
                    }
                }

                std::shared_ptr<fonts::pdf_fonts::Font> resolvedFont = nullptr;
                if (matchedFontInfo.has_value()) {
                    auto resolvedFontRes = getResolvedFont(*matchedFontInfo);
                    if (resolvedFontRes.has_value()) {
                        resolvedFont = *resolvedFontRes;
                        spdlog::info("Font Engine: resolved font '{}'", matchedFontInfo->fontName);
                    } else {
                        spdlog::warn("Font Engine: failed to resolve font '{}': {}", matchedFontInfo->fontName, resolvedFontRes.error());
                    }
                }

                bool fontSupportsAll = true;
                double totalWidth = 0.0;

                std::shared_ptr<fonts::FontFace> measureFace;
                {
                    std::vector<uint8_t> mb;
                    if (auto perObj = getFontDataFromObjects(pageIndex, objectIndices, internalFontId);
                        perObj.has_value() && !perObj->empty()) mb = std::move(*perObj);
                    else if (!internalFontId.empty()) {
                        if (auto fd = getFontData(internalFontId); fd.has_value() && !fd->empty())
                            mb = std::move(fd.value());
                    }
                    if (!mb.empty()) {
                        auto mf = std::make_shared<fonts::FontFace>();
                        if (mf->loadFromMemory(mb)) measureFace = mf;
                    }
                }

                auto utf16 = utf8_to_utf16le(newText);
                std::vector<uint32_t> unicodeCodepoints;
                for (size_t i = 0; i < utf16.size(); ) {
                    uint32_t cp = utf16[i];
                    if (cp >= 0xD800 && cp <= 0xDBFF && i + 1 < utf16.size()) {
                        uint32_t low = utf16[i + 1];
                        if (low >= 0xDC00 && low <= 0xDFFF) {
                            cp = 0x10000 + ((cp - 0xD800) << 10) + (low - 0xDC00);
                            i += 2;
                        } else {
                            i += 1;
                        }
                    } else {
                        i += 1;
                    }
                    unicodeCodepoints.push_back(cp);
                }

                bool isSubsetFont = matchedFontInfo && matchedFontInfo->isSubset;
                bool subsetLacksGlyphs = false;
                
                if (resolvedFont) {
                    for (uint32_t cp : unicodeCodepoints) {
                        if (!resolvedFont->hasGlyph(cp)) {
                            if (isSubsetFont) {
                                subsetLacksGlyphs = true;
                            } else {
                                fontSupportsAll = false;
                            }
                            spdlog::warn("Font Engine: Glyph for codepoint {} not found in font {}", cp, matchedFontInfo ? matchedFontInfo->fontName : "Unknown");
                        }
                    }
                } else {
                    fontSupportsAll = false;
                }

                bool shapedSuccessful = false;
                constexpr unsigned int kRefMeasure = 1000;
                fonts::FontFace* mface = measureFace ? measureFace.get()
                                       : (resolvedFont ? &resolvedFont->getFontFace() : nullptr);
                if (mface) {
                    try {
                        fonts::HbShaper shaper;
                        auto shapedGlyphs = shaper.shapeRun(newText, *mface, kRefMeasure);
                        if (!shapedGlyphs.empty()) {
                            double sum = 0.0;
                            for (const auto& sg : shapedGlyphs) sum += sg.advanceX;
                            totalWidth = sum * (fontSize > 0.0 ? fontSize : 12.0) / static_cast<double>(kRefMeasure);
                            shapedSuccessful = true;
                            spdlog::info("Font Engine: measured {} chars -> width {:.2f} ({} face)",
                                         newText.size(), totalWidth, measureFace ? "embedded" : "resolved");
                        }
                    } catch (const std::exception& e) {
                        spdlog::warn("Font Engine: shaping failed: {}", e.what());
                    } catch (...) {
                        spdlog::warn("Font Engine: shaping failed (unknown)");
                    }
                }

                if (!shapedSuccessful && resolvedFont) {
                    totalWidth = 0.0;
                    for (uint32_t cp : unicodeCodepoints) {
                        double w = resolvedFont->getAdvanceWidth(cp, fontSize);
                        totalWidth += w;
                    }
                    spdlog::info("Font Engine: FreeType fallback total advance width = {}", totalWidth);
                }

                float origLeft = 999999.0f, origRight = -999999.0f;
                float origBottom = 999999.0f, origTop = -999999.0f;
                bool hasOrigBounds = false;
                for (int idx : objectIndices) {
                    FPDF_PAGEOBJECT obj = FPDFPage_GetObject(page, idx);
                    if (obj) {
                        float left = 0.0f, bottom = 0.0f, right = 0.0f, top = 0.0f;
                        if (FPDFPageObj_GetBounds(obj, &left, &bottom, &right, &top)) {
                            if (left < origLeft) origLeft = left;
                            if (right > origRight) origRight = right;
                            if (bottom < origBottom) origBottom = bottom;
                            if (top > origTop) origTop = top;
                            hasOrigBounds = true;
                        }
                    }
                }

                double origWidth = 0.0;
                double origCenterY = 0.0;
                if (hasOrigBounds) {
                    origWidth = origRight - origLeft;
                    origCenterY = (origBottom + origTop) / 2.0;
                }

                bool axisAligned = (std::abs(b) < 1e-6 && std::abs(c) < 1e-6 && a > 0.0 && d > 0.0);
                double colRight = origRight;
                bool sawSibling = false;
                bool hasFollowingText = false;
                double rowTolFollow = (std::max)(4.0, (origTop - origBottom) * 0.6);
                if (axisAligned && hasOrigBounds) {
                    int nObjForCol = FPDFPage_CountObjects(page);
                    for (int k = 0; k < nObjForCol; ++k) {
                        if (std::find(objectIndices.begin(), objectIndices.end(), k) != objectIndices.end()) continue;
                        FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, k);
                        if (!o || FPDFPageObj_GetType(o) != FPDF_PAGEOBJ_TEXT) continue;
                        float l = 0, bo = 0, rr = 0, tt = 0;
                        if (!FPDFPageObj_GetBounds(o, &l, &bo, &rr, &tt)) continue;
                        if (std::abs(l - origLeft) <= 3.0) { sawSibling = true; if (rr > colRight) colRight = rr; }
                        if (std::abs((bo + tt) / 2.0 - origCenterY) <= rowTolFollow && l > origRight + 1.0)
                            hasFollowingText = true;
                    }
                }
                double justifyTol = (std::max)(4.0, (colRight - origLeft) * 0.02);
                bool wasJustified = !disableJustify && axisAligned && resolvedFont && hasOrigBounds && sawSibling &&
                                    !hasFollowingText &&
                                    (colRight - origLeft) > 20.0 && (origRight >= colRight - justifyTol);

                bool doSiblingShift = !wasJustified && hasOrigBounds;

                for (int idx : objectIndices) {
                    FPDF_PAGEOBJECT objToRemove = FPDFPage_GetObject(page, idx);
                    if (objToRemove) {
                        FPDFPage_RemoveObject(page, objToRemove);
                        FPDFPageObj_Destroy(objToRemove);
                    }
                }

                FPDF_FONT font = nullptr;
                std::string cacheKey = "";
                bool useEmbedded = false;
                bool useSystem = false;

                if (resolvedFont && matchedFontInfo) {
                    if (matchedFontInfo->isEmbedded && !isSubsetFont && fontSupportsAll) {
                        cacheKey = matchedFontInfo->internalFontId;
                        useEmbedded = true;
                    } else if (matchedFontInfo->isEmbedded && isSubsetFont && !subsetLacksGlyphs) {
                        cacheKey = matchedFontInfo->internalFontId;
                        useEmbedded = true;
                    } else if (!matchedFontInfo->isEmbedded) {
                        cacheKey = "standard_" + fontName;
                    } else {
                        cacheKey = "system_embed_" + matchedFontInfo->fontName + "_" + (bold ? "B" : "") + (italic ? "I" : "");
                        useSystem = true;
                    }
                } else {
                    cacheKey = "standard_" + fontName;
                }

                {
                    std::lock_guard<std::mutex> lock(loadedFontsMutex_);
                    if (loadedFontsCache_.count(cacheKey)) {
                        font = loadedFontsCache_[cacheKey];
                        spdlog::info("Font Engine: Reusing cached FPDF_FONT for key '{}'", cacheKey);
                    }
                }

                FPDF_FONT reconFont = nullptr;
                const fonts::pdf_fonts::ReconstructedFont* reconRf = nullptr;
                bool reconFullyCovered = false;
                if (matchedFontInfo && matchedFontInfo->isEmbedded && classifyFontFidelity(*matchedFontInfo) != "exact") {
                    reconRf = lookupReconFont(matchedFontInfo->internalFontId);
                    if (reconRf && reconRf->ok) {
                        std::lock_guard<std::mutex> lock(loadedFontsMutex_);
                        const std::string rkey = "recon_" + matchedFontInfo->internalFontId;
                        if (loadedFontsCache_.count(rkey)) reconFont = loadedFontsCache_[rkey];
                        else {
                            loadedFontDataBuffers_[rkey] = reconRf->sfnt;
                            const auto& bytes = loadedFontDataBuffers_[rkey];
                            reconFont = FPDFText_LoadFont(doc_, bytes.data(), static_cast<uint32_t>(bytes.size()), FPDF_FONT_TRUETYPE, true);
                            if (reconFont) loadedFontsCache_[rkey] = reconFont;
                        }
                        if (reconFont) {
                            reconFullyCovered = true;
                            for (uint32_t cp : unicodeCodepoints)
                                if (cp >= 0x20 && !reconRf->coveredUnicode.count(cp)) { reconFullyCovered = false; break; }
                        }
                    }
                }

                if (!font) {
                    if (useEmbedded) {
                        auto fontDataRes = getFontData(matchedFontInfo->internalFontId);
                        if (fontDataRes.has_value()) {
                            std::lock_guard<std::mutex> lock(loadedFontsMutex_);
                            loadedFontDataBuffers_[cacheKey] = fontDataRes.value();
                            const auto& bytes = loadedFontDataBuffers_[cacheKey];
                            font = FPDFText_LoadFont(doc_, bytes.data(), static_cast<uint32_t>(bytes.size()), FPDF_FONT_TRUETYPE, false);
                            if (font) {
                                spdlog::info("Font Engine: Loaded embedded font '{}' (cache key: {})", matchedFontInfo->fontName, cacheKey);
                            }
                        }
                    } else if (useSystem) {
                        std::string fontPath = fonts::pdf_fonts::FontFallback::getInstance().getFallbackFontPath(
                            matchedFontInfo->normalizedFamily.empty() ? matchedFontInfo->fontName : matchedFontInfo->normalizedFamily,
                            bold,
                            italic
                        );
                        std::ifstream fs(fontPath, std::ios::binary);
                        if (fs) {
                            std::vector<uint8_t> fileBytes((std::istreambuf_iterator<char>(fs)), std::istreambuf_iterator<char>());
                            if (!fileBytes.empty()) {
                                const size_t fullSize = fileBytes.size();
                                std::lock_guard<std::mutex> lock(loadedFontsMutex_);
                                loadedFontDataBuffers_[cacheKey] = std::move(fileBytes);
                                const auto& bytes = loadedFontDataBuffers_[cacheKey];
                                font = FPDFText_LoadFont(doc_, bytes.data(), static_cast<uint32_t>(bytes.size()), FPDF_FONT_TRUETYPE, true);
                                if (font) {
                                    spdlog::info("Font Engine: Embedded FULL CID system font '{}' ({} bytes) from '{}'",
                                                 matchedFontInfo->fontName, fullSize, fontPath);
                                }
                            }
                        } else {
                            spdlog::warn("Font Engine: Failed to open system font file '{}' for embedding", fontPath);
                        }
                    }

                    if (!font && reconFont && reconFullyCovered) {
                        font = reconFont;
                        spdlog::info("Tier-2: replace_text reconstructed fallback '{}'", matchedFontInfo->internalFontId);
                    }

                    if (!font) {
                        spdlog::info("Font Engine: Loading standard PDF font for replace_text: {}", fontName);
                        font = FPDFText_LoadStandardFont(doc_, fontName.c_str());
                        if (!font) {
                            font = FPDFText_LoadStandardFont(doc_, "Helvetica");
                        }
                    }

                    if (font) {
                        std::lock_guard<std::mutex> lock(loadedFontsMutex_);
                        loadedFontsCache_[cacheKey] = font;
                    }
                }

                if (font && useEmbedded) reconFont = nullptr;
                
                std::vector<FPDF_PAGEOBJECT> emittedObjs;
                if (font) {
                    constexpr unsigned int kRef = 1000;
                    double emToPage = (fontSize > 0.0 ? fontSize : 1.0) * a / static_cast<double>(kRef);
                    auto pageWidthOf = [&](const std::string& s) -> double {
                        if (s.empty() || !resolvedFont) return 0.0;
                        double sum = 0.0;
                        try {
                            fonts::HbShaper sh;
                            auto gl = sh.shapeRun(s, resolvedFont->getFontFace(), kRef);
                            for (const auto& gg : gl) sum += gg.advanceX;
                        } catch (...) {
                            for (unsigned char ch : s) sum += resolvedFont->getAdvanceWidth(ch, kRef);
                        }
                        return sum * emToPage;
                    };

                    std::vector<std::string> words;
                    if (wasJustified) {
                        std::string cur;
                        for (char ch : newText) {
                            if (ch == ' ') { if (!cur.empty()) { words.push_back(cur); cur.clear(); } }
                            else cur.push_back(ch);
                        }
                        if (!cur.empty()) words.push_back(cur);
                    }

                    auto measuredWidth = [&](const std::vector<unsigned short>& u16le) -> double {
                        FPDF_PAGEOBJECT m = FPDFPageObj_CreateTextObj(doc_, font, static_cast<float>(fontSize));
                        if (!m) return 0.0;
                        FPDFText_SetText(m, reinterpret_cast<FPDF_WIDESTRING>(u16le.data()));
                        FPDFPageObj_Transform(m, a, b, c, d, 0.0, 0.0);
                        float l = 0, bo = 0, rr = 0, tt = 0;
                        double w = FPDFPageObj_GetBounds(m, &l, &bo, &rr, &tt) ? (rr - l) : 0.0;
                        FPDFPageObj_Destroy(m);
                        return w;
                    };

                    if (wasJustified && words.size() > 1) {
                        std::vector<double> wpx;
                        wpx.reserve(words.size());
                        double estWords = 0.0;
                        for (const auto& w : words) { double ww = pageWidthOf(w); wpx.push_back(ww); estWords += ww; }
                        double estSpace = pageWidthOf(" ");
                        int gaps = static_cast<int>(words.size()) - 1;
                        double estTotal = estWords + gaps * estSpace;
                        double actualFull = measuredWidth(utf16);
                        double k = (estTotal > 1e-6 && actualFull > 1e-6) ? actualFull / estTotal : 1.0;
                        double targetW = colRight - e;
                        double slack = targetW - actualFull;
                        double extraPerGap = (slack > 0.0) ? slack / gaps : 0.0;
                        spdlog::info("replace_text: justify {} words targetW={:.1f} actualW={:.1f} extraPerGap={:.2f}",
                                     words.size(), targetW, actualFull, extraPerGap);
                        double penX = e;
                        for (size_t wi = 0; wi < words.size(); ++wi) {
                            FPDF_PAGEOBJECT wobj = FPDFPageObj_CreateTextObj(doc_, font, static_cast<float>(fontSize));
                            if (wobj) {
                                FPDFPageObj_SetFillColor(wobj, r, g, b_color, a_color);
                                FPDFTextObj_SetTextRenderMode(wobj, renderMode);
                                auto wu = utf8_to_utf16le(words[wi]); wu.push_back(0);
                                FPDFText_SetText(wobj, reinterpret_cast<FPDF_WIDESTRING>(wu.data()));
                                FPDFPageObj_Transform(wobj, a, b, c, d, penX, f);
                                FPDFPage_InsertObjectAtIndex(page, wobj, minIndex);
                                emittedObjs.push_back(wobj);
                            }
                            penX += (wpx[wi] + estSpace) * k + extraPerGap;
                        }
                    } else {
                      bool didHybrid = false;
                      if (reconFont && reconRf && font && font != reconFont && !unicodeCodepoints.empty()) {
                        fonts::FontFace reconFace; bool haveReconFace = reconFace.loadFromMemory(reconRf->sfnt);
                        fonts::FontFace subFace; bool haveSubFace = false;
                        {
                            std::lock_guard<std::mutex> lock(loadedFontsMutex_);
                            auto it = loadedFontDataBuffers_.find(cacheKey);
                            if (it != loadedFontDataBuffers_.end() && !it->second.empty())
                                haveSubFace = subFace.loadFromMemory(it->second);
                        }
                        auto segWidthPage = [&](fonts::FontFace* face, const std::string& s) -> double {
                            if (!face || s.empty()) return 0.0;
                            double sum = 0.0;
                            try { fonts::HbShaper sh; for (const auto& gg : sh.shapeRun(s, *face, kRef)) sum += gg.advanceX; }
                            catch (...) { return 0.0; }
                            return sum * emToPage;
                        };
                        auto isCov = [&](uint32_t cp){ return cp < 0x20 || reconRf->coveredUnicode.count(cp) != 0; };
                        auto cpToU16 = [](uint32_t cp, std::vector<unsigned short>& dst){
                            if (cp <= 0xFFFF) dst.push_back(static_cast<unsigned short>(cp));
                            else { cp -= 0x10000; dst.push_back(static_cast<unsigned short>(0xD800 + (cp >> 10)));
                                   dst.push_back(static_cast<unsigned short>(0xDC00 + (cp & 0x3FF))); }
                        };
                        auto cpToU8 = [](uint32_t cp, std::string& d){
                            if (cp < 0x80) d += static_cast<char>(cp);
                            else if (cp < 0x800) { d += static_cast<char>(0xC0 | (cp >> 6)); d += static_cast<char>(0x80 | (cp & 0x3F)); }
                            else if (cp < 0x10000) { d += static_cast<char>(0xE0 | (cp >> 12)); d += static_cast<char>(0x80 | ((cp >> 6) & 0x3F)); d += static_cast<char>(0x80 | (cp & 0x3F)); }
                            else { d += static_cast<char>(0xF0 | (cp >> 18)); d += static_cast<char>(0x80 | ((cp >> 12) & 0x3F)); d += static_cast<char>(0x80 | ((cp >> 6) & 0x3F)); d += static_cast<char>(0x80 | (cp & 0x3F)); }
                        };
                        double penX = e;
                        size_t i = 0;
                        while (i < unicodeCodepoints.size()) {
                            bool cov = isCov(unicodeCodepoints[i]);
                            std::vector<unsigned short> seg; std::string seg8;
                            while (i < unicodeCodepoints.size() && isCov(unicodeCodepoints[i]) == cov) {
                                cpToU16(unicodeCodepoints[i], seg); cpToU8(unicodeCodepoints[i], seg8); ++i;
                            }
                            seg.push_back(0);
                            FPDF_FONT segFont = cov ? reconFont : font;
                            fonts::FontFace* segFace = cov ? (haveReconFace ? &reconFace : nullptr)
                                                           : (haveSubFace ? &subFace : nullptr);
                            FPDF_PAGEOBJECT obj = FPDFPageObj_CreateTextObj(doc_, segFont, static_cast<float>(fontSize));
                            if (obj) {
                                FPDFPageObj_SetFillColor(obj, r, g, b_color, a_color);
                                FPDFTextObj_SetTextRenderMode(obj, renderMode);
                                FPDFText_SetText(obj, reinterpret_cast<FPDF_WIDESTRING>(seg.data()));
                                FPDFPageObj_Transform(obj, a, b, c, d, penX, f);
                                FPDFPage_InsertObjectAtIndex(page, obj, minIndex);
                                emittedObjs.push_back(obj);
                            }
                            double adv = segWidthPage(segFace, seg8);
                            if (adv <= 0.0) {  // shaping unavailable -> fall back to ink bbox
                                if (obj) { float l=0,bo=0,rr=0,tt=0; if (FPDFPageObj_GetBounds(obj,&l,&bo,&rr,&tt)) adv = rr - l; }
                            }
                            penX += adv;
                        }
                        didHybrid = true;
                        spdlog::info("Tier-2: replace_text HYBRID emission for '{}' (mixed embedded/substitute)", internalFontId);
                      }
                      if (!didHybrid)
                      {
                        double aScale = a;
                        if (disableJustify && hasOrigBounds && axisAligned) {
                            double newW = measuredWidth(utf16);
                            double rowTol = (std::max)(5.0, (origTop - origBottom) * 0.5);
                            double nextLeft = 1e18;
                            int nObj = FPDFPage_CountObjects(page);
                            for (int k = 0; k < nObj; ++k) {
                                if (std::find(objectIndices.begin(), objectIndices.end(), k) != objectIndices.end()) continue;
                                FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, k);
                                if (!o || FPDFPageObj_GetType(o) != FPDF_PAGEOBJ_TEXT) continue;
                                float l = 0, bo = 0, rr = 0, tt = 0;
                                if (!FPDFPageObj_GetBounds(o, &l, &bo, &rr, &tt)) continue;
                                if (std::abs((bo + tt) / 2.0 - origCenterY) <= rowTol && l > origRight + 1.0 && l < nextLeft) {
                                    nextLeft = l;
                                }
                            }
                            if (nextLeft < 1e17) {
                                double avail = nextLeft - e - 2.0;
                                if (avail > 1.0 && newW > avail) aScale = a * (avail / newW);
                            }
                        }
                        FPDF_PAGEOBJECT newTextObj = FPDFPageObj_CreateTextObj(doc_, font, static_cast<float>(fontSize));
                        if (newTextObj) {
                            FPDFPageObj_SetFillColor(newTextObj, r, g, b_color, a_color);
                            FPDFTextObj_SetTextRenderMode(newTextObj, renderMode);
                            FPDFText_SetText(newTextObj, reinterpret_cast<FPDF_WIDESTRING>(utf16.data()));
                            FPDFPageObj_Transform(newTextObj, aScale, b, c, d, e, f);

                            FPDFPage_InsertObjectAtIndex(page, newTextObj, minIndex);
                            emittedObjs.push_back(newTextObj);
                        } else {
                            spdlog::error("Failed to create new text object");
                        }
                      }
                    }
                }

                if (doSiblingShift) {
                    double shift = totalWidth - origWidth;
                    if (std::abs(shift) > 0.05) {
                        double rowTol = (std::max)(5.0, fontSize * 0.5);
                        int nObj = FPDFPage_CountObjects(page);
                        int moved = 0;
                        for (int k = 0; k < nObj; ++k) {
                            FPDF_PAGEOBJECT o = FPDFPage_GetObject(page, k);
                            if (!o || FPDFPageObj_GetType(o) != FPDF_PAGEOBJ_TEXT) continue;
                            if (std::find(emittedObjs.begin(), emittedObjs.end(), o) != emittedObjs.end()) continue;
                            float l = 0, bo = 0, rr = 0, tt = 0;
                            if (!FPDFPageObj_GetBounds(o, &l, &bo, &rr, &tt)) continue;
                            if (std::abs((bo + tt) / 2.0 - origCenterY) <= rowTol && l >= origRight - 2.0f) {
                                FPDFPageObj_Transform(o, 1.0, 0.0, 0.0, 1.0, shift, 0.0);
                                moved++;
                            }
                        }
                        spdlog::info("replace_text: sibling shift {} obj by {:.2f} (deltaX = newW {:.2f} - origW {:.2f})",
                                     moved, shift, totalWidth, origWidth);
                    }
                }

                if (!FPDFPage_GenerateContent(page)) {
                    spdlog::error("Failed to generate page content after replace_text");
                }

                FPDF_ClosePage(page);
    return {};
#else
    (void)op; (void)pageIndex;
    return std::unexpected(EngineError::Unknown);
#endif
}

}