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

#include "SkColor.h"
#include "SkColorMatrixFilter.h"
#include "SkGradientShader.h"
#include "SkImage.h"
#include "SkPM4f.h"
#include "SkShader.h"

#include "Test.h"
#include "SkRandom.h"

const float kTolerance = 1.0f / (1 << 20);

static bool nearly_equal(float a, float b, float tol = kTolerance) {
    SkASSERT(tol >= 0);
    return fabsf(a - b) <= tol;
}

static bool nearly_equal(const SkPM4f a, const SkPM4f& b, float tol = kTolerance) {
    for (int i = 0; i < 4; ++i) {
        if (!nearly_equal(a.fVec[i], b.fVec[i], tol)) {
            return false;
        }
    }
    return true;
}

DEF_TEST(SkColor4f_FromColor, reporter) {
    const struct {
        SkColor     fC;
        SkColor4f   fC4;
    } recs[] = {
        { SK_ColorBLACK, { 1, 0, 0, 0 } },
        { SK_ColorWHITE, { 1, 1, 1, 1 } },
        { SK_ColorRED,   { 1, 1, 0, 0 } },
        { SK_ColorGREEN, { 1, 0, 1, 0 } },
        { SK_ColorBLUE,  { 1, 0, 0, 1 } },
        { 0,             { 0, 0, 0, 0 } },
        { 0x55AAFF00,    { 1/3.0f, 2/3.0f, 1, 0 } },
    };

    for (const auto& r : recs) {
        SkColor4f c4 = SkColor4f::FromColor(r.fC);
        REPORTER_ASSERT(reporter, c4 == r.fC4);
    }
}

DEF_TEST(Color4f_premul, reporter) {
    SkRandom rand;

    for (int i = 0; i < 1000000; ++i) {
        // First just test opaque colors, so that the premul should be exact
        SkColor4f c4 {
            1, rand.nextUScalar1(), rand.nextUScalar1(), rand.nextUScalar1()
        };
        SkPM4f pm4 = c4.premul();
        REPORTER_ASSERT(reporter, pm4.a() == c4.fA);
        REPORTER_ASSERT(reporter, pm4.r() == c4.fA * c4.fR);
        REPORTER_ASSERT(reporter, pm4.g() == c4.fA * c4.fG);
        REPORTER_ASSERT(reporter, pm4.b() == c4.fA * c4.fB);

        // We compare with a tolerance, in case our premul multiply is implemented at slightly
        // different precision than the test code.
        c4.fA = rand.nextUScalar1();
        pm4 = c4.premul();
        REPORTER_ASSERT(reporter, pm4.fVec[SK_A_INDEX] == c4.fA);
        REPORTER_ASSERT(reporter, nearly_equal(pm4.r(), c4.fA * c4.fR));
        REPORTER_ASSERT(reporter, nearly_equal(pm4.g(), c4.fA * c4.fG));
        REPORTER_ASSERT(reporter, nearly_equal(pm4.b(), c4.fA * c4.fB));
    }
}

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

static sk_sp<SkColorFilter> make_mode_cf() {
    return SkColorFilter::MakeModeFilter(0xFFBB8855, SkXfermode::kPlus_Mode);
}

static sk_sp<SkColorFilter> make_mx_cf() {
    const float mx[] = {
        0.5f, 0,    0, 0, 0.1f,
        0,    0.5f, 0, 0, 0.2f,
        0,    0,    1, 0, -0.1f,
        0,    0,    0, 1, 0,
    };
    return SkColorFilter::MakeMatrixFilterRowMajor255(mx);
}

static sk_sp<SkColorFilter> make_compose_cf() {
    return SkColorFilter::MakeComposeFilter(make_mode_cf(), make_mx_cf());
}

static sk_sp<SkShader> make_color_sh() { return SkShader::MakeColorShader(0xFFBB8855); }

static sk_sp<SkShader> make_image_sh() {
    const SkImageInfo info = SkImageInfo::MakeN32Premul(2, 2);
    const SkPMColor pixels[] {
        SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
        SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
        SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
        SkPackARGB32(0xFF, 0xBB, 0x88, 0x55),
    };
    sk_sp<SkImage> image(SkImage::MakeRasterCopy(SkPixmap(info, pixels, sizeof(SkPMColor) * 2)));
    return image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
}

static sk_sp<SkShader> make_grad_sh() {
#if 0
    const SkPoint pts[] {{ 0, 0 }, { 100, 100 }};
    const SkColor colors[] { SK_ColorRED, SK_ColorBLUE };
    return SkGradientShader::CreateLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode);
#else
    // TODO: need to convert new gradient code to enforce PM4f --> RGBA order
    return make_color_sh();
#endif
}

static sk_sp<SkShader> make_cf_sh() {
    return make_color_sh()->makeWithColorFilter(make_mx_cf());
}

static bool compare_spans(const SkPM4f span4f[], const SkPMColor span4b[], int count,
                          float tolerance = 1.0f/255) {
    for (int i = 0; i < count; ++i) {
        SkPM4f c0 = SkPM4f::FromPMColor(span4b[i]);
        SkPM4f c1 = span4f[i];
        if (!nearly_equal(c0, c1, tolerance)) {
            return false;
        }
    }
    return true;
}

DEF_TEST(Color4f_shader, reporter) {
    struct {
        sk_sp<SkShader> (*fFact)();
        bool            fSupports4f;
        float           fTolerance;
    } recs[] = {
        { make_color_sh, true,  1.0f/255   },
        // PMColor 4f gradients are interpolated in 255-multiplied values, so we need a
        // slightly relaxed tolerance to accommodate the cumulative precision deviation.
        { make_grad_sh,  true,  1.001f/255 },
        { make_image_sh, false, 1.0f/255   },
        { make_cf_sh,    true,  1.0f/255   },
    };

    SkPaint paint;
    for (const auto& rec : recs) {
        uint32_t storage[300];
        paint.setShader(rec.fFact());
        // Encourage 4f context selection. At some point we may need
        // to instantiate two separate contexts for optimal 4b/4f selection.
        const SkShader::ContextRec contextRec(paint, SkMatrix::I(), nullptr,
                                              SkShader::ContextRec::kPM4f_DstType);
        SkASSERT(paint.getShader()->contextSize(contextRec) <= sizeof(storage));
        SkShader::Context* ctx = paint.getShader()->createContext(contextRec, storage);
        if (rec.fSupports4f) {
            const int N = 100;
            SkPM4f buffer4f[N];
            ctx->shadeSpan4f(0, 0, buffer4f, N);
            SkPMColor buffer4b[N];
            ctx->shadeSpan(0, 0, buffer4b, N);
            REPORTER_ASSERT(reporter, compare_spans(buffer4f, buffer4b, N, rec.fTolerance));
        }
        ctx->~Context();
    }
}

DEF_TEST(Color4f_colorfilter, reporter) {
    struct {
        sk_sp<SkColorFilter>    (*fFact)();
        bool                    fSupports4f;
        const char*             fName;
    } recs[] = {
        { make_mode_cf,     true, "mode" },
        { make_mx_cf,       true, "matrix" },
        { make_compose_cf,  true, "compose" },
    };

    // prepare the src
    const int N = 100;
    SkPMColor src4b[N];
    SkPM4f    src4f[N];
    SkRandom rand;
    for (int i = 0; i < N; ++i) {
        src4b[i] = SkPreMultiplyColor(rand.nextU());
        src4f[i] = SkPM4f::FromPMColor(src4b[i]);
    }
    // confirm that our srcs are (nearly) equal
    REPORTER_ASSERT(reporter, compare_spans(src4f, src4b, N));

    for (const auto& rec : recs) {
        auto filter(rec.fFact());
        SkPMColor dst4b[N];
        filter->filterSpan(src4b, N, dst4b);
        SkPM4f dst4f[N];
        filter->filterSpan4f(src4f, N, dst4f);
        REPORTER_ASSERT(reporter, compare_spans(dst4f, dst4b, N));
    }
}

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

typedef SkPM4f (*SkXfermodeProc4f)(const SkPM4f& src, const SkPM4f& dst);

static bool compare_procs(SkXfermodeProc proc32, SkXfermodeProc4f proc4f) {
    const float kTolerance = 1.0f / 255;

    const SkColor colors[] = {
        0, 0xFF000000, 0xFFFFFFFF, 0x80FF0000
    };

    for (auto s32 : colors) {
        SkPMColor s_pm32 = SkPreMultiplyColor(s32);
        SkPM4f    s_pm4f = SkColor4f::FromColor(s32).premul();
        for (auto d32 : colors) {
            SkPMColor d_pm32 = SkPreMultiplyColor(d32);
            SkPM4f    d_pm4f = SkColor4f::FromColor(d32).premul();

            SkPMColor r32 = proc32(s_pm32, d_pm32);
            SkPM4f    r4f = proc4f(s_pm4f, d_pm4f);

            SkPM4f r32_4f = SkPM4f::FromPMColor(r32);
            if (!nearly_equal(r4f, r32_4f, kTolerance)) {
                return false;
            }
        }
    }
    return true;
}

// Check that our Proc and Proc4f return (nearly) the same results
//
DEF_TEST(Color4f_xfermode_proc4f, reporter) {
    // TODO: extend xfermodes so that all cases can be tested.
    //
    for (int mode = SkXfermode::kClear_Mode; mode <= SkXfermode::kScreen_Mode; ++mode) {
        SkXfermodeProc   proc32 = SkXfermode::GetProc((SkXfermode::Mode)mode);
        SkXfermodeProc4f proc4f = SkXfermode::GetProc4f((SkXfermode::Mode)mode);
        REPORTER_ASSERT(reporter, compare_procs(proc32, proc4f));
    }
}