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

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/core/SkTypes.h"
#include "include/private/SkDebug.h"
#include "src/core/SkEdgeClipper.h"
#include "src/core/SkLineClipper.h"
#include "tests/Test.h"

#include <array>
#include <cstring>

static void test_hairclipping(skiatest::Reporter* reporter) {
    SkBitmap bm;
    bm.allocN32Pixels(4, 4);
    bm.eraseColor(SK_ColorWHITE);

    SkPaint paint;
    paint.setAntiAlias(true);

    SkCanvas canvas(bm);
    canvas.clipRect(SkRect::MakeWH(SkIntToScalar(4), SkIntToScalar(2)));
    canvas.drawLine(1.5f, 1.5f,
                    3.5f, 3.5f, paint);

    /**
     *  We had a bug where we misinterpreted the bottom of the clip, and
     *  would draw another pixel (to the right in this case) on the same
     *  last scanline. i.e. we would draw to [2,1], even though this hairline
     *  should just draw to [1,1], [2,2], [3,3] modulo the clip.
     *
     *  The result of this entire draw should be that we only draw to [1,1]
     *
     *  Fixed in rev. 3366
     */
    for (int y = 0; y < 4; ++y) {
        for (int x = 0; x < 4; ++x) {
            bool nonWhite = (1 == y) && (1 == x);
            SkPMColor c = *bm.getAddr32(x, y);
            if (nonWhite) {
                REPORTER_ASSERT(reporter, 0xFFFFFFFF != c);
            } else {
                REPORTER_ASSERT(reporter, 0xFFFFFFFF == c);
            }
        }
    }
}

static void test_edgeclipper() {
    SkEdgeClipper clipper(false);

    const SkPoint pts[] = {
        { 3.0995476e+010f,  42.929779f },
        { -3.0995163e+010f, 51.050385f },
        { -3.0995157e+010f, 51.050392f },
        { -3.0995134e+010f, 51.050400f },
    };

    const SkRect clip = { 0, 0, SkIntToScalar(300), SkIntToScalar(200) };

    // this should not assert, even though our choppers do a poor numerical
    // job when computing their t values.
    // http://code.google.com/p/skia/issues/detail?id=444
    clipper.clipCubic(pts, clip);
}

static void test_intersectline(skiatest::Reporter* reporter) {
    static constexpr SkScalar L = 0;
    static constexpr SkScalar T = 0;
    static constexpr SkScalar R = SkIntToScalar(100);
    static constexpr SkScalar B = SkIntToScalar(100);
    static constexpr SkScalar CX = (L + R) / 2.f;
    static constexpr SkScalar CY = (T + B) / 2.f;
    static constexpr SkRect gR = {L, T, R, B};

    size_t i;
    SkPoint dst[2];

    static constexpr auto gEmpty = std::to_array<SkPoint>({
            // sides
            SkPoint{ L, CY }, SkPoint{ L - 10, CY },
            SkPoint{ R, CY }, SkPoint{ R + 10, CY },
            SkPoint{ CX, T }, SkPoint{ CX, T - 10 },
            SkPoint{ CX, B }, SkPoint{ CX, B + 10 },
            // corners
            SkPoint{ L, T }, SkPoint{ L - 10, T - 10 },
            SkPoint{ L, B }, SkPoint{ L - 10, B + 10 },
            SkPoint{ R, T }, SkPoint{ R + 10, T - 10 },
            SkPoint{ R, B }, SkPoint{ R + 10, B + 10 },
    });
    for (i = 0; i < std::size(gEmpty); i += 2) {
        bool valid = SkLineClipper::IntersectLine(&gEmpty[i], gR, dst);
        if (valid) {
            SkDebugf("----- [%zu] %g %g -> %g %g\n",
                     i/2, dst[0].fX, dst[0].fY, dst[1].fX, dst[1].fY);
        }
        REPORTER_ASSERT(reporter, !valid);
    }

    static constexpr auto gFull = std::to_array<SkPoint>({
            // diagonals, chords
            SkPoint{ L, T }, SkPoint{ R, B },
            SkPoint{ L, B }, SkPoint{ R, T },
            SkPoint{ CX, T }, SkPoint{ CX, B },
            SkPoint{ L, CY }, SkPoint{ R, CY },
            SkPoint{ CX, T }, SkPoint{ R, CY },
            SkPoint{ CX, T }, SkPoint{ L, CY },
            SkPoint{ L, CY }, SkPoint{ CX, B },
            SkPoint{ R, CY }, SkPoint{ CX, B },
            // edges
            SkPoint{ L, T }, SkPoint{ L, B },
            SkPoint{ R, T }, SkPoint{ R, B },
            SkPoint{ L, T }, SkPoint{ R, T },
            SkPoint{ L, B }, SkPoint{ R, B },
    });
    for (i = 0; i < std::size(gFull); i += 2) {
        bool valid = SkLineClipper::IntersectLine(&gFull[i], gR, dst);
        if (!valid || 0 != memcmp(&gFull[i], dst, sizeof(dst))) {
            SkDebugf("++++ [%zu] %g %g -> %g %g\n",
                     i/2, dst[0].fX, dst[0].fY, dst[1].fX, dst[1].fY);
        }
        REPORTER_ASSERT(reporter, valid && !memcmp(&gFull[i], dst, sizeof(dst)));
    }

    static constexpr auto gPartial = std::to_array<SkPoint>({
            SkPoint{ L - 10, CY }, SkPoint{ CX, CY }, SkPoint{ L, CY }, SkPoint{ CX, CY },
            SkPoint{ CX, T - 10 }, SkPoint{ CX, CY }, SkPoint{ CX, T }, SkPoint{ CX, CY },
            SkPoint{ R + 10, CY }, SkPoint{ CX, CY }, SkPoint{ R, CY }, SkPoint{ CX, CY },
            SkPoint{ CX, B + 10 }, SkPoint{ CX, CY }, SkPoint{ CX, B }, SkPoint{ CX, CY },
            // extended edges
            SkPoint{ L, T - 10 }, SkPoint{ L, B + 10 }, SkPoint{ L, T }, SkPoint{ L, B },
            SkPoint{ R, T - 10 }, SkPoint{ R, B + 10 }, SkPoint{ R, T }, SkPoint{ R, B },
            SkPoint{ L - 10, T }, SkPoint{ R + 10, T }, SkPoint{ L, T }, SkPoint{ R, T },
            SkPoint{ L - 10, B }, SkPoint{ R + 10, B }, SkPoint{ L, B }, SkPoint{ R, B },
    });
    for (i = 0; i < std::size(gPartial); i += 4) {
        bool valid = SkLineClipper::IntersectLine(&gPartial[i], gR, dst);
        if (!valid || 0 != memcmp(&gPartial[i+2], dst, sizeof(dst))) {
            SkDebugf("++++ [%zu] %g %g -> %g %g\n",
                     i/2, dst[0].fX, dst[0].fY, dst[1].fX, dst[1].fY);
        }
        REPORTER_ASSERT(reporter, valid &&
                                  !memcmp(&gPartial[i+2], dst, sizeof(dst)));
    }

}

DEF_TEST(Clipper, reporter) {
    test_intersectline(reporter);
    test_edgeclipper();
    test_hairclipping(reporter);
}

DEF_TEST(LineClipper_skbug_7981, r) {
    SkPoint src[] = {{ -5.77698802E+17f, -1.81758057E+23f}, {38127, 2}};
    SkPoint dst[2];
    SkRect clip = { -32767, -32767, 32767, 32767 };

    SkLineClipper::IntersectLine(src, clip, dst);
}