/*
 * Copyright (C) 2021 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1.  Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 * 2.  Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "GradientRendererCG.h"

#include "ColorInterpolation.h"
#include "ColorSpaceCG.h"
#include "GradientColorStops.h"
#include <pal/spi/cg/CoreGraphicsSPI.h>

namespace WebCore {

GradientRendererCG::GradientRendererCG(ColorInterpolationMethod colorInterpolationMethod, const GradientColorStops& stops)
    : m_strategy { pickStrategy(colorInterpolationMethod, stops) }
{
}

// MARK: - Strategy selection.

#if !HAVE(CORE_GRAPHICS_PREMULTIPLIED_INTERPOLATION_GRADIENT)

enum class EmulatedAlphaPremuliplicationAnalysisResult {
    UseGradientAsIs,
    UseGradientWithAlphaTransforms,
    UseShading
};

enum class AlphaType {
    Opaque,
    PartiallyTransparent,
    FullyTransparent
};

static constexpr AlphaType classifyAlphaType(float alpha)
{
    if (alpha == 1.0f)
        return AlphaType::Opaque;
    if (alpha == 0.0f)
        return AlphaType::FullyTransparent;
    return AlphaType::PartiallyTransparent;
}

static EmulatedAlphaPremuliplicationAnalysisResult analyzeColorStopsForEmulatedAlphaPremuliplicationOppertunity(const GradientColorStops& stops)
{
    if (stops.size() < 2)
        return EmulatedAlphaPremuliplicationAnalysisResult::UseGradientAsIs;

    bool uniformAlpha = true;

    auto& initialStop = *stops.begin();
    auto previousStopAlpha = initialStop.color.alphaAsFloat();
    auto previousStopAlphaType = classifyAlphaType(previousStopAlpha);

    auto stopIterator = stops.begin();
    ++stopIterator;

    while (stopIterator != stops.end()) {
        auto& stop = *stopIterator;

        auto stopAlpha = stop.color.alphaAsFloat();
        auto stopAlphaType = classifyAlphaType(stopAlpha);

        switch (stopAlphaType) {
        case AlphaType::Opaque:
            switch (previousStopAlphaType) {
            case AlphaType::Opaque:
                break;
            case AlphaType::PartiallyTransparent:
                return EmulatedAlphaPremuliplicationAnalysisResult::UseShading;
            case AlphaType::FullyTransparent:
                uniformAlpha = false;
                break;
            }
            break;

        case AlphaType::PartiallyTransparent:
            switch (previousStopAlphaType) {
            case AlphaType::Opaque:
                return EmulatedAlphaPremuliplicationAnalysisResult::UseShading;
            case AlphaType::PartiallyTransparent:
                if (previousStopAlpha != stopAlpha)
                    return EmulatedAlphaPremuliplicationAnalysisResult::UseShading;
                break;
            case AlphaType::FullyTransparent:
                uniformAlpha = false;
                break;
            }
            break;

        case AlphaType::FullyTransparent:
            switch (previousStopAlphaType) {
            case AlphaType::Opaque:
            case AlphaType::PartiallyTransparent:
                uniformAlpha = false;
                break;

            case AlphaType::FullyTransparent:
                break;
            }
            break;
        }

        previousStopAlpha = stopAlpha;
        previousStopAlphaType = stopAlphaType;

        ++stopIterator;
    }

    return uniformAlpha ? EmulatedAlphaPremuliplicationAnalysisResult::UseGradientAsIs : EmulatedAlphaPremuliplicationAnalysisResult::UseGradientWithAlphaTransforms;
}

static GradientColorStops alphaTransformStopsToEmulateAlphaPremuliplication(const GradientColorStops& stops)
{
    // The following is the set of transforms that can be performed on a color stop list to transform it from one used with a premuliplied alpha gradient
    // implmentation to one used by with an un-premultiplied gradient implementation.

    // ... Opaque  -> Transparent -> Opaque  ...                                  ==>    ... Opaque  -> TRANSFORM{Transparent(PreviousChannels)} | ADDITION{Transparent(NextChannels)} -> Opaque  ...
    // ... Partial -> Transparent -> Partial ...                                  ==>    ... Partial -> TRANSFORM{Transparent(PreviousChannels)} | ADDITION{Transparent(NextChannels)} -> Partial ...
    // ... Opaque  -> Transparent -> Partial ...                                  ==>    ... Opaque  -> TRANSFORM{Transparent(PreviousChannels)} | ADDITION{Transparent(NextChannels)} -> Partial ...
    // ... Partial -> Transparent -> Opaque  ...                                  ==>    ... Partial -> TRANSFORM{Transparent(PreviousChannels)} | ADDITION{Transparent(NextChannels)} -> Opaque  ...
    //
    // ... Opaque  -> Transparent -> Transparent -> Opaque  ...                   ==>    ... Opaque  -> TRANSFORM{Transparent(PreviousChannels)} -> TRANSFORM{Transparent(NextChannels)} -> Opaque  ...
    // ... Partial -> Transparent -> Transparent -> Partial ...                   ==>    ... Partial -> TRANSFORM{Transparent(PreviousChannels)} -> TRANSFORM{Transparent(NextChannels)} -> Partial ...
    // ... Opaque  -> Transparent -> Transparent -> Partial ...                   ==>    ... Opaque  -> TRANSFORM{Transparent(PreviousChannels)} -> TRANSFORM{Transparent(NextChannels)} -> Partial ...
    // ... Partial -> Transparent -> Transparent -> Opaque  ...                   ==>    ... Partial -> TRANSFORM{Transparent(PreviousChannels)} -> TRANSFORM{Transparent(NextChannels)} -> Opaque  ...
    //
    // ... Opaque  -> Transparent -> Transparent -> Transparent -> Opaque  ...    ==>    ... Opaque  -> TRANSFORM{Transparent(PreviousChannels)} -> Transparent -> TRANSFORM{Transparent(NextChannels)} -> Opaque  ...
    // ... Partial -> Transparent -> Transparent -> Transparent -> Partial ...    ==>    ... Partial -> TRANSFORM{Transparent(PreviousChannels)} -> Transparent -> TRANSFORM{Transparent(NextChannels)} -> Partial ...
    // ... Opaque  -> Transparent -> Transparent -> Transparent -> Partial ...    ==>    ... Opaque  -> TRANSFORM{Transparent(PreviousChannels)} -> Transparent -> TRANSFORM{Transparent(NextChannels)} -> Partial ...
    // ... Partial -> Transparent -> Transparent -> Transparent -> Opaque  ...    ==>    ... Partial -> TRANSFORM{Transparent(PreviousChannels)} -> Transparent -> TRANSFORM{Transparent(NextChannels)} -> Opaque  ...
    //
    // [ Transparent -> Opaque      ...                                           ==>    [ TRANSFORM{Transparent(NextChannels)} -> Opaque      ...
    // [ Transparent -> Partial     ...                                           ==>    [ TRANSFORM{Transparent(NextChannels)} -> Partial     ...
    // [ Transparent -> Transparent ...                                           ==>    [ Transparent                          -> Transparent ...
    //
    // ... Opaque       -> Transparent ]                                          ==>    ... Opaque      -> TRANSFORM{Transparent(PreviousChannels)} ]
    // ... Partial      -> Transparent ]                                          ==>    ... Partial     -> TRANSFORM{Transparent(PreviousChannels)} ]
    // ... Transparent  -> Transparent ]                                          ==>    ... Transparent -> Transparent                              ]

    // For each stop the following actions are possible:
    //      - Default           Append self
    //      - Steal previous    Append previous.colorWithAlpha(0.0f)
    //      - Steal next        Append next.colorWithAlpha(0.0f)
    //      - Split             Append previous.colorWithAlpha(0.0f) + next.colorWithAlpha(0.0f)

    ASSERT(stops.size() > 1);

    // Special case when we only have two stops to avoid complicating the cases with more.
    if (stops.size() == 2) {
        // Illegal pairs (ruled out in analysis)
        //   Opaque  -> Partial
        //   Partial -> Opaque
        //
        // Possible pairs
        //   Opaque      -> Opaque       (default, default)
        //   Partial     -> Partial      (default, default)
        //   Transparent -> Transparent  (default, default)
        //   Opaque      -> Transparent  (default, steal previous)
        //   Partial     -> Transparent  (default, steal previous)
        //   Transparent -> Opaque       (steals next, default)
        //   Transparent -> Partial      (steals next, default)

        GradientColorStops::StopVector result;
        result.reserveInitialCapacity(2);

        auto& stop1 = stops.stops()[0];
        auto& stop2 = stops.stops()[1];

        auto stop1AlphaType = classifyAlphaType(stop1.color.alphaAsFloat());
        auto stop2AlphaType = classifyAlphaType(stop2.color.alphaAsFloat());

        switch (stop1AlphaType) {
        case AlphaType::Opaque:
        case AlphaType::PartiallyTransparent:
            // ACTION (stop1): Default.
            result.uncheckedAppend(stop1);

            switch (stop2AlphaType) {
            case AlphaType::Opaque:
            case AlphaType::PartiallyTransparent:
                // ACTION (stop2): Default.
                result.uncheckedAppend(stop2);
                break;
            case AlphaType::FullyTransparent:
                // ACTION (stop2): Steal previous.
                result.uncheckedAppend({ stop2.offset, stop1.color.colorWithAlpha(0.0f) });
                break;
            }

            break;

        case AlphaType::FullyTransparent:
            switch (stop2AlphaType) {
            case AlphaType::Opaque:
            case AlphaType::PartiallyTransparent:
                // ACTION (stop1): Steal next.
                result.uncheckedAppend({ stop1.offset, stop2.color.colorWithAlpha(0.0f) });
                break;
            case AlphaType::FullyTransparent:
                // ACTION (stop1): Default.
                result.uncheckedAppend(stop1);
                break;
            }
            // ACTION (stop2): Default.
            result.uncheckedAppend(stop2);
            break;
        }

        return GradientColorStops::Sorted { WTFMove(result) };
    }

    GradientColorStops::StopVector result;

    // 1. Handle first stop.
    //
    // [first stop matters]
    //
    // Illegal pairs (ruled out in analysis)
    //   Opaque  -> Partial
    //   Partial -> Opaque
    //
    // Possible pairs
    //   Opaque      -> Opaque       (default)
    //   Partial     -> Partial      (default)
    //   Transparent -> Transparent  (default)
    //   Opaque      -> Transparent  (default)
    //   Partial     -> Transparent  (default)
    //   Transparent -> Opaque       (steals next)
    //   Transparent -> Partial      (steals next)

    auto& firstStop = stops.stops()[0];
    auto& secondStop = stops.stops()[1];

    auto firstStopAlphaType = classifyAlphaType(firstStop.color.alphaAsFloat());
    auto secondStopAlphaType = classifyAlphaType(secondStop.color.alphaAsFloat());

    if (firstStopAlphaType == AlphaType::FullyTransparent && secondStopAlphaType != AlphaType::FullyTransparent) {
        // ACTION: Steal next.
        result.append({ firstStop.offset, secondStop.color.colorWithAlpha(0.0f) });
    } else {
        // ACTION: Default.
        result.append(firstStop);
    }

    // 2. Handle middle stops.
    //
    // [middle stop matters]
    //
    // Illegal triplets (ruled out in analysis)
    //   Opaque      -> Opaque      -> Partial
    //   Opaque      -> Partial     -> Partial
    //   Opaque      -> Partial     -> Opaque
    //   Partial     -> Opaque      -> Opaque
    //   Partial     -> Partial     -> Opaque
    //   Partial     -> Opaque      -> Partial
    //
    // Possible triplets
    //   Opaque      -> Opaque      -> Opaque       (default)
    //   Partial     -> Partial     -> Partial      (default)
    //   Opaque      -> Opaque      -> Transparent  (default)
    //   Opaque      -> Partial     -> Transparent  (default)
    //   Partial     -> Partial     -> Transparent  (default)
    //   Partial     -> Opaque      -> Transparent  (default)
    //   Transparent -> Opaque      -> Transparent  (default)
    //   Transparent -> Partial     -> Transparent  (default)
    //   Transparent -> Transparent -> Transparent  (default)
    //   Opaque      -> Transparent -> Opaque       (splits, steals previous + next)
    //   Opaque      -> Transparent -> Partial      (splits, steals previous + next)
    //   Partial     -> Transparent -> Partial      (splits, steals previous + next)
    //   Partial     -> Transparent -> Opaque       (splits, steals previous + next)
    //   Transparent -> Transparent -> Opaque       (steals next)
    //   Transparent -> Transparent -> Partial      (steals next)
    //   Opaque      -> Transparent -> Transparent  (steals previous)
    //   Partial     -> Transparent -> Transparent  (steals previous)

    size_t previousStopIndex = 0;
    size_t stopIndex = 1;
    size_t nextStopIndex = 2;

    for (; nextStopIndex < stops.size(); ++previousStopIndex, ++stopIndex, ++nextStopIndex) {
        auto& previousStop = stops.stops()[previousStopIndex];
        auto& stop = stops.stops()[stopIndex];
        auto& nextStop = stops.stops()[nextStopIndex];

        auto previousStopAlphaType = classifyAlphaType(previousStop.color.alphaAsFloat());
        auto stopAlphaType = classifyAlphaType(stop.color.alphaAsFloat());
        auto nextStopAlphaType = classifyAlphaType(nextStop.color.alphaAsFloat());

        if (stopAlphaType == AlphaType::FullyTransparent) {
            switch (previousStopAlphaType) {
            case AlphaType::Opaque:
            case AlphaType::PartiallyTransparent:
                switch (nextStopAlphaType) {
                case AlphaType::Opaque:
                case AlphaType::PartiallyTransparent:
                    // ACTION: Split.
                    result.append({ stop.offset, previousStop.color.colorWithAlpha(0.0f) });
                    result.append({ stop.offset, nextStop.color.colorWithAlpha(0.0f) });
                    break;

                case AlphaType::FullyTransparent:
                    // ACTION: Steal previous.
                    result.append({ stop.offset, previousStop.color.colorWithAlpha(0.0f) });
                    break;
                }
                break;

            case AlphaType::FullyTransparent:
                switch (nextStopAlphaType) {
                case AlphaType::Opaque:
                case AlphaType::PartiallyTransparent:
                    // ACTION: Steal next.
                    result.append({ stop.offset, nextStop.color.colorWithAlpha(0.0f) });
                    break;

                case AlphaType::FullyTransparent:
                    // ACTION: Default.
                    result.append(stop);
                    break;
                }
                break;
            }
        } else {
            // ACTION: Default.
            result.append(stop);
        }
    }

    ASSERT(nextStopIndex == stops.size());

    // 3. Handle last stop.
    //
    // [last stop matters]
    //
    // Illegal pairs (ruled out in analysis phase)
    //   Opaque  -> Partial
    //   Partial -> Opaque
    //
    // Possible pairs
    //   Opaque      -> Opaque       (default)
    //   Partial     -> Partial      (default)
    //   Transparent -> Transparent  (default)
    //   Opaque      -> Transparent  (steals previous)
    //   Partial     -> Transparent  (steals previous)
    //   Transparent -> Opaque       (default)
    //   Transparent -> Partial      (default)

    auto& secondToLastStop = stops.stops()[previousStopIndex];
    auto& lastStop = stops.stops()[stopIndex];

    auto secondToLastStopAlphaType = classifyAlphaType(secondToLastStop.color.alphaAsFloat());
    auto lastStopAlphaType = classifyAlphaType(lastStop.color.alphaAsFloat());

    if (lastStopAlphaType == AlphaType::FullyTransparent && secondToLastStopAlphaType != AlphaType::FullyTransparent) {
        // ACTION: Steal previous.
        result.append({ lastStop.offset, secondToLastStop.color.colorWithAlpha(0.0f) });
    } else {
        // ACTION: Default.
        result.append(lastStop);
    }

    return GradientColorStops::Sorted { WTFMove(result) };
}
#endif

static bool anyComponentIsNone(const GradientColorStops& stops)
{
    for (auto& stop : stops) {
        if (stop.color.anyComponentIsNone())
            return true;
    }
    
    return false;
}

GradientRendererCG::Strategy GradientRendererCG::pickStrategy(ColorInterpolationMethod colorInterpolationMethod, const GradientColorStops& stops) const
{
    return WTF::switchOn(colorInterpolationMethod.colorSpace,
        [&] (const ColorInterpolationMethod::SRGB&) -> Strategy {
            // FIXME: As an optimization we can precompute 'none' replacements and create a transformed stop list rather than falling back on CGShadingRef.
            if (anyComponentIsNone(stops))
                return makeShading(colorInterpolationMethod, stops);

            switch (colorInterpolationMethod.alphaPremultiplication) {
            case AlphaPremultiplication::Unpremultiplied:
                return makeGradient(colorInterpolationMethod, stops);
            case AlphaPremultiplication::Premultiplied:
#if HAVE(CORE_GRAPHICS_PREMULTIPLIED_INTERPOLATION_GRADIENT)
                return makeGradient(colorInterpolationMethod, stops);
#else
                switch (analyzeColorStopsForEmulatedAlphaPremuliplicationOppertunity(stops)) {
                case EmulatedAlphaPremuliplicationAnalysisResult::UseGradientAsIs:
                    return makeGradient({ ColorInterpolationMethod::SRGB { }, AlphaPremultiplication::Unpremultiplied }, stops);
                case EmulatedAlphaPremuliplicationAnalysisResult::UseGradientWithAlphaTransforms:
                    return makeGradient({ ColorInterpolationMethod::SRGB { }, AlphaPremultiplication::Unpremultiplied }, alphaTransformStopsToEmulateAlphaPremuliplication(stops));
                case EmulatedAlphaPremuliplicationAnalysisResult::UseShading:
                    return makeShading(colorInterpolationMethod, stops);
                }
#endif
            }
        },
        [&] (const auto&) -> Strategy {
            return makeShading(colorInterpolationMethod, stops);
        }
    );
}

// MARK: - Gradient strategy.

GradientRendererCG::Strategy GradientRendererCG::makeGradient(ColorInterpolationMethod colorInterpolationMethod, const GradientColorStops& stops) const
{
    ASSERT_UNUSED(colorInterpolationMethod, std::holds_alternative<ColorInterpolationMethod::SRGB>(colorInterpolationMethod.colorSpace));
#if !HAVE(CORE_GRAPHICS_PREMULTIPLIED_INTERPOLATION_GRADIENT)
    ASSERT_UNUSED(colorInterpolationMethod, colorInterpolationMethod.alphaPremultiplication == AlphaPremultiplication::Unpremultiplied);
#endif

#if HAVE(CORE_GRAPHICS_GRADIENT_CREATE_WITH_OPTIONS)
#if HAVE(CORE_GRAPHICS_PREMULTIPLIED_INTERPOLATION_GRADIENT)
    auto gradientInterpolatesPremultipliedOptionsDictionary = [] () -> CFDictionaryRef {
        static CFTypeRef keys[] = { kCGGradientInterpolatesPremultiplied };
        static CFTypeRef values[] = { kCFBooleanTrue };
        static CFDictionaryRef options = CFDictionaryCreate(kCFAllocatorDefault, keys, values, WTF_ARRAY_LENGTH(keys), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);

        return options;
    };

   auto gradientOptionsDictionary = [&] (auto colorInterpolationMethod) -> CFDictionaryRef {
        switch (colorInterpolationMethod.alphaPremultiplication) {
        case AlphaPremultiplication::Unpremultiplied:
            return nullptr;
        case AlphaPremultiplication::Premultiplied:
            return gradientInterpolatesPremultipliedOptionsDictionary();
        }
   };
#else
   auto gradientOptionsDictionary = [] (auto) -> CFDictionaryRef {
        return nullptr;
   };
#endif
#endif

    auto hasOnlyBoundedSRGBColorStops = [] (const auto& stops) {
        for (const auto& stop : stops) {
            if (stop.color.colorSpace() != ColorSpace::SRGB)
                return false;
        }
        return true;
    };

    auto numberOfStops = stops.size();

    static constexpr auto reservedStops = 3;
    Vector<CGFloat, reservedStops> locations;
    locations.reserveInitialCapacity(numberOfStops);

    Vector<CGFloat, 4 * reservedStops> colorComponents;
    colorComponents.reserveInitialCapacity(numberOfStops * 4);

    auto cgColorSpace = [&] {
        // FIXME: Now that we only ever use CGGradientCreateWithColorComponents, we should investigate
        // if there is any real benefit to using sRGB when all the stops are bounded vs just using
        // extended sRGB for all gradients.
        if (hasOnlyBoundedSRGBColorStops(stops)) {
            for (const auto& stop : stops) {
                auto [r, g, b, a] = stop.color.toColorTypeLossy<SRGBA<float>>().resolved();
                colorComponents.uncheckedAppend(r);
                colorComponents.uncheckedAppend(g);
                colorComponents.uncheckedAppend(b);
                colorComponents.uncheckedAppend(a);

                locations.uncheckedAppend(stop.offset);
            }
            return cachedCGColorSpace<ColorSpaceFor<SRGBA<float>>>();
        }

        using OutputSpaceColorType = std::conditional_t<HasCGColorSpaceMapping<ColorSpace::ExtendedSRGB>, ExtendedSRGBA<float>, SRGBA<float>>;
        for (const auto& stop : stops) {
            auto [r, g, b, a] = stop.color.toColorTypeLossy<OutputSpaceColorType>().resolved();
            colorComponents.uncheckedAppend(r);
            colorComponents.uncheckedAppend(g);
            colorComponents.uncheckedAppend(b);
            colorComponents.uncheckedAppend(a);

            locations.uncheckedAppend(stop.offset);
        }
        return cachedCGColorSpace<ColorSpaceFor<OutputSpaceColorType>>();
    }();

#if HAVE(CORE_GRAPHICS_GRADIENT_CREATE_WITH_OPTIONS)
    return Gradient { adoptCF(CGGradientCreateWithColorComponentsAndOptions(cgColorSpace, colorComponents.data(), locations.data(), numberOfStops, gradientOptionsDictionary(colorInterpolationMethod))) };
#else
    return Gradient { adoptCF(CGGradientCreateWithColorComponents(cgColorSpace, colorComponents.data(), locations.data(), numberOfStops)) };
#endif
}

// MARK: - Shading strategy.

template<typename InterpolationSpace, AlphaPremultiplication alphaPremultiplication>
void GradientRendererCG::Shading::shadingFunction(void* info, const CGFloat* in, CGFloat* out)
{
    using InterpolationSpaceColorType = typename InterpolationSpace::ColorType;
    using OutputSpaceColorType = std::conditional_t<HasCGColorSpaceMapping<ColorSpace::ExtendedSRGB>, ExtendedSRGBA<float>, SRGBA<float>>;

    auto* data = static_cast<GradientRendererCG::Shading::Data*>(info);

    // Compute color at offset 'in[0]' and assign the components to out[0 -> 3].

    float requestedOffset = in[0];

    // 1. Find stops that bound the requested offset.
    auto [stop0, stop1] = [&] {
        for (size_t stop = 1; stop < data->stops().size(); ++stop) {
            if (requestedOffset <= data->stops()[stop].offset)
                return std::tie(data->stops()[stop - 1], data->stops()[stop]);
        }
        RELEASE_ASSERT_NOT_REACHED();
    }();

    // 2. Compute percentage offset between the two stops.
    float offset = (stop1.offset == stop0.offset) ? 0.0f : (requestedOffset - stop0.offset) / (stop1.offset - stop0.offset);

    // 3. Interpolate the two stops' colors by the computed offset.
    // FIXME: We don't want to due hue fixup for each call, so we should figure out how to precompute that.
    auto interpolatedColor = interpolateColorComponents<alphaPremultiplication>(
        std::get<InterpolationSpace>(data->colorInterpolationMethod().colorSpace),
        makeFromComponents<InterpolationSpaceColorType>(stop0.colorComponents), 1.0f - offset,
        makeFromComponents<InterpolationSpaceColorType>(stop1.colorComponents), offset);

    // 4. Convert to the output color space.
    auto interpolatedColorConvertedToOutputSpace = asColorComponents(convertColor<OutputSpaceColorType>(interpolatedColor).resolved());

    // 5. Write color components to 'out' pointer.
    for (size_t componentIndex = 0; componentIndex < interpolatedColorConvertedToOutputSpace.size(); ++componentIndex)
        out[componentIndex] = interpolatedColorConvertedToOutputSpace[componentIndex];
}

GradientRendererCG::Strategy GradientRendererCG::makeShading(ColorInterpolationMethod colorInterpolationMethod, const GradientColorStops& stops) const
{
    using OutputSpaceColorType = std::conditional_t<HasCGColorSpaceMapping<ColorSpace::ExtendedSRGB>, ExtendedSRGBA<float>, SRGBA<float>>;

    auto makeData = [&] (auto colorInterpolationMethod, auto& stops) {
        auto convertColorToColorInterpolationSpace = [&] (const Color& color, auto colorInterpolationMethod) -> ColorComponents<float, 4> {
            return WTF::switchOn(colorInterpolationMethod.colorSpace,
                [&] (auto& colorSpace) -> ColorComponents<float, 4> {
                    using ColorType = typename std::remove_reference_t<decltype(colorSpace)>::ColorType;
                    return asColorComponents(color.template toColorTypeLossy<ColorType>().unresolved());
                }
            );
        };

        auto totalNumberOfStops = stops.size();
        bool hasZero = false;
        bool hasOne = false;

        for (const auto& stop : stops) {
            auto offset = stop.offset;
            ASSERT(offset >= 0);
            ASSERT(offset <= 1);
            
            if (offset == 0)
                hasZero = true;
            else if (offset == 1)
                hasOne = true;
        }

        if (!hasZero)
            totalNumberOfStops++;
        if (!hasOne)
            totalNumberOfStops++;

        // FIXME: To avoid duplicate work in the shader function, we could precompute a few things:
        //   - If we have a polar coordinate color space, we can pre-fixup the hues, inserting an extra stop at the same offset if both the fixup on the left and right require different results.
        //   - If we have 'none' components, we can precompute 'none' replacements, inserting an extra stop at the same offset if the replacements on the left and right are different.

        Vector<ColorConvertedToInterpolationColorSpaceStop> convertedStops;
        convertedStops.reserveInitialCapacity(totalNumberOfStops);

        if (!hasZero)
            convertedStops.uncheckedAppend({ 0.0f, { 0.0f, 0.0f, 0.0f, 0.0f } });

        for (const auto& stop : stops)
            convertedStops.uncheckedAppend({ stop.offset, convertColorToColorInterpolationSpace(stop.color, colorInterpolationMethod) });

        if (!hasOne)
            convertedStops.uncheckedAppend({ 1.0f, convertedStops.last().colorComponents });

        if (!hasZero)
            convertedStops[0].colorComponents = convertedStops[1].colorComponents;

        return Shading::Data::create(colorInterpolationMethod, WTFMove(convertedStops));
    };

    auto makeFunction = [&] (auto colorInterpolationMethod, auto& data) {
        auto makeEvaluateCallback = [&] (auto colorInterpolationMethod) -> CGFunctionEvaluateCallback {
            return WTF::switchOn(colorInterpolationMethod.colorSpace,
                [&] (auto& colorSpace) -> CGFunctionEvaluateCallback {
                    using InterpolationMethodColorSpace = typename std::remove_reference_t<decltype(colorSpace)>;
                    
                    switch (colorInterpolationMethod.alphaPremultiplication) {
                    case AlphaPremultiplication::Unpremultiplied:
                        return &Shading::shadingFunction<InterpolationMethodColorSpace, AlphaPremultiplication::Unpremultiplied>;
                    case AlphaPremultiplication::Premultiplied:
                        return &Shading::shadingFunction<InterpolationMethodColorSpace, AlphaPremultiplication::Premultiplied>;
                    }
                }
            );
        };

        const CGFunctionCallbacks callbacks = {
            0,
            makeEvaluateCallback(colorInterpolationMethod),
            [] (void* info) {
                static_cast<GradientRendererCG::Shading::Data*>(info)->deref();
            }
        };

        constexpr auto outputSpaceComponentInfo = OutputSpaceColorType::Model::componentInfo;

        static constexpr std::array<CGFloat, 2> domain = { 0, 1 };
        static constexpr std::array<CGFloat, 8> range = {
            outputSpaceComponentInfo[0].min, outputSpaceComponentInfo[0].max,
            outputSpaceComponentInfo[1].min, outputSpaceComponentInfo[1].max,
            outputSpaceComponentInfo[2].min, outputSpaceComponentInfo[2].max,
            0, 1
        };

        Ref dataRefCopy = data;
        return adoptCF(CGFunctionCreate(&dataRefCopy.leakRef(), domain.size() / 2, domain.data(), range.size() / 2, range.data(), &callbacks));
    };

    auto data = makeData(colorInterpolationMethod, stops);
    auto function = makeFunction(colorInterpolationMethod, data);

    // FIXME: Investigate using bounded sRGB when the input stops are all bounded sRGB.
    auto colorSpace = cachedCGColorSpace<ColorSpaceFor<OutputSpaceColorType>>();

    return Shading { WTFMove(data), WTFMove(function), colorSpace };
}

// MARK: - Drawing functions.

void GradientRendererCG::drawLinearGradient(CGContextRef platformContext, CGPoint startPoint, CGPoint endPoint, CGGradientDrawingOptions options)
{
    WTF::switchOn(m_strategy,
        [&] (Gradient& gradient) {
            CGContextDrawLinearGradient(platformContext, gradient.gradient.get(), startPoint, endPoint, options);
        },
        [&] (Shading& shading) {
            bool startExtend = (options & kCGGradientDrawsBeforeStartLocation) != 0;
            bool endExtend = (options & kCGGradientDrawsAfterEndLocation) != 0;

            CGContextDrawShading(platformContext, adoptCF(CGShadingCreateAxial(shading.colorSpace.get(), startPoint, endPoint, shading.function.get(), startExtend, endExtend)).get());
        }
    );
}

void GradientRendererCG::drawRadialGradient(CGContextRef platformContext, CGPoint startCenter, CGFloat startRadius, CGPoint endCenter, CGFloat endRadius, CGGradientDrawingOptions options)
{
    WTF::switchOn(m_strategy,
        [&] (Gradient& gradient) {
            CGContextDrawRadialGradient(platformContext, gradient.gradient.get(), startCenter, startRadius, endCenter, endRadius, options);
        },
        [&] (Shading& shading) {
            bool startExtend = (options & kCGGradientDrawsBeforeStartLocation) != 0;
            bool endExtend = (options & kCGGradientDrawsAfterEndLocation) != 0;

            CGContextDrawShading(platformContext, adoptCF(CGShadingCreateRadial(shading.colorSpace.get(), startCenter, startRadius, endCenter, endRadius, shading.function.get(), startExtend, endExtend)).get());
        }
    );
}

void GradientRendererCG::drawConicGradient(CGContextRef platformContext, CGPoint center, CGFloat angle)
{
#if HAVE(CORE_GRAPHICS_CONIC_GRADIENTS)
    WTF::switchOn(m_strategy,
        [&] (Gradient& gradient) {
            CGContextDrawConicGradient(platformContext, gradient.gradient.get(), center, angle);
        },
        [&] (Shading& shading) {
            CGContextDrawShading(platformContext, adoptCF(CGShadingCreateConic(shading.colorSpace.get(), center, angle, shading.function.get())).get());
        }
    );
#else
    UNUSED_PARAM(platformContext);
    UNUSED_PARAM(center);
    UNUSED_PARAM(angle);
#endif
}

}