/*
 * Copyright (c) 2003, 2019, 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.Component;
import java.awt.DisplayMode;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Transparency;
import java.awt.Window;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.util.ArrayList;

/**
 * @test
 * @bug 4836241 6364134 8232200
 * @key headful
 * @summary verify that images are restored correctly after display mode
 *          switches and that no other rendering or crash problems occur
 * @run main/timeout=500 CycleDMImage
 */
public class CycleDMImage extends Component implements Runnable, KeyListener {
    /**
     * This test cycles through all available display modes, waiting after
     * each call to setDisplayMode() to ensure that the new one is active
     * before proceeding on to the next one.  The Component is filled with
     * a green background color and then compatible images of all 3
     * Transparency types are copied to the screen.  The results of these
     * operations are checked (using Robot) and the test fails if any of the
     * rendering is wrong in any of the DisplayModes.  The purpose of this
     * test is to ensure that display mode switches do not cause problems
     * with image restoration (or other rendering operations).
     */
    boolean painted = false;
    boolean earlyExit = false;
    Image rImage = null, wImage = null, bImage = null;
    int imgSize = 10;
    Robot robot = null;
    volatile static boolean done = false;
    static String errorMessage = null;

    public synchronized void paint(Graphics g) {
        if (!painted) {
            painted = true;
            (new Thread(this)).start();
        }
        if (rImage == null) {
            GraphicsConfiguration gc = getGraphicsConfiguration();
            rImage = gc.createCompatibleImage(imgSize, imgSize);
            wImage = gc.createCompatibleImage(imgSize, imgSize,
                                              Transparency.BITMASK);
            bImage = gc.createCompatibleImage(imgSize, imgSize,
                                              Transparency.TRANSLUCENT);
            Graphics imgGraphics = rImage.getGraphics();
            imgGraphics.setColor(Color.red);
            imgGraphics.fillRect(0, 0, imgSize, imgSize);
            imgGraphics = wImage.getGraphics();
            imgGraphics.setColor(Color.white);
            imgGraphics.fillRect(0, 0, imgSize, imgSize);
            imgGraphics = bImage.getGraphics();
            imgGraphics.setColor(Color.blue);
            imgGraphics.fillRect(0, 0, imgSize, imgSize);
        }
        g.setColor(Color.green);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.drawImage(rImage, 0, 0, this);
        g.drawImage(wImage, imgSize, 0, this);
        g.drawImage(bImage, imgSize*2, 0, this);
        g.drawImage(rImage, 0, getHeight()-imgSize, null);
        g.drawImage(rImage, getWidth()-imgSize, getHeight()-imgSize, null);
        g.drawImage(rImage, getWidth()-imgSize, 0, null);
    }

    static void delay(long ms) {
        try {
            Thread.sleep(ms);
        } catch (Exception e) {}
    }

    public boolean checkResult(DisplayMode dm) {
        if (robot == null) {
            try {
                robot = new Robot();
            }
            catch (Exception e) {
                errorMessage = "Problems creating Robot";
                return false;
            }
        }
        Rectangle bounds = getGraphicsConfiguration().getBounds();
        int pixels[] = new int[imgSize * 4];
        BufferedImage clientPixels =
            robot.createScreenCapture(new Rectangle(bounds.x, bounds.y,
                                                    imgSize*4, 1));
        clientPixels.getRGB(0, 0, imgSize * 4, 1, pixels, 0, getWidth());
        // Now check the results.  We expect: imgSize blocks of r/w/b/g
        int colors[] = {0xffff0000, 0xffffffff, 0xff0000ff, 0xff00ff00};
        for (int color = 0; color < 4; ++color) {
            for (int i = 0; i < imgSize; ++i) {
                int pixelIndex = imgSize * color + i;
                if (pixels[pixelIndex] != colors[color]) {
                    errorMessage = "\n    DisplayMode(" +
                        dm.getWidth() + " x " +
                        dm.getHeight() + " x " +
                        dm.getBitDepth() + "bpp x " +
                        dm.getRefreshRate() +
                        ")\n    Pixel " + i +
                        ": Expected " +
                        Integer.toHexString(colors[color]) +
                        ", got " +
                        Integer.toHexString(pixels[pixelIndex]) +
                        " at " + i;
                    return false;
                }
            }
        }
        return true;
    }

    boolean displayModesEqual(DisplayMode dm1, DisplayMode dm2) {
        if (dm1.equals(dm2)) {
            return true;
        }
        // not enough - check whether the modes are equal except for
        // refreshRate, if either mode has REFRESH_RATE_UNKNOWN
        // value for this parameter
        if (dm1.getWidth() != dm2.getWidth() ||
            dm1.getHeight() != dm2.getHeight() ||
            dm1.getBitDepth() != dm2.getBitDepth())
        {
            // core parameters must match
            return false;
        }
        // Now we know that w1 == w2, h1 == h2, and d1 == d2; must be the
        // case that the refresh rates do not match.
        // Is either one REFRESH_RATE_UNKNOWN?
        if (dm1.getRefreshRate() == DisplayMode.REFRESH_RATE_UNKNOWN ||
            dm2.getRefreshRate() == DisplayMode.REFRESH_RATE_UNKNOWN)
        {
            return true;
        }
        return false;
    }

    public void run() {
        GraphicsDevice gd = getGraphicsConfiguration().getDevice();
        gd.setFullScreenWindow((Window) getParent());
        // First, delay a bit just to let the fullscreen window
        // settle down before switching display modes
        delay(1000);

        if (!gd.isDisplayChangeSupported()) {
            System.err.println("Display change is not supported,"+
                               " the test is considered passed.");
            finished();
            return;
        }

        // We are really only interested in unique w/h/d resolutions
        // and it would be nice to skip the myriad of refresh rate
        // varations, so let us construct a subset that contains
        // only those DisplayModes with unique w/h/d values
        // Also, due to a current bug (4837228), we should skip the
        // 24-bit depths since attempting to create bitmask-transparent
        // ddraw images can cause the test to crash (we should change this
        // test to include that depth when the bug is fixed).
        ArrayList<DisplayMode> dmSubset = new ArrayList<>();
        for (final DisplayMode dm : gd.getDisplayModes()) {
            boolean skip = false;
            for (final DisplayMode dmUnique : dmSubset) {
                int bitDepth = dm.getBitDepth();
                if (bitDepth == 24 ||
                        (dmUnique.getWidth() == dm.getWidth() &&
                         dmUnique.getHeight() == dm.getHeight() &&
                         dmUnique.getBitDepth() == dm.getBitDepth())) {
                    skip = true;
                    break;
                }
            }
            if (!skip) {
                dmSubset.add(dm);
            }
        }

        // Now, cycle through the display modes one-by-one.  For
        // each new display mode, delay until we detect that the
        // new mode == the current mode.  Then delay an additional
        // second (to allow any repaints to occur)

        for (DisplayMode newDM : dmSubset) {
            gd.setDisplayMode(newDM);
            while (!displayModesEqual(newDM, gd.getDisplayMode())) {
                delay(100);
            }
            // Delay another few seconds after the new display mode is active
            delay(4000);

            // Check the rendering results
            if (!checkResult(newDM)) {
                finished();
                return;
            }

            // Escape out if requested by the user
            if (earlyExit) {
                System.out.println("Exiting test early, by request");
                System.exit(0);
            }
        }

        // Done with test; if we got here, we passed
        System.out.println("Passed");
        finished();
    }

    public static void finished() {
        synchronized (CycleDMImage.class) {
            done = true;
            CycleDMImage.class.notify();
        }
    }

    /**
     * KeyListener methods; these provide a way for a user to escape out of
     * a potentially lengthy test.
     */

    public void keyTyped(KeyEvent e) {
    }

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            earlyExit = true;
        }
    }

    public void keyReleased(KeyEvent e) {
    }

    public static void main(String args[]) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        for (final GraphicsDevice gd: ge.getScreenDevices()) {
            if (!gd.isFullScreenSupported()) {
                System.err.println("FullScreen mode is not supported,"+
                                           " the test is considered passed.");
                continue;
            }
            done = false;
            Frame frame = new Frame(gd.getDefaultConfiguration());
            try {
                frame.setSize(400, 400);
                frame.setUndecorated(true);
                CycleDMImage comp = new CycleDMImage();
                frame.addKeyListener(comp);
                frame.add(comp);
                frame.setVisible(true);
                // Sleep awaiting frame disposal
                synchronized (CycleDMImage.class) {
                    while (!done) {
                        try {
                            CycleDMImage.class.wait(100);
                        } catch (InterruptedException e) {
                        }
                    }
                }
            } finally {
                frame.dispose();
            }
            if (errorMessage != null) {
                throw new RuntimeException(errorMessage);
            }
            // delay a bit just to let the fullscreen window disposing complete
            // before switching to next display
            delay(4000);
        }
    }
}