/*

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

 */

package org.netbeans.jemmy;

import java.awt.AWTEvent;

import java.awt.Toolkit;

import java.awt.event.AWTEventListener;

import java.lang.ref.Reference;

import java.lang.ref.WeakReference;

import java.lang.reflect.Field;

import java.lang.reflect.Modifier;

import java.util.Vector;

/**

 *

 * Provides methods to check last dispatched events, to wait for events of

 * specific types, or to guarantee that events of specific types are not

 * dispatched during some time frame.

 * <BR><BR>

 * All possible listeners are added during this class initialization in case if

 * "jemmy.event_listening" system property is not equal to "no", so, by default,

 * all events are listened.

 *

 * Uses timeouts:<BR>

 * EventTool.WaitEventTimeout - time to wait for AWT events.<BR>

 * EventTool.WaitNoEventTimeout - when checking for the absence of incoming AWT

 * events.<BR>

 * EventTool.EventCheckingDelta - time delta between checks for AWT events.

 *

 * @author Alexandre Iline (alexandre.iline@oracle.com)

 */

public class EventTool implements Timeoutable, Outputable {

    private static final long WAIT_EVENT_TIMEOUT = 60000;

    private static final long WAIT_NO_EVENT_TIMEOUT = 180000;

    private static final long EVENT_CHECKING_DELTA = 10;

    private static ListenerSet listenerSet;

    private static long currentEventMask = 0;

    private TestOut output;

    private Timeouts timeouts;

    /**

     * Constructor.

     */

    public EventTool() {

        setOutput(JemmyProperties.getProperties().getOutput());

        setTimeouts(JemmyProperties.getProperties().getTimeouts());

    }

    /**

     * Returns time of the last dispatched event under mask.

     *

     * @param eventMask Events types to be searched.

     * {@code AWTEvent.*_EVENT_MASK} fields combination.

     * @return time in milliseconds

     * @see #addListeners(long)

     */

    public static long getLastEventTime(long eventMask) {

        return listenerSet.getLastEventTime(eventMask);

    }

    /**

     * Returns last dispatched event under mask.

     *

     * @param eventMask Events types to be searched.

     * {@code AWTEvent.*_EVENT_MASK} fields combination.

     * @return AWTEvent

     * @see #addListeners(long)

     */

    public static AWTEvent getLastEvent(long eventMask) {

        return listenerSet.getLastEvent(eventMask);

    }

    /**

     * Returns time of the last dispatched event.

     *

     * @return time in milliseconds

     * @see #addListeners(long)

     */

    public static long getLastEventTime() {

        return getLastEventTime(listenerSet.getTheWholeMask());

    }

    /**

     * Returns last dispatched event.

     *

     * @return AWTEvent

     * @see #addListeners(long)

     */

    public static AWTEvent getLastEvent() {

        return getLastEvent(listenerSet.getTheWholeMask());

    }

    /**

     * Adds listeners to listen events under mask. Invokes

     * {@code removeListeners()} first, so any event history is lost.

     *

     * @param eventMask Mask to listen events under.

     * {@code AWTEvent.*_EVENT_MASK} fields combination.

     * @see #addListeners()

     * @see #removeListeners()

     */

    public static void addListeners(long eventMask) {

        removeListeners();

        listenerSet.addListeners(eventMask);

        currentEventMask = eventMask;

    }

    /**

     * Adds listeners to listen all types of events. Invokes

     * {@code removeListeners()} first, so any event history is lost. This

     * method is invoked during static section of this class.

     *

     * @see #addListeners(long)

     * @see #removeListeners()

     * @see #getTheWholeEventMask()

     */

    public static void addListeners() {

        addListeners(listenerSet.getTheWholeMask());

    }

    /**

     * Removes all listeners.

     *

     * @see #addListeners(long)

     * @see #addListeners()

     */

    public static void removeListeners() {

        listenerSet.removeListeners();

    }

    /**

     * Returns event mask last time used by {@code addListeners(long)}

     * method. In case if {@code addListeners()} method was used last,

     * {@code getTheWholeEventMask() } result is returned.

     *

     * @return a long representing the current event mask value

     * @see #getTheWholeEventMask()

     */

    public static long getCurrentEventMask() {

        return currentEventMask;

    }

    /**

     * Returns a combination of all {@code AWTEvent.*_EVENT_MASK} fields..

     *

     * @return a combination of all {@code AWTEvent.*_EVENT_MASK} fields.

     */

    public static long getTheWholeEventMask() {

        return listenerSet.getTheWholeMask();

    }

    static {

        Timeouts.initDefault("EventTool.WaitEventTimeout", WAIT_EVENT_TIMEOUT);

        Timeouts.initDefault("EventTool.WaitNoEventTimeout", WAIT_NO_EVENT_TIMEOUT);

        Timeouts.initDefault("EventTool.EventCheckingDelta", EVENT_CHECKING_DELTA);

        listenerSet = new ListenerSet();

        if (System.getProperty("jemmy.event_listening") == null

                || !System.getProperty("jemmy.event_listening").equals("no")) {

            listenerSet.addListeners();

        }

    }

    /**

     * Defines current timeouts.

     *

     * @param ts ?t? A collection of timeout assignments.

     * @see org.netbeans.jemmy.Timeouts

     * @see org.netbeans.jemmy.Timeoutable

     * @see #getTimeouts

     */

    @Override

    public void setTimeouts(Timeouts ts) {

        timeouts = ts;

    }

    /**

     * Return current timeouts.

     *

     * @return the collection of current timeout assignments.

     * @see org.netbeans.jemmy.Timeouts

     * @see org.netbeans.jemmy.Timeoutable

     * @see #setTimeouts

     */

    @Override

    public Timeouts getTimeouts() {

        return timeouts;

    }

    /**

     * Defines print output streams or writers.

     *

     * @param out Identify the streams or writers used for print output.

     * @see org.netbeans.jemmy.Outputable

     * @see org.netbeans.jemmy.TestOut

     * @see #getOutput

     */

    @Override

    public void setOutput(TestOut out) {

        output = out;

    }

    /**

     * Returns print output streams or writers.

     *

     * @return an object that contains references to objects for printing to

     * output and err streams.

     * @see org.netbeans.jemmy.Outputable

     * @see org.netbeans.jemmy.TestOut

     * @see #setOutput

     */

    @Override

    public TestOut getOutput() {

        return output;

    }

    /**

     * Waits for the first event under mask. Waits during

     * {@code EventTool.WaitEventTimeout} milliseconds.

     *

     * @param eventMask Mask to wait events under.

     * {@code AWTEvent.*_EVENT_MASK} fields combination.

     * @return an AWTEvent object

     * @see #waitEvent()

     * @throws TimeoutExpiredException

     */

    public AWTEvent waitEvent(long eventMask) {

        return (waitEvent(eventMask,

                timeouts.getTimeout("EventTool.WaitEventTimeout"),

                output.createErrorOutput()));

    }

    /**

     * Waits for the first event. Waits during

     * {@code EventTool.WaitEventTimeout} milliseconds.

     *

     * @return an AWTEvent object

     * @see #waitEvent(long)

     * @see #getTheWholeEventMask()

     * @throws TimeoutExpiredException

     */

    public AWTEvent waitEvent() {

        return waitEvent(listenerSet.getTheWholeMask());

    }

    /**

     * Check that no event under mask will be dispatched during time specified.

     *

     * @param eventMask Mask to wait events under.

     * {@code AWTEvent.*_EVENT_MASK} fields combination.

     * @param waitTime Quiet time (millisecons).

     * @return true if no event ahs found.

     * @see #checkNoEvent(long)

     */

    public boolean checkNoEvent(long eventMask, long waitTime) {

        return checkNoEvent(eventMask, waitTime, output);

    }

    /**

     * Check that no event will be dispatched during time specified.

     *

     * @param waitTime Quiet time (millisecons).

     * @return true if no event ahs found.

     * @see #checkNoEvent(long, long)

     * @see #getTheWholeEventMask()

     */

    public boolean checkNoEvent(long waitTime) {

        return checkNoEvent(listenerSet.getTheWholeMask(), waitTime);

    }

    /**

     * During {@code EventTool.WaitNoEventTimeout} time waits for true

     * result of checkNoEvent(long, long) method.

     *

     * @param eventMask Mask to wait events under.

     * {@code AWTEvent.*_EVENT_MASK} fields combination.

     * @param waitTime Quiet time (millisecons).

     * @see #checkNoEvent(long, long)

     * @see #waitNoEvent(long)

     * @throws TimeoutExpiredException

     */

    public void waitNoEvent(long eventMask, long waitTime) {

        NoEventWaiter waiter = new NoEventWaiter(eventMask, waitTime);

        waiter.setTimeouts(timeouts.cloneThis());

        waiter.getTimeouts().

                setTimeout("Waiter.WaitingTime",

                        timeouts.getTimeout("EventTool.WaitNoEventTimeout"));

        waiter.getTimeouts().

                setTimeout("Waiter.TimeDelta",

                        timeouts.getTimeout("EventTool.EventCheckingDelta"));

        try {

            waiter.waitAction(null);

        } catch (InterruptedException e) {

            output.printStackTrace(e);

        }

    }

    /**

     * During {@code EventTool.WaitNoEventTimeout} time waits for true

     * result of {@code checkNoEvent(long)} method.

     *

     * @param waitTime Quiet time (millisecons).

     * @see #checkNoEvent(long)

     * @see #waitNoEvent(long, long)

     * @throws TimeoutExpiredException

     */

    public void waitNoEvent(long waitTime) {

        ListenerSet ls = listenerSet;

        if (ls != null) {

            // surprisingly this field can be null in case of massive

            // garbage collecting efforts like in NbTestCase.assertGC

            waitNoEvent(ls.getTheWholeMask(), waitTime);

        }

    }

    private AWTEvent waitEvent(long eventMask, long waitTime, TestOut waiterOutput) {

        EventWaiter waiter = new EventWaiter(eventMask);

        waiter.setTimeouts(timeouts.cloneThis());

        waiter.setOutput(waiterOutput);

        waiter.getTimeouts().

                setTimeout("Waiter.WaitingTime",

                        waitTime);

        waiter.getTimeouts().

                setTimeout("Waiter.TimeDelta",

                        timeouts.getTimeout("EventTool.EventCheckingDelta"));

        try {

            return waiter.waitAction(null);

        } catch (InterruptedException e) {

            output.printStackTrace(e);

            return null;

        }

    }

    private boolean checkNoEvent(long eventMask, long waitTime, TestOut waiterOutput) {

        try {

            AWTEvent event = waitEvent(eventMask, waitTime, TestOut.getNullOutput());

            waiterOutput.printLine("AWT event was produced during waiting: ");

            // used instead of event.toString() because it is not thread safe

            waiterOutput.printLine(event.getClass().getName());

            return false;

        } catch (TimeoutExpiredException e) {

            return true;

        }

    }

    private static class EventType implements AWTEventListener {

        long eventMask;

        long eventTime;

        private Reference<AWTEvent> eventRef;

        public EventType(long eventMask) {

            this.eventMask = eventMask;

            eventRef = new WeakReference<>(null);

            eventTime = -1;

        }

        @Override

        public void eventDispatched(AWTEvent event) {

            eventRef = new WeakReference<>(event);

            eventTime = System.currentTimeMillis();

        }

        public AWTEvent getEvent() {

            return eventRef.get();

        }

        public long getTime() {

            return eventTime;

        }

        public long getEventMask() {

            return eventMask;

        }

    }

    private static class ListenerSet {

        private Vector<EventType> eventTypes;

        private long theWholeMask;

        public ListenerSet() {

            eventTypes = new Vector<>();

            try {

                Class<?> eventClass = Class.forName("java.awt.AWTEvent");

                Field[] fields = eventClass.getFields();

                theWholeMask = 0;

                long eventMask;

                for (Field field : fields) {

                    if ((field.getModifiers()

                            & (Modifier.PUBLIC | Modifier.STATIC)) != 0

                            && field.getType().equals(Long.TYPE)

                            && field.getName().endsWith("_EVENT_MASK")) {

                        eventMask = (Long) field.get(null);

                        eventTypes.add(new EventType(eventMask));

                        theWholeMask = theWholeMask | eventMask;

                    }

                }

            } catch (ClassNotFoundException | IllegalAccessException e) {

                JemmyProperties.getCurrentOutput().printStackTrace(e);

            }

        }

        public void addListeners(long eventMask) {

            Toolkit dtk = Toolkit.getDefaultToolkit();

            for (EventType et : eventTypes) {

                if ((et.getEventMask() & eventMask) != 0) {

                    dtk.addAWTEventListener(et, et.getEventMask());

                }

            }

        }

        public void addListeners() {

            addListeners(getTheWholeMask());

        }

        public void removeListeners() {

            Toolkit dtk = Toolkit.getDefaultToolkit();

            for (EventType eventType : eventTypes) {

                dtk.removeAWTEventListener(eventType);

            }

        }

        public long getTheWholeMask() {

            return theWholeMask;

        }

        public long getLastEventTime(long eventMask) {

            EventType et = getLastEventType(eventMask);

            return (et == null) ? -1 : et.getTime();

        }

        public AWTEvent getLastEvent(long eventMask) {

            EventType et = getLastEventType(eventMask);

            return (et == null) ? null : et.getEvent();

        }

        private EventType getLastEventType(long eventMask) {

            long maxTime = -1;

            EventType maxType = null;

            for (EventType et : eventTypes) {

                if ((eventMask & et.getEventMask()) != 0

                        && et.getTime() > maxTime) {

                    maxType = et;

                    maxTime = maxType.getTime();

                }

            }

            return maxType;

        }

    }

    private static class EventWaiter extends Waiter<AWTEvent, Void> {

        long eventMask;

        long startTime;

        public EventWaiter(long eventMask) {

            this.eventMask = eventMask;

            startTime = getLastEventTime(eventMask);

        }

        @Override

        public AWTEvent actionProduced(Void obj) {

            EventType et = listenerSet.getLastEventType(eventMask);

            if (et != null

                    && et.getTime() > startTime) {

                return et.getEvent();

            } else {

                return null;

            }

        }

        @Override

        public String getDescription() {

            return ("Last event under "

                    + Long.toString(eventMask, 2) + " event mask");

        }

        @Override

        public String toString() {

            return "EventWaiter{" + "eventMask=" + Long.toString(eventMask, 2) + ", startTime=" + startTime + '}';

        }

    }

    private class NoEventWaiter extends Waiter<String, Void> {

        long eventMask;

        long waitTime;

        public NoEventWaiter(long eventMask, long waitTime) {

            this.eventMask = eventMask;

            this.waitTime = waitTime;

        }

        @Override

        public String actionProduced(Void obj) {

            return (checkNoEvent(eventMask, waitTime, TestOut.getNullOutput())

                    ? "Reached!"

                    : null);

        }

        @Override

        public String getDescription() {

            return ("No event under "

                    + Long.toString(eventMask, 2)

                    + " event mask during "

                    + Long.toString(waitTime)