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

#include "SkTypes.h"

#if SK_SUPPORT_GPU

#include "GrContextFactory.h"
#include "Resources.h"
#include "SkAutoPixmapStorage.h"
#include "SkBitmap.h"
#include "SkCanvas.h"
#include "SkCrossContextImageData.h"
#include "SkSemaphore.h"
#include "SkSurface.h"
#include "SkThreadUtils.h"
#include "Test.h"

using namespace sk_gpu_test;

static SkImageInfo read_pixels_info(SkImage* image) {
    return SkImageInfo::MakeN32(image->width(), image->height(), image->alphaType());
}

static bool colors_are_close(SkColor a, SkColor b, int error) {
    return SkTAbs((int)SkColorGetR(a) - (int)SkColorGetR(b)) <= error &&
           SkTAbs((int)SkColorGetG(a) - (int)SkColorGetG(b)) <= error &&
           SkTAbs((int)SkColorGetB(a) - (int)SkColorGetB(b)) <= error;
}

static void assert_equal(skiatest::Reporter* reporter, SkImage* a, SkImage* b, int error) {
    REPORTER_ASSERT(reporter, a->width() == b->width());
    REPORTER_ASSERT(reporter, a->height() == b->height());

    SkAutoPixmapStorage pmapA, pmapB;
    pmapA.alloc(read_pixels_info(a));
    pmapB.alloc(read_pixels_info(b));

    REPORTER_ASSERT(reporter, a->readPixels(pmapA, 0, 0));
    REPORTER_ASSERT(reporter, b->readPixels(pmapB, 0, 0));

    for (int y = 0; y < a->height(); ++y) {
        for (int x = 0; x < a->width(); ++x) {
            SkColor ca = pmapA.getColor(x, y);
            SkColor cb = pmapB.getColor(x, y);
            if (!error) {
                if (ca != cb) {
                    ERRORF(reporter, "Expected 0x%08x but got 0x%08x at (%d, %d)", ca, cb, x, y);
                    return;
                }
            } else {
                if (!colors_are_close(ca, cb, error)) {
                    ERRORF(reporter, "Expected 0x%08x +-%d but got 0x%08x at (%d, %d)",
                           ca, error, cb, x, y);
                    return;
                }
            }
        }
    }
}

static void draw_image_test_pattern(SkCanvas* canvas) {
    canvas->clear(SK_ColorWHITE);
    SkPaint paint;
    paint.setColor(SK_ColorBLACK);
    canvas->drawRect(SkRect::MakeXYWH(5, 5, 10, 10), paint);
}

static sk_sp<SkImage> create_test_image() {
    SkBitmap bm;
    bm.allocN32Pixels(20, 20, true);
    SkCanvas canvas(bm);
    draw_image_test_pattern(&canvas);

    return SkImage::MakeFromBitmap(bm);
}

static sk_sp<SkData> create_test_data(SkEncodedImageFormat format) {
    auto image = create_test_image();
    return sk_sp<SkData>(image->encode(format, 100));
}

DEF_GPUTEST(CrossContextImage_SameContext, reporter, /*factory*/) {
    GrContextFactory factory;
    sk_sp<SkImage> testImage = create_test_image();

    // Test both PNG and JPG, to exercise GPU YUV conversion
    for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
        sk_sp<SkData> encoded = create_test_data(format);

        for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
            GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
            if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
                continue;
            }

            ContextInfo info = factory.getContextInfo(ctxType);
            if (!info.grContext()) {
                continue;
            }

            auto ccid = SkCrossContextImageData::MakeFromEncoded(info.grContext(), encoded,
                                                                 nullptr);
            REPORTER_ASSERT(reporter, ccid != nullptr);

            auto image = SkImage::MakeFromCrossContextImageData(info.grContext(), std::move(ccid));
            REPORTER_ASSERT(reporter, image != nullptr);

            // JPEG encode -> decode won't round trip the image perfectly
            assert_equal(reporter, testImage.get(), image.get(),
                         SkEncodedImageFormat::kJPEG == format ? 2 : 0);
        }
    }
}

DEF_GPUTEST(CrossContextImage_SharedContextSameThread, reporter, /*factory*/) {
    GrContextFactory factory;
    sk_sp<SkImage> testImage = create_test_image();

    // Test both PNG and JPG, to exercise GPU YUV conversion
    for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
        sk_sp<SkData> encoded = create_test_data(format);

        for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
            GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
            if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
                continue;
            }

            ContextInfo info = factory.getContextInfo(ctxType);
            if (!info.grContext()) {
                continue;
            }
            auto ccid = SkCrossContextImageData::MakeFromEncoded(info.grContext(), encoded,
                                                                 nullptr);
            REPORTER_ASSERT(reporter, ccid != nullptr);

            ContextInfo info2 = factory.getSharedContextInfo(info.grContext());
            GrContext* ctx2 = info2.grContext();
            int resourceCountBefore = 0, resourceCountAfter = 0;
            size_t resourceBytesBefore = 0, resourceBytesAfter = 0;
            if (ctx2 && info.grContext()->caps()->crossContextTextureSupport()) {
                ctx2->getResourceCacheUsage(&resourceCountBefore, &resourceBytesBefore);
            }

            auto image = SkImage::MakeFromCrossContextImageData(ctx2, std::move(ccid));
            REPORTER_ASSERT(reporter, image != nullptr);

            if (ctx2 && info.grContext()->caps()->crossContextTextureSupport()) {
                // MakeFromCrossContextImageData should have imported the texture back into our
                // cache, so we should see an uptick. (If we have crossContextTextureSupport,
                // otherwise we're just handing around a CPU or codec-backed image, so no cache
                // impact will occur).
                ctx2->getResourceCacheUsage(&resourceCountAfter, &resourceBytesAfter);
                REPORTER_ASSERT(reporter, resourceCountAfter == resourceCountBefore + 1);
                REPORTER_ASSERT(reporter, resourceBytesAfter > resourceBytesBefore);
            }

            // JPEG encode -> decode won't round trip the image perfectly
            assert_equal(reporter, testImage.get(), image.get(),
                         SkEncodedImageFormat::kJPEG == format ? 2 : 0);
        }
    }
}

namespace {
struct CrossContextImage_ThreadContext {
    GrContext* fGrContext;
    sk_gpu_test::TestContext* fTestContext;
    SkSemaphore fSemaphore;
    std::unique_ptr<SkCrossContextImageData> fCCID;
    sk_sp<SkData> fEncoded;
};
}

static void upload_image_thread_proc(void* data) {
    CrossContextImage_ThreadContext* ctx = static_cast<CrossContextImage_ThreadContext*>(data);
    ctx->fTestContext->makeCurrent();
    ctx->fCCID = SkCrossContextImageData::MakeFromEncoded(ctx->fGrContext, ctx->fEncoded, nullptr);
    ctx->fSemaphore.signal();
}

DEF_GPUTEST(CrossContextImage_SharedContextOtherThread, reporter, /*factory*/) {
    sk_sp<SkImage> testImage = create_test_image();

    // Test both PNG and JPG, to exercise GPU YUV conversion
    for (auto format : { SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG }) {
        // Use a new factory for each batch of tests. Otherwise the shared context will still be
        // current on the upload thread when we do the second iteration, and we get undefined
        // behavior.
        GrContextFactory factory;
        sk_sp<SkData> encoded = create_test_data(format);

        for (int i = 0; i < GrContextFactory::kContextTypeCnt; ++i) {
            GrContextFactory::ContextType ctxType = static_cast<GrContextFactory::ContextType>(i);
            if (!sk_gpu_test::GrContextFactory::IsRenderingContext(ctxType)) {
                continue;
            }

            // Create two GrContexts in a share group
            ContextInfo info = factory.getContextInfo(ctxType);
            if (!info.grContext()) {
                continue;
            }
            ContextInfo info2 = factory.getSharedContextInfo(info.grContext());
            if (!info2.grContext()) {
                continue;
            }

            // Make the first one current (on this thread) again
            info.testContext()->makeCurrent();

            // Bundle up data for the worker thread
            CrossContextImage_ThreadContext ctx;
            ctx.fGrContext = info2.grContext();
            ctx.fTestContext = info2.testContext();
            ctx.fEncoded = encoded;

            SkThread uploadThread(upload_image_thread_proc, &ctx);
            SkAssertResult(uploadThread.start());

            ctx.fSemaphore.wait();
            auto image = SkImage::MakeFromCrossContextImageData(info.grContext(),
                                                                std::move(ctx.fCCID));
            REPORTER_ASSERT(reporter, image != nullptr);

            // JPEG encode -> decode won't round trip the image perfectly
            assert_equal(reporter, testImage.get(), image.get(),
                         SkEncodedImageFormat::kJPEG == format ? 2 : 0);

            uploadThread.join();
        }
    }
}

#endif