/*
 * Copyright 2013 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/effects/SkImageFilters.h"

#include "include/core/SkBlendMode.h"
#include "include/core/SkBlender.h"
#include "include/core/SkColor.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkM44.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkShader.h"
#include "include/core/SkTypes.h"
#include "include/effects/SkBlenders.h"
#include "include/private/base/SkSpan_impl.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkImageFilterTypes.h"
#include "src/core/SkImageFilter_Base.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkRectPriv.h"
#include "src/core/SkWriteBuffer.h"

#include <cstdint>
#include <optional>
#include <utility>

namespace {

class SkBlendImageFilter : public SkImageFilter_Base {
    // Input image filter indices
    static constexpr int kBackground = 0;
    static constexpr int kForeground = 1;

public:
    SkBlendImageFilter(sk_sp<SkBlender> blender,
                       const std::optional<SkV4>& coefficients,
                       bool enforcePremul,
                       sk_sp<SkImageFilter> inputs[2])
            : SkImageFilter_Base(inputs, 2)
            , fBlender(std::move(blender))
            , fArithmeticCoefficients(coefficients)
            , fEnforcePremul(enforcePremul) {
        // A null blender represents src-over, which should have been filled in by the factory
        SkASSERT(fBlender);
    }

    SkRect computeFastBounds(const SkRect& bounds) const override;

protected:
    void flatten(SkWriteBuffer&) const override;

private:
    static constexpr uint32_t kArithmetic_SkBlendMode = kCustom_SkBlendMode + 1;

    friend void ::SkRegisterBlendImageFilterFlattenable();
    SK_FLATTENABLE_HOOKS(SkBlendImageFilter)
    static sk_sp<SkFlattenable> LegacyArithmeticCreateProc(SkReadBuffer& buffer);

    MatrixCapability onGetCTMCapability() const override { return MatrixCapability::kComplex; }

    bool onAffectsTransparentBlack() const override {
        // An arbitrary runtime blender or an arithmetic runtime blender with k3 != 0 affects
        // transparent black.
        return !as_BB(fBlender)->asBlendMode().has_value() &&
               (!fArithmeticCoefficients.has_value() || (*fArithmeticCoefficients)[3] != 0.f);
    }

    skif::FilterResult onFilterImage(const skif::Context&) const override;

    skif::LayerSpace<SkIRect> onGetInputLayerBounds(
            const skif::Mapping& mapping,
            const skif::LayerSpace<SkIRect>& desiredOutput,
            std::optional<skif::LayerSpace<SkIRect>> contentBounds) const override;

    std::optional<skif::LayerSpace<SkIRect>> onGetOutputLayerBounds(
            const skif::Mapping& mapping,
            std::optional<skif::LayerSpace<SkIRect>> contentBounds) const override;

    sk_sp<SkShader> makeBlendShader(sk_sp<SkShader> bg, sk_sp<SkShader> fg) const;

    sk_sp<SkBlender> fBlender;

    // Normally runtime SkBlenders are pessimistic about the bounds they affect. For Arithmetic,
    // we remember the coefficients so that bounds can be reasoned about.
    std::optional<SkV4> fArithmeticCoefficients;
    bool fEnforcePremul; // Remembered to serialize the Arithmetic variant correctly
};

sk_sp<SkImageFilter> make_blend(sk_sp<SkBlender> blender,
                                sk_sp<SkImageFilter> background,
                                sk_sp<SkImageFilter> foreground,
                                const SkImageFilters::CropRect& cropRect,
                                std::optional<SkV4> coefficients = {},
                                bool enforcePremul = false) {
    if (!blender) {
        blender = SkBlender::Mode(SkBlendMode::kSrcOver);
    }

    auto cropped = [cropRect](sk_sp<SkImageFilter> filter) {
        if (cropRect) {
            filter = SkImageFilters::Crop(*cropRect, std::move(filter));
        }
        return filter;
    };

    if (auto bm = as_BB(blender)->asBlendMode()) {
        if (bm == SkBlendMode::kSrc) {
            return cropped(std::move(foreground));
        } else if (bm == SkBlendMode::kDst) {
            return cropped(std::move(background));
        } else if (bm == SkBlendMode::kClear) {
            return SkImageFilters::Empty();
        }
    }

    sk_sp<SkImageFilter> inputs[2] = { std::move(background), std::move(foreground) };
    sk_sp<SkImageFilter> filter{new SkBlendImageFilter(blender, coefficients,
                                                       enforcePremul, inputs)};
    return cropped(std::move(filter));
}

} // anonymous namespace

sk_sp<SkImageFilter> SkImageFilters::Blend(SkBlendMode mode,
                                           sk_sp<SkImageFilter> background,
                                           sk_sp<SkImageFilter> foreground,
                                           const CropRect& cropRect) {
    return make_blend(SkBlender::Mode(mode),
                      std::move(background),
                      std::move(foreground),
                      cropRect);
}

sk_sp<SkImageFilter> SkImageFilters::Blend(sk_sp<SkBlender> blender,
                                           sk_sp<SkImageFilter> background,
                                           sk_sp<SkImageFilter> foreground,
                                           const CropRect& cropRect) {
    return make_blend(std::move(blender), std::move(background), std::move(foreground), cropRect);
}

sk_sp<SkImageFilter> SkImageFilters::Arithmetic(SkScalar k1,
                                                SkScalar k2,
                                                SkScalar k3,
                                                SkScalar k4,
                                                bool enforcePMColor,
                                                sk_sp<SkImageFilter> background,
                                                sk_sp<SkImageFilter> foreground,
                                                const CropRect& cropRect) {
    auto blender = SkBlenders::Arithmetic(k1, k2, k3, k4, enforcePMColor);
    if (!blender) {
        // Arithmetic() returns null on an error, not to optimize src-over
        return nullptr;
    }
    return make_blend(std::move(blender),
                      std::move(background),
                      std::move(foreground),
                      cropRect,
                      // Carry arithmetic coefficients and premul behavior into image filter for
                      // serialization and bounds analysis
                      SkV4{k1, k2, k3, k4},
                      enforcePMColor);
}

void SkRegisterBlendImageFilterFlattenable() {
    SK_REGISTER_FLATTENABLE(SkBlendImageFilter);
    // TODO (michaelludwig) - Remove after grace period for SKPs to stop using old name
    SkFlattenable::Register("SkXfermodeImageFilter_Base", SkBlendImageFilter::CreateProc);
    SkFlattenable::Register("SkXfermodeImageFilterImpl", SkBlendImageFilter::CreateProc);
    SkFlattenable::Register("ArithmeticImageFilterImpl",
                            SkBlendImageFilter::LegacyArithmeticCreateProc);
    SkFlattenable::Register("SkArithmeticImageFilter",
                            SkBlendImageFilter::LegacyArithmeticCreateProc);
}

sk_sp<SkFlattenable> SkBlendImageFilter::LegacyArithmeticCreateProc(SkReadBuffer& buffer) {
    // Newer SKPs should be using the updated Blend CreateProc.
    if (!buffer.validate(buffer.isVersionLT(SkPicturePriv::kCombineBlendArithmeticFilters))) {
        SkASSERT(false); // debug-only, so release will just see a failed deserialization
        return nullptr;
    }

    SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);
    float k[4];
    for (int i = 0; i < 4; ++i) {
        k[i] = buffer.readScalar();
    }
    const bool enforcePremul = buffer.readBool();
    return SkImageFilters::Arithmetic(k[0], k[1], k[2], k[3], enforcePremul,
                                      common.getInput(0), common.getInput(1), common.cropRect());
}

sk_sp<SkFlattenable> SkBlendImageFilter::CreateProc(SkReadBuffer& buffer) {
    SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 2);

    sk_sp<SkBlender> blender;
    std::optional<SkV4> coefficients;
    bool enforcePremul = false;

    const uint32_t mode = buffer.read32();
    if (mode == kArithmetic_SkBlendMode) {
        // Should only see this sentinel value in newer SKPs
        if (buffer.validate(!buffer.isVersionLT(SkPicturePriv::kCombineBlendArithmeticFilters))) {
            SkV4 k;
            for (int i = 0; i < 4; ++i) {
                k[i] = buffer.readScalar();
            }
            coefficients = k;
            enforcePremul = buffer.readBool();
            blender = SkBlenders::Arithmetic(k.x, k.y, k.z, k.w, enforcePremul);
            if (!buffer.validate(SkToBool(blender))) {
                return nullptr; // A null arithmetic blender is an error condition
            }
        }
    } else if (mode == kCustom_SkBlendMode) {
        blender = buffer.readBlender();
    } else {
        if (!buffer.validate(mode <= (unsigned) SkBlendMode::kLastMode)) {
            return nullptr;
        }
        blender = SkBlender::Mode((SkBlendMode)mode);
    }

    return make_blend(std::move(blender),
                      common.getInput(kBackground),
                      common.getInput(kForeground),
                      common.cropRect(),
                      coefficients,
                      enforcePremul);
}

void SkBlendImageFilter::flatten(SkWriteBuffer& buffer) const {
    this->SkImageFilter_Base::flatten(buffer);
    if (fArithmeticCoefficients.has_value()) {
        buffer.write32(kArithmetic_SkBlendMode);

        const SkV4& k = *fArithmeticCoefficients;
        buffer.writeScalar(k[0]);
        buffer.writeScalar(k[1]);
        buffer.writeScalar(k[2]);
        buffer.writeScalar(k[3]);
        buffer.writeBool(fEnforcePremul);
    } else if (auto bm = as_BB(fBlender)->asBlendMode()) {
        buffer.write32((unsigned)bm.value());
    } else {
        buffer.write32(kCustom_SkBlendMode);
        buffer.writeFlattenable(fBlender.get());
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////

sk_sp<SkShader> SkBlendImageFilter::makeBlendShader(sk_sp<SkShader> bg, sk_sp<SkShader> fg) const {
    // A null input shader signifies transparent black when image filtering, but SkShaders::Blend
    // expects non-null shaders. So we have to do some clean up.
    if (!bg || !fg) {
        // If we don't affect transparent black and both inputs are null, then return a null
        // shader to skip any evaluation.
        if (!this->onAffectsTransparentBlack() && !bg && !fg) {
            return nullptr;
        }
        // Otherwise if only one input is null, we might be able to just return that one.
        if (auto bm = as_BB(fBlender)->asBlendMode()) {
            SkBlendModeCoeff src, dst;
            if (SkBlendMode_AsCoeff(*bm, &src, &dst)) {
                if (bg && (dst == SkBlendModeCoeff::kOne ||
                           dst == SkBlendModeCoeff::kISA ||
                           dst == SkBlendModeCoeff::kISC)) {
                    return bg;
                }
                if (fg && (src == SkBlendModeCoeff::kOne ||
                           src == SkBlendModeCoeff::kIDA)) {
                    return fg;
                }
            }
        }
        // If we made it this far, the blend has non-trivial behavior even when one of the
        // inputs is transparent black, so replace the null shaders with that color.
        if (!bg) { bg = SkShaders::Color(SK_ColorTRANSPARENT); }
        if (!fg) { fg = SkShaders::Color(SK_ColorTRANSPARENT); }
    }

    return SkShaders::Blend(fBlender, std::move(bg), std::move(fg));
}

skif::FilterResult SkBlendImageFilter::onFilterImage(const skif::Context& ctx) const {
    // We could just request 'desiredOutput' for the blend's required input size, since that's what
    // it is expected to fill. However, some blend modes restrict the output to something other
    // than the union of the foreground and background. To make this restriction available to both
    // children before evaluating them, we determine the maximum possible output the blend can
    // produce from the contentBounds and require that for both children to produce.
    auto requiredInput = this->onGetOutputLayerBounds(ctx.mapping(), ctx.source().layerBounds());
    if (requiredInput) {
        if (!requiredInput->intersect(ctx.desiredOutput())) {
            return {};
        }
    } else {
        requiredInput = ctx.desiredOutput();
    }

    skif::Context inputCtx = ctx.withNewDesiredOutput(*requiredInput);
    skif::FilterResult::Builder builder{ctx};
    builder.add(this->getChildOutput(kBackground, inputCtx));
    builder.add(this->getChildOutput(kForeground, inputCtx));
    return builder.eval(
            [&](SkSpan<sk_sp<SkShader>> inputs) -> sk_sp<SkShader> {
                return this->makeBlendShader(inputs[kBackground], inputs[kForeground]);
            }, requiredInput);
}

skif::LayerSpace<SkIRect> SkBlendImageFilter::onGetInputLayerBounds(
        const skif::Mapping& mapping,
        const skif::LayerSpace<SkIRect>& desiredOutput,
        std::optional<skif::LayerSpace<SkIRect>> contentBounds) const {

    skif::LayerSpace<SkIRect> requiredInput;
    std::optional<skif::LayerSpace<SkIRect>> maxOutput;
    if (contentBounds && (maxOutput = this->onGetOutputLayerBounds(mapping, *contentBounds))) {
        // See comment in onFilterImage().
        requiredInput = *maxOutput;
        if (!requiredInput.intersect(desiredOutput)) {
            // Don't bother recursing if we know the blend will discard everything
            return skif::LayerSpace<SkIRect>::Empty();
        }
    } else {
        // The content and/or the output of the child are unbounded so the intersection with the
        // desired output is simply the desired output.
        requiredInput = desiredOutput;
    }

    // Return the union of both FG and BG required inputs to ensure both have all necessary pixels
    skif::LayerSpace<SkIRect> bgInput =
            this->getChildInputLayerBounds(kBackground, mapping, requiredInput, contentBounds);
    skif::LayerSpace<SkIRect> fgInput =
            this->getChildInputLayerBounds(kForeground, mapping, requiredInput, contentBounds);

    bgInput.join(fgInput);
    return bgInput;
}

std::optional<skif::LayerSpace<SkIRect>> SkBlendImageFilter::onGetOutputLayerBounds(
        const skif::Mapping& mapping,
        std::optional<skif::LayerSpace<SkIRect>> contentBounds) const {
    // Blending is (k0*FG*BG +       k1*FG +       k2*BG + k3) for arithmetic blenders OR
    //             ( 0*FG*BG + srcCoeff*FG + dstCoeff*BG + 0 ) for Porter-Duff blend modes OR
    //              un-inspectable(FG, BG) for advanced blend modes and other runtime blenders.
    //
    // There are six possible output bounds that can be produced:
    //   1. No output: K = (0,0,0,0) or (srcCoeff,dstCoeff) = (kZero,kZero)
    //   2. intersect(FG,BG): K = (non-zero, 0,0,0) or (srcCoeff,dstCoeff) = (kZero|kDA, kZero|kSA)
    //   3. FG-only: K = (0, non-zero, 0,0) or (srcCoeff,dstCoeff) = (!kZero&!kDA, kZero|kSA)
    //   4. BG-only: K = (0,0, non-zero, 0) or (srcCoeff,dstCoeff) = (kZero|kDA, !kZero&!kSA)
    //   5. union(FG,BG): K = (*,*,*,0) or (srcCoeff,dstCoeff) = (!kZero&!kDA, !kZero&!kSA)
    //        or an advanced blend mode.
    //   6. infinite: K = (*,*,*, non-zero) or a runtime blender other than SkBlenders::Arithmetic.
    bool transparentOutsideFG = false;
    bool transparentOutsideBG = false;
    if (auto bm = as_BB(fBlender)->asBlendMode()) {
        SkASSERT(*bm != SkBlendMode::kClear); // Should have been caught at creation time
        SkBlendModeCoeff src, dst;
        if (SkBlendMode_AsCoeff(*bm, &src, &dst)) {
            // If dst's coefficient is 0 then nothing can produce non-transparent content outside
            // of the foreground. When dst coefficient is SA, it will always be 0 outside the FG.
            // For purposes of transparency analysis, SC == SA.
            transparentOutsideFG = dst == SkBlendModeCoeff::kZero || dst == SkBlendModeCoeff::kSA
                                                                  || dst == SkBlendModeCoeff::kSC;
            // And the reverse is true for src and the background content.
            transparentOutsideBG = src == SkBlendModeCoeff::kZero || src == SkBlendModeCoeff::kDA;
        }
        // NOTE: advanced blends use src-over for their alpha channel, which should produce the
        // union of FG and BG. That is the outcome if we leave transparentOutsideFG/BG false.
    } else if (fArithmeticCoefficients.has_value()) {
        [[maybe_unused]] static constexpr SkV4 kClearCoeff = {0.f, 0.f, 0.f, 0.f};
        const SkV4& k = *fArithmeticCoefficients;
        SkASSERT(k != kClearCoeff); // Should have been converted to an empty filter

        if (k[3] != 0.f) {
            // The arithmetic equation produces non-transparent black everywhere
            return skif::LayerSpace<SkIRect>::Unbounded();
        } else {
            // Given the earlier assert and if, then (k[1] == k[2] == 0) implies k[0] != 0. If only
            // one of k[1] or k[2] are non-zero then, regardless of k[0], then only that bounds
            // has non-transparent content.
            transparentOutsideFG = k[2] == 0.f;
            transparentOutsideBG = k[1] == 0.f;
        }
    } else {
        // A non-arithmetic runtime blender, so pessimistically assume it can return non-transparent
        // black anywhere.
        return skif::LayerSpace<SkIRect>::Unbounded();
    }

    auto foregroundBounds = this->getChildOutputLayerBounds(kForeground, mapping, contentBounds);
    auto backgroundBounds = this->getChildOutputLayerBounds(kBackground, mapping, contentBounds);
    if (transparentOutsideFG) {
        if (transparentOutsideBG) {
            // Output is the intersection of both
            if (!foregroundBounds && backgroundBounds) {
                foregroundBounds = *backgroundBounds;
            } else if (backgroundBounds && !foregroundBounds->intersect(*backgroundBounds)) {
                return skif::LayerSpace<SkIRect>::Empty();
            }
            // When both fore and background are infinite, foregroundBounds remains uninstantiated.
            // When only foreground is provided, it's left unmodified, which is the correct result.
        }
        return foregroundBounds;
    } else {
        if (!transparentOutsideBG) {
            // Output is the union of both (infinite blend-induced bounds were detected earlier).
            if (foregroundBounds && backgroundBounds) {
                backgroundBounds->join(*foregroundBounds);
            } else {
                // At least one of the union arguments is unbounded, so the union is infinite
                backgroundBounds.reset();
            }
        }
        return backgroundBounds;
    }
}

SkRect SkBlendImageFilter::computeFastBounds(const SkRect& bounds) const {
    // TODO: This is a prime example of why computeFastBounds() and onGetOutputLayerBounds() should
    // be combined into the same function.
    bool transparentOutsideFG = false;
    bool transparentOutsideBG = false;
    if (auto bm = as_BB(fBlender)->asBlendMode()) {
        SkASSERT(*bm != SkBlendMode::kClear); // Should have been caught at creation time
        SkBlendModeCoeff src, dst;
        if (SkBlendMode_AsCoeff(*bm, &src, &dst)) {
            // If dst's coefficient is 0 then nothing can produce non-transparent content outside
            // of the foreground. When dst coefficient is SA, it will always be 0 outside the FG.
            transparentOutsideFG = dst == SkBlendModeCoeff::kZero || dst == SkBlendModeCoeff::kSA;
            // And the reverse is true for src and the background content.
            transparentOutsideBG = src == SkBlendModeCoeff::kZero || src == SkBlendModeCoeff::kDA;
        }
    } else if (fArithmeticCoefficients.has_value()) {
        [[maybe_unused]] static constexpr SkV4 kClearCoeff = {0.f, 0.f, 0.f, 0.f};
        const SkV4& k = *fArithmeticCoefficients;
        SkASSERT(k != kClearCoeff); // Should have been converted to an empty image filter

        if (k[3] != 0.f) {
            // The arithmetic equation produces non-transparent black everywhere
            return SkRectPriv::MakeLargeS32();
        } else {
            // Given the earlier assert and if, then (k[1] == k[2] == 0) implies k[0] != 0. If only
            // one of k[1] or k[2] are non-zero then, regardless of k[0], then only that bounds
            // has non-transparent content.
            transparentOutsideFG = k[2] == 0.f;
            transparentOutsideBG = k[1] == 0.f;
        }
    } else {
        // A non-arithmetic runtime blender, so pessimistically assume it can return non-transparent
        // black anywhere.
        return SkRectPriv::MakeLargeS32();
    }

    SkRect foregroundBounds = this->getInput(kForeground) ?
            this->getInput(kForeground)->computeFastBounds(bounds) : bounds;
    SkRect backgroundBounds = this->getInput(kBackground) ?
            this->getInput(kBackground)->computeFastBounds(bounds) : bounds;
    if (transparentOutsideFG) {
        if (transparentOutsideBG) {
            // Output is the intersection of both
            if (!foregroundBounds.intersect(backgroundBounds)) {
                return SkRect::MakeEmpty();
            }
        }
        return foregroundBounds;
    } else {
        if (!transparentOutsideBG) {
            // Output is the union of both (infinite bounds were detected earlier).
            backgroundBounds.join(foregroundBounds);
        }
        return backgroundBounds;
    }
}