/*

 * Copyright (c) 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.

 */

import javax.swing.*;

import javax.swing.border.EmptyBorder;

import java.awt.*;

import java.awt.event.*;

import java.awt.geom.Area;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.security.SecureRandom;

public abstract class Common {

    ExtendedRobot robot;

    Class<? extends JFrame> windowClass;

    JFrame background;

    BufferedImage foreground;

    Window window;

    volatile boolean gradientBackgroundEnabled = false;

    volatile int gradientWidth = 255;

    volatile int gradientHeight = 255;

    float opacity = 1.0f;

    float perPixelTranslucency = 1.0f;

    static Color BG_COLOR = Color.BLUE;

    static Color FG_COLOR = Color.RED;

    static final int delay = 1000;

    static final SecureRandom random = new SecureRandom();

    static final int dl = 100;

    static final Class[] WINDOWS_TO_TEST = { JWindow.class, JFrame.class, JDialog.class };

    volatile int clicked;

    public Common(Class windowClass, float opacity, float perPixelTranslucency, boolean gradient) throws Exception {

        this.gradientBackgroundEnabled = gradient;

        this.perPixelTranslucency = perPixelTranslucency;

        this.opacity = opacity;

        robot = new ExtendedRobot();

        this.windowClass = windowClass;

        EventQueue.invokeAndWait(this::initBackgroundFrame);

        EventQueue.invokeAndWait(this::initGUI);

    }

    public Common(Class windowClass) throws Exception {

        this(windowClass, 1.0f, 1.0f, false);

    }

    public Common(Class windowClass, boolean gradient) throws Exception {

        this(windowClass, 1.0f, 1.0f, gradient);

    }

    public abstract void doTest() throws Exception;

    public void dispose() {

        window.dispose();

        background.dispose();

    }

    public void applyShape() {};

    public void applyDynamicShape() {

        final Area a = new Area();

        Dimension size = window.getSize();

        for (int x = 0; x < 3; x++) {

            for (int y = 0; y < 3; y++) {

                a.add(new Area(new Rectangle2D.Double(

                        x * size.getWidth() / 17*6, y * size.getHeight() / 17*6,

                        size.getWidth() / 17*5, size.getHeight() / 17*5)));

            }

        }

        window.setShape(a);

    }

    public BufferedImage getForegroundWindow() throws Exception {

        final BufferedImage f[] = new BufferedImage[1];

        EventQueue.invokeAndWait( () -> {

            f[0] = new BufferedImage(window.getWidth(),

                    window.getHeight(), BufferedImage.TYPE_INT_RGB);

            window.printAll(f[0].createGraphics());

        });

        robot.waitForIdle(delay);

        return f[0];

    }

    public static boolean checkTranslucencyMode(GraphicsDevice.WindowTranslucency mode) {

        if (!GraphicsEnvironment

                .getLocalGraphicsEnvironment()

                .getDefaultScreenDevice()

                .isWindowTranslucencySupported(mode)){

            System.out.println(mode+" translucency mode isn't supported");

            return false;

        } else {

            return true;

        }

    }

    public void applyAppDragNResizeSupport() {

        MouseAdapter m = new MouseAdapter() {

            private Point dragOrigin = null;

            private Dimension origSize = null;

            private Point origLoc = null;

            private boolean left = false;

            private boolean top = false;

            private boolean bottom = false;

            private boolean right = false;

            public void mousePressed(MouseEvent e) {

                dragOrigin = e.getLocationOnScreen();

                origSize = window.getSize();

                origLoc = window.getLocationOnScreen();

                right = (origLoc.x + window.getWidth() - dragOrigin.x) < 5;

                left = !right && dragOrigin.x - origLoc.x < 5;

                bottom = (origLoc.y + window.getHeight() - dragOrigin.y) < 5;

                top = !bottom && dragOrigin.y - origLoc.y < 5;

            }

            public void mouseReleased(MouseEvent e) { resize(e); }

            public void mouseDragged(MouseEvent e) { resize(e); }

            void resize(MouseEvent e) {

                Point dragDelta = e.getLocationOnScreen();

                dragDelta.translate(-dragOrigin.x, -dragOrigin.y);

                Point newLoc = new Point(origLoc);

                newLoc.translate(dragDelta.x, dragDelta.y);

                Dimension newSize = new Dimension(origSize);

                if (left || right) {

                    newSize.width += right ? dragDelta.x : -dragDelta.x;

                }

                if (top || bottom) {

                    newSize.height += bottom ? dragDelta.y : -dragDelta.y;

                }

                if (right || (top || bottom) && !left) {

                    newLoc.x = origLoc.x;

                }

                if (bottom || (left || right) && !top) {

                    newLoc.y = origLoc.y;

                }

                window.setBounds(newLoc.x, newLoc.y, newSize.width, newSize.height);

            }

        };

        for (Component comp : window.getComponents()) {

            comp.addMouseListener(m);

            comp.addMouseMotionListener(m);

        }

        window.addMouseListener(m);

        window.addMouseMotionListener(m);

    }

    public void checkTranslucentShape() throws Exception {

        foreground = getForegroundWindow();

        Point[] points = new Point[4];

        Dimension size = window.getSize();

        Point location = window.getLocationOnScreen();

        points[0] = new Point(20, 20);

        points[1] = new Point(20, size.height-20);

        points[2] = new Point(size.width-20, 20);

        points[3] = new Point(size.width-20, size.height-20);

        for (Point p : points){

            p.translate(location.x, location.y);

            Color actual = robot.getPixelColor(p.x, p.y);

            if (actual.equals(BG_COLOR)|| actual.equals(FG_COLOR))

                throw new RuntimeException("Error in point "+p+": "+actual+" equals to foreground or background color");

            else

                System.out.println("OK with foreground point "+p);

        }

    }

    public void checkDynamicShape() throws Exception {

        Point[] points = new Point[4];

        Dimension size = window.getSize();

        int blockSizeX = (int) (size.getWidth() / 17);

        int blockSizeY = (int) (size.getHeight() / 17);

        // background

        points[0] = new Point((int) (blockSizeX * 5.5), (int) (blockSizeY * 5.5));

        points[1] = new Point((int) (size.getWidth() - blockSizeX * 5.5), (int) (size.getHeight() - blockSizeY * 5.5));

        points[2] = new Point((int) (blockSizeX * 5.5), (int) (size.getHeight() - blockSizeY * 5.5));

        points[3] = new Point((int) (size.getWidth() - blockSizeX * 5.5), (int) (blockSizeY * 5.5));

        checkShape(points, true);

        // foreground

        if (opacity < 1.0f){

            checkTranslucentShape();

        } else {

            points[0] = new Point(3 * blockSizeX, 3 * blockSizeY);

            points[1] = new Point(14 * blockSizeX, 14 * blockSizeY);

            points[2] = new Point(3 * blockSizeX, 14 * blockSizeY);

            points[3] = new Point(14 * blockSizeX, 3 * blockSizeY);

            checkShape(points, false);

        }

    }

    public void checkShape(Point[] points, boolean areBackgroundPoints) throws Exception {

        Point location = window.getLocationOnScreen();

        for (Point p : points) {

            p.translate(location.x, location.y);

            Color pixel = robot.getPixelColor(p.x, p.y);

            if (areBackgroundPoints) {

                if (pixel.getRed() != 0

                    || pixel.getGreen() != 0 )

                    throw new RuntimeException("Background point " + p +

                            " color " + pixel +

                            " does not equal to background color " + BG_COLOR);

                else

                    System.out.println("OK with background point " + p);

            } else {

                if (pixel.equals(BG_COLOR))

                    throw new RuntimeException("Foreground point " + p +

                            " color " + pixel +

                            " equals to background color " + BG_COLOR);

                else

                    System.out.println("OK with foreground point " + p);

            }

        }

    }

    public void initBackgroundFrame() {

        background = new JFrame();

        background.setUndecorated(true);

        background.getContentPane().setBackground(BG_COLOR);

        background.setSize(500, 500);

        background.setLocation(dl, dl);

        background.setVisible(true);

    }

    public void initGUI() {

        Container contentPane;

        if (windowClass.equals(Frame.class)) {

            window = new JFrame();

            ((JFrame) window).setUndecorated(true);

            contentPane = ((JFrame) window).getContentPane();

        } else  if (windowClass.equals(Dialog.class)) {

            window = new JDialog(background);

            ((JDialog) window).setUndecorated(true);

            contentPane = ((JDialog) window).getContentPane();

        } else {

            window = new JWindow(background);

            contentPane = ((JWindow) window).getContentPane();

        }

        if (perPixelTranslucency < 1.0f) {

            contentPane.setBackground(colorWithOpacity(FG_COLOR, perPixelTranslucency));

            window.setBackground(colorWithOpacity(FG_COLOR, perPixelTranslucency));

        } else {

            contentPane.setBackground(FG_COLOR);

            window.setBackground(FG_COLOR);

        }

        window.setLocation(2 * dl, 2 * dl);

        window.setSize(255, 255);

        window.setPreferredSize(new Dimension(255, 255));

        createSwingComponents();

        if (opacity < 1.0f)

            window.setOpacity(opacity);

        window.addComponentListener(new ComponentAdapter() {

            @Override

            public void componentResized(ComponentEvent e) {

                applyShape();

            }

        });

        applyShape();

        window.setVisible(true);

        applyAppDragNResizeSupport();

        window.toFront();

    }

    public void createSwingComponents() {

        Container contentPane;

        if (gradientBackgroundEnabled) {

            JPanel jPanel = new JPanel() {

                @Override

                protected void paintComponent(Graphics g) {

                    if (g instanceof Graphics2D) {

                        Color background = Color.RED;

                        Paint p = new GradientPaint(0.0f, 0.0f, colorWithOpacity(background, 0),

                                0.0f, gradientHeight - 3, colorWithOpacity(background, 1), true);

                        Graphics2D g2d = (Graphics2D) g;

                        g2d.setPaint(p);

                        g2d.fillRect(0, 3, gradientWidth, gradientHeight - 3);

                    } else {

                        super.paintComponent(g);

                    }

                }

            };

            jPanel.setBorder(new EmptyBorder(15, 5, 5, 5));

            jPanel.setOpaque(false);

            contentPane = jPanel;

            RootPaneContainer.class.cast(window).setContentPane(contentPane);

        } else {

            contentPane = RootPaneContainer.class.cast(window).getContentPane();

        }

        contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));

        JButton button = new JButton("JButton");

        window.add(button);

        JTextArea textArea = new JTextArea("JTextArea");

        window.add(textArea);

        JCheckBox checkbox = new JCheckBox("JCheckBox");

        checkbox.setOpaque(false);

        window.add(checkbox);

        JComboBox comboBox = new JComboBox(new String[]{"JComboBox", "Some item"});

        window.add(comboBox);

        JLabel label = new JLabel("JLabel");

        window.add(label);

        JTextField textField = new JTextField("JTextField");

        window.add(textField);

        JPanel panel = new JPanel();

        panel.setOpaque(false);

        window.add(panel);

        JComboBox comboBox2 = new JComboBox(new String[]{"JComboBox2", "Another item"});

        window.add(comboBox2);

        JRadioButton radioButton = new JRadioButton("JRadioButton");

        radioButton.setOpaque(false);

        window.add(radioButton);

    }

    Color colorWithOpacity(Color color, float opacity) {

        return new Color(color.getColorSpace(), color.getColorComponents(null), opacity);

    }

    public void checkTranslucent() throws Exception {

        checkTranslucentShape();

        // Drag

        Point location = window.getLocationOnScreen();

        robot.dragAndDrop(location.x + 30, location.y + 5, location.x + dl + random.nextInt(dl), location.y + random.nextInt(dl));

        robot.waitForIdle(2*delay);

        checkTranslucentShape();

        // Resize

        location = window.getLocationOnScreen();

        robot.dragAndDrop(location.x + 4, location.y + 4, location.x + random.nextInt(2*dl)-dl, location.y + random.nextInt(2*dl)-dl);

        robot.waitForIdle(2*delay);

        checkTranslucentShape();

        EventQueue.invokeAndWait(this::dispose);

    }

    public void checkDynamic() throws Exception {

        checkDynamicShape();

        // Drag

        Point location = window.getLocationOnScreen();

        robot.dragAndDrop(location.x + 30, location.y + 5, location.x + dl + random.nextInt(dl), location.y + random.nextInt(dl));

        robot.waitForIdle(2*delay);

        checkDynamicShape();

        // Resize

        location = window.getLocationOnScreen();

        robot.dragAndDrop(location.x + 4, location.y + 4, location.x + random.nextInt(2*dl)-dl, location.y + random.nextInt(2*dl)-dl);

        robot.waitForIdle(2*delay);

        checkDynamicShape();

        EventQueue.invokeAndWait(this::dispose);

    }

    void checkClick(int x, int y, int flag) throws Exception {

        System.out.println("Trying to click point " + x + ", " + y + ", looking for " + flag + " flag to trigger.");

        clicked = 0;

        robot.mouseMove(x, y);

        robot.click();

        for (int i = 0; i < 100; i++)

            if ((clicked & (1 << flag)) == 0)

                robot.delay(50);

            else

                break;

        if ((clicked & (1 << flag)) == 0)

            throw new RuntimeException("FAIL: Flag " + flag + " is not triggered for point " + x + ", " + y + "!");

    }

}