#include "rive/text/text.hpp"
#include "rive/text/text_modifier_range.hpp"
#include "rive/text/text_modifier_group.hpp"
#include "rive/text/text_value_run.hpp"
#include "rive/text/glyph_lookup.hpp"
#include "rive/animation/cubic_interpolator_component.hpp"
#include "rive/core_context.hpp"

using namespace rive;

StatusCode TextModifierRange::onAddedDirty(CoreContext* context)
{
    StatusCode code = Super::onAddedDirty(context);
    if (code != StatusCode::Ok)
    {
        return code;
    }

    if (runId() != Core::emptyId)
    {
        auto coreObject = context->resolve(runId());
        if (coreObject == nullptr || !coreObject->is<TextValueRun>())
        {
            return StatusCode::MissingObject;
        }
        m_run = static_cast<TextValueRun*>(coreObject);
    }

    if (parent() != nullptr && parent()->is<TextModifierGroup>())
    {
        parent()->as<TextModifierGroup>()->addModifierRange(this);
        return StatusCode::Ok;
    }

    return StatusCode::MissingObject;
}

void TextModifierRange::addChild(Component* component)
{
    Super::addChild(component);
    if (component->is<CubicInterpolatorComponent>())
    {
        // mark this as the cubic interpolator.
        m_interpolator = component->as<CubicInterpolatorComponent>();
    }
}

void TextModifierRange::clearRangeMap() { m_rangeMapper.clear(); }

void TextModifierRange::computeRange(
    Span<const Unichar> text,
    const SimpleArray<Paragraph>& shape,
    const SimpleArray<SimpleArray<GlyphLine>>& lines,
    const GlyphLookup& glyphLookup)
{
    // Check if the range mapper is still valid.
    if (!m_rangeMapper.empty())
    {
        return;
    }
    uint32_t start = 0;
    uint32_t end = (uint32_t)text.size();
    if (m_run != nullptr)
    {
        start = m_run->offset();
        end = start + m_run->length();
    }
    switch (units())
    {
        case TextRangeUnits::charactersExcludingSpaces:
            m_rangeMapper.fromCharacters(text, start, end, glyphLookup, true);
            break;
        case TextRangeUnits::words:
            m_rangeMapper.fromWords(text, start, end);
            break;
        case TextRangeUnits::lines:
            m_rangeMapper
                .fromLines(text, start, end, shape, lines, glyphLookup);
            break;
        default:
            m_rangeMapper.fromCharacters(text, start, end, glyphLookup);
            break;
    }
}

float TextModifierRange::coverageAt(float t)
{
    float c = 0.0f;
    if (m_indexTo >= m_indexFrom)
    {
        if (t < m_indexFrom || t > m_indexTo)
        {
            c = 0.0f;
        }
        else if (t < m_indexFalloffFrom)
        {
            float range = std::max(0.0f, m_indexFalloffFrom - m_indexFrom);
            c = range == 0.0f ? 1.0f : std::max(0.0f, t - m_indexFrom) / range;
            if (m_interpolator != nullptr)
            {
                c = m_interpolator->transform(c);
            }
        }
        else if (t > m_indexFalloffTo)
        {
            float range = std::max(0.0f, m_indexTo - m_indexFalloffTo);
            c = range == 0.0f
                    ? 1.0f
                    : 1.0f - std::min(1.0f, (t - m_indexFalloffTo) / range);
            if (m_interpolator != nullptr)
            {
                c = m_interpolator->transform(c);
            }
        }
        else
        {
            c = 1.0f;
        }
    }
    return c;
}

void TextModifierRange::computeCoverage(Span<float> coverage)
{
    if (m_rangeMapper.empty())
    {
        return;
    }

    // Compute range mapped coverage.
    uint32_t count = m_rangeMapper.unitCount();
    switch (type())
    {
        case TextRangeType::unitIndex:
            m_indexFrom = offsetModifyFrom();
            m_indexTo = offsetModifyTo();
            m_indexFalloffFrom = offsetFalloffFrom();
            m_indexFalloffTo = offsetFalloffTo();
            break;
        case TextRangeType::percentage:
            m_indexFrom = count * offsetModifyFrom();
            m_indexTo = count * offsetModifyTo();
            m_indexFalloffFrom = count * offsetFalloffFrom();
            m_indexFalloffTo = count * offsetFalloffTo();
            break;
    }

    TextRangeMode rangeMode = mode();
    for (uint32_t unitIndex = 0; unitIndex < count; unitIndex++)
    {
        uint32_t unitLength = (uint32_t)m_rangeMapper.unitLength(unitIndex);
        uint32_t characterIndex = m_rangeMapper.unitCharacterIndex(unitIndex);
        float c = strength() * coverageAt(unitIndex + 0.5f);
        for (uint32_t i = 0; i < unitLength; i++)
        {
            assert((characterIndex + i) < (uint32_t)coverage.size());
            float current = coverage[characterIndex + i];
            switch (rangeMode)
            {
                case TextRangeMode::add:
                    current += c;
                    break;
                case TextRangeMode::subtract:
                    current -= c;
                    break;
                case TextRangeMode::max:
                    current = std::max(current, c);
                    break;
                case TextRangeMode::min:
                    current = std::min(current, c);
                    break;
                case TextRangeMode::multiply:
                    current *= c;
                    break;
                case TextRangeMode::difference:
                    current = std::abs(current - c);
                    break;
            }
            coverage[characterIndex + i] =
                clamp() ? std::max(0.0f, std::min(1.0f, current)) : current;
        }

        // Set space between units coverage to 0.
        if (unitIndex + 1 < m_rangeMapper.unitCharacterIndexCount())
        {
            uint32_t nextCharacterIndex =
                m_rangeMapper.unitCharacterIndex(unitIndex + 1);
            for (uint32_t i = characterIndex + unitLength;
                 i < nextCharacterIndex;
                 i++)
            {
                coverage[i] = 0;
            }
        }
    }
}

void TextModifierRange::modifyFromChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::modifyToChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::strengthChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::unitsValueChanged()
{
    parent()->as<TextModifierGroup>()->rangeTypeChanged();
}
void TextModifierRange::typeValueChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::modeValueChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::clampChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::falloffFromChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::falloffToChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}
void TextModifierRange::offsetChanged()
{
    parent()->as<TextModifierGroup>()->rangeChanged();
}

bool TextModifierRange::needsShape() const
{
    return units() == TextRangeUnits::lines;
}

void RangeMapper::clear()
{
    m_unitCharacterIndices.clear();
    m_unitLengths.clear();
}

float RangeMapper::unitToCharacterRange(float word) const
{
    if (m_unitCharacterIndices.empty())
    {
        return 0.0f;
    }
    float clampedUnit = std::min(std::max(word, 0.0f),
                                 (float)(m_unitCharacterIndices.size() - 1));
    size_t intUnit = (size_t)clampedUnit;
    float characters = (float)m_unitCharacterIndices[intUnit];
    if (intUnit < m_unitLengths.size())
    {
        float fraction = clampedUnit - intUnit;
        characters += m_unitLengths[intUnit] * fraction;
    }
    return characters;
}

void RangeMapper::addRange(uint32_t indexFrom,
                           uint32_t indexTo,
                           uint32_t startOffset,
                           uint32_t endOffset)
{
    if (indexTo > startOffset && endOffset > indexFrom)
    {
        uint32_t actualStart = std::max(startOffset, indexFrom);
        uint32_t actualEnd = std::min(endOffset, indexTo);
        if (actualEnd > actualStart)
        {
            m_unitCharacterIndices.push_back(actualStart);
            m_unitLengths.push_back(actualEnd - actualStart);
        }
    }
}

void RangeMapper::fromWords(Span<const Unichar> text,
                            uint32_t start,
                            uint32_t end)
{
    if (text.empty())
    {
        return;
    }

    bool wantWhiteSpace = false;
    uint32_t characterCount = 0;
    uint32_t index = 0;
    uint32_t indexFrom = 0;
    for (Unichar unit : text)
    {
        if (wantWhiteSpace == isWhiteSpace(unit))
        {
            if (!wantWhiteSpace)
            {
                indexFrom = index;
            }
            else
            {
                addRange(indexFrom, indexFrom + characterCount, start, end);

                characterCount = 0;
            }
            wantWhiteSpace = !wantWhiteSpace;
        }
        if (wantWhiteSpace)
        {
            characterCount++;
        }
        index++;
    }
    if (characterCount > 0)
    {
        addRange(indexFrom, indexFrom + characterCount, start, end);
    }
    m_unitCharacterIndices.push_back(end);
}

void RangeMapper::fromCharacters(Span<const Unichar> text,
                                 uint32_t start,
                                 uint32_t end,
                                 const GlyphLookup& glyphLookup,
                                 bool withoutSpaces)
{
    if (text.empty())
    {
        return;
    }
    for (uint32_t i = start; i < end;)
    {
        Unichar unit = text[i];
        if (withoutSpaces && isWhiteSpace(unit))
        {
            i++;
            continue;
        }
        // Don't break ligated glyphs.
        uint32_t codePoints = glyphLookup.count(i);
        m_unitCharacterIndices.push_back(i);
        m_unitLengths.push_back(codePoints);
        i += codePoints;
    }

    m_unitCharacterIndices.push_back(end);
}

void RangeMapper::fromLines(Span<const Unichar> text,
                            uint32_t start,
                            uint32_t end,
                            const SimpleArray<Paragraph>& shape,
                            const SimpleArray<SimpleArray<GlyphLine>>& lines,
                            const GlyphLookup& glyphLookup)
{
    if (text.empty())
    {
        return;
    }
    uint32_t paragraphIndex = 0;
    for (const SimpleArray<GlyphLine>& paragraphLines : lines)
    {
        const Paragraph& paragraph = shape[paragraphIndex++];
        const SimpleArray<GlyphRun>& glyphRuns = paragraph.runs;
        for (const GlyphLine& line : paragraphLines)
        {
            const GlyphRun& rf = glyphRuns[line.startRunIndex];
            uint32_t indexFrom = rf.textIndices[line.startGlyphIndex];

            const GlyphRun& rt = glyphRuns[line.endRunIndex];
            uint32_t endGlyphIndex =
                line.endGlyphIndex == 0 ? 0 : line.endGlyphIndex - 1;
            uint32_t indexTo = rt.textIndices[endGlyphIndex];
            indexTo += glyphLookup.count(indexTo);

            addRange(indexFrom, indexTo, start, end);
        }
    }
    m_unitCharacterIndices.push_back(end);
}