#include "IO/ImageExporter.h"
#include "Rendering/HslBlend.h"
#include "Rendering/LayerRenderer.h"
#include "RenderFixtures.h"
#include <QPixmap>
#include <QRandomGenerator>
#include "AddressSpaceLimit.h"
#include <QtTest>
#include <algorithm>
#include <array>

namespace {
using Rgb = std::array<double, 3>;





double lum(const Rgb &color)
{
    return 0.3 * color[0] + 0.59 * color[1] + 0.11 * color[2];
}

Rgb clipColor(Rgb color)
{
    const double l = lum(color), low = *std::min_element(color.begin(), color.end()),
                 high = *std::max_element(color.begin(), color.end());
    for (double &channel : color) {
        if (low < 0)
            channel = l + (channel - l) * l / (l - low);
        if (high > 1)
            channel = l + (channel - l) * (1 - l) / (high - l);
    }
    return color;
}

Rgb setLum(Rgb color, double l)
{
    const double shift = l - lum(color);
    for (double &channel : color)
        channel += shift;
    return clipColor(color);
}

double sat(const Rgb &color)
{
    return *std::max_element(color.begin(), color.end()) - *std::min_element(color.begin(), color.end());
}

Rgb setSat(Rgb color, double s)
{
    const auto [low, high] = std::minmax_element(color.begin(), color.end());
    const double floor = *low, ceiling = *high;
    for (double &channel : color)
        channel = ceiling > floor ? (channel - floor) * s / (ceiling - floor) : 0;
    return color;
}

// The PDF and W3C blend function B(backdrop, source) per mode.
Rgb reference(LayerBlendMode mode, const Rgb &backdrop, const Rgb &source)
{
    Rgb result{};
    for (int channel = 0; channel < 3; ++channel) {
        const double b = backdrop[channel], s = source[channel];
        const auto hardLight = [](double below, double above) {
            return above <= 0.5 ? below * 2 * above : below + (2 * above - 1) - below * (2 * above - 1);
        };
        switch (mode) {
        case LayerBlendMode::normal: result[channel] = s; break;
        case LayerBlendMode::multiply: result[channel] = b * s; break;
        case LayerBlendMode::screen: result[channel] = b + s - b * s; break;
        case LayerBlendMode::overlay: result[channel] = hardLight(s, b); break;
        case LayerBlendMode::softLight: {
            const double d = b <= 0.25 ? ((16 * b - 12) * b + 4) * b : std::sqrt(b);
            result[channel] = s <= 0.5 ? b - (1 - 2 * s) * b * (1 - b) : b + (2 * s - 1) * (d - b);
            break;
        }
        case LayerBlendMode::darken: result[channel] = std::min(b, s); break;
        case LayerBlendMode::lighten: result[channel] = std::max(b, s); break;
        case LayerBlendMode::difference: result[channel] = std::abs(b - s); break;
        case LayerBlendMode::colorDodge: result[channel] = b == 0 ? 0 : s >= 1 ? 1 : std::min(1.0, b / (1 - s)); break;
        case LayerBlendMode::colorBurn: result[channel] = b >= 1 ? 1 : s <= 0 ? 0 : 1 - std::min(1.0, (1 - b) / s); break;
        default: break;
        }
    }
    switch (mode) {
    case LayerBlendMode::hue: return setLum(setSat(source, sat(backdrop)), lum(backdrop));
    case LayerBlendMode::saturation: return setLum(setSat(backdrop, sat(source)), lum(backdrop));
    case LayerBlendMode::color: return setLum(source, lum(backdrop));
    case LayerBlendMode::luminosity: return setLum(backdrop, lum(source));
    default: return result;
    }
}

// Expected premultiplied bytes, from the premultiplied bytes drawn.
std::array<int, 4> composited(LayerBlendMode mode, QRgb backdropPixel, QRgb sourcePixel)
{
    const auto color = [](QRgb pixel) {
        const double alpha = std::max(1, qAlpha(pixel));
        return Rgb{qRed(pixel) / alpha, qGreen(pixel) / alpha, qBlue(pixel) / alpha};
    };
    const Rgb backdrop = color(backdropPixel), source = color(sourcePixel);
    const double backdropAlpha = qAlpha(backdropPixel) / 255.0, sourceAlpha = qAlpha(sourcePixel) / 255.0;
    const Rgb both = reference(mode, backdrop, source);
    std::array<int, 4> bytes{};
    for (int channel = 0; channel < 3; ++channel) {
        const double value = source[channel] * sourceAlpha * (1 - backdropAlpha)
            + backdrop[channel] * backdropAlpha * (1 - sourceAlpha) + both[channel] * sourceAlpha * backdropAlpha;
        bytes[channel] = int(std::lround(value * 255));
    }
    bytes[3] = int(std::lround((sourceAlpha + backdropAlpha - sourceAlpha * backdropAlpha) * 255));
    return bytes;
}

QRgb premultiplied(const Rgb &color, double alpha)
{
    return qRgba(int(std::lround(color[0] * alpha * 255)), int(std::lround(color[1] * alpha * 255)),
                 int(std::lround(color[2] * alpha * 255)), int(std::lround(alpha * 255)));
}
}

class BlendModeTests : public QObject {
    Q_OBJECT
private slots:
    void everyBlendModeMatchesThePdfFormulas_data();
    void everyBlendModeMatchesThePdfFormulas();
    void hslModesHonorLayerOpacity();
    void hslModesIgnoreThePaintersOwnOpacity();
    void hslResultsStayValidPremultipliedPixels();
    void hslModesRespectThePainterClip();
    void hslModesNeedAnImageBackedPainter();
    void hslBlendChecksItsInputs();
};

void BlendModeTests::everyBlendModeMatchesThePdfFormulas_data()
{
    QTest::addColumn<LayerBlendMode>("mode");
    const std::pair<const char *, LayerBlendMode> modes[] = {
        {"normal", LayerBlendMode::normal}, {"multiply", LayerBlendMode::multiply}, {"screen", LayerBlendMode::screen},
        {"overlay", LayerBlendMode::overlay}, {"softLight", LayerBlendMode::softLight}, {"darken", LayerBlendMode::darken}, {"lighten", LayerBlendMode::lighten},
        {"difference", LayerBlendMode::difference}, {"colorDodge", LayerBlendMode::colorDodge},
        {"colorBurn", LayerBlendMode::colorBurn}, {"hue", LayerBlendMode::hue}, {"saturation", LayerBlendMode::saturation},
        {"color", LayerBlendMode::color}, {"luminosity", LayerBlendMode::luminosity}};
    for (const auto &[name, mode] : modes)
        QTest::newRow(name) << mode;
}

void BlendModeTests::everyBlendModeMatchesThePdfFormulas()
{
    QFETCH(LayerBlendMode, mode);
    const Rgb colors[] = {{0.9, 0.2, 0.4}, {0.1, 0.6, 0.3}, {0.5, 0.5, 0.5}, {1, 1, 1}, {0, 0, 0}, {0.25, 0.75, 1}};
    const double alphas[] = {1, 0.6, 0.2, 0};
    const LayerTransform transform = placedAt({0, 0}, {2, 2});
    for (const Rgb &backdrop : colors) {
        for (const Rgb &source : colors) {
            for (double backdropAlpha : alphas) {
                for (double sourceAlpha : alphas) {
                    const QRgb below = premultiplied(backdrop, backdropAlpha), above = premultiplied(source, sourceAlpha);
                    QImage surface = solid(2, 2, below);
                    QPainter painter(&surface);
                    LayerRenderer::draw(solid(2, 2, above), transform, transform.center(), painter, {.blendMode = mode});
                    painter.end();
                    const std::array<int, 4> expected = composited(mode, below, above);
                    const uchar *pixel = surface.constScanLine(1) + 4;
                    for (int channel = 0; channel < 4; ++channel) {
                        QVERIFY2(std::abs(pixel[channel] - expected[channel]) <= 2,
                                 qPrintable(QString("channel %1: %2 not %3, backdrop alpha %4, source alpha %5")
                                                .arg(channel).arg(pixel[channel]).arg(expected[channel])
                                                .arg(backdropAlpha).arg(sourceAlpha)));
                    }
                }
            }
        }
    }
}

void BlendModeTests::hslModesHonorLayerOpacity()
{
    const QRgb below = qRgba(200, 40, 40, 255), above = qRgba(30, 90, 220, 255);
    const LayerTransform transform = placedAt({0, 0}, {2, 2});
    for (LayerBlendMode mode : {LayerBlendMode::hue, LayerBlendMode::saturation, LayerBlendMode::color, LayerBlendMode::luminosity}) {
        QImage surface = solid(2, 2, below);
        QPainter painter(&surface);
        LayerRenderer::draw(solid(2, 2, above), transform, transform.center(), painter, {.opacity = 0.4, .blendMode = mode});
        painter.end();
        const std::array<int, 4> expected = composited(mode, below, qRgba(12, 36, 88, 102));
        const uchar *pixel = surface.constScanLine(0);
        for (int channel = 0; channel < 4; ++channel)
            QVERIFY(std::abs(pixel[channel] - expected[channel]) <= 2);
        QVERIFY(surface.pixel(0, 0) != below);
    }
}

void BlendModeTests::hslModesRespectThePainterClip()
{
    QImage surface = solid(8, 8, qRgba(200, 40, 40, 255));
    QPainter painter(&surface);
    painter.setClipRect(QRect(0, 0, 4, 8));
    const LayerTransform transform = placedAt({0, 0}, {8, 8});
    LayerRenderer::draw(solid(8, 8, qRgba(40, 40, 200, 255)), transform, transform.center(), painter,
                        {.blendMode = LayerBlendMode::color});
    painter.end();
    QVERIFY(surface.pixel(1, 1) != qRgba(200, 40, 40, 255));
    QCOMPARE(surface.pixel(5, 5), qRgba(200, 40, 40, 255));
}

void BlendModeTests::hslModesNeedAnImageBackedPainter()
{
    QPixmap pixmap(4, 4);
    QPainter painter(&pixmap);
    const LayerTransform transform = placedAt({0, 0}, {4, 4});
    QVERIFY_THROWS_EXCEPTION(std::logic_error, LayerRenderer::draw(solid(4, 4, qRgba(9, 9, 9, 255)), transform,
                                                                   transform.center(), painter,
                                                                   {.blendMode = LayerBlendMode::luminosity}));
}

void BlendModeTests::hslBlendChecksItsInputs()
{
    const QImage color = solid(2, 2, qRgba(9, 9, 9, 255));
    QVERIFY_THROWS_EXCEPTION(std::logic_error, HslBlend::blend(color, solid(3, 2, qRgba(9, 9, 9, 255)), LayerBlendMode::hue, 1));
    QVERIFY_THROWS_EXCEPTION(std::logic_error, HslBlend::blend(color.convertToFormat(QImage::Format_ARGB32), color, LayerBlendMode::hue, 1));
    QVERIFY_THROWS_EXCEPTION(std::logic_error, HslBlend::blend(color, color.convertToFormat(QImage::Format_ARGB32), LayerBlendMode::hue, 1));
    QVERIFY_THROWS_EXCEPTION(std::logic_error, HslBlend::blend(color, color, LayerBlendMode::multiply, 1));
    QVERIFY(HslBlend::handles(LayerBlendMode::hue) && HslBlend::handles(LayerBlendMode::saturation));
    QVERIFY(HslBlend::handles(LayerBlendMode::color) && HslBlend::handles(LayerBlendMode::luminosity));
    QVERIFY(!HslBlend::handles(LayerBlendMode::normal) && !HslBlend::handles(LayerBlendMode::colorBurn));

    const QImage large(8192, 8192, QImage::Format_RGBA8888_Premultiplied), other(8192, 8192, QImage::Format_RGBA8888_Premultiplied);
    std::optional<AddressSpaceLimit> limit(std::in_place, 16 * 1024 * 1024);
    std::optional<ExportError::Kind> thrown;
    try {
        HslBlend::blend(large, other, LayerBlendMode::hue, 1);
    } catch (const ExportError &error) {
        thrown = error.kind;
    }
    limit.reset();
    QCOMPARE(thrown, std::optional(ExportError::Kind::render));
}

void BlendModeTests::hslModesIgnoreThePaintersOwnOpacity()
{
    QImage surface = BrushRaster::context(2, 2, false);
    QPainter painter(&surface);
    painter.setOpacity(0.25);
    const LayerTransform transform = placedAt({0, 0}, {2, 2});
    LayerRenderer::draw(solid(2, 2, qRgba(30, 90, 220, 255)), transform, transform.center(), painter,
                        {.blendMode = LayerBlendMode::color});
    QCOMPARE(painter.opacity(), 0.25);
    painter.end();
    QCOMPARE(surface.pixel(0, 0), qRgba(30, 90, 220, 255));
}

void BlendModeTests::hslResultsStayValidPremultipliedPixels()
{
    const QImage worst = HslBlend::blend(solid(1, 1, qRgba(30, 30, 30, 30)), solid(1, 1, qRgba(17, 17, 17, 17)),
                                         LayerBlendMode::hue, 0.9);
    const uchar *pixel = worst.constScanLine(0);
    QVERIFY(pixel[0] <= pixel[3] && pixel[1] <= pixel[3] && pixel[2] <= pixel[3]);
    QCOMPARE(pixel[3], uchar(43));

    QRandomGenerator random(7);
    QImage backdrop = BrushRaster::context(64, 64, false), source = backdrop;
    for (QImage *image : {&backdrop, &source}) {
        for (int y = 0; y < 64; ++y) {
            for (int x = 0; x < 64; ++x) {
                const int alpha = random.bounded(256);
                image->setPixel(x, y, qRgba(random.bounded(alpha + 1), random.bounded(alpha + 1), random.bounded(alpha + 1), alpha));
            }
        }
    }
    for (LayerBlendMode mode : {LayerBlendMode::hue, LayerBlendMode::saturation, LayerBlendMode::color, LayerBlendMode::luminosity}) {
        for (double opacity : {1.0, 0.9, 0.37}) {
            const QImage blended = HslBlend::blend(backdrop, source, mode, opacity);
            int invalid = 0;
            for (int y = 0; y < 64; ++y) {
                const uchar *row = blended.constScanLine(y);
                for (int x = 0; x < 64; ++x, row += 4)
                    invalid += row[0] > row[3] || row[1] > row[3] || row[2] > row[3];
            }
            QCOMPARE(invalid, 0);
        }
    }
}

QTEST_MAIN(BlendModeTests)
#include "BlendModeTests.moc"