/*
 * Copyright 2026 Rive
 */

#include "rive/text/line_break.hpp"
#include <cassert>
#include <vector>

using namespace rive;

namespace rive
{
extern const uint32_t kLineBreakHighStart;
extern const uint32_t kLineBreakTopShift;
extern const uint32_t kLineBreakBlockShift;
extern const uint8_t kLineBreakDefault;
extern const LineBreakProps kLineBreakExtClasses[];
extern const uint8_t kLineBreakTop[];
extern const uint16_t kLineBreakMid[];
extern const uint8_t kLineBreakData[];
} // namespace rive

LineBreakProps rive::lineBreakProps(uint32_t cp)
{
    if (cp >= kLineBreakHighStart)
    {
        return kLineBreakExtClasses[kLineBreakDefault];
    }
    uint32_t midEntries = 1u << (kLineBreakTopShift - kLineBreakBlockShift);
    uint32_t mid = kLineBreakTop[cp >> kLineBreakTopShift] * midEntries +
                   ((cp >> kLineBreakBlockShift) & (midEntries - 1));
    uint32_t blockSize = 1u << kLineBreakBlockShift;
    uint32_t data = kLineBreakMid[mid] * blockSize + (cp & (blockSize - 1));
    return kLineBreakExtClasses[kLineBreakData[data]];
}

namespace
{
using C = LineBreakClass;

// One entry per codepoint that survives LB9 (combining sequences collapse
// onto their base), so the rules can index neighbours directly.
struct Item
{
    C cls;
    uint8_t flags;
    bool afterZwj;  // the codepoint just before this item is a ZWJ
    uint32_t index; // first codepoint of the item
};

// Items live on the stack for typical UI strings.
constexpr size_t kInlineItems = 256;

bool isHardBreak(C c)
{
    return c == C::BK || c == C::CR || c == C::LF || c == C::NL;
}

bool isAlphabetic(C c) { return c == C::AL || c == C::HL; }

bool isBrahmicBase(const Item& i)
{
    return i.cls == C::AK || i.cls == C::AS ||
           (i.flags & lineBreakDottedCircle) != 0;
}

bool isAkOrDottedCircle(const Item& i)
{
    return i.cls == C::AK || (i.flags & lineBreakDottedCircle) != 0;
}

bool isEastAsian(const Item& i) { return (i.flags & lineBreakEastAsian) != 0; }

bool isKorean(C c)
{
    return c == C::JL || c == C::JV || c == C::JT || c == C::H2 || c == C::H3;
}

// Decides the boundary before items[k] (1 <= k < items.size()). Rules run in
// UAX #14 order and the first match wins.
LineBreak breakBefore(const Item* items,
                      size_t count,
                      size_t k,
                      size_t beforeSpaces,
                      size_t regionalIndicators)
{
    const Item& prev = items[k - 1];
    const Item& next = items[k];
    C p = prev.cls;
    C n = next.cls;
    // Class of the last item before any run of spaces ending at k - 1. SP
    // stands in when there is none so no rule matches it.
    C ps = beforeSpaces < count ? items[beforeSpaces].cls : C::SP;
    bool atStart = k == 1;

    // LB4, LB5
    if (p == C::BK)
    {
        return LineBreak::mandatory;
    }
    if (p == C::CR && n == C::LF)
    {
        return LineBreak::none;
    }
    if (p == C::CR || p == C::LF || p == C::NL)
    {
        return LineBreak::mandatory;
    }
    // LB6, LB7
    if (isHardBreak(n) || n == C::SP || n == C::ZW)
    {
        return LineBreak::none;
    }
    // LB8
    if (p == C::ZW || (p == C::SP && ps == C::ZW))
    {
        return LineBreak::allowed;
    }
    // LB8a
    if (next.afterZwj)
    {
        return LineBreak::none;
    }
    // The two dominant pairs skip the rule chain: no rule between here and
    // LB28 touches letter-letter, and none before LB31 touches ideograph
    // pairs.
    if (isAlphabetic(p) && isAlphabetic(n))
    {
        return LineBreak::none;
    }
    if (p == C::ID && n == C::ID)
    {
        return LineBreak::allowed;
    }
    // LB11, LB12
    if (n == C::WJ || p == C::WJ || p == C::GL)
    {
        return LineBreak::none;
    }
    // LB12a
    if (n == C::GL && p != C::SP && p != C::BA && p != C::HY && p != C::HH)
    {
        return LineBreak::none;
    }
    // LB13
    if (n == C::CL || n == C::CP || n == C::EX || n == C::SY)
    {
        return LineBreak::none;
    }
    // LB14
    if (p == C::OP || (p == C::SP && ps == C::OP))
    {
        return LineBreak::none;
    }
    // LB15a
    {
        size_t j = p == C::SP ? beforeSpaces : k - 1;
        if (j < count && items[j].cls == C::QU &&
            (items[j].flags & lineBreakPi) != 0)
        {
            bool ok = j == 0;
            if (!ok)
            {
                C b = items[j - 1].cls;
                ok = isHardBreak(b) || b == C::OP || b == C::QU || b == C::GL ||
                     b == C::SP || b == C::ZW;
            }
            if (ok)
            {
                return LineBreak::none;
            }
        }
    }
    // LB15b
    if (n == C::QU && (next.flags & lineBreakPf) != 0)
    {
        bool ok = k + 1 == count;
        if (!ok)
        {
            C a = items[k + 1].cls;
            ok = a == C::SP || a == C::GL || a == C::WJ || a == C::CL ||
                 a == C::QU || a == C::CP || a == C::EX || a == C::IS ||
                 a == C::SY || isHardBreak(a) || a == C::ZW;
        }
        if (ok)
        {
            return LineBreak::none;
        }
    }
    // LB15c
    if (p == C::SP && n == C::IS && k + 1 < count && items[k + 1].cls == C::NU)
    {
        return LineBreak::allowed;
    }
    // LB15d
    if (n == C::IS)
    {
        return LineBreak::none;
    }
    // LB16
    if (n == C::NS && (p == C::CL || p == C::CP ||
                       (p == C::SP && (ps == C::CL || ps == C::CP))))
    {
        return LineBreak::none;
    }
    // LB17
    if (n == C::B2 && (p == C::B2 || (p == C::SP && ps == C::B2)))
    {
        return LineBreak::none;
    }
    // LB18
    if (p == C::SP)
    {
        return LineBreak::allowed;
    }
    // LB19
    if (n == C::QU && (next.flags & lineBreakPi) == 0)
    {
        return LineBreak::none;
    }
    if (p == C::QU && (prev.flags & lineBreakPf) == 0)
    {
        return LineBreak::none;
    }
    // LB19a
    if (n == C::QU)
    {
        if (!isEastAsian(prev) || k + 1 == count || !isEastAsian(items[k + 1]))
        {
            return LineBreak::none;
        }
    }
    if (p == C::QU)
    {
        if (!isEastAsian(next) || atStart || !isEastAsian(items[k - 2]))
        {
            return LineBreak::none;
        }
    }
    // LB20
    if (n == C::CB || p == C::CB)
    {
        return LineBreak::allowed;
    }
    // LB20a
    if ((p == C::HY || p == C::HH) && isAlphabetic(n))
    {
        bool ok = atStart;
        if (!ok)
        {
            C b = items[k - 2].cls;
            ok = isHardBreak(b) || b == C::SP || b == C::ZW || b == C::CB ||
                 b == C::GL;
        }
        if (ok)
        {
            return LineBreak::none;
        }
    }
    // LB21
    if (n == C::BA || n == C::HH || n == C::HY || n == C::NS || p == C::BB)
    {
        return LineBreak::none;
    }
    // LB21a
    if ((p == C::HY || p == C::HH) && n != C::HL && !atStart &&
        items[k - 2].cls == C::HL)
    {
        return LineBreak::none;
    }
    // LB21b
    if (p == C::SY && n == C::HL)
    {
        return LineBreak::none;
    }
    // LB22
    if (n == C::IN)
    {
        return LineBreak::none;
    }
    // LB23
    if ((isAlphabetic(p) && n == C::NU) || (p == C::NU && isAlphabetic(n)))
    {
        return LineBreak::none;
    }
    // LB23a
    if (p == C::PR && (n == C::ID || n == C::EB || n == C::EM))
    {
        return LineBreak::none;
    }
    if ((p == C::ID || p == C::EB || p == C::EM) && n == C::PO)
    {
        return LineBreak::none;
    }
    // LB24
    if (((p == C::PR || p == C::PO) && isAlphabetic(n)) ||
        (isAlphabetic(p) && (n == C::PR || n == C::PO)))
    {
        return LineBreak::none;
    }
    // LB25
    if (n == C::PO || n == C::PR || n == C::NU)
    {
        // NU (SY | IS)* (CL | CP)? × (PO | PR) and NU (SY | IS)* × NU
        size_t j = k - 1;
        bool searching = true;
        if (n != C::NU && (items[j].cls == C::CL || items[j].cls == C::CP))
        {
            searching = j > 0;
            j--;
        }
        while (searching && (items[j].cls == C::SY || items[j].cls == C::IS))
        {
            searching = j > 0;
            j--;
        }
        if (searching && items[j].cls == C::NU)
        {
            return LineBreak::none;
        }
    }
    if (p == C::PO || p == C::PR)
    {
        if (n == C::NU)
        {
            return LineBreak::none;
        }
        if (n == C::OP && k + 1 < count)
        {
            if (items[k + 1].cls == C::NU)
            {
                return LineBreak::none;
            }
            if (items[k + 1].cls == C::IS && k + 2 < count &&
                items[k + 2].cls == C::NU)
            {
                return LineBreak::none;
            }
        }
    }
    if ((p == C::HY || p == C::IS) && n == C::NU)
    {
        return LineBreak::none;
    }
    // LB26
    if (p == C::JL && (n == C::JL || n == C::JV || n == C::H2 || n == C::H3))
    {
        return LineBreak::none;
    }
    if ((p == C::JV || p == C::H2) && (n == C::JV || n == C::JT))
    {
        return LineBreak::none;
    }
    if ((p == C::JT || p == C::H3) && n == C::JT)
    {
        return LineBreak::none;
    }
    // LB27
    if ((isKorean(p) && n == C::PO) || (p == C::PR && isKorean(n)))
    {
        return LineBreak::none;
    }
    // LB28
    if (isAlphabetic(p) && isAlphabetic(n))
    {
        return LineBreak::none;
    }
    // LB28a
    if (p == C::AP && isBrahmicBase(next))
    {
        return LineBreak::none;
    }
    if (isBrahmicBase(prev) && (n == C::VF || n == C::VI))
    {
        return LineBreak::none;
    }
    if (p == C::VI && !atStart && isBrahmicBase(items[k - 2]) &&
        isAkOrDottedCircle(next))
    {
        return LineBreak::none;
    }
    if (isBrahmicBase(prev) && isBrahmicBase(next) && k + 1 < count &&
        items[k + 1].cls == C::VF)
    {
        return LineBreak::none;
    }
    // LB29
    if (p == C::IS && isAlphabetic(n))
    {
        return LineBreak::none;
    }
    // LB30
    if ((isAlphabetic(p) || p == C::NU) && n == C::OP && !isEastAsian(next))
    {
        return LineBreak::none;
    }
    if (p == C::CP && !isEastAsian(prev) && (isAlphabetic(n) || n == C::NU))
    {
        return LineBreak::none;
    }
    // LB30a
    if (p == C::RI && n == C::RI && (regionalIndicators & 1))
    {
        return LineBreak::none;
    }
    // LB30b
    if (n == C::EM &&
        (p == C::EB || (prev.flags & lineBreakPictographicCn) != 0))
    {
        return LineBreak::none;
    }
    // LB31
    return LineBreak::allowed;
}
} // namespace

void rive::computeLineBreaks(Span<const uint32_t> text, Span<LineBreak> out)
{
    size_t n = text.size();
    assert(out.size() == n + 1);
    for (size_t i = 0; i <= n; i++)
    {
        out[i] = LineBreak::none;
    }
    if (n == 0)
    {
        return;
    }
    out[n] = LineBreak::allowed;

    // LB1 is baked into the table; CJ resolves to NS (strict) here. LB9 and
    // LB10: combining marks and ZWJ attach to any base except hard breaks,
    // spaces and ZW, otherwise they act as AL.
    Item inlineItems[kInlineItems];
    std::vector<Item> heapItems;
    Item* items = inlineItems;
    if (n > kInlineItems)
    {
        heapItems.resize(n);
        items = heapItems.data();
    }
    size_t count = 0;
    bool afterZwj = false;
    for (uint32_t i = 0; i < n; i++)
    {
        LineBreakProps props = lineBreakProps(text[i]);
        C cls = props.cls;
        bool isZwj = cls == C::ZWJ;
        if (cls == C::CJ)
        {
            cls = C::NS;
        }
        if (cls == C::CM || cls == C::ZWJ)
        {
            if (count > 0)
            {
                C base = items[count - 1].cls;
                if (!isHardBreak(base) && base != C::SP && base != C::ZW)
                {
                    afterZwj = isZwj;
                    continue;
                }
            }
            cls = C::AL;
            props.flags = 0;
        }
        items[count++] = {cls, props.flags, afterZwj, i};
        afterZwj = isZwj;
    }

    size_t beforeSpaces = count;
    // Count of consecutive regional indicators ending at k - 1.
    size_t regionalIndicators = 0;
    for (size_t k = 1; k < count; k++)
    {
        if (items[k - 1].cls != C::SP)
        {
            beforeSpaces = k - 1;
        }
        regionalIndicators =
            items[k - 1].cls == C::RI ? regionalIndicators + 1 : 0;
        out[items[k].index] =
            breakBefore(items, count, k, beforeSpaces, regionalIndicators);
    }
    if (isHardBreak(items[count - 1].cls))
    {
        out[n] = LineBreak::mandatory;
    }
}