/*

 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import java.io.File;

import java.lang.reflect.Method;

import java.net.URL;

import javax.imageio.ImageIO;

import sun.awt.OSInfo;

import sun.awt.SunHints;

import java.awt.MediaTracker;

import java.awt.geom.AffineTransform;

import java.awt.image.ImageObserver;

import java.util.Arrays;

import java.util.List;

import javax.swing.JPanel;

import sun.awt.SunToolkit;

import sun.awt.image.MultiResolutionImage;

/**

 * @test

 * @bug 8011059

 * @author Alexander Scherbatiy

 * @summary [macosx] Make JDK demos look perfect on retina displays

 * @run main MultiResolutionImageTest CUSTOM

 * @run main MultiResolutionImageTest TOOLKIT_PREPARE

 * @run main MultiResolutionImageTest TOOLKIT_LOAD

 * @run main MultiResolutionImageTest TOOLKIT

 */

public class MultiResolutionImageTest {

    private static final int IMAGE_WIDTH = 300;

    private static final int IMAGE_HEIGHT = 200;

    private static final Color COLOR_1X = Color.GREEN;

    private static final Color COLOR_2X = Color.BLUE;

    private static final String IMAGE_NAME_1X = "image.png";

    private static final String IMAGE_NAME_2X = "image@2x.png";

    public static void main(String[] args) throws Exception {

        System.out.println("args: " + args.length);

        if (args.length == 0) {

            throw new RuntimeException("Not found a test");

        }

        String test = args[0];

        System.out.println("TEST: " + test);

        System.out.println("CHECK OS: " + checkOS());

        if ("CUSTOM".equals(test)) {

            testCustomMultiResolutionImage();

        } else if (checkOS()) {

            switch (test) {

                case "CUSTOM":

                    break;

                case "TOOLKIT_PREPARE":

                    testToolkitMultiResolutionImagePrepare();

                    break;

                case "TOOLKIT_LOAD":

                    testToolkitMultiResolutionImageLoad();

                    break;

                case "TOOLKIT":

                    testToolkitMultiResolutionImage();

                    testImageNameTo2xParsing();

                    break;

                default:

                    throw new RuntimeException("Unknown test: " + test);

            }

        }

    }

    static boolean checkOS() {

        return OSInfo.getOSType() == OSInfo.OSType.MACOSX;

    }

    public static void testCustomMultiResolutionImage() {

        testCustomMultiResolutionImage(false);

        testCustomMultiResolutionImage(true);

    }

    public static void testCustomMultiResolutionImage(boolean enableImageScaling) {

        Image image = new MultiResolutionBufferedImage();

        // Same image size

        BufferedImage bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, 0, 0, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        // Twice image size

        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        // Scale 2x

        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.scale(2, 2);

        g2d.drawImage(image, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        // Rotate

        bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, 0, 0, null);

        g2d.rotate(Math.PI / 4);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        // Scale 2x and Rotate

        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.scale(-2, 2);

        g2d.rotate(-Math.PI / 10);

        g2d.drawImage(image, -IMAGE_WIDTH, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        // General Transform

        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        float delta = 0.05f;

        float cos = 1 - delta * delta / 2;

        float sin = 1 + delta;

        AffineTransform transform = new AffineTransform(2 * cos, 0.1, 0.3, -2 * sin, 10, -5);

        g2d.setTransform(transform);

        g2d.drawImage(image, 0, -IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        int D = 10;

        // From Source to small Destination region

        bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2, IMAGE_WIDTH - D, IMAGE_HEIGHT - D,

                D, D, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        // From Source to large Destination region

        bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        g2d = (Graphics2D) bufferedImage.getGraphics();

        setImageScalingHint(g2d, enableImageScaling);

        g2d.drawImage(image, D, D, 2 * IMAGE_WIDTH - D, 2 * IMAGE_HEIGHT - D,

                IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);

        checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

    }

    static class MultiResolutionBufferedImage extends BufferedImage

            implements MultiResolutionImage {

        Image highResolutionImage;

        public MultiResolutionBufferedImage() {

            super(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

            highResolutionImage = new BufferedImage(

                    2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

            draw(getGraphics(), 1);

            draw(highResolutionImage.getGraphics(), 2);

        }

        void draw(Graphics graphics, float resolution) {

            Graphics2D g2 = (Graphics2D) graphics;

            g2.scale(resolution, resolution);

            g2.setColor((resolution == 1) ? COLOR_1X : COLOR_2X);

            g2.fillRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);

        }

        @Override

        public Image getResolutionVariant(int width, int height) {

            return ((width <= getWidth() && height <= getHeight()))

                    ? this : highResolutionImage;

        }

        @Override

        public List<Image> getResolutionVariants() {

            return Arrays.asList(this, highResolutionImage);

        }

    }

    static void testToolkitMultiResolutionImagePrepare() throws Exception {

        generateImages();

        File imageFile = new File(IMAGE_NAME_1X);

        String fileName = imageFile.getAbsolutePath();

        Image image = Toolkit.getDefaultToolkit().getImage(fileName);

        SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();

        toolkit.prepareImage(image, IMAGE_WIDTH, IMAGE_HEIGHT, new LoadImageObserver(image));

        testToolkitMultiResolutionImageLoad(image);

    }

    static void testToolkitMultiResolutionImageLoad() throws Exception {

        generateImages();

        File imageFile = new File(IMAGE_NAME_1X);

        String fileName = imageFile.getAbsolutePath();

        Image image = Toolkit.getDefaultToolkit().getImage(fileName);

        testToolkitMultiResolutionImageLoad(image);

    }

    static void testToolkitMultiResolutionImageLoad(Image image) throws Exception {

        MediaTracker tracker = new MediaTracker(new JPanel());

        tracker.addImage(image, 0);

        tracker.waitForID(0);

        if (tracker.isErrorAny()) {

            throw new RuntimeException("Error during image loading");

        }

        tracker.removeImage(image, 0);

        testImageLoaded(image);

        int w = image.getWidth(null);

        int h = image.getHeight(null);

        Image resolutionVariant = ((MultiResolutionImage) image)

                .getResolutionVariant(2 * w, 2 * h);

        if (image == resolutionVariant) {

            throw new RuntimeException("Resolution variant is not loaded");

        }

        testImageLoaded(resolutionVariant);

    }

    static void testImageLoaded(Image image) {

        SunToolkit toolkit = (SunToolkit) Toolkit.getDefaultToolkit();

        int flags = toolkit.checkImage(image, IMAGE_WIDTH, IMAGE_WIDTH, new SilentImageObserver());

        if ((flags & (ImageObserver.FRAMEBITS | ImageObserver.ALLBITS)) == 0) {

            throw new RuntimeException("Image is not loaded!");

        }

    }

    static class SilentImageObserver implements ImageObserver {

        @Override

        public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

            throw new RuntimeException("Observer should not be called!");

        }

    }

    static class LoadImageObserver implements ImageObserver {

        Image image;

        public LoadImageObserver(Image image) {

            this.image = image;

        }

        @Override

        public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

            if (image != img) {

                throw new RuntimeException("Original image is not passed to the observer");

            }

            if ((infoflags & ImageObserver.WIDTH) != 0) {

                if (width != IMAGE_WIDTH) {

                    throw new RuntimeException("Original width is not passed to the observer");

                }

            }

            if ((infoflags & ImageObserver.HEIGHT) != 0) {

                if (height != IMAGE_HEIGHT) {

                    throw new RuntimeException("Original height is not passed to the observer");

                }

            }

            return (infoflags & ALLBITS) == 0;

        }

    }

    static void testToolkitMultiResolutionImage() throws Exception {

        generateImages();

        File imageFile = new File(IMAGE_NAME_1X);

        String fileName = imageFile.getAbsolutePath();

        URL url = imageFile.toURI().toURL();

        testToolkitMultiResolutionImageChache(fileName, url);

        Image image = Toolkit.getDefaultToolkit().getImage(fileName);

        testToolkitImageObserver(image);

        testToolkitMultiResolutionImage(image, false);

        testToolkitMultiResolutionImage(image, true);

        image = Toolkit.getDefaultToolkit().getImage(url);

        testToolkitImageObserver(image);

        testToolkitMultiResolutionImage(image, false);

        testToolkitMultiResolutionImage(image, true);

    }

    static void testToolkitMultiResolutionImageChache(String fileName, URL url) {

        Image img1 = Toolkit.getDefaultToolkit().getImage(fileName);

        if (!(img1 instanceof MultiResolutionImage)) {

            throw new RuntimeException("Not a MultiResolutionImage");

        }

        Image img2 = Toolkit.getDefaultToolkit().getImage(fileName);

        if (img1 != img2) {

            throw new RuntimeException("Image is not cached");

        }

        img1 = Toolkit.getDefaultToolkit().getImage(url);

        if (!(img1 instanceof MultiResolutionImage)) {

            throw new RuntimeException("Not a MultiResolutionImage");

        }

        img2 = Toolkit.getDefaultToolkit().getImage(url);

        if (img1 != img2) {

            throw new RuntimeException("Image is not cached");

        }

    }

    static void testToolkitMultiResolutionImage(Image image, boolean enableImageScaling)

            throws Exception {

        MediaTracker tracker = new MediaTracker(new JPanel());

        tracker.addImage(image, 0);

        tracker.waitForID(0);

        if (tracker.isErrorAny()) {

            throw new RuntimeException("Error during image loading");

        }

        final BufferedImage bufferedImage1x = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        Graphics2D g1x = (Graphics2D) bufferedImage1x.getGraphics();

        setImageScalingHint(g1x, false);

        g1x.drawImage(image, 0, 0, null);

        checkColor(bufferedImage1x.getRGB(3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);

        Image resolutionVariant = ((MultiResolutionImage) image).

                getResolutionVariant(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);

        if (resolutionVariant == null) {

            throw new RuntimeException("Resolution variant is null");

        }

        MediaTracker tracker2x = new MediaTracker(new JPanel());

        tracker2x.addImage(resolutionVariant, 0);

        tracker2x.waitForID(0);

        if (tracker2x.isErrorAny()) {

            throw new RuntimeException("Error during scalable image loading");

        }

        final BufferedImage bufferedImage2x = new BufferedImage(2 * IMAGE_WIDTH,

                2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        Graphics2D g2x = (Graphics2D) bufferedImage2x.getGraphics();

        setImageScalingHint(g2x, enableImageScaling);

        g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);

        checkColor(bufferedImage2x.getRGB(3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);

        if (!(image instanceof MultiResolutionImage)) {

            throw new RuntimeException("Not a MultiResolutionImage");

        }

        MultiResolutionImage multiResolutionImage = (MultiResolutionImage) image;

        Image image1x = multiResolutionImage.getResolutionVariant(IMAGE_WIDTH, IMAGE_HEIGHT);

        Image image2x = multiResolutionImage.getResolutionVariant(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT);

        if (image1x.getWidth(null) * 2 != image2x.getWidth(null)

                || image1x.getHeight(null) * 2 != image2x.getHeight(null)) {

            throw new RuntimeException("Wrong resolution variant size");

        }

    }

    static void testToolkitImageObserver(final Image image) {

        ImageObserver observer = new ImageObserver() {

            @Override

            public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

                if (img != image) {

                    throw new RuntimeException("Wrong image in observer");

                }

                if ((infoflags & (ImageObserver.ERROR | ImageObserver.ABORT)) != 0) {

                    throw new RuntimeException("Error during image loading");

                }

                return (infoflags & ImageObserver.ALLBITS) == 0;

            }

        };

        final BufferedImage bufferedImage2x = new BufferedImage(2 * IMAGE_WIDTH,

                2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);

        Graphics2D g2x = (Graphics2D) bufferedImage2x.getGraphics();

        setImageScalingHint(g2x, true);

        g2x.drawImage(image, 0, 0, 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, observer);

    }

    static void setImageScalingHint(Graphics2D g2d, boolean enableImageScaling) {

        g2d.setRenderingHint(SunHints.KEY_RESOLUTION_VARIANT, enableImageScaling

                ? SunHints.VALUE_RESOLUTION_VARIANT_ON

                : SunHints.VALUE_RESOLUTION_VARIANT_OFF);

    }

    static void checkColor(int rgb, boolean isImageScaled) {

        if (!isImageScaled && COLOR_1X.getRGB() != rgb) {

            throw new RuntimeException("Wrong 1x color: " + new Color(rgb));

        }

        if (isImageScaled && COLOR_2X.getRGB() != rgb) {

            throw new RuntimeException("Wrong 2x color" + new Color(rgb));

        }

    }

    static void generateImages() throws Exception {

        if (!new File(IMAGE_NAME_1X).exists()) {

            generateImage(1);

        }

        if (!new File(IMAGE_NAME_2X).exists()) {

            generateImage(2);

        }

    }

    static void generateImage(int scale) throws Exception {

        BufferedImage image = new BufferedImage(scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT,

                BufferedImage.TYPE_INT_RGB);

        Graphics g = image.getGraphics();

        g.setColor(scale == 1 ? COLOR_1X : COLOR_2X);

        g.fillRect(0, 0, scale * IMAGE_WIDTH, scale * IMAGE_HEIGHT);

        File file = new File(scale == 1 ? IMAGE_NAME_1X : IMAGE_NAME_2X);

        ImageIO.write(image, "png", file);

    }

    static void testImageNameTo2xParsing() throws Exception {

        for (String[] testNames : TEST_FILE_NAMES) {

            String testName = testNames[0];

            String goldenName = testNames[1];

            String resultName = getTestScaledImageName(testName);

            if (!isValidPath(testName) && resultName == null) {

                continue;

            }

            if (goldenName.equals(resultName)) {

                continue;

            }

            throw new RuntimeException("Test name " + testName

                    + ", result name: " + resultName);

        }

        for (URL[] testURLs : TEST_URLS) {

            URL testURL = testURLs[0];

            URL goldenURL = testURLs[1];

            URL resultURL = getTestScaledImageURL(testURL);

            if (!isValidPath(testURL.getPath()) && resultURL == null) {

                continue;

            }

            if (goldenURL.equals(resultURL)) {

                continue;

            }

            throw new RuntimeException("Test url: " + testURL

                    + ", result url: " + resultURL);

        }

    }

    static URL getTestScaledImageURL(URL url) throws Exception {

        Method method = getScalableImageMethod("getScaledImageURL", URL.class);

        return (URL) method.invoke(null, url);

    }

    static String getTestScaledImageName(String name) throws Exception {

        Method method = getScalableImageMethod("getScaledImageName", String.class);

        return (String) method.invoke(null, name);

    }

    private static boolean isValidPath(String path) {

        return !path.isEmpty() && !path.endsWith("/") && !path.endsWith(".")

                && !path.contains("@2x");

    }