/*
 * Copyright 2026 Rive
 */

#include "rive/text/line_break.hpp"
#include "rive/text/line_break_dictionary.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 and LB27 never match: Hangul resolves to AL before the rules run.
  // 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. Hangul
  // resolves to AL so space delimited Korean wraps at spaces, as it did
  // before UAX #14, instead of between syllables. 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;
    }
    else if (isKorean(cls))
    {
      cls = C::AL;
    }
    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);
  }
#ifdef RIVE_LINE_BREAK_DICTIONARIES
  applyLineBreakDictionaries(text, out);
#endif
  if (isHardBreak(items[count - 1].cls))
  {
    out[n] = LineBreak::mandatory;
  }
}