/*

 * 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 java.awt.*;

import java.awt.event.*;

import java.awt.peer.ComponentPeer;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import javax.swing.*;

import sun.awt.*;

import java.io.*;

/**

 * <p>This class provides basis for AWT Mixing testing.

 * <p>It provides all standard test machinery and should be used by

 * extending and overriding next methods:

 * <li> {@link OverlappingTestBase#prepareControls()} - setup UI components

 * <li> {@link OverlappingTestBase#performTest()} -  run particular test

 * Those methods would be run in the loop for each AWT component.

 * <p>Current AWT component should be added to the tested UI by {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) ()}.

 * There AWT components are prepared to be tested as being overlayed by other (e.g. Swing) components - they are colored to

 * {@link OverlappingTestBase#AWT_BACKGROUND_COLOR} and throws failure on catching mouse event.

 * <p> Validation of component being overlayed should be tested by {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point) }

 * See each method javadoc for more details.

 *

 * <p>Due to test machinery limitations all test should be run from their own main() by calling next coe

 * <code>

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

 *        instance = new YourTestInstance();

 *        OverlappingTestBase.doMain(args);

 *     }

 * </code>

 *

 * @author Sergey Grinev

 */

public abstract class OverlappingTestBase {

    // working variables

    private static volatile boolean wasHWClicked = false;

    private static volatile boolean passed = true;

    // constants

    /**

     * Default color for AWT component used for validate correct drawing of overlapping. <b>Never</b> use it for lightweight components.

     */

    protected static final Color AWT_BACKGROUND_COLOR = new Color(21, 244, 54);

    protected static Color AWT_VERIFY_COLOR = AWT_BACKGROUND_COLOR;

    protected static final int ROBOT_DELAY = 500;

    private static final String[] simpleAwtControls = {"Button", "Checkbox", "Label", "TextArea"};

    /**

     * Generic strings array. To be used for population of List based controls.

     */

    protected static final String[] petStrings = {"Bird", "Cat", "Dog", "Rabbit", "Rhynocephalia Granda", "Bear", "Tiger", "Mustang"};

    // "properties"

    /**

     * Tests customization. Set this variable to test only control from java.awt

     * <p>Usage of this variable should be marked with CR being the reason.

     * <p>Do not use this variable simultaneously with {@link OverlappingTestBase#skipClassNames}

     */

    protected String onlyClassName = null;

    /**

     * For customizing tests. List classes' simple names to skip them from testings.

     * <p>Usage of this variable should be marked with CR being the reason.

     */

    protected String[] skipClassNames = null;

    /**

     * Set to false to avoid event delivery validation

     * @see OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean)

     */

    protected boolean useClickValidation = true;

    /**

     * Set to false if test doesn't supposed to verify EmbeddedFrame

     */

    protected boolean testEmbeddedFrame = false;

    /**

     * Set this variable to true if testing embedded frame is impossible (on Mac, for instance, for now).

     * The testEmbeddedFrame is explicitly set to true in dozen places.

     */

    protected boolean skipTestingEmbeddedFrame = false;

    public static final boolean isMac = System.getProperty("os.name").toLowerCase().contains("os x");

    private boolean isFrameBorderCalculated;

    private int borderShift;

    {    if (Toolkit.getDefaultToolkit().getClass().getName().matches(".*L.*Toolkit")) {

             // No EmbeddedFrame in LWToolkit/LWCToolkit, yet

             // And it should be programmed some other way, too, in any case

             System.err.println("skipTestingEmbeddedFrame");

             skipTestingEmbeddedFrame = true;

         }else {

             System.err.println("do not skipTestingEmbeddedFrame");

         }

    }

    protected int frameBorderCounter() {

        if (!isFrameBorderCalculated) {

            try {

                new FrameBorderCounter(); // force compilation by jtreg

                String JAVA_HOME = System.getProperty("java.home");

                Process p = Runtime.getRuntime().exec(JAVA_HOME + "/bin/java FrameBorderCounter");

                try {

                    p.waitFor();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                    throw new RuntimeException(e);

                }

                if (p.exitValue() != 0) {

                    throw new RuntimeException("FrameBorderCounter exited with not null code!\n" + readInputStream(p.getErrorStream()));

                }

                borderShift = Integer.parseInt(readInputStream(p.getInputStream()).trim());

                isFrameBorderCalculated = true;

            } catch (IOException e) {

                e.printStackTrace();

                System.exit(1);

            }

        }

        return borderShift;

    }

    public void getVerifyColor() {

        try {

            final int size = 200;

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

            final Point[] p = new Point[1];

            SwingUtilities.invokeAndWait(new Runnable() {

                public void run(){

                    JFrame frame = new JFrame("set back");

                    frame.getContentPane().setBackground(AWT_BACKGROUND_COLOR);

                    frame.setSize(size, size);

                    frame.setUndecorated(true);

                    frame.setVisible(true);

                    frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

                    p[0] = frame.getLocation();

                }

            });

            Robot robot = new Robot();

            toolkit.realSync();

            Thread.sleep(ROBOT_DELAY);

            AWT_VERIFY_COLOR = robot.getPixelColor(p[0].x+size/2, p[0].y+size/2);

            System.out.println("Color will be compared with " + AWT_VERIFY_COLOR + " instead of " + AWT_BACKGROUND_COLOR);

        } catch (Exception e) {

            System.err.println("Cannot get verify color: "+e.getMessage());

        }

    }

    private String readInputStream(InputStream is) throws IOException {

        byte[] buffer = new byte[4096];

        int len = 0;

        StringBuilder sb = new StringBuilder();

        try (InputStreamReader isr = new InputStreamReader(is)) {

            while ((len = is.read(buffer)) > 0) {

                sb.append(new String(buffer, 0, len));

            }

        }

        return sb.toString();

    }

    private void setupControl(final Component control) {

        if (useClickValidation) {

            control.addMouseListener(new MouseAdapter() {

                @Override

                public void mouseClicked(MouseEvent e) {

                    System.err.println("ERROR: " + control.getClass() + " received mouse click.");

                    wasHWClicked = true;

                }

            });

        }

        control.setBackground(AWT_BACKGROUND_COLOR);

        control.setForeground(AWT_BACKGROUND_COLOR);

        control.setPreferredSize(new Dimension(150, 150));

        control.setFocusable(false);

    }

    private void addAwtControl(java.util.List<Component> container, final Component control) {

        String simpleName = control.getClass().getSimpleName();

        if (onlyClassName != null && !simpleName.equals(onlyClassName)) {

            return;

        }

        if (skipClassNames != null) {

            for (String skipMe : skipClassNames) {

                if (simpleName.equals(skipMe)) {

                    return;

                }

            }

        }

        setupControl(control);

        container.add(control);

    }

    private void addSimpleAwtControl(java.util.List<Component> container, String className) {

        try {

            Class definition = Class.forName("java.awt." + className);

            Constructor constructor = definition.getConstructor(new Class[]{String.class});

            java.awt.Component component = (java.awt.Component) constructor.newInstance(new Object[]{"AWT Component " + className});

            addAwtControl(container, component);

        } catch (Exception ex) {

            System.err.println(ex.getMessage());

            fail("Setup error, this jdk doesn't have awt conrol " + className);

        }

    }

    /**

     * Adds current AWT control to container

     * <p>N.B.: if testEmbeddedFrame == true this method will also add EmbeddedFrame over Canvas

     * and it should be called <b>after</b> Frame.setVisible(true) call

     * @param container container to hold AWT component

     */

    protected final void propagateAWTControls(Container container) {

        if (currentAwtControl != null) {

            container.add(currentAwtControl);

        } else { // embedded frame

            try {

                //create embedder

                Canvas embedder = new Canvas();

                embedder.setBackground(Color.RED);

                embedder.setPreferredSize(new Dimension(150, 150));

                container.add(embedder);

                container.setVisible(true); // create peer

                long frameWindow = 0;

                String getWindowMethodName = "getHWnd";

                if (Toolkit.getDefaultToolkit().getClass().getName().contains("XToolkit")) {

                    getWindowMethodName = "getWindow";

                }

                ComponentPeer peer = embedder.getPeer();

//                System.err.println("Peer: " + peer);

                Method getWindowMethod = peer.getClass().getMethod(getWindowMethodName);

                frameWindow = (Long) getWindowMethod.invoke(peer);

//                System.err.println("frame peer ID: " + frameWindow);

                String eframeClassName = "sun.awt.windows.WEmbeddedFrame";

                if (Toolkit.getDefaultToolkit().getClass().getName().contains("XToolkit")) {

                    eframeClassName = "sun.awt.X11.XEmbeddedFrame";

                }

                Class eframeClass = Class.forName(eframeClassName);

                Constructor eframeCtor = eframeClass.getConstructor(long.class);

                EmbeddedFrame eframe = (EmbeddedFrame) eframeCtor.newInstance(frameWindow);

                setupControl(eframe);

                eframe.setSize(new Dimension(150, 150));

                eframe.setVisible(true);

//                System.err.println(eframe.getSize());

            } catch (Exception ex) {

                ex.printStackTrace();

                fail("Failed to instantiate EmbeddedFrame: " + ex.getMessage());

            }

        }

    }

    private static final Font hugeFont = new Font("Arial", Font.BOLD, 70);

    private java.util.List<Component> getAWTControls() {

        java.util.List<Component> components = new ArrayList<Component>();

        for (String clazz : simpleAwtControls) {

            addSimpleAwtControl(components, clazz);

        }

        TextField tf = new TextField();

        tf.setFont(hugeFont);

        addAwtControl(components, tf);

        // more complex controls

        Choice c = new Choice();

        for (int i = 0; i < petStrings.length; i++) {

            c.add(petStrings[i]);

        }

        addAwtControl(components, c);

        c.setPreferredSize(null);

        c.setFont(hugeFont); // to make control bigger as setPrefferedSize don't do his job here

        List l = new List(petStrings.length);

        for (int i = 0; i < petStrings.length; i++) {

            l.add(petStrings[i]);

        }

        addAwtControl(components, l);

        Canvas canvas = new Canvas();

        canvas.setSize(100, 200);

        addAwtControl(components, canvas);

        Scrollbar sb = new Scrollbar(Scrollbar.VERTICAL, 500, 1, 0, 500);

        addAwtControl(components, sb);

        Scrollbar sb2 = new Scrollbar(Scrollbar.HORIZONTAL, 500, 1, 0, 500);

        addAwtControl(components, sb2);

        return components;

    }

    /**

     * Default shift for {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point) }

     */

    protected static Point shift = new Point(16, 16);

    /**

     * Verifies point using specified AWT Robot. Supposes <code>defaultShift == true</code> for {@link OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean) }.

     * This method is used to verify controls by providing just their plain screen coordinates.

     * @param robot AWT Robot. Usually created by {@link Util#createRobot() }

     * @param lLoc point to verify

     * @see OverlappingTestBase#clickAndBlink(java.awt.Robot, java.awt.Point, boolean)

     */

    protected void clickAndBlink(Robot robot, Point lLoc) {

        clickAndBlink(robot, lLoc, true);

    }

    /**

     * Default failure message for color check

     * @see OverlappingTestBase#performTest()

     */

    protected String failMessageColorCheck = "The LW component did not pass pixel color check and is overlapped";

    /**

     * Default failure message event check

     * @see OverlappingTestBase#performTest()

     */

    protected String failMessage = "The LW component did not received the click.";

    private static boolean isValidForPixelCheck(Component component) {

        if ((component instanceof java.awt.Scrollbar) || isMac && (component instanceof java.awt.Button)) {

            return false;

        }

        return true;

    }

    /**

     * Preliminary validation - should be run <b>before</b> overlapping happens to ensure test is correct.

     * @param robot AWT Robot. Usually created by {@link Util#createRobot() }

     * @param lLoc point to validate to be <b>of</b> {@link OverlappingTestBase#AWT_BACKGROUND_COLOR}

     * @param component tested component, should be pointed out as not all components are valid for pixel check.

     */

    protected void pixelPreCheck(Robot robot, Point lLoc, Component component) {

        if (isValidForPixelCheck(component)) {

            int tries = 10;

            Color c = null;

            while (tries-- > 0) {

                c = robot.getPixelColor(lLoc.x, lLoc.y);

                System.out.println("Precheck. color: "+c+" compare with "+AWT_VERIFY_COLOR);

                if (c.equals(AWT_VERIFY_COLOR)) {

                    return;

                }

                try {

                    Thread.sleep(100);

                } catch (InterruptedException e) {

                }

            }

            System.err.println(lLoc + ": " + c);

            fail("Dropdown test setup failure, colored part of AWT component is not located at click area");

        }

    }

    /**

     * Verifies point using specified AWT Robot.

     * <p>Firstly, verifies point by color pixel check

     * <p>Secondly, verifies event delivery by mouse click

     * @param robot AWT Robot. Usually created by {@link Util#createRobot() }

     * @param lLoc point to verify

     * @param defaultShift if true verified position will be shifted by {@link OverlappingTestBase#shift }.

     */

    protected void clickAndBlink(Robot robot, Point lLoc, boolean defaultShift) {

        Point loc = lLoc.getLocation();

        //check color

        Util.waitForIdle(robot);

        try{

            Thread.sleep(500);

        }catch(Exception exx){

            exx.printStackTrace();

        }

        if (defaultShift) {

            loc.translate(shift.x, shift.y);

        }

        if (!(System.getProperty("os.name").toLowerCase().contains("os x"))) {

            Color c = robot.getPixelColor(loc.x, loc.y);

            System.out.println("C&B. color: "+c+" compare with "+AWT_VERIFY_COLOR);

            if (c.equals(AWT_VERIFY_COLOR)) {

                fail(failMessageColorCheck);

                passed = false;

            }

            // perform click

            Util.waitForIdle(robot);

        }

        robot.mouseMove(loc.x, loc.y);

        robot.mousePress(InputEvent.BUTTON1_MASK);

        robot.mouseRelease(InputEvent.BUTTON1_MASK);

        Util.waitForIdle(robot);

    }

    /**

     * This method should be overriden with code which setups UI for testing.

     * Code in this method <b>will</b> be called only from AWT thread so Swing operations can be called directly.

     *

     * @see {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) } for instructions about adding tested AWT control to UI

     */

    protected abstract void prepareControls();

    /**

     * This method should be overriden with test execution. It will <b>not</b> be called from AWT thread so all Swing operations should be treated accordingly.

     * @return true if test passed. Otherwise fail with default fail message.

     * @see {@link OverlappingTestBase#failMessage} default fail message

     */

    protected abstract boolean performTest();

    /**

     * This method can be overriden with cleanup routines. It will be called from AWT thread so all Swing operations should be treated accordingly.

     */

    protected void cleanup() {

        // intentionally do nothing

    }

    /**

     * Currect tested AWT Control. Usually shouldn't be accessed directly.

     *

     * @see {@link OverlappingTestBase#propagateAWTControls(java.awt.Container) } for instructions about adding tested AWT control to UI

     */

    protected Component currentAwtControl;

    private void testComponent(Component component) throws InterruptedException, InvocationTargetException {

        currentAwtControl = component;

        System.out.println("Testing " + currentAwtControl.getClass().getSimpleName());

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                prepareControls();

            }

        });

        if (component != null) {

            Util.waitTillShown(component);

        }

        Util.waitForIdle(null);

        try {

            Thread.sleep(500); // wait for graphic effects on systems like Win7

        } catch (InterruptedException ex) {

        }

        if (!instance.performTest()) {

            fail(failMessage);

            passed = false;

        }

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                cleanup();

            }

        });

    }

    private void testEmbeddedFrame() throws InvocationTargetException, InterruptedException {

        System.out.println("Testing EmbeddedFrame");

        currentAwtControl = null;

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                prepareControls();

            }

        });

        Util.waitForIdle(null);

        try {

            Thread.sleep(500); // wait for graphic effects on systems like Win7

        } catch (InterruptedException ex) {

        }

        if (!instance.performTest()) {

            fail(failMessage);

            passed = false;

        }

        SwingUtilities.invokeAndWait(new Runnable() {

            public void run() {

                cleanup();

            }

        });

    }

    private void testAwtControls() throws InterruptedException {

        try {

            for (Component component : getAWTControls()) {

                testComponent(component);

            }

            if (testEmbeddedFrame && !skipTestingEmbeddedFrame) {

                testEmbeddedFrame();

            }

        } catch (InvocationTargetException ex) {

            ex.printStackTrace();

            fail(ex.getMessage());

        }

    }

    /**

     * Used by standard test machinery. See usage at {@link OverlappingTestBase }

     */

    protected static OverlappingTestBase instance;

    protected OverlappingTestBase() {

        getVerifyColor();

    }

    /*****************************************************

     * Standard Test Machinery Section

     * DO NOT modify anything in this section -- it's a

     * standard chunk of code which has all of the

     * synchronisation necessary for the test harness.

     * By keeping it the same in all tests, it is easier

     * to read and understand someone else's test, as

     * well as insuring that all tests behave correctly

     * with the test harness.

     * There is a section following this for test-

     * classes

     ******************************************************/

    private static void init() throws InterruptedException {

        //*** Create instructions for the user here ***

        //System.setProperty("sun.awt.disableMixing", "true");

        String[] instructions = {

            "This is an AUTOMATIC test, simply wait until it is done.",

            "The result (passed or failed) will be shown in the",

            "message window below."

        };

        Sysout.createDialog();