/*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "Sk4fGradientBase.h"

#include <functional>

namespace {

Sk4f pack_color(SkColor c, bool premul, const Sk4f& component_scale) {
    const SkColor4f c4f = SkColor4f::FromColor(c);
    const Sk4f pm4f = premul
        ? c4f.premul().to4f()
        : Sk4f{c4f.fR, c4f.fG, c4f.fB, c4f.fA};

    return pm4f * component_scale;
}

class IntervalIterator {
public:
    IntervalIterator(const SkColor* colors, const SkScalar* pos, int count, bool reverse)
        : fColors(colors)
        , fPos(pos)
        , fCount(count)
        , fFirstPos(reverse ? SK_Scalar1 : 0)
        , fBegin(reverse ? count - 1 : 0)
        , fAdvance(reverse ? -1 : 1) {
        SkASSERT(colors);
        SkASSERT(count > 0);
    }

    void iterate(std::function<void(SkColor, SkColor, SkScalar, SkScalar)> func) const {
        if (!fPos) {
            this->iterateImplicitPos(func);
            return;
        }

        const int end = fBegin + fAdvance * (fCount - 1);
        const SkScalar lastPos = 1 - fFirstPos;
        int prev = fBegin;
        SkScalar prevPos = fFirstPos;

        do {
            const int curr = prev + fAdvance;
            SkASSERT(curr >= 0 && curr < fCount);

            // TODO: this sanitization should be done in SkGradientShaderBase
            const SkScalar currPos = (fAdvance > 0)
                ? SkTPin(fPos[curr], prevPos, lastPos)
                : SkTPin(fPos[curr], lastPos, prevPos);

            if (currPos != prevPos) {
                SkASSERT((currPos - prevPos > 0) == (fAdvance > 0));
                func(fColors[prev], fColors[curr], prevPos, currPos);
            }

            prev = curr;
            prevPos = currPos;
        } while (prev != end);
    }

private:
    void iterateImplicitPos(std::function<void(SkColor, SkColor, SkScalar, SkScalar)> func) const {
        // When clients don't provide explicit color stop positions (fPos == nullptr),
        // the color stops are distributed evenly across the unit interval
        // (implicit positioning).
        const SkScalar dt = fAdvance * SK_Scalar1 / (fCount - 1);
        const int end = fBegin + fAdvance * (fCount - 2);
        int prev = fBegin;
        SkScalar prevPos = fFirstPos;

        while (prev != end) {
            const int curr = prev + fAdvance;
            SkASSERT(curr >= 0 && curr < fCount);

            const SkScalar currPos = prevPos + dt;
            func(fColors[prev], fColors[curr], prevPos, currPos);
            prev = curr;
            prevPos = currPos;
        }

        // emit the last interval with a pinned end position, to avoid precision issues
        func(fColors[prev], fColors[prev + fAdvance], prevPos, 1 - fFirstPos);
    }

    const SkColor*  fColors;
    const SkScalar* fPos;
    const int       fCount;
    const SkScalar  fFirstPos;
    const int       fBegin;
    const int       fAdvance;
};

} // anonymous namespace

SkGradientShaderBase::GradientShaderBase4fContext::
Interval::Interval(const Sk4f& c0, SkScalar p0,
                   const Sk4f& c1, SkScalar p1)
    : fP0(p0)
    , fP1(p1)
    , fZeroRamp((c0 == c1).allTrue()) {
    SkASSERT(p0 != p1);
    // Either p0 or p1 can be (-)inf for synthetic clamp edge intervals.
    SkASSERT(SkScalarIsFinite(p0) || SkScalarIsFinite(p1));

    const auto dp = p1 - p0;

    // Clamp edge intervals are always zero-ramp.
    SkASSERT(SkScalarIsFinite(dp) || fZeroRamp);
    const Sk4f dc = SkScalarIsFinite(dp) ? (c1 - c0) / dp : 0;

    c0.store(&fC0.fVec);
    dc.store(&fDc.fVec);
}

SkGradientShaderBase::
GradientShaderBase4fContext::GradientShaderBase4fContext(const SkGradientShaderBase& shader,
                                                         const ContextRec& rec)
    : INHERITED(shader, rec)
    , fFlags(this->INHERITED::getFlags())
#ifdef SK_SUPPORT_LEGACY_GRADIENT_DITHERING
    , fDither(true)
#else
    , fDither(rec.fPaint->isDither())
#endif
{
    const SkMatrix& inverse = this->getTotalInverse();
    fDstToPos.setConcat(shader.fPtsToUnit, inverse);
    fDstToPosProc = fDstToPos.getMapXYProc();
    fDstToPosClass = static_cast<uint8_t>(INHERITED::ComputeMatrixClass(fDstToPos));

    if (shader.fColorsAreOpaque && this->getPaintAlpha() == SK_AlphaOPAQUE) {
        fFlags |= kOpaqueAlpha_Flag;
    }

    fColorsArePremul =
        (shader.fGradFlags & SkGradientShader::kInterpolateColorsInPremul_Flag)
        || shader.fColorsAreOpaque;
}

bool SkGradientShaderBase::
GradientShaderBase4fContext::isValid() const {
    return fDstToPos.isFinite();
}

void SkGradientShaderBase::
GradientShaderBase4fContext::buildIntervals(const SkGradientShaderBase& shader,
                                            const ContextRec& rec, bool reverse) {
    // The main job here is to build a specialized interval list: a different
    // representation of the color stops data, optimized for efficient scan line
    // access during shading.
    //
    //   [{P0,C0} , {P1,C1}) [{P1,C2} , {P2,c3}) ... [{Pn,C2n} , {Pn+1,C2n+1})
    //
    // The list may be inverted when requested (such that e.g. points are sorted
    // in increasing x order when dx < 0).
    //
    // Note: the current representation duplicates pos data; we could refactor to
    //       avoid this if interval storage size becomes a concern.
    //
    // Aside from reordering, we also perform two more pre-processing steps at
    // this stage:
    //
    //   1) scale the color components depending on paint alpha and the requested
    //      interpolation space (note: the interval color storage is SkPM4f, but
    //      that doesn't necessarily mean the colors are premultiplied; that
    //      property is tracked in fColorsArePremul)
    //
    //   2) inject synthetic intervals to support tiling.
    //
    //      * for kRepeat, no extra intervals are needed - the iterator just
    //        wraps around at the end:
    //
    //          ->[P0,P1)->..[Pn-1,Pn)->
    //
    //      * for kClamp, we add two "infinite" intervals before/after:
    //
    //          [-/+inf , P0)->[P0 , P1)->..[Pn-1 , Pn)->[Pn , +/-inf)
    //
    //        (the iterator should never run off the end in this mode)
    //
    //      * for kMirror, we extend the range to [0..2] and add a flipped
    //        interval series - then the iterator operates just as in the
    //        kRepeat case:
    //
    //          ->[P0,P1)->..[Pn-1,Pn)->[2 - Pn,2 - Pn-1)->..[2 - P1,2 - P0)->
    //
    // TODO: investigate collapsing intervals << 1px.

    SkASSERT(shader.fColorCount > 0);
    SkASSERT(shader.fOrigColors);

    const float paintAlpha = rec.fPaint->getAlpha() * (1.0f / 255);
    const Sk4f componentScale = fColorsArePremul
        ? Sk4f(paintAlpha)
        : Sk4f(1.0f, 1.0f, 1.0f, paintAlpha);
    const int first_index = reverse ? shader.fColorCount - 1 : 0;
    const int last_index = shader.fColorCount - 1 - first_index;
    const SkScalar first_pos = reverse ? SK_Scalar1 : 0;
    const SkScalar last_pos = SK_Scalar1 - first_pos;

    if (shader.fTileMode == SkShader::kClamp_TileMode) {
        // synthetic edge interval: -/+inf .. P0
        const Sk4f clamp_color = pack_color(shader.fOrigColors[first_index],
                                            fColorsArePremul, componentScale);
        const SkScalar clamp_pos = reverse ? SK_ScalarInfinity : SK_ScalarNegativeInfinity;
        fIntervals.emplace_back(clamp_color, clamp_pos,
                                clamp_color, first_pos);
    } else if (shader.fTileMode == SkShader::kMirror_TileMode && reverse) {
        // synthetic mirror intervals injected before main intervals: (2 .. 1]
        addMirrorIntervals(shader, componentScale, false);
    }

    const IntervalIterator iter(shader.fOrigColors,
                                shader.fOrigPos,
                                shader.fColorCount,
                                reverse);
    iter.iterate([this, &componentScale] (SkColor c0, SkColor c1, SkScalar p0, SkScalar p1) {
        SkASSERT(fIntervals.empty() || fIntervals.back().fP1 == p0);

        fIntervals.emplace_back(pack_color(c0, fColorsArePremul, componentScale),
                                p0,
                                pack_color(c1, fColorsArePremul, componentScale),
                                p1);
    });

    if (shader.fTileMode == SkShader::kClamp_TileMode) {
        // synthetic edge interval: Pn .. +/-inf
        const Sk4f clamp_color = pack_color(shader.fOrigColors[last_index],
                                            fColorsArePremul, componentScale);
        const SkScalar clamp_pos = reverse ? SK_ScalarNegativeInfinity : SK_ScalarInfinity;
        fIntervals.emplace_back(clamp_color, last_pos,
                                clamp_color, clamp_pos);
    } else if (shader.fTileMode == SkShader::kMirror_TileMode && !reverse) {
        // synthetic mirror intervals injected after main intervals: [1 .. 2)
        addMirrorIntervals(shader, componentScale, true);
    }
}

void SkGradientShaderBase::
GradientShaderBase4fContext::addMirrorIntervals(const SkGradientShaderBase& shader,
                                            const Sk4f& componentScale, bool reverse) {
    const IntervalIterator iter(shader.fOrigColors,
                                shader.fOrigPos,
                                shader.fColorCount,
                                reverse);
    iter.iterate([this, &componentScale] (SkColor c0, SkColor c1, SkScalar p0, SkScalar p1) {
        SkASSERT(fIntervals.empty() || fIntervals.back().fP1 == 2 - p0);

        const auto mirror_p0 = 2 - p0;
        const auto mirror_p1 = 2 - p1;
        // mirror_p1 & mirror_p1 may collapse for very small values - recheck to avoid
        // triggering Interval asserts.
        if (mirror_p0 != mirror_p1) {
            fIntervals.emplace_back(pack_color(c0, fColorsArePremul, componentScale),
                                    mirror_p0,
                                    pack_color(c1, fColorsArePremul, componentScale),
                                    mirror_p1);
        }
    });
}

void SkGradientShaderBase::
GradientShaderBase4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) {
    if (fColorsArePremul) {
        this->shadePremulSpan<DstType::L32, ApplyPremul::False>(x, y, dst, count);
    } else {
        this->shadePremulSpan<DstType::L32, ApplyPremul::True>(x, y, dst, count);
    }
}

void SkGradientShaderBase::
GradientShaderBase4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
    if (fColorsArePremul) {
        this->shadePremulSpan<DstType::F32, ApplyPremul::False>(x, y, dst, count);
    } else {
        this->shadePremulSpan<DstType::F32, ApplyPremul::True>(x, y, dst, count);
    }
}

template<DstType dstType, ApplyPremul premul>
void SkGradientShaderBase::
GradientShaderBase4fContext::shadePremulSpan(int x, int y,
                                             typename DstTraits<dstType, premul>::Type dst[],
                                             int count) const {
    const SkGradientShaderBase& shader =
        static_cast<const SkGradientShaderBase&>(fShader);

    switch (shader.fTileMode) {
    case kClamp_TileMode:
        this->shadeSpanInternal<dstType,
                                premul,
                                kClamp_TileMode>(x, y, dst, count);
        break;
    case kRepeat_TileMode:
        this->shadeSpanInternal<dstType,
                                premul,
                                kRepeat_TileMode>(x, y, dst, count);
        break;
    case kMirror_TileMode:
        this->shadeSpanInternal<dstType,
                                premul,
                                kMirror_TileMode>(x, y, dst, count);
        break;
    }
}

template<DstType dstType, ApplyPremul premul, SkShader::TileMode tileMode>
void SkGradientShaderBase::
GradientShaderBase4fContext::shadeSpanInternal(int x, int y,
                                               typename DstTraits<dstType, premul>::Type dst[],
                                               int count) const {
    static const int kBufSize = 128;
    SkScalar ts[kBufSize];
    TSampler<dstType, premul, tileMode> sampler(*this);

    SkASSERT(count > 0);
    do {
        const int n = SkTMin(kBufSize, count);
        this->mapTs(x, y, ts, n);
        for (int i = 0; i < n; ++i) {
            const Sk4f c = sampler.sample(ts[i]);
            DstTraits<dstType, premul>::store(c, dst++);
        }
        x += n;
        count -= n;
    } while (count > 0);
}

template<DstType dstType, ApplyPremul premul, SkShader::TileMode tileMode>
class SkGradientShaderBase::GradientShaderBase4fContext::TSampler {
public:
    TSampler(const GradientShaderBase4fContext& ctx)
        : fFirstInterval(ctx.fIntervals.begin())
        , fLastInterval(ctx.fIntervals.end() - 1)
        , fInterval(nullptr) {
        SkASSERT(fLastInterval >= fFirstInterval);
        switch (tileMode) {
        case kClamp_TileMode:
            fLargestIntervalValue = SK_ScalarInfinity;
            break;
        case kRepeat_TileMode:
            fLargestIntervalValue = nextafterf(1, 0);
            break;
        case kMirror_TileMode:
            fLargestIntervalValue = nextafterf(2.0f, 0);
            break;
        }
    }

    Sk4f sample(SkScalar t) {
        const auto tiled_t = tileProc(t);

        if (!fInterval) {
            // Very first sample => locate the initial interval.
            // TODO: maybe do this in ctor to remove a branch?
            fInterval = this->findFirstInterval(tiled_t);
            this->loadIntervalData(fInterval);
        } else if (tiled_t < fInterval->fP0 || tiled_t >= fInterval->fP1) {
            fInterval = this->findNextInterval(t, tiled_t);
            this->loadIntervalData(fInterval);
        }

        fPrevT = t;
        return lerp(tiled_t);
    }

private:
    SkScalar tileProc(SkScalar t) const {
        switch (tileMode) {
        case kClamp_TileMode:
            // synthetic clamp-mode edge intervals allow for a free-floating t:
            //   [-inf..0)[0..1)[1..+inf)
            return t;
        case kRepeat_TileMode:
            // t % 1  (intervals range: [0..1))
            // Due to the extra arithmetic, we must clamp to ensure the value remains less than 1.
            return SkTMin(t - SkScalarFloorToScalar(t), fLargestIntervalValue);
        case kMirror_TileMode:
            // t % 2  (synthetic mirror intervals expand the range to [0..2)
            // Due to the extra arithmetic, we must clamp to ensure the value remains less than 2.
            return SkTMin(t - SkScalarFloorToScalar(t / 2) * 2, fLargestIntervalValue);
        }

        SK_ABORT("Unhandled tile mode.");
        return 0;
    }

    Sk4f lerp(SkScalar t) {
        SkASSERT(t >= fInterval->fP0 && t < fInterval->fP1);
        return fCc + fDc * (t - fInterval->fP0);
    }

    const Interval* findFirstInterval(SkScalar t) const {
        // Binary search.
        const Interval* i0 = fFirstInterval;
        const Interval* i1 = fLastInterval;

        while (i0 != i1) {
            SkASSERT(i0 < i1);
            SkASSERT(t >= i0->fP0 && t < i1->fP1);

            const Interval* i = i0 + ((i1 - i0) >> 1);

            if (t >= i->fP1) {
                i0 = i + 1;
            } else {
                i1 = i;
            }
        }

        SkASSERT(t >= i0->fP0 && t <= i0->fP1);
        return i0;
    }

    const Interval* findNextInterval(SkScalar t, SkScalar tiled_t) const {
        SkASSERT(tiled_t < fInterval->fP0 || tiled_t >= fInterval->fP1);
        SkASSERT(tiled_t >= fFirstInterval->fP0 && tiled_t < fLastInterval->fP1);

        const Interval* i = fInterval;

        // Use the t vs. prev_t signal to figure which direction we should search for
        // the next interval, then perform a linear search.
        if (t >= fPrevT) {
            do {
                i += 1;
                if (i > fLastInterval) {
                    i = fFirstInterval;
                }
            } while (tiled_t < i->fP0 || tiled_t >= i->fP1);
        } else {
            do {
                i -= 1;
                if (i < fFirstInterval) {
                    i = fLastInterval;
                }
            } while (tiled_t < i->fP0 || tiled_t >= i->fP1);
        }

        return i;
    }

    void loadIntervalData(const Interval* i) {
        fCc = DstTraits<dstType, premul>::load(i->fC0);
        fDc = DstTraits<dstType, premul>::load(i->fDc);
    }

    const Interval* fFirstInterval;
    const Interval* fLastInterval;
    const Interval* fInterval;
    SkScalar        fPrevT;
    SkScalar        fLargestIntervalValue;
    Sk4f            fCc;
    Sk4f            fDc;
};