/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package android.graphics.cts;

import static org.junit.Assert.assertEquals;

import android.graphics.Bitmap;
import android.graphics.BitmapShader;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Shader;

import androidx.test.filters.SmallTest;

import com.android.compatibility.common.util.ColorUtils;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

import junitparams.JUnitParamsRunner;
import junitparams.Parameters;

@SmallTest
@RunWith(JUnitParamsRunner.class)
public class BitmapShaderTest {
    private static final int TILE_WIDTH = 20;
    private static final int TILE_HEIGHT = 20;
    private static final int BORDER_WIDTH = 5;
    private static final int BORDER_COLOR = Color.BLUE;
    private static final int CENTER_COLOR = Color.RED;
    private static final int NUM_TILES = 4;

    private Object[] testConfigs() {
        return new Object[] {
            Bitmap.Config.ARGB_8888,
            Bitmap.Config.RGBA_1010102
        };
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testBitmapShader(Bitmap.Config config) {
        Bitmap tile = Bitmap.createBitmap(TILE_WIDTH, TILE_HEIGHT, config);
        tile.eraseColor(BORDER_COLOR);
        Canvas c = new Canvas(tile);
        Paint p = new Paint();
        p.setColor(CENTER_COLOR);
        c.drawRect(BORDER_WIDTH, BORDER_WIDTH,
                TILE_WIDTH - BORDER_WIDTH, TILE_HEIGHT - BORDER_WIDTH, p);
        BitmapShader shader = new BitmapShader(tile, Shader.TileMode.REPEAT,
                Shader.TileMode.REPEAT);
        Paint paint = new Paint();
        paint.setShader(shader);
        // create a bitmap that fits (NUM_TILES - 0.5) tiles in both directions
        Bitmap b = Bitmap.createBitmap(NUM_TILES * TILE_WIDTH - TILE_WIDTH / 2,
                NUM_TILES * TILE_HEIGHT - TILE_HEIGHT / 2, config);
        b.eraseColor(Color.BLACK);
        Canvas canvas = new Canvas(b);
        canvas.drawPaint(paint);

        for (int y = 0; y < NUM_TILES; y++) {
            for (int x = 0; x < NUM_TILES; x++) {
                verifyTile(b, x * TILE_WIDTH, y * TILE_HEIGHT);
            }
        }
    }

    /**
     * Check the colors of the tile at the given coordinates in the given
     * bitmap.
     */
    private void verifyTile(Bitmap bitmap, int tileX, int tileY) {
        for (int y = 0; y < TILE_HEIGHT; y++) {
            for (int x = 0; x < TILE_WIDTH; x++) {
                if (x < BORDER_WIDTH || x >= TILE_WIDTH - BORDER_WIDTH ||
                    y < BORDER_WIDTH || y >= TILE_HEIGHT - BORDER_WIDTH) {
                    verifyColor(BORDER_COLOR, bitmap, x + tileX, y + tileY);
                } else {
                    verifyColor(CENTER_COLOR, bitmap, x + tileX, y + tileY);
                }
            }
        }
    }

    /**
     * Asserts that the pixel at the given coordinates in the given bitmap
     * matches the given color. Simply returns if the coordinates are outside
     * the bitmap area.
     */
    private void verifyColor(int color, Bitmap bitmap, int x, int y) {
        if (x < bitmap.getWidth() && y < bitmap.getHeight()) {
            assertEquals(color, bitmap.getPixel(x, y));
        }
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testClamp(Bitmap.Config config) {
        Bitmap bitmap = Bitmap.createBitmap(2, 1, config);
        bitmap.setPixel(0, 0, Color.RED);
        bitmap.setPixel(1, 0, Color.BLUE);

        BitmapShader shader = new BitmapShader(bitmap,
                Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);

        Bitmap dstBitmap = Bitmap.createBitmap(4, 1, config);
        Canvas canvas = new Canvas(dstBitmap);
        Paint paint = new Paint();
        paint.setShader(shader);
        canvas.drawRect(0, 0, 4, 1, paint);
        canvas.setBitmap(null);

        int[] pixels = new int[4];
        dstBitmap.getPixels(pixels, 0, 4, 0, 0, 4, 1);
        Assert.assertArrayEquals(new int[] { Color.RED, Color.BLUE, Color.BLUE, Color.BLUE },
                pixels);
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testRepeat(Bitmap.Config config) {
        Bitmap bitmap = Bitmap.createBitmap(2, 1, config);
        bitmap.setPixel(0, 0, Color.RED);
        bitmap.setPixel(1, 0, Color.BLUE);

        BitmapShader shader = new BitmapShader(bitmap,
                Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);

        Bitmap dstBitmap = Bitmap.createBitmap(4, 1, config);
        Canvas canvas = new Canvas(dstBitmap);
        Paint paint = new Paint();
        paint.setShader(shader);
        canvas.drawRect(0, 0, 4, 1, paint);
        canvas.setBitmap(null);

        int[] pixels = new int[4];
        dstBitmap.getPixels(pixels, 0, 4, 0, 0, 4, 1);
        Assert.assertArrayEquals(new int[] { Color.RED, Color.BLUE, Color.RED, Color.BLUE },
                pixels);
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testMirror(Bitmap.Config config) {
        Bitmap bitmap = Bitmap.createBitmap(2, 1, config);
        bitmap.setPixel(0, 0, Color.RED);
        bitmap.setPixel(1, 0, Color.BLUE);

        BitmapShader shader = new BitmapShader(bitmap,
                Shader.TileMode.MIRROR, Shader.TileMode.MIRROR);

        Bitmap dstBitmap = Bitmap.createBitmap(4, 1, config);
        Canvas canvas = new Canvas(dstBitmap);
        Paint paint = new Paint();
        paint.setShader(shader);
        canvas.drawRect(0, 0, 4, 1, paint);
        canvas.setBitmap(null);

        int[] pixels = new int[4];
        dstBitmap.getPixels(pixels, 0, 4, 0, 0, 4, 1);
        Assert.assertArrayEquals(new int[] { Color.RED, Color.BLUE, Color.BLUE, Color.RED },
                pixels);
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testFiltering(Bitmap.Config config) {
        Bitmap bitmap = Bitmap.createBitmap(2, 2, config);
        bitmap.setPixel(0, 0, Color.RED);
        bitmap.setPixel(1, 0, Color.BLUE);
        bitmap.setPixel(0, 1, Color.BLUE);
        bitmap.setPixel(1, 1, Color.RED);

        BitmapShader shader = new BitmapShader(bitmap,
                Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
        Assert.assertEquals(BitmapShader.FILTER_MODE_DEFAULT, shader.getFilterMode());

        // use slightly left than half to avoid any confusion on which pixel
        // is sampled with FILTER_MODE_NEAREST
        Matrix matrix = new Matrix();
        matrix.postScale(0.49f, 0.49f);
        shader.setLocalMatrix(matrix);

        Bitmap dstBitmap = Bitmap.createBitmap(1, 1, config);
        Canvas canvas = new Canvas(dstBitmap);
        Paint paint = new Paint();
        paint.setShader(shader);

        paint.setFilterBitmap(false);
        canvas.drawPaint(paint);
        ColorUtils.verifyColor("expected solid red color", Color.RED, dstBitmap.getPixel(0, 0), 0);

        paint.setFilterBitmap(true);
        canvas.drawPaint(paint);
        ColorUtils.verifyColor("color should be a blue/red mix", Color.valueOf(0.5f, 0.0f, 0.5f),
                dstBitmap.getColor(0, 0), 0.05f);

        shader.setFilterMode(BitmapShader.FILTER_MODE_NEAREST);
        canvas.drawPaint(paint);
        ColorUtils.verifyColor("expected solid red color", Color.RED, dstBitmap.getPixel(0, 0), 0);

        shader.setFilterMode(BitmapShader.FILTER_MODE_LINEAR);
        paint.setFilterBitmap(false);
        canvas.drawPaint(paint);
        ColorUtils.verifyColor("color should be a blue/red mix", Color.valueOf(0.5f, 0.0f, 0.5f),
                dstBitmap.getColor(0, 0), 0.05f);
    }
}