/*
 * 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 <initializer_list>
#include <functional>
#include "Test.h"
#if SK_SUPPORT_GPU
#include "GrShape.h"
#include "SkPath.h"
#include "SkDashPathEffect.h"

namespace {
class TestCase {
public:
    TestCase(const SkRRect& rrect, const SkPaint& paint) : fBase(rrect, paint) {
        this->init();
    }

    struct SelfExpectations {
        bool fPEHasEffect;
        bool fPEHasValidKey;
        bool fStrokeApplies;
    };

    void testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const;

    enum ComparisonExpecation {
        kAllDifferent_ComparisonExpecation,
        kSameUpToPE_ComparisonExpecation,
        kSameUpToStroke_ComparisonExpecation,
        kAllSame_ComparisonExpecation,
    };

    void compare(skiatest::Reporter*, const TestCase& that, ComparisonExpecation) const;

private:
    void init() {
        fAppliedPE           = fBase.applyPathEffect();
        fAppliedPEThenStroke = fAppliedPE.applyFullStyle();
        fAppliedFull         = fBase.applyFullStyle();

        fBaseKeyIsValid                = MakeKey(&fBaseKey, fBase);
        fAppliedPEKeyIsValid           = MakeKey(&fAppliedPEKey, fAppliedPE);
        fAppliedPEThenStrokeKeyIsValid = MakeKey(&fAppliedPEThenStrokeKey, fAppliedPEThenStroke);
        fAppliedFullKeyIsValid         = MakeKey(&fAppliedFullKey, fAppliedFull);
    }

    using Key = SkTArray<uint32_t>;

    static bool MakeKey(Key* key, const GrShape& shape) {
        int size = shape.unstyledKeySize();
        if (size <= 0) {
            return false;
        }
        key->reset(size);
        shape.writeUnstyledKey(key->begin());
        return true;
    }

    GrShape fBase;
    GrShape fAppliedPE;
    GrShape fAppliedPEThenStroke;
    GrShape fAppliedFull;

    Key fBaseKey;
    Key fAppliedPEKey;
    Key fAppliedPEThenStrokeKey;
    Key fAppliedFullKey;

    bool fBaseKeyIsValid;
    bool fAppliedPEKeyIsValid;
    bool fAppliedPEThenStrokeKeyIsValid;
    bool fAppliedFullKeyIsValid;
};

void TestCase::testExpectations(skiatest::Reporter* reporter, SelfExpectations expectations) const {
    // Applying the path effect and then the stroke should always be the same as applying
    // both in one go.
    REPORTER_ASSERT(reporter, fAppliedPEThenStrokeKey == fAppliedFullKey);
    // The base's key should always be valid (unless the path is volatile)
    REPORTER_ASSERT(reporter, fBaseKeyIsValid);
    if (expectations.fPEHasEffect) {
        REPORTER_ASSERT(reporter, fBaseKey != fAppliedPEKey);
        REPORTER_ASSERT(reporter, expectations.fPEHasEffect == fAppliedPEKeyIsValid);
        REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
        REPORTER_ASSERT(reporter, expectations.fPEHasEffect == fAppliedFullKeyIsValid);
        if (expectations.fStrokeApplies && expectations.fPEHasValidKey) {
            REPORTER_ASSERT(reporter, fAppliedPEKey != fAppliedFullKey);
            REPORTER_ASSERT(reporter, expectations.fPEHasEffect == fAppliedFullKeyIsValid);
        }
    } else {
        REPORTER_ASSERT(reporter, fBaseKey == fAppliedPEKey);
        if (expectations.fStrokeApplies) {
            REPORTER_ASSERT(reporter, fBaseKey != fAppliedFullKey);
        } else {
            REPORTER_ASSERT(reporter, fBaseKey == fAppliedFullKey);
        }
    }
}

void TestCase::compare(skiatest::Reporter* reporter, const TestCase& that,
                       ComparisonExpecation expectation) const {
    switch (expectation) {
        case kAllDifferent_ComparisonExpecation:
            REPORTER_ASSERT(reporter, fBaseKey != that.fBaseKey);
            REPORTER_ASSERT(reporter, fAppliedPEKey != that.fAppliedPEKey);
            REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey);
            break;
        case kSameUpToPE_ComparisonExpecation:
            REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey);
            REPORTER_ASSERT(reporter, fAppliedPEKey != that.fAppliedPEKey);
            REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey);
            break;
        case kSameUpToStroke_ComparisonExpecation:
            REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey);
            REPORTER_ASSERT(reporter, fAppliedPEKey == that.fAppliedPEKey);
            REPORTER_ASSERT(reporter, fAppliedFullKey != that.fAppliedFullKey);
            break;
        case kAllSame_ComparisonExpecation:
            REPORTER_ASSERT(reporter, fBaseKey == that.fBaseKey);
            REPORTER_ASSERT(reporter, fAppliedPEKey == that.fAppliedPEKey);
            REPORTER_ASSERT(reporter, fAppliedFullKey == that.fAppliedFullKey);
            break;
    }
}
}  // namespace

static sk_sp<SkPathEffect> make_dash() {
    static const SkScalar kIntervals[] = { 0.25, 3.f, 0.5, 2.f };
    static const SkScalar kPhase = 0.75;
    return SkDashPathEffect::Make(kIntervals, SK_ARRAY_COUNT(kIntervals), kPhase);
}

static sk_sp<SkPathEffect> make_null_dash() {
    static const SkScalar kNullIntervals[] = {0, 0, 0, 0, 0, 0};
    return SkDashPathEffect::Make(kNullIntervals, SK_ARRAY_COUNT(kNullIntervals), 0.f);
}

static void test_basic(skiatest::Reporter* reporter, const SkRRect& rrect) {
    sk_sp<SkPathEffect> dashPE = make_dash();

    TestCase::SelfExpectations expectations;
    SkPaint fill;

    TestCase fillCase(rrect, fill);
    expectations.fPEHasEffect = false;
    expectations.fPEHasValidKey = false;
    expectations.fStrokeApplies = false;
    fillCase.testExpectations(reporter, expectations);
    // Test that another GrShape instance built from the same primitive is the same.
    TestCase(rrect, fill).compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);

    SkPaint stroke2RoundBevel;
    stroke2RoundBevel.setStyle(SkPaint::kStroke_Style);
    stroke2RoundBevel.setStrokeCap(SkPaint::kRound_Cap);
    stroke2RoundBevel.setStrokeJoin(SkPaint::kBevel_Join);
    stroke2RoundBevel.setStrokeWidth(2.f);
    TestCase stroke2RoundBevelCase(rrect, stroke2RoundBevel);
    expectations.fPEHasValidKey = true;
    expectations.fPEHasEffect = false;
    expectations.fStrokeApplies = true;
    stroke2RoundBevelCase.testExpectations(reporter, expectations);
    TestCase(rrect, stroke2RoundBevel).compare(reporter, stroke2RoundBevelCase,
                                               TestCase::kAllSame_ComparisonExpecation);

    SkPaint stroke2RoundBevelDash = stroke2RoundBevel;
    stroke2RoundBevelDash.setPathEffect(make_dash());
    TestCase stroke2RoundBevelDashCase(rrect, stroke2RoundBevelDash);
    expectations.fPEHasValidKey = true;
    expectations.fPEHasEffect = true;
    expectations.fStrokeApplies = true;
    stroke2RoundBevelDashCase.testExpectations(reporter, expectations);
    TestCase(rrect, stroke2RoundBevelDash).compare(reporter, stroke2RoundBevelDashCase,
                                                   TestCase::kAllSame_ComparisonExpecation);

    fillCase.compare(reporter, stroke2RoundBevelCase,
                     TestCase::kSameUpToStroke_ComparisonExpecation);
    fillCase.compare(reporter, stroke2RoundBevelDashCase,
                     TestCase::kSameUpToPE_ComparisonExpecation);
    stroke2RoundBevelCase.compare(reporter, stroke2RoundBevelDashCase,
                                  TestCase::kSameUpToPE_ComparisonExpecation);
}

template <typename T>
static void test_stroke_param(skiatest::Reporter* reporter, const SkRRect& rrect,
                              std::function<void(SkPaint*, T)> setter, T a, T b) {
    // Set the stroke width so that we don't get hairline. However, call the function second so that
    // it can override.
    SkPaint strokeA;
    strokeA.setStyle(SkPaint::kStroke_Style);
    strokeA.setStrokeWidth(2.f);
    setter(&strokeA, a);
    SkPaint strokeB;
    strokeB.setStyle(SkPaint::kStroke_Style);
    strokeB.setStrokeWidth(2.f);
    setter(&strokeB, b);

    TestCase strokeACase(rrect, strokeA);
    TestCase strokeBCase(rrect, strokeB);
    strokeACase.compare(reporter, strokeBCase, TestCase::kSameUpToStroke_ComparisonExpecation);

    // Make sure stroking params don't affect fill style.
    SkPaint fillA = strokeA, fillB = strokeB;
    fillA.setStyle(SkPaint::kFill_Style);
    fillB.setStyle(SkPaint::kFill_Style);
    TestCase fillACase(rrect, fillA);
    TestCase fillBCase(rrect, fillB);
    fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation);

    // Make sure just applying the dash but not stroke gives the same key for both stroking
    // variations.
    SkPaint dashA = strokeA, dashB = strokeB;
    dashA.setPathEffect(make_dash());
    dashB.setPathEffect(make_dash());
    TestCase dashACase(rrect, dashA);
    TestCase dashBCase(rrect, dashB);
    dashACase.compare(reporter, dashBCase, TestCase::kSameUpToStroke_ComparisonExpecation);
}

static void test_miter_limit(skiatest::Reporter* reporter, const SkRRect& rrect) {
    // Miter limit should only matter when stroking with miter joins. It shouldn't affect other
    // joins or fills.
    SkPaint miterA;
    miterA.setStyle(SkPaint::kStroke_Style);
    miterA.setStrokeWidth(2.f);
    miterA.setStrokeJoin(SkPaint::kMiter_Join);
    miterA.setStrokeMiter(0.5f);
    SkPaint miterB = miterA;
    miterA.setStrokeMiter(0.6f);

    TestCase miterACase(rrect, miterA);
    TestCase miterBCase(rrect, miterB);
    miterACase.compare(reporter, miterBCase, TestCase::kSameUpToStroke_ComparisonExpecation);

    SkPaint noMiterA = miterA, noMiterB = miterB;
    noMiterA.setStrokeJoin(SkPaint::kRound_Join);
    noMiterB.setStrokeJoin(SkPaint::kRound_Join);
    TestCase noMiterACase(rrect, noMiterA);
    TestCase noMiterBCase(rrect, noMiterB);
    noMiterACase.compare(reporter, noMiterBCase, TestCase::kAllSame_ComparisonExpecation);

    SkPaint fillA = miterA, fillB = miterB;
    fillA.setStyle(SkPaint::kFill_Style);
    fillB.setStyle(SkPaint::kFill_Style);
    TestCase fillACase(rrect, fillA);
    TestCase fillBCase(rrect, fillB);
    fillACase.compare(reporter, fillBCase, TestCase::kAllSame_ComparisonExpecation);
}

static void test_dash_fill(skiatest::Reporter* reporter, const SkRRect& rrect) {
    // A dash with no stroke should have no effect
    for (auto md : {make_dash, make_null_dash}) {
        SkPaint dashFill;
        dashFill.setPathEffect(md());
        TestCase dashFillCase(rrect, dashFill);

        TestCase fillCase(rrect, SkPaint());
        dashFillCase.compare(reporter, fillCase, TestCase::kAllSame_ComparisonExpecation);
    }
}

void test_null_dash(skiatest::Reporter* reporter, const SkRRect& rrect) {
    SkPaint fill;
    SkPaint stroke;
    stroke.setStyle(SkPaint::kStroke_Style);
    stroke.setStrokeWidth(1.f);
    SkPaint dash;
    dash.setStyle(SkPaint::kStroke_Style);
    dash.setStrokeWidth(1.f);
    dash.setPathEffect(make_dash());
    SkPaint nullDash;
    nullDash.setStyle(SkPaint::kStroke_Style);
    nullDash.setStrokeWidth(1.f);
    nullDash.setPathEffect(make_null_dash());

    TestCase fillCase(rrect, fill);
    TestCase strokeCase(rrect, stroke);
    TestCase dashCase(rrect, dash);
    TestCase nullDashCase(rrect, nullDash);

    nullDashCase.compare(reporter, fillCase, TestCase::kSameUpToStroke_ComparisonExpecation);
    nullDashCase.compare(reporter, strokeCase, TestCase::kAllSame_ComparisonExpecation);
    nullDashCase.compare(reporter, dashCase, TestCase::kSameUpToPE_ComparisonExpecation);
}

DEF_TEST(GrShape, reporter) {
    sk_sp<SkPathEffect> dashPE = make_dash();

    for (auto rr : { SkRRect::MakeRect(SkRect::MakeWH(10, 10)),
                     SkRRect::MakeRectXY(SkRect::MakeWH(10, 10), 3, 4)}) {
        test_basic(reporter, rr);
        test_dash_fill(reporter, rr);
        test_null_dash(reporter, rr);
        // Test modifying various stroke params.
        test_stroke_param<SkScalar>(
                          reporter, rr,
                          [](SkPaint* p, SkScalar w) { p->setStrokeWidth(w);},
                          SkIntToScalar(2), SkIntToScalar(4));
        test_stroke_param<SkPaint::Cap>(
                          reporter, rr,
                          [](SkPaint* p, SkPaint::Cap c) { p->setStrokeCap(c);},
                          SkPaint::kButt_Cap, SkPaint::kRound_Cap);
        test_stroke_param<SkPaint::Join>(
                          reporter, rr,
                          [](SkPaint* p, SkPaint::Join j) { p->setStrokeJoin(j);},
                          SkPaint::kMiter_Join, SkPaint::kRound_Join);
        test_miter_limit(reporter, rr);
    }
}

#endif