/*

 * Copyright (c) 1996, 2010, 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.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

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

import java.awt.event.MouseEvent;

import java.awt.event.ActionEvent;

import java.awt.event.WindowEvent;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Executor;

import java.util.concurrent.LinkedBlockingQueue;

import sun.util.logging.PlatformLogger;

import sun.awt.dnd.SunDragSourceContextPeer;

import sun.awt.EventQueueDelegate;

/**

 * EventDispatchThread is a package-private AWT class which takes

 * events off the EventQueue and dispatches them to the appropriate

 * AWT components.

 *

 * The Thread starts a "permanent" event pump with a call to

 * pumpEvents(Conditional) in its run() method. Event handlers can choose to

 * block this event pump at any time, but should start a new pump (<b>not</b>

 * a new EventDispatchThread) by again calling pumpEvents(Conditional). This

 * secondary event pump will exit automatically as soon as the Condtional

 * evaluate()s to false and an additional Event is pumped and dispatched.

 *

 * @author Tom Ball

 * @author Amy Fowler

 * @author Fred Ecks

 * @author David Mendenhall

 *

 * @since 1.1

 */

final class EventDispatchThread {

    private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.EventDispatchThread");

    private EventQueue theQueue;

    private boolean doDispatch = true;

    private volatile boolean shutdown = false;

    static final int ANY_EVENT = -1;

    private final Executor executor;

    private ArrayList<EventFilter> eventFilters = new ArrayList<EventFilter>();

    EventDispatchThread(ThreadGroup group, String name, EventQueue queue, ClassLoader l) {

        // right now using simple executor that sort of mimics the old

        // behavior of the run() method of EventDispatchThread. But when

        // running together with FX, the executor should dispatch the runnable

        // using Platform.invokeLater to share the same processing thread

        executor = defaultThread(group, name, l);

        setEventQueue(queue);

    }

    private static Executor defaultThread(ThreadGroup group, String name, ClassLoader classLoader) {

        class ExecRuns implements Executor, Runnable {

            final BlockingQueue<Runnable> toRun = new LinkedBlockingQueue<>();

            @Override

            public void execute(Runnable command) {

                toRun.add(command);

            }

            @Override

            public void run() {

                while (true) {

                    Runnable r;

                    try {

                        r = toRun.take();

                    } catch (InterruptedException ex) {

                        eventLog.severe(ex.getMessage(), ex);

                        continue;

                    }

                    r.run();

                }

            }

        }

        ExecRuns er = new ExecRuns();

        Thread t = new Thread(group, name);

        t.setContextClassLoader(classLoader);

        t.setPriority(Thread.NORM_PRIORITY + 1);

        t.setDaemon(false);

        t.start();

        return er;

    }

    /*

     * Must be called on EDT only, that's why no synchronization

     */

    public void stopDispatching() {

        doDispatch = false;

    }

    public void interrupt() {

        shutdown = true;

//XXX        super.interrupt();

    }

    public void processEvents() {

        executor.execute(new Runnable() {

            @Override

            public void run() {

                try {

                    // XXX: the meaning now should be: the pumpEvents processes

                    // currently pending events, and then it returns without

                    // any blocking

                    pumpEvents(new Conditional() {

                        public boolean evaluate() {

                            return true;

                        }

                    });

                } finally {

                    if(getEventQueue().detachDispatchThread(this, shutdown)) {

                        return;

                    }

                }

            }

        });

    }

    // MacOSX change:

    //  This was added because this class (and java.awt.Conditional) are package private.

    //  There are certain instances where classes in other packages need to block the

    //  AWTEventQueue while still allowing it to process events. This uses reflection

    //  to call back into the caller in order to remove dependencies.

    //

    // NOTE: This uses reflection in its implementation, so it is not for performance critical code.

    //

    //  cond is an instance of sun.lwawt.macosx.EventDispatchAccess

    //

    private Conditional _macosxGetConditional(final Object cond) {

        try {

            return new Conditional() {

                final Method evaluateMethod = Class.forName("sun.lwawt.macosx.EventDispatchAccess").getMethod("evaluate", null);

                public boolean evaluate() {

                    try {

                        return ((Boolean)evaluateMethod.invoke(cond, null)).booleanValue();

                    } catch (Exception e) {

                        return false;

                    }

                }

            };

        } catch (Exception e) {

            return new Conditional() { public boolean evaluate() { return false; } };

        }

    }

    void pumpEvents(Conditional cond) {

        pumpEvents(ANY_EVENT, cond);

    }

    void pumpEventsForHierarchy(Conditional cond, Component modalComponent) {

        pumpEventsForHierarchy(ANY_EVENT, cond, modalComponent);

    }

    void pumpEvents(int id, Conditional cond) {

        pumpEventsForHierarchy(id, cond, null);

    }

    void pumpEventsForHierarchy(int id, Conditional cond, Component modalComponent) {

        pumpEventsForFilter(id, cond, new HierarchyEventFilter(modalComponent));

    }

    void pumpEventsForFilter(Conditional cond, EventFilter filter) {

        pumpEventsForFilter(ANY_EVENT, cond, filter);

    }

    //XXX

    boolean isInterrupted() {

        return false;

    }

    void pumpEventsForFilter(int id, Conditional cond, EventFilter filter) {

        addEventFilter(filter);

        doDispatch = true;

        shutdown |= isInterrupted();

        while (doDispatch && !shutdown && cond.evaluate()) {

            pumpOneEventForFilters(id);

        }

        removeEventFilter(filter);

    }

    void addEventFilter(EventFilter filter) {

        eventLog.finest("adding the event filter: " + filter);

        synchronized (eventFilters) {

            if (!eventFilters.contains(filter)) {

                if (filter instanceof ModalEventFilter) {

                    ModalEventFilter newFilter = (ModalEventFilter)filter;

                    int k = 0;

                    for (k = 0; k < eventFilters.size(); k++) {

                        EventFilter f = eventFilters.get(k);

                        if (f instanceof ModalEventFilter) {

                            ModalEventFilter cf = (ModalEventFilter)f;

                            if (cf.compareTo(newFilter) > 0) {

                                break;

                            }

                        }

                    }

                    eventFilters.add(k, filter);

                } else {

                    eventFilters.add(filter);

                }

            }

        }

    }

    void removeEventFilter(EventFilter filter) {

        eventLog.finest("removing the event filter: " + filter);

        synchronized (eventFilters) {

            eventFilters.remove(filter);

        }

    }

    boolean blockWhenNoEvent() {

        return true;

    }

    void pumpOneEventForFilters(int id) {

        AWTEvent event = null;

        boolean eventOK = false;

        try {

            EventQueue eq = null;

            EventQueueDelegate.Delegate delegate = null;

            do {

                // EventQueue may change during the dispatching

                eq = getEventQueue();

                delegate = EventQueueDelegate.getDelegate();

                if (delegate != null && id == ANY_EVENT) {

                    event = delegate.getNextEvent(eq);

                } else {

                    event = eq.getNextEvent(id, blockWhenNoEvent());

                }

                if (event == null) {

                    return;

                }

                eventOK = true;

                synchronized (eventFilters) {

                    for (int i = eventFilters.size() - 1; i >= 0; i--) {

                        EventFilter f = eventFilters.get(i);

                        EventFilter.FilterAction accept = f.acceptEvent(event);

                        if (accept == EventFilter.FilterAction.REJECT) {

                            eventOK = false;

                            break;

                        } else if (accept == EventFilter.FilterAction.ACCEPT_IMMEDIATELY) {

                            break;

                        }

                    }

                }

                eventOK = eventOK && SunDragSourceContextPeer.checkEvent(event);

                if (!eventOK) {

                    event.consume();

                }

            }

            while (eventOK == false);

            if (eventLog.isLoggable(PlatformLogger.FINEST)) {

                eventLog.finest("Dispatching: " + event);

            }

            Object handle = null;

            if (delegate != null) {

                handle = delegate.beforeDispatch(event);

            }

            eq.dispatchEvent(event);

            if (delegate != null) {

                delegate.afterDispatch(event, handle);

            }

        }

        catch (ThreadDeath death) {

            shutdown = true;

            throw death;

        }

        catch (InterruptedException interruptedException) {

            shutdown = true; // AppContext.dispose() interrupts all

                             // Threads in the AppContext

        }

        catch (Throwable e) {

            processException(e);

        }

    }

    private void processException(Throwable e) {

        if (eventLog.isLoggable(PlatformLogger.FINE)) {

            eventLog.fine("Processing exception: " + e);

        }

//XXX        getUncaughtExceptionHandler().uncaughtException(this, e);

    }

    public static EventDispatchThread findCurrent() {

//XXX        return (EventDispatchThread)Thread.currentThread();

        return null;

    }

    public synchronized EventQueue getEventQueue() {

        return theQueue;

    }

    public synchronized void setEventQueue(EventQueue eq) {

        theQueue = eq;

    }

    private static class HierarchyEventFilter implements EventFilter {

        private Component modalComponent;

        public HierarchyEventFilter(Component modalComponent) {

            this.modalComponent = modalComponent;

        }

        public FilterAction acceptEvent(AWTEvent event) {

            if (modalComponent != null) {

                int eventID = event.getID();

                boolean mouseEvent = (eventID >= MouseEvent.MOUSE_FIRST) &&

                                     (eventID <= MouseEvent.MOUSE_LAST);

                boolean actionEvent = (eventID >= ActionEvent.ACTION_FIRST) &&

                                      (eventID <= ActionEvent.ACTION_LAST);

                boolean windowClosingEvent = (eventID == WindowEvent.WINDOW_CLOSING);

                /*

                 * filter out MouseEvent and ActionEvent that's outside

                 * the modalComponent hierarchy.

                 * KeyEvent is handled by using enqueueKeyEvent

                 * in Dialog.show

                 */

                if (Component.isInstanceOf(modalComponent, "javax.swing.JInternalFrame")) {

                    /*

                     * Modal internal frames are handled separately. If event is

                     * for some component from another heavyweight than modalComp,

                     * it is accepted. If heavyweight is the same - we still accept

                     * event and perform further filtering in LightweightDispatcher

                     */

                    return windowClosingEvent ? FilterAction.REJECT : FilterAction.ACCEPT;

                }

                if (mouseEvent || actionEvent || windowClosingEvent) {

                    Object o = event.getSource();

                    if (o instanceof sun.awt.ModalExclude) {

                        // Exclude this object from modality and

                        // continue to pump it's events.

                        return FilterAction.ACCEPT;

                    } else if (o instanceof Component) {

                        Component c = (Component) o;

                        // 5.0u3 modal exclusion

                        boolean modalExcluded = false;

                        if (modalComponent instanceof Container) {

                            while (c != modalComponent && c != null) {

                                if ((c instanceof Window) &&

                                    (sun.awt.SunToolkit.isModalExcluded((Window)c))) {

                                    // Exclude this window and all its children from

                                    //  modality and continue to pump it's events.

                                    modalExcluded = true;

                                    break;

                                }

                                c = c.getParent();

                            }

                        }

                        if (!modalExcluded && (c != modalComponent)) {

                            return FilterAction.REJECT;

                        }

                    }

                }

            }

            return FilterAction.ACCEPT;

        }

    }

}