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

#include "tests/graphite/precompile/PaintParamsTestUtils.h"

#if defined(SK_GRAPHITE)

#include "include/core/SkBitmap.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkFont.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkPathBuilder.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkRRect.h"
#include "include/core/SkShader.h"
#include "include/core/SkYUVAPixmaps.h"
#include "include/effects/SkBlenders.h"
#include "include/effects/SkColorMatrix.h"
#include "include/effects/SkGradient.h"
#include "include/effects/SkHighContrastFilter.h"
#include "include/effects/SkImageFilters.h"
#include "include/effects/SkLumaColorFilter.h"
#include "include/effects/SkOverdrawColorFilter.h"
#include "include/effects/SkPerlinNoiseShader.h"
#include "include/effects/SkRuntimeEffect.h"
#include "include/gpu/graphite/Image.h"
#include "include/gpu/graphite/Recorder.h"
#include "include/gpu/graphite/precompile/Precompile.h"
#include "include/gpu/graphite/precompile/PrecompileBlender.h"
#include "include/gpu/graphite/precompile/PrecompileColorFilter.h"
#include "include/gpu/graphite/precompile/PrecompileImageFilter.h"
#include "include/gpu/graphite/precompile/PrecompileMaskFilter.h"
#include "include/gpu/graphite/precompile/PrecompileRuntimeEffect.h"
#include "include/gpu/graphite/precompile/PrecompileShader.h"
#include "src/core/SkBlenderBase.h"
#include "src/core/SkColorFilterPriv.h"
#include "src/gpu/graphite/PrecompileContextPriv.h"
#include "src/gpu/graphite/precompile/PrecompileColorFiltersPriv.h"
#include "src/gpu/graphite/precompile/PrecompileShadersPriv.h"
#include "src/shaders/SkImageShader.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/graphite/precompile/PrecompileEffectFactories.h"

using namespace skgpu::graphite;
using PrecompileShaders::GradientShaderFlags;
using PrecompileShaders::ImageShaderFlags;
using PrecompileShaders::YUVImageShaderFlags;

namespace skiatest::graphite {

//--------------------------------------------------------------------------------------------------
// String Converters
//--------------------------------------------------------------------------------------------------

const char* ToStr(ShaderType s) {
    switch (s) {
#define M(type)               \
    case ShaderType::k##type: \
        return "ShaderType::k" #type;
        SK_ALL_TEST_SHADERS(M)
#undef M
    }
    SkUNREACHABLE;
}

const char* ToStr(MaskFilterType mf) {
    switch (mf) {
#define M(type)                   \
    case MaskFilterType::k##type: \
        return "MaskFilterType::k" #type;
        SK_ALL_TEST_MASKFILTERS(M)
#undef M
    }
    SkUNREACHABLE;
}

const char* ToStr(BlenderType b) {
    switch (b) {
#define M(type)                \
    case BlenderType::k##type: \
        return "BlenderType::k" #type;
        SK_ALL_TEST_BLENDERS(M)
#undef M
    }
    SkUNREACHABLE;
}

const char* ToStr(ColorFilterType cf) {
    switch (cf) {
#define M(type)                    \
    case ColorFilterType::k##type: \
        return "ColorFilterType::k" #type;
        SK_ALL_TEST_COLORFILTERS(M)
#undef M
    }
    SkUNREACHABLE;
}

const char* ToStr(ClipType c) {
    switch (c) {
#define M(type)             \
    case ClipType::k##type: \
        return "ClipType::k" #type;
        SK_ALL_TEST_CLIPS(M)
#undef M
    }
    SkUNREACHABLE;
}

const char* ToStr(ImageFilterType c) {
    switch (c) {
#define M(type)                    \
    case ImageFilterType::k##type: \
        return "ImageFilterType::k" #type;
        SK_ALL_TEST_IMAGE_FILTERS(M)
#undef M
    }
    SkUNREACHABLE;
}

const char* ToStr(DrawTypeFlags dt) {
    // Note: This logic assumes single-bit flags for simple string conversion,
    // but the flags can be combined.
    // We mask out modifiers (like kAnalyticClip) for the base check.
    DrawTypeFlags base = static_cast<DrawTypeFlags>(dt & ~DrawTypeFlags::kAnalyticClip);

    switch (base) {
        case DrawTypeFlags::kBitmapText_Mask:
            return "DrawTypeFlags::kBitmapText_Mask";
        case DrawTypeFlags::kBitmapText_LCD:
            return "DrawTypeFlags::kBitmapText_LCD";
        case DrawTypeFlags::kBitmapText_Color:
            return "DrawTypeFlags::kBitmapText_Color";
        case DrawTypeFlags::kSDFText:
            return "DrawTypeFlags::kSDFText";
        case DrawTypeFlags::kSDFText_LCD:
            return "DrawTypeFlags::kSDFText_LCD";
        case DrawTypeFlags::kDrawVertices:
            return "DrawTypeFlags::kDrawVertices";
        case DrawTypeFlags::kCircularArc:
            return "DrawTypeFlags::kCircularArc";
        case DrawTypeFlags::kAnalyticRRect:
            return "DrawTypeFlags::kAnalyticRRect";
        case DrawTypeFlags::kPerEdgeAAQuad:
            return "DrawTypeFlags::kPerEdgeAAQuad";
        case DrawTypeFlags::kNonAAFillRect:
            return "DrawTypeFlags::kNonAAFillRect";
        case DrawTypeFlags::kNonSimpleShape:
            return "DrawTypeFlags::kNonSimpleShape";
        default:
            break;
    }

    if (dt == DrawTypeFlags::kNone) return "DrawTypeFlags::kNone";

    return "DrawTypeFlags::kMultiple/Combo";
}

//--------------------------------------------------------------------------------------------------
// Internal Helpers (Static)
//--------------------------------------------------------------------------------------------------

static constexpr skcms_TransferFunction gTransferFunctions[] = {
        SkNamedTransferFn::kSRGB,
        SkNamedTransferFn::k2Dot2,
        SkNamedTransferFn::kLinear,
        SkNamedTransferFn::kRec2020,
        SkNamedTransferFn::kPQ,
        SkNamedTransferFn::kHLG,
};

static constexpr int kTransferFunctionCount = std::size(gTransferFunctions);

static const skcms_TransferFunction& random_xfer_function(SkRandom* rand) {
    return gTransferFunctions[rand->nextULessThan(kTransferFunctionCount)];
}

static constexpr skcms_Matrix3x3 gGamuts[] = {
        SkNamedGamut::kSRGB,
        SkNamedGamut::kAdobeRGB,
        SkNamedGamut::kDisplayP3,
        SkNamedGamut::kRec2020,
        SkNamedGamut::kXYZ,
};

static constexpr int kGamutCount = std::size(gGamuts);

static const skcms_Matrix3x3& random_gamut(SkRandom* rand) {
    return gGamuts[rand->nextULessThan(kGamutCount)];
}

enum class ColorSpaceType { kNone, kSRGB, kSRGBLinear, kSRGBSpin, kRGB, kLast = kRGB };

static constexpr int kColorSpaceTypeCount = static_cast<int>(ColorSpaceType::kLast) + 1;

static ColorSpaceType random_colorspacetype(SkRandom* rand) {
    return static_cast<ColorSpaceType>(rand->nextULessThan(kColorSpaceTypeCount));
}

static sk_sp<SkColorSpace> random_colorspace(SkRandom* rand) {
    ColorSpaceType cs = random_colorspacetype(rand);

    switch (cs) {
        case ColorSpaceType::kNone:
            return nullptr;
        case ColorSpaceType::kSRGB:
            return SkColorSpace::MakeSRGB();
        case ColorSpaceType::kSRGBLinear:
            return SkColorSpace::MakeSRGBLinear();
        case ColorSpaceType::kSRGBSpin:
            return SkColorSpace::MakeSRGB()->makeColorSpin();
        case ColorSpaceType::kRGB:
            return SkColorSpace::MakeRGB(random_xfer_function(rand), random_gamut(rand));
    }
    SkUNREACHABLE;
}

enum class ColorConstraint {
    kNone,
    kOpaque,
    kTransparent,
};

static SkColor random_color(SkRandom* rand, ColorConstraint constraint) {
    uint32_t color = rand->nextU();
    switch (constraint) {
        case ColorConstraint::kNone:
            return color;
        case ColorConstraint::kOpaque:
            return 0xff000000 | color;
        case ColorConstraint::kTransparent:
            return 0x80000000 | color;
    }
    SkUNREACHABLE;
}

static SkColor4f random_color4f(SkRandom* rand, ColorConstraint constraint) {
    SkColor4f result = {rand->nextRangeF(0.0f, 1.0f),
                        rand->nextRangeF(0.0f, 1.0f),
                        rand->nextRangeF(0.0f, 1.0f),
                        rand->nextRangeF(0.0f, 1.0f)};
    switch (constraint) {
        case ColorConstraint::kNone:
            return result;
        case ColorConstraint::kOpaque:
            result.fA = 1.0f;
            return result;
        case ColorConstraint::kTransparent:
            result.fA = 0.5f;
            return result;
    }
    SkUNREACHABLE;
}

static SkTileMode random_tilemode(SkRandom* rand) {
    return static_cast<SkTileMode>(rand->nextULessThan(kSkTileModeCount));
}

static ShaderType random_shadertype(SkRandom* rand) {
    // defined in PaintParamsTestUtils.h, assumes contiguous enum ending at kLast
    return static_cast<ShaderType>(rand->nextULessThan(static_cast<int>(ShaderType::kLast) + 1));
}

static SkBlendMode random_porter_duff_bm(SkRandom* rand) {
    return static_cast<SkBlendMode>(
            rand->nextRangeU((unsigned int)SkBlendMode::kClear, (unsigned int)SkBlendMode::kPlus));
}

static SkBlendMode random_complex_bm(SkRandom* rand) {
    return static_cast<SkBlendMode>(rand->nextRangeU((unsigned int)SkBlendMode::kPlus,
                                                     (unsigned int)SkBlendMode::kLastMode));
}

static SkBlendMode random_blend_mode(SkRandom* rand) {
    return static_cast<SkBlendMode>(rand->nextULessThan(kSkBlendModeCount));
}

static BlenderType random_blendertype(SkRandom* rand) {
    return static_cast<BlenderType>(rand->nextULessThan(static_cast<int>(BlenderType::kLast) + 1));
}

static ColorFilterType random_colorfiltertype(SkRandom* rand) {
    return static_cast<ColorFilterType>(
            rand->nextULessThan(static_cast<int>(ColorFilterType::kLast) + 1));
}

[[maybe_unused]] static ImageFilterType random_imagefiltertype(SkRandom* rand) {
    return static_cast<ImageFilterType>(
            rand->nextULessThan(static_cast<int>(ImageFilterType::kLast) + 1));
}

DrawTypeFlags RandomDrawType(SkRandom* rand) {
    uint32_t index = rand->nextULessThan(11);

    switch (index) {
        case 0:
            return DrawTypeFlags::kBitmapText_Mask;
        case 1:
            return DrawTypeFlags::kBitmapText_LCD;
        case 2:
            return DrawTypeFlags::kBitmapText_Color;
        case 3:
            return DrawTypeFlags::kSDFText;
        case 4:
            return DrawTypeFlags::kSDFText_LCD;
        case 5:
            return DrawTypeFlags::kDrawVertices;
        case 6:
            return DrawTypeFlags::kCircularArc;
        case 7:
            return DrawTypeFlags::kAnalyticRRect;
        case 8:
            return DrawTypeFlags::kPerEdgeAAQuad;
        case 9:
            return DrawTypeFlags::kNonAAFillRect;
        case 10:
            return DrawTypeFlags::kNonSimpleShape;
    }

    SkASSERT(0);
    return DrawTypeFlags::kNone;
}

enum LocalMatrixConstraint {
    kNone,
    kWithPerspective,
};

static SkMatrix* random_local_matrix(
        SkRandom* rand,
        SkMatrix* storage,
        LocalMatrixConstraint constraint = LocalMatrixConstraint::kNone) {
    uint32_t matrix = rand->nextULessThan(constraint == LocalMatrixConstraint::kNone ? 4 : 3);
    switch (matrix) {
        case 0:
            storage->setTranslate(2.0f, 2.0f);
            break;
        case 1:
            storage->setIdentity();
            break;
        case 2:
            storage->setScale(0.25f, 0.25f, 0.0f, 0.0f);
            break;
        case 3:
            return nullptr;
    }
    if (constraint == LocalMatrixConstraint::kWithPerspective) {
        storage->setPerspX(0.5f);
    }
    return storage;
}

static sk_sp<SkImage> make_image(SkRandom* rand, Recorder* recorder) {
    SkColorType ct = SkColorType::kRGBA_8888_SkColorType;
    if (rand->nextBool()) {
        ct = SkColorType::kAlpha_8_SkColorType;
    }
    SkImageInfo info = SkImageInfo::Make(32, 32, ct, kPremul_SkAlphaType, random_colorspace(rand));
    SkBitmap bitmap;
    bitmap.allocPixels(info);
    bitmap.eraseColor(SK_ColorBLACK);
    sk_sp<SkImage> img = bitmap.asImage();
    return SkImages::TextureFromImage(recorder, img, {false});
}

static sk_sp<SkImage> make_yuv_image(SkRandom* rand, Recorder* recorder) {
    SkYUVAInfo::PlaneConfig planeConfig = SkYUVAInfo::PlaneConfig::kY_UV;
    if (rand->nextBool()) {
        planeConfig = SkYUVAInfo::PlaneConfig::kY_U_V_A;
    }
    SkYUVAInfo yuvaInfo(
            {
                    32,
                    32,
            },
            planeConfig,
            SkYUVAInfo::Subsampling::k420,
            kJPEG_Full_SkYUVColorSpace);
    SkYUVAPixmapInfo pmInfo(yuvaInfo, SkYUVAPixmapInfo::DataType::kUnorm8, nullptr);
    SkYUVAPixmaps pixmaps = SkYUVAPixmaps::Allocate(pmInfo);
    for (int i = 0; i < pixmaps.numPlanes(); ++i) {
        pixmaps.plane(i).erase(SK_ColorBLACK);
    }
    sk_sp<SkColorSpace> cs;
    if (rand->nextBool()) {
        cs = SkColorSpace::MakeSRGBLinear();
    }
    return SkImages::TextureFromYUVAPixmaps(recorder,
                                            pixmaps,
                                            {/* fMipmapped= */ false},
                                            /* limitToMaxTextureSize= */ false,
                                            std::move(cs));
}

static sk_sp<SkPicture> make_picture(SkRandom* rand) {
    constexpr SkRect kRect = SkRect::MakeWH(128, 128);
    SkPictureRecorder recorder;
    SkCanvas* canvas = recorder.beginRecording(kRect);
    SkPaint paint;
    canvas->drawRect(kRect, paint);
    return recorder.finishRecordingAsPicture();
}

//--------------------------------------------------------------------------------------------------
// Shader Generators
//--------------------------------------------------------------------------------------------------

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_coord_clamp_shader(SkRandom* rand,
                                                                              Recorder* recorder,
                                                                              bool* reqSKPOption) {
    auto [s, o] = CreateRandomShader(rand, recorder, random_shadertype(rand), reqSKPOption);
    SkASSERT(!s == !o);
    if (!s) {
        return {nullptr, nullptr};
    }
    constexpr SkRect kSubset{0, 0, 256, 256};
    sk_sp<SkShader> ccs = SkShaders::CoordClamp(std::move(s), kSubset);
    sk_sp<PrecompileShader> cco = PrecompileShaders::CoordClamp({std::move(o)});
    return {ccs, cco};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_perlin_noise_shader(SkRandom* rand) {
    sk_sp<SkShader> s;
    sk_sp<PrecompileShader> o;
    if (rand->nextBool()) {
        s = SkShaders::MakeFractalNoise(0.3f, 0.3f, 2, 4);
        o = PrecompileShaders::MakeFractalNoise();
    } else {
        s = SkShaders::MakeTurbulence(0.3f, 0.3f, 2, 4);
        o = PrecompileShaders::MakeTurbulence();
    }
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_picture_shader(SkRandom* rand,
                                                                          bool* reqSKPOption) {
    sk_sp<SkPicture> picture = make_picture(rand);

    if (reqSKPOption) {
        *reqSKPOption = true;
    }

    SkMatrix lmStorage;
    SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);

    sk_sp<SkShader> s = picture->makeShader(
            SkTileMode::kClamp, SkTileMode::kClamp, SkFilterMode::kLinear, lmPtr, nullptr);
    sk_sp<PrecompileShader> o = PrecompileShadersPriv::Picture(SkToBool(lmPtr));
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_solid_shader(
        SkRandom* rand, ColorConstraint constraint = ColorConstraint::kNone) {
    sk_sp<SkShader> s;
    sk_sp<PrecompileShader> o;
    if (rand->nextBool()) {
        s = SkShaders::Color(random_color(rand, constraint));
        o = PrecompileShaders::Color();
    } else {
        sk_sp<SkColorSpace> cs = random_colorspace(rand);
        s = SkShaders::Color(random_color4f(rand, constraint), cs);
        o = PrecompileShaders::Color(std::move(cs));
    }
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_gradient_shader(
        SkRandom* rand,
        SkShaderBase::GradientType type,
        ColorConstraint constraint = ColorConstraint::kOpaque) {
    static constexpr int kMaxNumStops = 9;
    SkColor4f colors[kMaxNumStops];
    for (int i = 0; i < kMaxNumStops; ++i) colors[i] = random_color4f(rand, constraint);

    static const SkPoint kPts[kMaxNumStops] = {{-100.0f, -100.0f},
                                               {-50.0f, -50.0f},
                                               {-25.0f, -25.0f},
                                               {-12.5f, -12.5f},
                                               {0.0f, 0.0f},
                                               {12.5f, 12.5f},
                                               {25.0f, 25.0f},
                                               {50.0f, 50.0f},
                                               {100.0f, 100.0f}};
    static const float kOffsets[kMaxNumStops] = {
            0.0f, 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.75f, 0.875f, 1.0f};

    size_t numStops;
    switch (rand->nextULessThan(3)) {
        case 0:
            numStops = 2;
            break;
        case 1:
            numStops = 7;
            break;
        case 2:
            [[fallthrough]];
        default:
            numStops = kMaxNumStops;
            break;
    }

    SkMatrix lmStorage;
    SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);
    const SkGradient::Interpolation::InPremul inPremul =
            rand->nextBool() ? SkGradient::Interpolation::InPremul::kYes
                             : SkGradient::Interpolation::InPremul::kNo;
    const SkGradient::Interpolation::ColorSpace colorSpace =
            static_cast<SkGradient::Interpolation::ColorSpace>(
                    rand->nextULessThan(SkGradient::Interpolation::kColorSpaceCount));
    SkGradient::Interpolation interpolation = {inPremul, colorSpace};

    sk_sp<SkShader> s;
    sk_sp<PrecompileShader> o;
    SkTileMode tm = random_tilemode(rand);
    const SkGradient grad = {{{colors, numStops}, {kOffsets, numStops}, tm}, interpolation};

    switch (type) {
        case SkShaderBase::GradientType::kLinear:
            s = SkShaders::LinearGradient(kPts, grad, lmPtr);
            o = PrecompileShaders::LinearGradient(GradientShaderFlags::kAll, interpolation);
            break;
        case SkShaderBase::GradientType::kRadial:
            s = SkShaders::RadialGradient(/* center= */ {0, 0}, /* radius= */ 100, grad, lmPtr);
            o = PrecompileShaders::RadialGradient(GradientShaderFlags::kAll, interpolation);
            break;
        case SkShaderBase::GradientType::kSweep:
            s = SkShaders::SweepGradient(/* center= */ {0, 0}, grad, lmPtr);
            o = PrecompileShaders::SweepGradient(GradientShaderFlags::kAll, interpolation);
            break;
        case SkShaderBase::GradientType::kConical:
            s = SkShaders::TwoPointConicalGradient(/* start= */ {100, 100},
                                                   /* startRadius= */ 100,
                                                   /* end= */ {-100, -100},
                                                   /* endRadius= */ 100,
                                                   grad, lmPtr);
            o = PrecompileShaders::TwoPointConicalGradient(GradientShaderFlags::kAll,
                                                           interpolation);
            break;
        case SkShaderBase::GradientType::kNone:
            SkDEBUGFAIL("Gradient shader says its type is none");
            break;
    }
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_localmatrix_shader(SkRandom* rand,
                                                                              Recorder* recorder,
                                                                              bool* reqSKPOption) {
    auto [s, o] = CreateRandomShader(rand, recorder, random_shadertype(rand), reqSKPOption);
    SkASSERT(!s == !o);
    if (!s) {
        return {nullptr, nullptr};
    }
    bool hasPerspective = rand->nextBool();
    SkMatrix lmStorage;
    random_local_matrix(rand,
                        &lmStorage,
                        hasPerspective ? LocalMatrixConstraint::kWithPerspective
                                       : LocalMatrixConstraint::kNone);
    return {s->makeWithLocalMatrix(lmStorage), o->makeWithLocalMatrix(hasPerspective)};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_colorfilter_shader(SkRandom* rand,
                                                                              Recorder* recorder,
                                                                              bool* reqSKPOption) {
    auto [s, o] = CreateRandomShader(rand, recorder, random_shadertype(rand), reqSKPOption);
    SkASSERT(!s == !o);
    if (!s) {
        return {nullptr, nullptr};
    }
    auto [cf, cfO] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    return {s->makeWithColorFilter(std::move(cf)), o->makeWithColorFilter(std::move(cfO))};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_image_shader(SkRandom* rand,
                                                                        Recorder* recorder) {
    SkTileMode tmX = random_tilemode(rand);
    SkTileMode tmY = random_tilemode(rand);
    std::vector<SkTileMode> precompileTileModes =
            (tmX == tmY) ? std::vector<SkTileMode>{tmX}
                         : std::vector<SkTileMode>{SkTileMode::kClamp, SkTileMode::kRepeat};

    SkMatrix lmStorage;
    SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);

    sk_sp<SkShader> s;
    sk_sp<PrecompileShader> o;
    sk_sp<SkImage> image = make_image(rand, recorder);
    SkColorInfo colorInfo = image->imageInfo().colorInfo();

    switch (rand->nextULessThan(4)) {
        case 0: {  // Non-subset image
            s = SkShaders::Image(std::move(image), tmX, tmY, SkSamplingOptions(), lmPtr);
            o = PrecompileShaders::Image(ImageShaderFlags::kAll, {colorInfo}, precompileTileModes);
        } break;
        case 1: {  // Subset image
            const SkRect subset = SkRect::MakeWH(image->width() / 2, image->height() / 2);
            s = SkImageShader::MakeSubset(
                    std::move(image), subset, tmX, tmY, SkSamplingOptions(), lmPtr);
            o = PrecompileShaders::Image(ImageShaderFlags::kAll, {colorInfo}, precompileTileModes);
        } break;
        case 2: {  // Cubic-sampled image
            s = SkShaders::Image(std::move(image), tmX, tmY, SkCubicResampler::Mitchell(), lmPtr);
            o = PrecompileShaders::Image(ImageShaderFlags::kAll, {colorInfo}, precompileTileModes);
        } break;
        default: {  // Raw image draw
            s = SkShaders::RawImage(std::move(image), tmX, tmY, SkSamplingOptions(), lmPtr);
            o = PrecompileShaders::RawImage(
                    ImageShaderFlags::kExcludeCubic, {colorInfo}, precompileTileModes);
        } break;
    }
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_yuv_image_shader(SkRandom* rand,
                                                                            Recorder* recorder) {
    SkTileMode tmX = random_tilemode(rand);
    SkTileMode tmY = random_tilemode(rand);
    SkMatrix lmStorage;
    SkMatrix* lmPtr = random_local_matrix(rand, &lmStorage);
    sk_sp<SkShader> s;
    sk_sp<PrecompileShader> o;
    SkSamplingOptions samplingOptions(SkFilterMode::kLinear);
    bool useCubic = rand->nextBool();
    if (useCubic) {
        samplingOptions = SkCubicResampler::Mitchell();
    }
    sk_sp<SkImage> yuvImage = make_yuv_image(rand, recorder);
    SkColorInfo colorInfo = yuvImage->imageInfo().colorInfo();

    if (rand->nextBool()) {
        s = SkImageShader::MakeSubset(std::move(yuvImage),
                                      SkRect::MakeXYWH(8, 8, 16, 16),
                                      tmX,
                                      tmY,
                                      samplingOptions,
                                      lmPtr);
    } else {
        s = SkShaders::Image(std::move(yuvImage), tmX, tmY, samplingOptions, lmPtr);
    }
    o = PrecompileShaders::YUVImage(
            useCubic ? YUVImageShaderFlags::kCubicSampling : YUVImageShaderFlags::kExcludeCubic,
            {colorInfo});
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_blend_shader(SkRandom* rand,
                                                                        Recorder* recorder,
                                                                        bool* reqSKPOption) {
    auto [blender, blenderO] = CreateRandomBlender(rand, random_blendertype(rand));
    auto [dstS, dstO] = CreateRandomShader(rand, recorder, random_shadertype(rand), reqSKPOption);
    if (!dstS) return {nullptr, nullptr};
    auto [srcS, srcO] = CreateRandomShader(rand, recorder, random_shadertype(rand), reqSKPOption);
    if (!srcS) return {nullptr, nullptr};

    auto s = SkShaders::Blend(std::move(blender), std::move(dstS), std::move(srcS));
    auto o = PrecompileShaders::Blend(
            SkSpan<const sk_sp<PrecompileBlender>>({blenderO}), {dstO}, {srcO});
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> create_workingCS_shader(SkRandom* rand,
                                                                            Recorder* recorder,
                                                                            bool* reqSKPOption) {
    auto [wrappedS, wrappedO] =
            CreateRandomShader(rand, recorder, random_shadertype(rand), reqSKPOption);
    if (!wrappedS) return {nullptr, nullptr};
    sk_sp<SkColorSpace> cs = random_colorspace(rand);
    sk_sp<SkShader> s = wrappedS->makeWithWorkingColorSpace(cs);
    sk_sp<PrecompileShader> o = wrappedO->makeWithWorkingColorSpace(std::move(cs));
    return {s, o};
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> CreateRandomShader(SkRandom* rand,
                                                                       Recorder* recorder,
                                                                       ShaderType shaderType,
                                                                       bool* reqSKPOption) {
    switch (shaderType) {
        case ShaderType::kNone:
            return {nullptr, nullptr};
        case ShaderType::kBlend:
            return create_blend_shader(rand, recorder, reqSKPOption);
        case ShaderType::kColorFilter:
            return create_colorfilter_shader(rand, recorder, reqSKPOption);
        case ShaderType::kCoordClamp:
            return create_coord_clamp_shader(rand, recorder, reqSKPOption);
        case ShaderType::kConicalGradient:
            return create_gradient_shader(rand, SkShaderBase::GradientType::kConical);
        case ShaderType::kImage:
            return create_image_shader(rand, recorder);
        case ShaderType::kLinearGradient:
            return create_gradient_shader(rand, SkShaderBase::GradientType::kLinear);
        case ShaderType::kLocalMatrix:
            return create_localmatrix_shader(rand, recorder, reqSKPOption);
        case ShaderType::kPerlinNoise:
            return create_perlin_noise_shader(rand);
        case ShaderType::kPicture:
            return create_picture_shader(rand, reqSKPOption);
        case ShaderType::kRadialGradient:
            return create_gradient_shader(rand, SkShaderBase::GradientType::kRadial);
        case ShaderType::kRuntime:
            return PrecompileFactories::CreateAnnulusRuntimeShader();
        case ShaderType::kSolidColor:
            return create_solid_shader(rand);
        case ShaderType::kSweepGradient:
            return create_gradient_shader(rand, SkShaderBase::GradientType::kSweep);
        case ShaderType::kYUVImage:
            return create_yuv_image_shader(rand, recorder);
        case ShaderType::kWorkingColorSpace:
            return create_workingCS_shader(rand, recorder, reqSKPOption);
    }
    SkUNREACHABLE;
}

std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> CreateClipShader(SkRandom* rand,
                                                                     Recorder* recorder) {
    switch (rand->nextULessThan(5)) {
        case 0:
            return create_gradient_shader(
                    rand, SkShaderBase::GradientType::kConical, ColorConstraint::kTransparent);
        case 1:
            return create_gradient_shader(
                    rand, SkShaderBase::GradientType::kLinear, ColorConstraint::kTransparent);
        case 2:
            return create_gradient_shader(
                    rand, SkShaderBase::GradientType::kRadial, ColorConstraint::kTransparent);
        case 3:
            return create_solid_shader(rand, ColorConstraint::kTransparent);
        case 4:
            return create_gradient_shader(
                    rand, SkShaderBase::GradientType::kSweep, ColorConstraint::kTransparent);
    }
    SkUNREACHABLE;
}

//--------------------------------------------------------------------------------------------------
// Blender Generators
//--------------------------------------------------------------------------------------------------

std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_bm_blender(SkRandom* rand,
                                                                        SkBlendMode bm) {
    return {SkBlender::Mode(bm), PrecompileBlenders::Mode(bm)};
}

std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_arithmetic_blender() {
    sk_sp<SkBlender> b = SkBlenders::Arithmetic(0.5f, 0.5f, 0.5f, 0.5f, true);
    sk_sp<PrecompileBlender> o = PrecompileBlenders::Arithmetic();
    return {std::move(b), std::move(o)};
}

std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> create_rt_blender(SkRandom* rand) {
    int option = rand->nextULessThan(3);
    switch (option) {
        case 0:
            return PrecompileFactories::CreateSrcRuntimeBlender();
        case 1:
            return PrecompileFactories::CreateDstRuntimeBlender();
        case 2:
            return PrecompileFactories::CreateComboRuntimeBlender();
    }
    return {nullptr, nullptr};
}

std::pair<sk_sp<SkBlender>, sk_sp<PrecompileBlender>> CreateRandomBlender(SkRandom* rand,
                                                                          BlenderType type) {
    switch (type) {
        case BlenderType::kNone:
            return {nullptr, nullptr};
        case BlenderType::kPorterDuff:
            return create_bm_blender(rand, random_porter_duff_bm(rand));
        case BlenderType::kShaderBased:
            return create_bm_blender(rand, random_complex_bm(rand));
        case BlenderType::kArithmetic:
            return create_arithmetic_blender();
        case BlenderType::kRuntime:
            return create_rt_blender(rand);
    }
    SkUNREACHABLE;
}

//--------------------------------------------------------------------------------------------------
// ColorFilter Generators
//--------------------------------------------------------------------------------------------------

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_rt_colorfilter(
        SkRandom* rand) {
    int option = rand->nextULessThan(3);
    switch (option) {
        case 0:
            return PrecompileFactories::CreateDoubleRuntimeColorFilter();
        case 1:
            return PrecompileFactories::CreateHalfRuntimeColorFilter();
        case 2:
            return PrecompileFactories::CreateComboRuntimeColorFilter();
    }
    return {nullptr, nullptr};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_lerp_colorfilter(
        SkRandom* rand) {
    auto [dst, dstO] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    auto [src, srcO] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    while (src == dst) {  // Avoid optimization where src == dst
        std::tie(src, srcO) = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    }
    sk_sp<SkColorFilter> cf = SkColorFilters::Lerp(0.5f, std::move(dst), std::move(src));
    sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::Lerp({dstO}, {srcO});
    return {cf, o};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_lighting_colorfilter() {
    return {SkColorFilters::Lighting(SK_ColorGREEN, SK_ColorRED),
            PrecompileColorFilters::Lighting()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_blendmode_colorfilter(
        SkRandom* rand) {
    sk_sp<SkColorFilter> cf;
    SkBlendMode blend;
    while (!cf) {
        blend = random_blend_mode(rand);
        cf = SkColorFilters::Blend(
                random_color4f(rand, ColorConstraint::kNone), random_colorspace(rand), blend);
    }
    sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::Blend({&blend, 1});
    return {std::move(cf), std::move(o)};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_matrix_colorfilter() {
    sk_sp<SkColorFilter> cf = SkColorFilters::Matrix(
            SkColorMatrix::RGBtoYUV(SkYUVColorSpace::kJPEG_Full_SkYUVColorSpace));
    sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::Matrix();
    return {std::move(cf), std::move(o)};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_color_space_colorfilter(
        SkRandom* rand) {
    sk_sp<SkColorSpace> src = random_colorspace(rand);
    sk_sp<SkColorSpace> dst = random_colorspace(rand);
    return {SkColorFilterPriv::MakeColorSpaceXform(src, dst),
            PrecompileColorFiltersPriv::ColorSpaceXform({src}, {dst})};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_compose_colorfilter(
        SkRandom* rand) {
    auto [outerCF, outerO] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    auto [innerCF, innerO] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    return {SkColorFilters::Compose(std::move(outerCF), std::move(innerCF)),
            PrecompileColorFilters::Compose({std::move(outerO)}, {std::move(innerO)})};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_gaussian_colorfilter() {
    return {SkColorFilterPriv::MakeGaussian(), PrecompileColorFiltersPriv::Gaussian()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_table_colorfilter() {
    static constexpr uint8_t kTable[256] = {0};
    return {SkColorFilters::Table(kTable), PrecompileColorFilters::Table()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_workingformat_colorfilter(
        SkRandom* rand) {
    auto [childCF, childO] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    if (!childCF) return {nullptr, nullptr};
    const skcms_TransferFunction* tf = rand->nextBool() ? &random_xfer_function(rand) : nullptr;
    const skcms_Matrix3x3* gamut = rand->nextBool() ? &random_gamut(rand) : nullptr;
    const SkAlphaType unpremul = kUnpremul_SkAlphaType;
    sk_sp<SkColorFilter> cf =
            SkColorFilterPriv::WithWorkingFormat(std::move(childCF), tf, gamut, &unpremul);
    sk_sp<PrecompileColorFilter> o = PrecompileColorFiltersPriv::WithWorkingFormat(
            {std::move(childO)}, tf, gamut, &unpremul);
    return {std::move(cf), std::move(o)};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_overdraw_colorfilter() {
    static const SkColor kColors[SkOverdrawColorFilter::kNumColors] = {
            SK_ColorBLACK, SK_ColorBLUE, SK_ColorCYAN, SK_ColorGREEN, SK_ColorYELLOW, SK_ColorRED};
    return {SkOverdrawColorFilter::MakeWithSkColors(kColors), PrecompileColorFilters::Overdraw()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_high_contrast_colorfilter() {
    SkHighContrastConfig config(false, SkHighContrastConfig::InvertStyle::kInvertBrightness, 0.5f);
    return {SkHighContrastFilter::Make(config), PrecompileColorFilters::HighContrast()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_luma_colorfilter() {
    return {SkLumaColorFilter::Make(), PrecompileColorFilters::Luma()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_linear_to_srgb_colorfilter() {
    return {SkColorFilters::LinearToSRGBGamma(), PrecompileColorFilters::LinearToSRGBGamma()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_srgb_to_linear_colorfilter() {
    return {SkColorFilters::SRGBToLinearGamma(), PrecompileColorFilters::SRGBToLinearGamma()};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> create_hsla_matrix_colorfilter() {
    sk_sp<SkColorFilter> cf = SkColorFilters::HSLAMatrix(
            SkColorMatrix::RGBtoYUV(SkYUVColorSpace::kJPEG_Full_SkYUVColorSpace));
    sk_sp<PrecompileColorFilter> o = PrecompileColorFilters::HSLAMatrix();
    return {std::move(cf), std::move(o)};
}

std::pair<sk_sp<SkColorFilter>, sk_sp<PrecompileColorFilter>> CreateRandomColorFilter(
        SkRandom* rand, ColorFilterType type) {
    switch (type) {
        case ColorFilterType::kNone:
            return {nullptr, nullptr};
        case ColorFilterType::kBlendMode:
            return create_blendmode_colorfilter(rand);
        case ColorFilterType::kColorSpaceXform:
            return create_color_space_colorfilter(rand);
        case ColorFilterType::kCompose:
            return create_compose_colorfilter(rand);
        case ColorFilterType::kGaussian:
            return create_gaussian_colorfilter();
        case ColorFilterType::kHighContrast:
            return create_high_contrast_colorfilter();
        case ColorFilterType::kHSLAMatrix:
            return create_hsla_matrix_colorfilter();
        case ColorFilterType::kLerp:
            return create_lerp_colorfilter(rand);
        case ColorFilterType::kLighting:
            return create_lighting_colorfilter();
        case ColorFilterType::kLinearToSRGB:
            return create_linear_to_srgb_colorfilter();
        case ColorFilterType::kLuma:
            return create_luma_colorfilter();
        case ColorFilterType::kMatrix:
            return create_matrix_colorfilter();
        case ColorFilterType::kOverdraw:
            return create_overdraw_colorfilter();
        case ColorFilterType::kRuntime:
            return create_rt_colorfilter(rand);
        case ColorFilterType::kSRGBToLinear:
            return create_srgb_to_linear_colorfilter();
        case ColorFilterType::kTable:
            return create_table_colorfilter();
        case ColorFilterType::kWorkingFormat:
            return create_workingformat_colorfilter(rand);
    }
    SkUNREACHABLE;
}

//--------------------------------------------------------------------------------------------------
// ImageFilter Generators
//--------------------------------------------------------------------------------------------------

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> arithmetic_imagefilter(SkRandom*) {
    sk_sp<SkImageFilter> arithmeticIF =
            SkImageFilters::Arithmetic(0.5f, 0.5f, 0.5f, 0.5f, false, nullptr, nullptr);
    sk_sp<PrecompileImageFilter> option = PrecompileImageFilters::Arithmetic(nullptr, nullptr);
    return {std::move(arithmeticIF), std::move(option)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> blendmode_imagefilter(
        SkRandom* rand) {
    SkBlendMode bm = random_blend_mode(rand);
    sk_sp<SkImageFilter> blendIF = SkImageFilters::Blend(bm, nullptr, nullptr);
    sk_sp<PrecompileImageFilter> blendO = PrecompileImageFilters::Blend(bm, nullptr, nullptr);
    return {std::move(blendIF), std::move(blendO)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> runtime_blender_imagefilter(
        SkRandom* rand) {
    auto [blender, blenderO] = CreateRandomBlender(rand, BlenderType::kRuntime);
    sk_sp<SkImageFilter> blenderIF = SkImageFilters::Blend(std::move(blender), nullptr, nullptr);
    sk_sp<PrecompileImageFilter> option =
            PrecompileImageFilters::Blend(std::move(blenderO), nullptr, nullptr);
    return {std::move(blenderIF), std::move(option)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> blur_imagefilter(SkRandom* rand) {
    float sigma = 5.0f;
    int option = rand->nextULessThan(3);
    if (option == 0)
        sigma = 1.0f;
    else if (option == 1)
        sigma = 2.0f;
    sk_sp<SkImageFilter> blurIF = SkImageFilters::Blur(sigma, sigma, nullptr);
    sk_sp<PrecompileImageFilter> blurO = PrecompileImageFilters::Blur(nullptr);
    return {std::move(blurIF), std::move(blurO)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> displacement_imagefilter(
        Recorder* recorder, SkRandom* rand) {
    sk_sp<SkImage> checkerboard =
            ToolUtils::create_checkerboard_image(16, 16, SK_ColorWHITE, SK_ColorBLACK, 4);
    checkerboard = SkImages::TextureFromImage(recorder, std::move(checkerboard), {false});
    sk_sp<SkImageFilter> imageIF(
            SkImageFilters::Image(std::move(checkerboard), SkFilterMode::kLinear));
    sk_sp<SkImageFilter> displacementIF = SkImageFilters::DisplacementMap(
            SkColorChannel::kR, SkColorChannel::kB, 2.0f, std::move(imageIF), nullptr);
    sk_sp<PrecompileImageFilter> option = PrecompileImageFilters::DisplacementMap(nullptr);
    return {std::move(displacementIF), std::move(option)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> colorfilter_imagefilter(
        SkRandom* rand) {
    auto [cf, o] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
    sk_sp<SkImageFilter> inputIF;
    sk_sp<PrecompileImageFilter> inputO;
    if (rand->nextBool()) {
        auto [cf2, o2] = CreateRandomColorFilter(rand, random_colorfiltertype(rand));
        inputIF = SkImageFilters::ColorFilter(std::move(cf2), nullptr);
        inputO = PrecompileImageFilters::ColorFilter(std::move(o2), nullptr);
    }
    sk_sp<SkImageFilter> cfIF = SkImageFilters::ColorFilter(std::move(cf), std::move(inputIF));
    sk_sp<PrecompileImageFilter> cfIFO =
            PrecompileImageFilters::ColorFilter(std::move(o), std::move(inputO));
    return {std::move(cfIF), std::move(cfIFO)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> lighting_imagefilter(SkRandom* rand) {
    static constexpr SkPoint3 kLocation{10.0f, 2.0f, 30.0f};
    static constexpr SkPoint3 kTarget{0, 0, 0};
    static constexpr SkPoint3 kDirection{0, 1, 0};
    sk_sp<SkImageFilter> lightingIF;
    int option = rand->nextULessThan(6);
    switch (option) {
        case 0:
            lightingIF =
                    SkImageFilters::DistantLitDiffuse(kDirection, SK_ColorRED, 1.0f, 0.5f, nullptr);
            break;
        case 1:
            lightingIF =
                    SkImageFilters::PointLitDiffuse(kLocation, SK_ColorGREEN, 1.0f, 0.5f, nullptr);
            break;
        case 2:
            lightingIF = SkImageFilters::SpotLitDiffuse(
                    kLocation, kTarget, 2.0f, 30.0f, SK_ColorBLUE, 1.0f, 0.5f, nullptr);
            break;
        case 3:
            lightingIF = SkImageFilters::DistantLitSpecular(
                    kDirection, SK_ColorCYAN, 1.0f, 0.5f, 2.0f, nullptr);
            break;
        case 4:
            lightingIF = SkImageFilters::PointLitSpecular(
                    kLocation, SK_ColorMAGENTA, 1.0f, 0.5f, 2.0f, nullptr);
            break;
        case 5:
            lightingIF = SkImageFilters::SpotLitSpecular(
                    kLocation, kTarget, 2.0f, 30.0f, SK_ColorYELLOW, 1.0f, 4.0f, 0.5f, nullptr);
            break;
    }
    sk_sp<PrecompileImageFilter> lightingO = PrecompileImageFilters::Lighting(nullptr);
    return {std::move(lightingIF), std::move(lightingO)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> matrix_convolution_imagefilter(
        SkRandom* rand) {
    int kernelSize = 1;
    int option = rand->nextULessThan(3);
    if (option == 0)
        kernelSize = 3;
    else if (option == 1)
        kernelSize = 7;
    else if (option == 2)
        kernelSize = 11;

    int center = (kernelSize * kernelSize - 1) / 2;
    std::vector<float> kernel(kernelSize * kernelSize, SkIntToScalar(1));
    kernel[center] = 2.0f - kernelSize * kernelSize;

    sk_sp<SkImageFilter> matrixConvIF = SkImageFilters::MatrixConvolution({kernelSize, kernelSize},
                                                                          kernel.data(),
                                                                          0.3f,
                                                                          100.0f,
                                                                          {1, 1},
                                                                          SkTileMode::kMirror,
                                                                          false,
                                                                          nullptr);
    sk_sp<PrecompileImageFilter> convOption = PrecompileImageFilters::MatrixConvolution(nullptr);
    return {std::move(matrixConvIF), std::move(convOption)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> morphology_imagefilter(
        SkRandom* rand) {
    static constexpr float kRadX = 2.0f, kRadY = 4.0f;
    sk_sp<SkImageFilter> morphologyIF;
    if (rand->nextBool()) {
        morphologyIF = SkImageFilters::Erode(kRadX, kRadY, nullptr);
    } else {
        morphologyIF = SkImageFilters::Dilate(kRadX, kRadY, nullptr);
    }
    sk_sp<PrecompileImageFilter> option = PrecompileImageFilters::Morphology(nullptr);
    return {std::move(morphologyIF), std::move(option)};
}

std::pair<sk_sp<SkImageFilter>, sk_sp<PrecompileImageFilter>> CreateRandomImageFilter(
        Recorder* recorder, SkRandom* rand, ImageFilterType type) {
    switch (type) {
        case ImageFilterType::kNone:
            return {};
        case ImageFilterType::kArithmetic:
            return arithmetic_imagefilter(rand);
        case ImageFilterType::kBlendMode:
            return blendmode_imagefilter(rand);
        case ImageFilterType::kRuntimeBlender:
            return runtime_blender_imagefilter(rand);
        case ImageFilterType::kBlur:
            return blur_imagefilter(rand);
        case ImageFilterType::kColorFilter:
            return colorfilter_imagefilter(rand);
        case ImageFilterType::kDisplacement:
            return displacement_imagefilter(recorder, rand);
        case ImageFilterType::kLighting:
            return lighting_imagefilter(rand);
        case ImageFilterType::kMatrixConvolution:
            return matrix_convolution_imagefilter(rand);
        case ImageFilterType::kMorphology:
            return morphology_imagefilter(rand);
    }
    SkUNREACHABLE;
}

//--------------------------------------------------------------------------------------------------
// MaskFilter Generators
//--------------------------------------------------------------------------------------------------

std::pair<sk_sp<SkMaskFilter>, sk_sp<PrecompileMaskFilter>> create_blur_maskfilter(SkRandom* rand) {
    SkBlurStyle style;
    switch (rand->nextULessThan(4)) {
        case 0:
            style = kNormal_SkBlurStyle;
            break;
        case 1:
            style = kSolid_SkBlurStyle;
            break;
        case 2:
            style = kOuter_SkBlurStyle;
            break;
        case 3:
            [[fallthrough]];
        default:
            style = kInner_SkBlurStyle;
            break;
    }
    float sigma = 1.0f;
    switch (rand->nextULessThan(2)) {
        case 0:
            sigma = 1.0f;
            break;
        case 1:
            sigma = 2.0f;
            break;
        case 2:
            [[fallthrough]];
        default:
            sigma = 5.0f;
            break;
    }
    bool respectCTM = rand->nextBool();
    return {SkMaskFilter::MakeBlur(style, sigma, respectCTM), PrecompileMaskFilters::Blur()};
}

std::pair<sk_sp<SkMaskFilter>, sk_sp<PrecompileMaskFilter>> CreateRandomMaskFilter(
        SkRandom* rand, MaskFilterType type) {
    switch (type) {
        case MaskFilterType::kNone:
            return {nullptr, nullptr};
        case MaskFilterType::kBlur:
            return create_blur_maskfilter(rand);
    }
    SkUNREACHABLE;
}

//--------------------------------------------------------------------------------------------------
// Main Entry Points
//--------------------------------------------------------------------------------------------------

std::pair<SkPaint, PaintOptions> CreateRandomPaint(SkRandom* rand,
                                                   Recorder* recorder,
                                                   ShaderType shaderType,
                                                   BlenderType blenderType,
                                                   ColorFilterType cfType,
                                                   MaskFilterType mfType,
                                                   ImageFilterType imageFilterType,
                                                   bool* reqSKPPaintOption) {
    SkColor paintColor = random_color(rand, ColorConstraint::kNone);
    SkPaint paint;
    paint.setColor(paintColor);
    PaintOptions paintOptions;
    paintOptions.setPaintColorIsOpaque(SkColorGetA(paintColor) == 0xFF);

    {
        std::pair<sk_sp<SkShader>, sk_sp<PrecompileShader>> sAndO;
        if (shaderType == ShaderType::kPicture) {
            sAndO = create_picture_shader(rand, reqSKPPaintOption);
        } else {
            sAndO = CreateRandomShader(rand, recorder, shaderType, reqSKPPaintOption);
        }

        auto [s, o] = sAndO;
        SkASSERT(!s == !o);

        if (s) {
            paint.setShader(std::move(s));
            paintOptions.setShaders({o});
        }
    }

    {
        auto [cf, o] = CreateRandomColorFilter(rand, cfType);
        SkASSERT(!cf == !o);
        if (cf) {
            paint.setColorFilter(std::move(cf));
            paintOptions.setColorFilters({o});
        }
    }

    {
        auto [mf, o] = CreateRandomMaskFilter(rand, mfType);
        SkASSERT(!mf == !o);
        if (mf) {
            paint.setMaskFilter(std::move(mf));
            paintOptions.setMaskFilters({o});
        }
    }

    {
        auto [b, o] = CreateRandomBlender(rand, blenderType);
        SkASSERT(!b == !o);
        if (b) {
            paint.setBlender(std::move(b));
            paintOptions.setBlenders({o});
        }
    }

    {
        auto [filter, o] = CreateRandomImageFilter(recorder, rand, imageFilterType);
        SkASSERT(!filter == !o);
        if (filter) {
            paint.setImageFilter(std::move(filter));
            paintOptions.setImageFilters({o});
        }
    }

    if (rand->nextBool()) {
        paint.setDither(true);
        paintOptions.setDither(true);
    }

    return {paint, paintOptions};
}

static SkPath make_path() {
    SkPathBuilder path;
    path.moveTo(0, 0);
    path.lineTo(8, 2);
    path.lineTo(16, 0);
    path.lineTo(14, 8);
    path.lineTo(16, 16);
    path.lineTo(8, 14);
    path.lineTo(0, 16);
    path.lineTo(2, 8);
    path.close();
    return path.detach();
}

DrawData::DrawData() {
    static constexpr int kMaskTextFontSize = 16;
    static constexpr int kPathTextFontSize = 300;

    SkFont font(ToolUtils::DefaultPortableTypeface(), kMaskTextFontSize);
    SkFont lcdFont(ToolUtils::DefaultPortableTypeface(), kMaskTextFontSize);
    lcdFont.setSubpixel(true);
    lcdFont.setEdging(SkFont::Edging::kSubpixelAntiAlias);

    ToolUtils::EmojiTestSample emojiTestSample =
            ToolUtils::EmojiSample(ToolUtils::EmojiFontFormat::ColrV0);
    SkFont emojiFont(emojiTestSample.typeface);
    SkFont pathFont(ToolUtils::DefaultPortableTypeface(), kPathTextFontSize);

    const char text[] = "hambur1";
    constexpr int kNumVerts = 4;
    constexpr SkPoint kPositions[kNumVerts]{{0, 0}, {0, 16}, {16, 16}, {16, 0}};
    constexpr SkColor kColors[kNumVerts] = {
            SK_ColorBLUE, SK_ColorGREEN, SK_ColorCYAN, SK_ColorYELLOW};

    fPath = make_path();
    fBlob = SkTextBlob::MakeFromText(text, strlen(text), font);
    fLCDBlob = SkTextBlob::MakeFromText(text, strlen(text), lcdFont);
    fEmojiBlob = SkTextBlob::MakeFromText(
            emojiTestSample.sampleText, strlen(emojiTestSample.sampleText), emojiFont);
    fPathBlob = SkTextBlob::MakeFromText(text, strlen(text), pathFont);
    fVertsWithColors = SkVertices::MakeCopy(
            SkVertices::kTriangleFan_VertexMode, kNumVerts, kPositions, kPositions, kColors);
    fVertsWithOutColors = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode,
                                               kNumVerts,
                                               kPositions,
                                               kPositions,
                                               /* colors= */ nullptr);
}

void non_simple_draws(SkCanvas* canvas, const SkPaint& paint, const DrawData& drawData) {
    canvas->drawPath(drawData.fPath, paint);
    canvas->drawTextBlob(drawData.fPathBlob, 0, 16, paint);
    if (paint.getStyle() == SkPaint::kStroke_Style) {
        canvas->drawArc({0, 0, 16, 16}, 0, 90, /* useCenter= */ true, paint);
    }
}

void ExecuteDraw(SkCanvas* canvas,
                 const SkPaint& paint,
                 const DrawData& drawData,
                 DrawTypeFlags dt) {
    // Mask out the modifiers that don't affect which API is called on the canvas
    DrawTypeFlags drawType = static_cast<DrawTypeFlags>(dt & ~DrawTypeFlags::kAnalyticClip);

    switch (drawType) {
        case DrawTypeFlags::kBitmapText_Mask:
            canvas->drawTextBlob(drawData.fBlob, 0, 16, paint);
            break;
        case DrawTypeFlags::kBitmapText_LCD:
            canvas->drawTextBlob(drawData.fLCDBlob, 0, 16, paint);
            break;
        case DrawTypeFlags::kBitmapText_Color:
            canvas->drawTextBlob(drawData.fEmojiBlob, 0, 16, paint);
            break;
        case DrawTypeFlags::kSDFText: {
            SkMatrix perspective;
            perspective.setPerspX(0.01f);
            perspective.setPerspY(0.001f);
            canvas->save();
            canvas->concat(perspective);
            canvas->drawTextBlob(drawData.fBlob, 0, 16, paint);
            canvas->restore();
        } break;
        case DrawTypeFlags::kSDFText_LCD: {
            SkMatrix perspective;
            perspective.setPerspX(0.01f);
            perspective.setPerspY(0.001f);
            canvas->save();
            canvas->concat(perspective);
            canvas->drawTextBlob(drawData.fLCDBlob, 0, 16, paint);
            canvas->restore();
        } break;
        case DrawTypeFlags::kDrawVertices:
            canvas->drawVertices(drawData.fVertsWithColors, SkBlendMode::kDst, paint);
            canvas->drawVertices(drawData.fVertsWithOutColors, SkBlendMode::kDst, paint);
            break;
        case DrawTypeFlags::kCircularArc:
            canvas->drawArc({0, 0, 16, 16}, 0, 90, /* useCenter= */ false, paint);
            if (paint.getStyle() == SkPaint::kFill_Style) {
                canvas->drawArc({0, 0, 16, 16}, 0, 90, /* useCenter= */ true, paint);
            }
            break;
        case DrawTypeFlags::kAnalyticRRect:
            canvas->drawRRect(SkRRect::MakeOval({0, 0, 15, 15}), paint);
            canvas->drawRRect(SkRRect::MakeRectXY({0, 0, 15, 15}, 4, 4), paint);
            break;
        case DrawTypeFlags::kPerEdgeAAQuad:
            if (!paint.getShader() && !paint.getColorFilter() && !paint.getImageFilter() &&
                paint.asBlendMode().has_value()) {
                canvas->experimental_DrawEdgeAAQuad(SkRect::MakeWH(15, 15),
                                                    nullptr,
                                                    SkCanvas::kAll_QuadAAFlags,
                                                    paint.getColor4f(),
                                                    paint.asBlendMode().value());
            }
            break;
        case DrawTypeFlags::kNonAAFillRect:
            canvas->drawRect(SkRect::MakeWH(15, 15), paint);
            break;
        case DrawTypeFlags::kNonSimpleShape:
            non_simple_draws(canvas, paint, drawData);
            break;
        default:
            SkASSERT(false);
            break;
    }
}

}  // namespace skiatest::graphite

#endif  // SK_GRAPHITE