/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "minikin/Measurement.h"

#include <cfloat>
#include <cmath>

#include "BidiUtils.h"
#include "LayoutSplitter.h"
#include "minikin/GraphemeBreak.h"
#include "minikin/LayoutCache.h"

namespace {
bool isAsciiOrBidiControlCharacter(uint16_t c) {
    return (0x0000 <= c && c <= 0x001F)                  // ASCII control characters
           || c == 0x061C || c == 0x200E || c == 0x200F  // BiDi control characters
           || (0x202A <= c && c <= 0x202E) || (0x2066 <= c && c <= 0x2069);
}

}  // namespace

namespace minikin {

// These could be considered helper methods of layout, but need only be loosely coupled, so
// are separate.

/**
 * Return the unsigned advance of the given offset from the run start.
 *
 * @param advances the computed advances of the characters in buf. The advance of
 * the i-th character in buf is stored at index (i - layoutStart) in this array.
 * @param buf the text stored in utf-16 format.
 * @param layoutStart the start index of the character that is laid out.
 * @param start the start index of the run.
 * @param count the number of the characters in this run.
 * @param offset the target offset to compute the index. It should be in the
 * range of [start, start + count).
 * @return the unsigned advance from the run start to the given offset.
 */
static float getRunAdvance(const float* advances, const uint16_t* buf, size_t layoutStart,
                           size_t start, size_t count, size_t offset) {
    float advance = 0.0f;
    size_t lastCluster = start;
    float clusterWidth = 0.0f;
    for (size_t i = start; i < offset; i++) {
        float charAdvance = advances[i - layoutStart];
        if (charAdvance != 0.0f) {
            advance += charAdvance;
            lastCluster = i;
            clusterWidth = charAdvance;
        }
    }
    if (offset < start + count && !isAsciiOrBidiControlCharacter(buf[offset]) &&
        advances[offset - layoutStart] == 0.0f) {
        // In the middle of a cluster, distribute width of cluster so that each grapheme cluster
        // gets an equal share.
        // TODO: get caret information out of font when that's available
        size_t nextCluster;
        for (nextCluster = offset + 1; nextCluster < start + count; nextCluster++) {
            if (advances[nextCluster - layoutStart] != 0.0f ||
                isAsciiOrBidiControlCharacter(buf[nextCluster])) {
                break;
            }
        }
        int numGraphemeClusters = 0;
        int numGraphemeClustersAfter = 0;
        for (size_t i = lastCluster; i < nextCluster; i++) {
            bool isAfter = i >= offset;
            if (GraphemeBreak::isGraphemeBreak(advances + (start - layoutStart), buf, start, count,
                                               i)) {
                numGraphemeClusters++;
                if (isAfter) {
                    numGraphemeClustersAfter++;
                }
            }
        }
        if (numGraphemeClusters > 0) {
            advance -= clusterWidth * numGraphemeClustersAfter / numGraphemeClusters;
        }
    }
    return advance;
}

/**
 * Helper method that distribute the advance to ligature characters.
 * When ligature is applied, the first character in the ligature is assigned with the entire width.
 * This method will evenly distribute the advance to each grapheme in the ligature.
 *
 * @param advances the computed advances of the characters in buf. The advance of
 * the i-th character in buf is stored at index (i - start) in this array. This
 * method will update this array so that advances is distributed evenly for
 * ligature characters.
 * @param buf the text stored in utf-16 format.
 * @param start the start index of the run.
 * @param count the number of the characters in this run.
 */
void distributeAdvances(float* advances, const uint16_t* buf, size_t start, size_t count) {
    size_t clusterStart = start;
    while (clusterStart < start + count) {
        float clusterAdvance = advances[clusterStart - start];
        size_t clusterEnd;
        for (clusterEnd = clusterStart + 1; clusterEnd < start + count; clusterEnd++) {
            if (advances[clusterEnd - start] != 0.0f ||
                isAsciiOrBidiControlCharacter(buf[clusterEnd])) {
                break;
            }
        }
        size_t numGraphemeClusters = 0;
        for (size_t i = clusterStart; i < clusterEnd; i++) {
            if (GraphemeBreak::isGraphemeBreak(advances, buf, start, count, i)) {
                numGraphemeClusters++;
            }
        }
        // When there are more than one grapheme in this cluster, ligature is applied.
        // And we will distribute the width to each grapheme.
        if (numGraphemeClusters > 1) {
            for (size_t i = clusterStart; i < clusterEnd; ++i) {
                if (GraphemeBreak::isGraphemeBreak(advances, buf, start, count, i)) {
                    // Only distribute the advance to the first character of the cluster.
                    advances[i - start] = clusterAdvance / numGraphemeClusters;
                }
            }
        }
        clusterStart = clusterEnd;
    }
}

float getRunAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count,
                    size_t offset) {
    return getRunAdvance(advances, buf, start, start, count, offset);
}

/**
 * Essentially the inverse of getRunAdvance. Compute the value of offset for which the
 * measured caret comes closest to the provided advance param, and which is on a grapheme
 * cluster boundary.
 *
 * The actual implementation fast-forwards through clusters to get "close", then does a finer-grain
 * search within the cluster and grapheme breaks.
 */
size_t getOffsetForAdvance(const float* advances, const uint16_t* buf, size_t start, size_t count,
                           float advance) {
    float x = 0.0f, xLastClusterStart = 0.0f, xSearchStart = 0.0f;
    size_t lastClusterStart = start, searchStart = start;
    size_t max = start + count;
    for (size_t i = start; i < max; i++) {
        if (GraphemeBreak::isGraphemeBreak(advances, buf, start, count, i)) {
            searchStart = lastClusterStart;
            xSearchStart = xLastClusterStart;
        }
        float width = advances[i - start];
        if (width != 0.0f) {
            lastClusterStart = i;
            xLastClusterStart = x;
            x += width;
            if (x > advance) {
                break;
            }
        }
    }
    size_t best = searchStart;
    float bestDist = FLT_MAX;
    for (size_t i = searchStart; i <= max; i++) {
        if (GraphemeBreak::isGraphemeBreak(advances, buf, start, count, i)) {
            // "getRunAdvance(layout, buf, start, count, i) - advance" but more efficient
            float delta = getRunAdvance(advances, buf, start, searchStart, max - searchStart, i)

                          + xSearchStart - advance;
            if (std::abs(delta) < bestDist) {
                bestDist = std::abs(delta);
                best = i;
            }
            if (delta >= 0.0f) {
                break;
            }
        }
    }
    return best;
}

struct BoundsComposer {
    BoundsComposer() : mAdvance(0) {}

    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint& /* paint */,
                    const MinikinRect& bounds) {
        if (layoutPiece.isVerticalText()) {
            mBounds.join(bounds, 0, mAdvance);
        } else {
            mBounds.join(bounds, mAdvance, 0);
        }
        mAdvance += layoutPiece.advance();
    }

    float mAdvance;
    MinikinRect mBounds;
};

void getBounds(const U16StringPiece& str, const Range& range, Bidi bidiFlag,
               const MinikinPaint& paint, StartHyphenEdit startHyphen, EndHyphenEdit endHyphen,
               MinikinRect* out) {
    BoundsComposer bc;
    for (const BidiText::RunInfo info : BidiText(str, range, bidiFlag)) {
        for (const auto [context, piece] : LayoutSplitter(str, info.range, info.isRtl)) {
            const StartHyphenEdit pieceStartHyphen =
                    (piece.getStart() == range.getStart()) ? startHyphen : StartHyphenEdit::NO_EDIT;
            const EndHyphenEdit pieceEndHyphen =
                    (piece.getEnd() == range.getEnd()) ? endHyphen : EndHyphenEdit::NO_EDIT;
            LayoutCache::getInstance().getOrCreate(
                    str.substr(context), piece - context.getStart(), paint, info.isRtl,
                    pieceStartHyphen, pieceEndHyphen, true /* bounds calculation */, bc);
            // Increment word spacing for spacer
            if (piece.getLength() == 1 && isWordSpace(str[piece.getStart()])) {
                bc.mAdvance += paint.wordSpacing;
            }
        }
    }
    *out = bc.mBounds;
}

struct ExtentComposer {
    ExtentComposer() {}

    void operator()(const LayoutPiece& layoutPiece, const MinikinPaint&, const MinikinRect&) {
        extent.extendBy(layoutPiece.extent());
    }

    MinikinExtent extent;
};

MinikinExtent getFontExtent(const U16StringPiece& textBuf, const Range& range, Bidi bidiFlag,
                            const MinikinPaint& paint) {
    ExtentComposer composer;
    for (const BidiText::RunInfo info : BidiText(textBuf, range, bidiFlag)) {
        for (const auto [context, piece] : LayoutSplitter(textBuf, info.range, info.isRtl)) {
            LayoutCache::getInstance().getOrCreate(textBuf.substr(context),
                                                   piece - context.getStart(), paint, info.isRtl,
                                                   StartHyphenEdit::NO_EDIT, EndHyphenEdit::NO_EDIT,
                                                   false /* bounds calculation */, composer);
        }
    }
    return composer.extent;
}

}  // namespace minikin