#include "Document/BrushStroke.h"
#include "Document/EditorSession.h"
#include "IO/ProjectStore+Json.h"
#include "UI/FilterSheet.h"
#include <QCheckBox>
#include <QJsonObject>
#include <QLabel>
#include <QLineEdit>
#include <QSlider>
#include <QtTest>
#include <cmath>

// Black & White, Color Balance: kernels, bounds, keys, sheet.
namespace {
QImage solid(QColor colour)
{
    QImage image(2, 2, QImage::Format_RGBA8888_Premultiplied);
    image.fill(colour);
    return image;
}

QColor first(const QImage &image)
{
    return image.pixelColor(0, 0);
}

bool near(const QColor &actual, const QColor &expected)
{
    return std::abs(actual.red() - expected.red()) <= 1 && std::abs(actual.green() - expected.green()) <= 1
        && std::abs(actual.blue() - expected.blue()) <= 1 && actual.alpha() == expected.alpha();
}

// Photoshop's tint: the gray as lightness at a hue, HSL.
QColor tinted(double gray, double hue, double saturation)
{
    const double c = (1 - std::abs(2 * gray - 1)) * saturation, h = hue / 60, x = c * (1 - std::abs(std::fmod(h, 2) - 1)), m = gray - c / 2;
    const std::array<double, 3> rgb = h < 1 ? std::array{c, x, 0.0} : h < 2 ? std::array{x, c, 0.0} : h < 3 ? std::array{0.0, c, x}
                                    : h < 4 ? std::array{0.0, x, c} : h < 5 ? std::array{x, 0.0, c} : std::array{c, 0.0, x};
    return QColor(int(std::lround((rgb[0] + m) * 255)), int(std::lround((rgb[1] + m) * 255)), int(std::lround((rgb[2] + m) * 255)));
}

struct Sheet {
    EditorSession session;
    std::unique_ptr<FilterSheet> sheet;
    explicit Sheet(FilterKind kind)
    {
        session.createDocument(4, 4);
        const QImage image = solid(QColor(120, 160, 200));
        session.insert(ImportedImage(image, image, QStringLiteral("Colour")));
        session.beginFilter(kind);
        sheet = std::make_unique<FilterSheet>(session);
    }
    const FilterSettings &settings() const { return session.filterEdit().value().settings; }
    QCheckBox &box(const QString &title) const
    {
        for (QCheckBox *each : sheet->findChildren<QCheckBox *>())
            if (each->text() == title)
                return *each;
        throw std::runtime_error("no such box");
    }
    QStringList labels() const
    {
        QStringList words;
        for (const QLabel *each : sheet->findChildren<QLabel *>())
            words << each->text();
        return words;
    }
};
}

class ColorAdjustmentTests : public QObject {
    Q_OBJECT
private slots:
    void blackWhiteWeighsEachFamilyOfColours();
    void blackWhiteTintsTheGrayItMakes();
    void colorBalanceShiftsEachToneAndCanKeepBrightness();
    void boundsFollowSwifts();
    void theManifestKeepsEveryKey();
    void theSheetShowsBlackAndWhitesFamiliesAndTint();
    void theSheetShowsColorBalancesThreeRanges();
    void theImageMenusFiltersChangeTheLayer();
    void aValuePastItsRangeIsExplained();
};

void ColorAdjustmentTests::blackWhiteWeighsEachFamilyOfColours()
{
    const BlackWhiteSettings defaults;
    // Photoshop's defaults: red at 40%, yellow 60%, blue 20%.
    QVERIFY(near(first(defaults.apply(solid(Qt::red))), QColor(102, 102, 102)));
    QVERIFY(near(first(defaults.apply(solid(Qt::yellow))), QColor(153, 153, 153)));
    QVERIFY(near(first(defaults.apply(solid(Qt::blue))), QColor(51, 51, 51)));
    QVERIFY(near(first(defaults.apply(solid(Qt::magenta))), QColor(204, 204, 204)));
    QVERIFY(near(first(defaults.apply(solid(Qt::white))), QColor(255, 255, 255)));
    // Gray keeps its level; a colour splits primary, secondary, gray.
    QVERIFY(near(first(defaults.apply(solid(QColor(90, 90, 90)))), QColor(90, 90, 90)));
    const double mixed = 0.2 + (0.6 - 0.2) * 0.6 + (1 - 0.6) * 0.4;
    const int level = int(std::lround(mixed * 255));
    QVERIFY(near(first(defaults.apply(solid(QColor::fromRgbF(1, 0.6f, 0.2f)))), QColor(level, level, level)));
    // Premultiplied pixels keep their alpha.
    QImage half(1, 1, QImage::Format_RGBA8888_Premultiplied);
    half.setPixel(0, 0, qRgba(128, 0, 0, 128));
    QCOMPARE(defaults.apply(half).pixel(0, 0), qRgba(51, 51, 51, 128));
    BlackWhiteSettings bright;
    bright.reds = 100;
    QVERIFY(near(first(bright.apply(solid(Qt::red))), QColor(255, 255, 255)));
    // Yellows and cyans reach the kernel each in its place.
    const BlackWhiteSettings apart{.yellows = 100, .cyans = 0};
    QVERIFY(near(first(apart.apply(solid(Qt::yellow))), QColor(255, 255, 255)));
    QVERIFY(near(first(apart.apply(solid(Qt::cyan))), QColor(0, 0, 0)));
}

void ColorAdjustmentTests::blackWhiteTintsTheGrayItMakes()
{
    BlackWhiteSettings settings;
    settings.tint = true;
    settings.tintHue = 30;
    settings.tintSaturation = 50;
    const double gray = 0.4;
    QVERIFY(near(first(settings.apply(solid(Qt::red))), tinted(gray, 30, 0.5)));
    settings.tintHue = 250;
    QVERIFY(near(first(settings.apply(solid(Qt::red))), tinted(gray, 250, 0.5)));
    // No saturation tints nothing.
    settings.tintSaturation = 0;
    QVERIFY(near(first(settings.apply(solid(Qt::red))), QColor(102, 102, 102)));
}

void ColorAdjustmentTests::colorBalanceShiftsEachToneAndCanKeepBrightness()
{
    // Untouched, the image is handed back as it is.
    const QImage gray = solid(QColor(128, 128, 128));
    QCOMPARE(ColorBalanceSettings().apply(gray).cacheKey(), gray.cacheKey());
    ColorBalanceSettings settings{.midCyanRed = 60, .preserveLuminosity = false};
    // A midtone weighs 0.7 in the midtones: red gains 0.42.
    QVERIFY(near(first(settings.apply(gray)), QColor(235, 128, 128)));
    // Shadows and highlights leave a midtone alone.
    QVERIFY(near(first(ColorBalanceSettings{.shadowCyanRed = 60, .preserveLuminosity = false}.apply(gray)), QColor(128, 128, 128)));
    QVERIFY(near(first(ColorBalanceSettings{.highlightCyanRed = 60, .preserveLuminosity = false}.apply(gray)), QColor(128, 128, 128)));
    // A shadow takes the shadows' shift.
    QVERIFY(near(first(ColorBalanceSettings{.shadowYellowBlue = 50, .preserveLuminosity = false}.apply(solid(QColor(20, 20, 20)))),
                 QColor(20, 20, 109)));
    // Preserve Luminosity scales the result back to its brightness.
    settings.preserveLuminosity = true;
    const QColor kept = first(settings.apply(gray));
    const double before = 128 / 255.0, after = 0.299 * (235 / 255.0) + 0.587 * before + 0.114 * before;
    QVERIFY(near(kept, QColor(int(std::lround(235 * before / after)), int(std::lround(128 * before / after)), int(std::lround(128 * before / after)))));
}

void ColorAdjustmentTests::boundsFollowSwifts()
{
    QVERIFY((BlackWhiteSettings{.reds = 300, .blues = -200}.isValid()));
    for (const BlackWhiteSettings &broken : {BlackWhiteSettings{.reds = 300.5}, BlackWhiteSettings{.magentas = -200.5},
                                            BlackWhiteSettings{.greens = std::nan("")}, BlackWhiteSettings{.tintHue = 360.5}, BlackWhiteSettings{.tintHue = -0.5},
                                            BlackWhiteSettings{.tintSaturation = -1}, BlackWhiteSettings{.tintSaturation = 100.5}}) {
        QVERIFY(!broken.isValid());
        QVERIFY_THROWS_EXCEPTION(ProjectError, broken.apply(solid(Qt::red)));
    }
    QVERIFY((ColorBalanceSettings{.shadowCyanRed = -100, .highlightYellowBlue = 100}.isValid()));
    for (const ColorBalanceSettings &broken : {ColorBalanceSettings{.midMagentaGreen = 100.5}, ColorBalanceSettings{.shadowYellowBlue = -100.5},
                                              ColorBalanceSettings{.highlightCyanRed = std::nan("")}}) {
        QVERIFY(!broken.isValid());
        QVERIFY_THROWS_EXCEPTION(ProjectError, broken.apply(solid(Qt::red)));
    }
    // An adjustment layer refuses settings of either past them.
    LayerAdjustment adjustment{AdjustmentKind::blackWhite};
    adjustment.setBlackWhite(BlackWhiteSettings{.cyans = 301});
    QVERIFY(!adjustment.isValid());
    adjustment = LayerAdjustment{AdjustmentKind::colorBalance};
    adjustment.setColorBalance(ColorBalanceSettings{.midYellowBlue = -101});
    QVERIFY(!adjustment.isValid());
}

void ColorAdjustmentTests::theManifestKeepsEveryKey()
{
    LayerAdjustment adjustment{AdjustmentKind::blackWhite};
    adjustment.setBlackWhite(BlackWhiteSettings{.yellows = 10, .tint = true});
    // Nine distinct amounts: no two keys can trade places unseen.
    adjustment.setColorBalance(ColorBalanceSettings{-40, -30, -20, -10, 10, 20, 30, 40, 50, false});
    const QJsonObject object = ManifestJson::encoded(adjustment);
    const QJsonObject gray = object.value("blackWhiteSettings").toObject(), balance = object.value("colorBalanceSettings").toObject();
    QCOMPARE(gray.keys(), (QStringList{"blues", "cyans", "greens", "magentas", "reds", "tint", "tintHue", "tintSaturation", "yellows"}));
    QCOMPARE(balance.keys(), (QStringList{"highlightCyanRed", "highlightMagentaGreen", "highlightYellowBlue", "midCyanRed", "midMagentaGreen",
                                          "midYellowBlue", "preserveLuminosity", "shadowCyanRed", "shadowMagentaGreen", "shadowYellowBlue"}));
    QVERIFY(ManifestJson::adjustment(object) == adjustment);
    const std::vector<std::pair<const char *, double>> amounts{
        {"shadowCyanRed", -40}, {"shadowMagentaGreen", -30}, {"shadowYellowBlue", -20}, {"midCyanRed", -10}, {"midMagentaGreen", 10},
        {"midYellowBlue", 20}, {"highlightCyanRed", 30}, {"highlightMagentaGreen", 40}, {"highlightYellowBlue", 50}};
    for (const auto &[key, amount] : amounts)
        QCOMPARE(balance.value(key).toDouble(), amount);
    QCOMPARE(balance.value("preserveLuminosity").toBool(), false);
    // Synthesized decoding needs every key, defaults or not.
    for (const QString &key : gray.keys()) {
        QJsonObject missing = object, inner = gray;
        inner.remove(key);
        missing.insert("blackWhiteSettings", inner);
        QVERIFY_THROWS_EXCEPTION(ProjectError, ManifestJson::adjustment(missing));
    }
    for (const QString &key : balance.keys()) {
        QJsonObject missing = object, inner = balance;
        inner.remove(key);
        missing.insert("colorBalanceSettings", inner);
        QVERIFY_THROWS_EXCEPTION(ProjectError, ManifestJson::adjustment(missing));
    }
}

void ColorAdjustmentTests::theSheetShowsBlackAndWhitesFamiliesAndTint()
{
    Sheet shown(FilterKind::blackWhite);
    shown.sheet->show();
    QVERIFY(QTest::qWaitForWindowExposed(shown.sheet.get()));
    for (const char *family : {"Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"})
        QVERIFY2(shown.labels().contains(family), family);
    QSlider &reds = *shown.sheet->findChild<QSlider *>("redsSlider");
    QCOMPARE(reds.value(), int(std::lround((40.0 + 200) / 500 * 1000)));
    reds.setValue(1000);
    QCOMPARE(shown.settings().blackWhite.reds, 300.0);
    // Tint's rows show while it is on, as Swift's `if`.
    QSlider &hue = *shown.sheet->findChild<QSlider *>("hueSlider");
    QVERIFY(hue.parentWidget()->isHidden());
    QCheckBox &tint = shown.box("Tint");
    QCOMPARE(tint.toolTip(), QString("Color the result while keeping its tones, for a sepia or a cyanotype"));
    tint.click();
    QVERIFY(shown.settings().blackWhite.tint && !hue.parentWidget()->isHidden());
    QVERIFY(!shown.sheet->findChild<QSlider *>("saturationSlider")->parentWidget()->isHidden());
    // Every row writes its own field, each set apart.
    const std::vector<std::pair<const char *, double BlackWhiteSettings::*>> rows{
        {"redsSlider", &BlackWhiteSettings::reds},   {"yellowsSlider", &BlackWhiteSettings::yellows},   {"greensSlider", &BlackWhiteSettings::greens},
        {"cyansSlider", &BlackWhiteSettings::cyans}, {"bluesSlider", &BlackWhiteSettings::blues},       {"magentasSlider", &BlackWhiteSettings::magentas},
        {"hueSlider", &BlackWhiteSettings::tintHue}, {"saturationSlider", &BlackWhiteSettings::tintSaturation}};
    int position = 100;
    for (const auto &[name, field] : rows) {
        shown.sheet->findChild<QSlider *>(name)->setValue(position);
        position += 100;
    }
    const auto at = [](int travel, double low, double high) { return low + (high - low) * travel / 1000; };
    position = 100;
    for (size_t row = 0; row < rows.size(); ++row, position += 100) {
        const bool tone = row >= 6;
        const double expected = tone ? std::round(at(position, 0, row == 6 ? 360 : 100)) : std::round(at(position, -200, 300));
        QCOMPARE(shown.settings().blackWhite.*rows[row].second, expected);
    }
    // Hue runs to 360 degrees at the slider's end.
    hue.setValue(1000);
    QCOMPARE(shown.settings().blackWhite.tintHue, 360.0);
    tint.click();
    QVERIFY(!shown.settings().blackWhite.tint && hue.parentWidget()->isHidden());
}

void ColorAdjustmentTests::theSheetShowsColorBalancesThreeRanges()
{
    Sheet shown(FilterKind::colorBalance);
    const QStringList words = shown.labels();
    for (const char *range : {"Shadows", "Midtones", "Highlights"})
        QCOMPARE(words.count(range), 1);
    // Swift's headline: bold, 13 pixels.
    for (const QLabel *label : shown.sheet->findChildren<QLabel *>())
        if (label->text() == "Midtones")
            QVERIFY(label->font().bold() && label->font().pixelSize() == 13);
    QCOMPARE(words.count("Cyan / Red"), 3);
    QCOMPARE(words.count("Magenta / Green"), 3);
    QCOMPARE(words.count("Yellow / Blue"), 3);
    QCheckBox &keep = shown.box("Preserve Luminosity");
    QCOMPARE(keep.toolTip(), QString("Put each pixel's brightness back afterwards, so only the color moves"));
    QVERIFY(keep.isChecked());
    keep.click();
    QVERIFY(!shown.settings().colorBalance.preserveLuminosity);
    // Each range's three rows, in Shadows, Midtones, Highlights order.
    const std::array<const char *, 3> pairs{"cyan/RedSlider", "magenta/GreenSlider", "yellow/BlueSlider"};
    const std::array<std::array<double ColorBalanceSettings::*, 3>, 3> fields{{
        {&ColorBalanceSettings::shadowCyanRed, &ColorBalanceSettings::midCyanRed, &ColorBalanceSettings::highlightCyanRed},
        {&ColorBalanceSettings::shadowMagentaGreen, &ColorBalanceSettings::midMagentaGreen, &ColorBalanceSettings::highlightMagentaGreen},
        {&ColorBalanceSettings::shadowYellowBlue, &ColorBalanceSettings::midYellowBlue, &ColorBalanceSettings::highlightYellowBlue}}};
    for (size_t pair = 0; pair < 3; ++pair) {
        const QList<QSlider *> rows = shown.sheet->findChildren<QSlider *>(pairs[pair]);
        QCOMPARE(rows.size(), 3);
        for (size_t range = 0; range < 3; ++range)
            rows[qsizetype(range)]->setValue(int(100 + 100 * (pair * 3 + range)));
    }
    for (size_t pair = 0; pair < 3; ++pair)
        for (size_t range = 0; range < 3; ++range)
            QCOMPARE(shown.settings().colorBalance.*fields[pair][range], -100 + 200 * (100 + 100 * double(pair * 3 + range)) / 1000);
}

// From the Image menu: one step that changes the pixels.
void ColorAdjustmentTests::theImageMenusFiltersChangeTheLayer()
{
    for (const FilterKind kind : {FilterKind::blackWhite, FilterKind::colorBalance}) {
        Sheet shown(kind);
        FilterSettings settings = shown.settings();
        settings.colorBalance.midCyanRed = 100;
        shown.session.updateFilter(settings, true);
        bool done = false;
        shown.session.commitFilter([&done] { done = true; });
        QTRY_VERIFY(done);
        QCOMPARE(shown.session.history.undoName(), rawValue(kind));
        const QColor made = shown.session.activeLayer().value().asset.value().image().pixelColor(1, 1);
        const QColor expected = first(kind == FilterKind::blackWhite ? BlackWhiteSettings().apply(solid(QColor(120, 160, 200)))
                                                                      : settings.colorBalance.apply(solid(QColor(120, 160, 200))));
        QCOMPARE(made, expected);
        QVERIFY(made != QColor(120, 160, 200));
    }
}

// Swift reports the refusal; its preview and commit never crash.
void ColorAdjustmentTests::aValuePastItsRangeIsExplained()
{
    const QString invalid = ProjectError(ProjectError::Kind::invalid).what();
    for (const FilterKind kind : {FilterKind::blackWhite, FilterKind::colorBalance}) {
        Sheet shown(kind);
        const ImageLayer before = shown.session.activeLayer().value();
        const int steps = shown.session.history.undoCount();
        FilterSettings settings = shown.settings();
        settings.blackWhite.reds = 301;
        settings.colorBalance.midCyanRed = 101;
        shown.session.updateFilter(settings, true);
        QTRY_VERIFY(!shown.session.filterEdit().value().preparing);
        QCOMPARE(shown.session.filterEdit().value().previewError, std::optional(invalid));
        shown.session.updateFilter(settings, false);
        bool done = false;
        shown.session.commitFilter([&done] { done = true; });
        QTRY_VERIFY(done);
        QCOMPARE(shown.session.brushError(), std::optional(invalid));
        QVERIFY(!shown.session.filterEdit());
        QCOMPARE(shown.session.history.undoCount(), steps);
        QVERIFY(shown.session.activeLayer().value().asset.value().identity() == before.asset.value().identity());
    }
    // Typed into the sheet's field, as a person would.
    Sheet typed(FilterKind::blackWhite);
    QLineEdit &field = *typed.sheet->findChild<QLineEdit *>("redsField");
    field.setFocus();
    field.selectAll();
    QTest::keyClicks(&field, "301");
    QTest::keyClick(&field, Qt::Key_Return);
    QTRY_COMPARE(typed.session.filterEdit().value().previewError, std::optional(invalid));
}

QTEST_MAIN(ColorAdjustmentTests)
#include "ColorAdjustmentTests.moc"