/*
 * Copyright (c) 2005, 2014 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.
 */

/*
 @test
 @bug 6275887 6429971 6459792
 @summary Test that we don't crash when alt+tabbing in and out of
         fullscreen app
 @author Dmitri.Trembovetski@sun.com: area=FullScreen
 @run main/othervm/timeout=100  AltTabCrashTest -auto -changedm
 @run main/othervm/timeout=100 -Dsun.java2d.d3d=True AltTabCrashTest -auto -changedm
 @run main/othervm/timeout=100 -Dsun.java2d.d3d=True AltTabCrashTest -auto -usebs -changedm
 @run main/othervm/timeout=100 -Dsun.java2d.opengl=True AltTabCrashTest -auto
*/

import java.awt.AWTException;
import java.awt.Color;
import java.awt.DisplayMode;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.Robot;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.VolatileImage;
import java.util.Random;
import java.util.Vector;

/**
 * Note that the alt+tabbing in and out part will most likely only work
 * on Windows, and only if there are no interventions.
 */

public class AltTabCrashTest extends Frame {
    public static int width;
    public static int height;
    public static volatile boolean autoMode;
    public static boolean useBS;
    public static final int NUM_OF_BALLS = 70;
    // number of times to alt+tab in and out of the app
    public static int altTabs = 5;
    private final Vector<Ball> balls = new Vector<>();
    GraphicsDevice gd = GraphicsEnvironment.getLocalGraphicsEnvironment()
        .getDefaultScreenDevice();
    VolatileImage vimg = null;
    BufferStrategy bufferStrategy = null;
    volatile boolean timeToQuit = false;
    static final Object lock = new Object();

    enum SpriteType {
        OVALS, VIMAGES, BIMAGES, AAOVALS, TEXT
    }

    private static boolean changeDM = false;
    private static SpriteType spriteType;
    static Random rnd = new Random();

    public AltTabCrashTest( ) {
        addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
                    timeToQuit = true;
                }
            }
        });
        setIgnoreRepaint(true);
        addMouseListener(new MouseHandler());
        for (int i = 0; i < NUM_OF_BALLS; i++) {
            int x = 50 + rnd.nextInt(550), y = 50 + rnd.nextInt(400);

            balls.addElement(createRandomBall(y, x));
        }
        setUndecorated(true);
        gd.setFullScreenWindow(this);
        GraphicsDevice gd = getGraphicsConfiguration().getDevice();
        if (gd.isDisplayChangeSupported() && changeDM) {
            DisplayMode dm = findDisplayMode();
            if (dm != null) {
                try {
                    gd.setDisplayMode(dm);
                } catch (IllegalArgumentException iae) {
                    System.err.println("Error setting display mode");
                }
            }
        }
        if (useBS) {
            createBufferStrategy(2);
            bufferStrategy = getBufferStrategy();
        } else {
            Graphics2D g = (Graphics2D) getGraphics();
            render(g);
            g.dispose();
        }
        Thread t = new BallThread();
        t.start();
        if (autoMode) {
            Thread tt = new AltTabberThread();
            tt.start();
            synchronized (lock) {
                while (!timeToQuit) {
                    try {
                        lock.wait(200);
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                }
            }
            t = null;
            dispose();
        }
    }

    private Ball createRandomBall(final int y, final int x) {
        Ball b;
        SpriteType type;

        if (spriteType == null) {
            int index = rnd.nextInt(SpriteType.values().length);
            type = SpriteType.values()[index];
        } else {
            type = spriteType;
        }
        switch (type) {
            case VIMAGES: b = new VISpriteBall(x, y); break;
            case AAOVALS: b = new AAOvalBall(x, y); break;
            case BIMAGES: b = new BISpriteBall(x, y); break;
            case TEXT: b = new TextBall(x,y, "Text Sprite!"); break;
            default: b = new Ball(x, y); break;
        }
        return b;
    }

    private class MouseHandler extends MouseAdapter  {
        public void mousePressed(MouseEvent e) {
            synchronized (balls) {
                balls.addElement(createRandomBall(e.getX(), e.getY()));
            }
        }
    }

    private class AltTabberThread extends Thread {
        Robot robot;

        void pressAltTab() {
            robot.keyPress(KeyEvent.VK_ALT);
            robot.keyPress(KeyEvent.VK_TAB);
            robot.keyRelease(KeyEvent.VK_TAB);
            robot.keyRelease(KeyEvent.VK_ALT);
        }
        void pressShiftAltTab() {
            robot.keyPress(KeyEvent.VK_SHIFT);
            pressAltTab();
            robot.keyRelease(KeyEvent.VK_SHIFT);
        }
        public void run() {
            try {
                robot = new Robot();
                robot.setAutoDelay(200);
            } catch (AWTException e) {
                throw new RuntimeException("Can't create robot");
            }
            boolean out = true;
            while (altTabs-- > 0 && !timeToQuit) {
                System.err.println("Alt+tabber Iteration: "+altTabs);
                try { Thread.sleep(2500); } catch (InterruptedException ex) {}

                if (out) {
                    System.err.println("Issuing alt+tab");
                    pressAltTab();
                } else {
                    System.err.println("Issuing shift ");
                    pressShiftAltTab();
                }
                out = !out;
            }
            System.err.println("Alt+tabber finished.");
            synchronized (lock) {
                timeToQuit = true;
                lock.notify();
            }
        }
    }

    private class BallThread extends Thread {
        public void run() {
            while (!timeToQuit) {
                if (useBS) {
                    renderToBS();
                    bufferStrategy.show();
                } else {
                    Graphics g = AltTabCrashTest.this.getGraphics();
                    render(g);
                    g.dispose();
                }
            }
            gd.setFullScreenWindow(null);
            AltTabCrashTest.this.dispose();
        }
    }

    static class Ball {

        int x, y;     // current location
        int dx, dy;   // motion delta
        int diameter = 40;
        Color color = Color.red;

        public Ball() {
        }

        public Ball(int x, int y) {
            this.x = x;
            this.y = y;
            dx = x % 20 + 1;
            dy = y % 20 + 1;
            color = new Color(rnd.nextInt(0x00ffffff));
        }

        public void move() {
            if (x < 10 || x >= AltTabCrashTest.width - 20)
                dx = -dx;
            if (y < 10 || y > AltTabCrashTest.height - 20)
                dy = -dy;
            x += dx;
            y += dy;
        }

        public void paint(Graphics g, Color c) {
            if (c == null) {
                g.setColor(color);
            } else {
                g.setColor(c);
            }
            g.fillOval(x, y, diameter, diameter);
        }

    }

    static class TextBall extends Ball {
        String text;
        public TextBall(int x, int y, String text) {
            super(x, y);
            this.text = text;
        }

        public void paint(Graphics g, Color c) {
            if (c == null) {
                g.setColor(color);
            } else {
                g.setColor(c);
            }
            g.drawString(text, x, y);
        }
    }

    static class AAOvalBall extends Ball {
        public AAOvalBall(int x, int y) {
            super(x, y);
        }
        public void paint(Graphics g, Color c) {
            if (c == null) {
                Graphics2D g2d = (Graphics2D)g.create();
                g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                     RenderingHints.VALUE_ANTIALIAS_ON);
                g2d.setColor(color);
                g2d.fillOval(x, y, diameter, diameter);
            } else {
                g.setColor(c);
                g.fillOval(x-2, y-2, diameter+4, diameter+4);
            }
        }
    }

    static abstract class SpriteBall extends Ball {
        Image image;
        public SpriteBall(int x, int y) {
            super(x, y);
            image = createSprite();
            Graphics g = image.getGraphics();
            g.setColor(color);
            g.fillRect(0, 0, image.getWidth(null), image.getHeight(null));
        }
        public void paint(Graphics g, Color c) {
            if (c != null) {
                g.setColor(c);
                g.fillRect(x, y, image.getWidth(null), image.getHeight(null));
            } else do {
                validateSprite();
                g.drawImage(image, x, y, null);
            } while (renderingIncomplete());
        }
        public abstract Image createSprite();
        public void validateSprite() {}
        public boolean renderingIncomplete() { return false; }
    }
    class VISpriteBall extends SpriteBall {

        public VISpriteBall(int x, int y) {
            super(x, y);
        }
        public boolean renderingIncomplete() {
            return ((VolatileImage)image).contentsLost();
        }

        public Image createSprite() {
            return gd.getDefaultConfiguration().
                createCompatibleVolatileImage(20, 20);
        }
        public void validateSprite() {
            int result =
                ((VolatileImage)image).validate(getGraphicsConfiguration());
            if (result == VolatileImage.IMAGE_INCOMPATIBLE) {
                image = createSprite();
                result = VolatileImage.IMAGE_RESTORED;
            }
            if (result == VolatileImage.IMAGE_RESTORED) {
                Graphics g = image.getGraphics();
                g.setColor(color);
                g.fillRect(0, 0, image.getWidth(null), image.getHeight(null));
            }
        }
    }
    class BISpriteBall extends SpriteBall {
        public BISpriteBall(int x, int y) {
            super(x, y);
        }
        public Image createSprite() {
            return new BufferedImage(20, 20, BufferedImage.TYPE_INT_RGB);
        }
    }


    public void renderOffscreen() {
        Graphics2D g2d = (Graphics2D) vimg.getGraphics();
        synchronized (balls) {
            for (Ball b : balls) {
                b.paint(g2d, getBackground());
                b.move();
                b.paint(g2d, null);
            }
        }
        g2d.dispose();
    }

    public void renderToBS() {
        width = getWidth();
        height = getHeight();

        do {
            Graphics2D g2d = (Graphics2D)bufferStrategy.getDrawGraphics();

            g2d.clearRect(0, 0, width, height);
            synchronized (balls) {
                for (Ball b : balls) {
                    b.move();
                    b.paint(g2d, null);
                }
            }
            g2d.dispose();
        } while (bufferStrategy.contentsLost() ||
                bufferStrategy.contentsRestored());
    }

    public void render(Graphics g)  {
        do {
            height = getBounds().height;
            width = getBounds().width;
            if (vimg == null) {
                vimg = createVolatileImage(width, height);
                renderOffscreen();
            }
            int returnCode = vimg.validate(getGraphicsConfiguration());
            if (returnCode == VolatileImage.IMAGE_RESTORED) {
                renderOffscreen();
            } else if (returnCode == VolatileImage.IMAGE_INCOMPATIBLE) {
                vimg = getGraphicsConfiguration().
                    createCompatibleVolatileImage(width, height);
                renderOffscreen();
            } else if (returnCode == VolatileImage.IMAGE_OK) {
                renderOffscreen();
            }
            g.drawImage(vimg, 0, 0, this);
        } while (vimg.contentsLost());
    }

    public static void main(String args[])  {
        for (String arg : args) {
            if (arg.equalsIgnoreCase("-auto")) {
                autoMode = true;
                System.err.println("Running in automatic mode using Robot");
            } else if (arg.equalsIgnoreCase("-usebs")) {
                useBS = true;
                System.err.println("Using BufferStrategy instead of VI");
            } else if (arg.equalsIgnoreCase("-changedm")) {
                changeDM= true;
                System.err.println("The test will change display mode");
            } else if (arg.equalsIgnoreCase("-vi")) {
                spriteType = SpriteType.VIMAGES;
            } else if (arg.equalsIgnoreCase("-bi")) {
                spriteType = SpriteType.BIMAGES;
            } else if (arg.equalsIgnoreCase("-ov")) {
                spriteType = SpriteType.OVALS;
            } else if (arg.equalsIgnoreCase("-aaov")) {
                spriteType = SpriteType.AAOVALS;
            } else if (arg.equalsIgnoreCase("-tx")) {
                spriteType = SpriteType.TEXT;
            } else {
                System.err.println("Usage: AltTabCrashTest [-usebs][-auto]" +
                                   "[-changedm][-vi|-bi|-ov|-aaov|-tx]");
                System.err.println(" -usebs: use BufferStrategy instead of VI");
                System.err.println(" -auto: automatically alt+tab in and out" +
                                   " of the application ");
                System.err.println(" -changedm: change display mode");
                System.err.println(" -(vi|bi|ov|tx|aaov) : use only VI, BI, " +
                                   "text or [AA] [draw]Oval sprites");
                System.exit(0);
            }
        }
        if (spriteType != null) {
            System.err.println("The test will only use "+spriteType+" sprites.");
        }
        new AltTabCrashTest();
    }

    private DisplayMode findDisplayMode() {
        GraphicsDevice gd = getGraphicsConfiguration().getDevice();
        DisplayMode dms[] = gd.getDisplayModes();
        DisplayMode currentDM = gd.getDisplayMode();
        for (DisplayMode dm : dms) {
            if (dm.getBitDepth() > 8 &&
                dm.getBitDepth() != DisplayMode.BIT_DEPTH_MULTI &&
                dm.getBitDepth() != currentDM.getBitDepth() &&
                dm.getWidth() == currentDM.getWidth() &&
                dm.getHeight() == currentDM.getHeight())
            {
                // found a mode which has the same dimensions but different
                // depth
                return dm;
            }
            if (dm.getBitDepth() == DisplayMode.BIT_DEPTH_MULTI &&
                (dm.getWidth() != currentDM.getWidth() ||
                 dm.getHeight() != currentDM.getHeight()))
            {
                // found a mode which has the same depth but different
                // dimensions
                return dm;
            }
        }

        return null;
    }
}
