/*

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

import java.util.TimerTask;

import java.util.concurrent.atomic.AtomicBoolean;

import java.security.PrivilegedAction;

import java.security.AccessController;

import sun.awt.PeerEvent;

import sun.util.logging.PlatformLogger;

/**

 * This utility class is used to suspend execution on a thread

 * while still allowing {@code EventDispatchThread} to dispatch events.

 * The API methods of the class are thread-safe.

 *

 * @author Anton Tarasov, Artem Ananiev

 *

 * @since 1.7

 */

class WaitDispatchSupport implements SecondaryLoop {

    private final static PlatformLogger log =

        PlatformLogger.getLogger("java.awt.event.WaitDispatchSupport");

    private EventDispatchThread dispatchThread;

    private EventFilter filter;

    private volatile Conditional extCondition;

    private volatile Conditional condition;

    private long interval;

    // Use a shared daemon timer to serve all the WaitDispatchSupports

    private static Timer timer;

    // When this WDS expires, we cancel the timer task leaving the

    // shared timer up and running

    private TimerTask timerTask;

    private AtomicBoolean keepBlockingEDT = new AtomicBoolean(false);

    private AtomicBoolean keepBlockingCT = new AtomicBoolean(false);

    private static synchronized void initializeTimer() {

        if (timer == null) {

            timer = new Timer("AWT-WaitDispatchSupport-Timer", true);

        }

    }

    /**

     * Creates a {@code WaitDispatchSupport} instance to

     * serve the given event dispatch thread.

     *

     * @param dispatchThread An event dispatch thread that

     *        should not stop dispatching events while waiting

     *

     * @since 1.7

     */

    public WaitDispatchSupport(EventDispatchThread dispatchThread) {

        this(dispatchThread, null);

    }

    /**

     * Creates a {@code WaitDispatchSupport} instance to

     * serve the given event dispatch thread.

     *

     * @param dispatchThread An event dispatch thread that

     *        should not stop dispatching events while waiting

     * @param extCondition A conditional object used to determine

     *        if the loop should be terminated

     *

     * @since 1.7

     */

    public WaitDispatchSupport(EventDispatchThread dispatchThread,

                               Conditional extCond)

    {

        if (dispatchThread == null) {

            throw new IllegalArgumentException("The dispatchThread can not be null");

        }

        this.dispatchThread = dispatchThread;

        this.extCondition = extCond;

        this.condition = new Conditional() {

            @Override

            public boolean evaluate() {

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

                    log.finest("evaluate(): blockingEDT=" + keepBlockingEDT.get() +

                               ", blockingCT=" + keepBlockingCT.get());

                }

                boolean extEvaluate =

                    (extCondition != null) ? extCondition.evaluate() : true;

                if (!keepBlockingEDT.get() || !extEvaluate) {

                    if (timerTask != null) {

                        timerTask.cancel();

                        timerTask = null;

                    }

                    return false;

                }

                return true;

            }

        };

    }

    /**

     * Creates a {@code WaitDispatchSupport} instance to

     * serve the given event dispatch thread.

     * <p>

     * The {@link EventFilter} is set on the {@code dispatchThread}

     * while waiting. The filter is removed on completion of the

     * waiting process.

     * <p>

     *

     *

     * @param dispatchThread An event dispatch thread that

     *        should not stop dispatching events while waiting

     * @param filter {@code EventFilter} to be set

     * @param interval A time interval to wait for. Note that

     *        when the waiting process takes place on EDT

     *        there is no guarantee to stop it in the given time

     *

     * @since 1.7

     */

    public WaitDispatchSupport(EventDispatchThread dispatchThread,

                               Conditional extCondition,

                               EventFilter filter, long interval)

    {

        this(dispatchThread, extCondition);

        this.filter = filter;

        if (interval < 0) {

            throw new IllegalArgumentException("The interval value must be >= 0");

        }

        this.interval = interval;

        if (interval != 0) {

            initializeTimer();

        }

    }

    /**

     * @inheritDoc

     */

    @Override

    public boolean enter() {

        log.fine("enter(): blockingEDT=" + keepBlockingEDT.get() +

                 ", blockingCT=" + keepBlockingCT.get());

        if (!keepBlockingEDT.compareAndSet(false, true)) {

            log.fine("The secondary loop is already running, aborting");

            return false;

        }

        final Runnable run = new Runnable() {

            public void run() {

                log.fine("Starting a new event pump");

                if (filter == null) {

                    dispatchThread.pumpEvents(condition);

                } else {

                    dispatchThread.pumpEventsForFilter(condition, filter);

                }

            }

        };

        // We have two mechanisms for blocking: if we're on the

        // dispatch thread, start a new event pump; if we're

        // on any other thread, call wait() on the treelock

        Thread currentThread = Thread.currentThread();

        if (currentThread == dispatchThread) {

            log.finest("On dispatch thread: " + dispatchThread);

            if (interval != 0) {

                log.finest("scheduling the timer for " + interval + " ms");

                timer.schedule(timerTask = new TimerTask() {

                    @Override

                    public void run() {

                        if (keepBlockingEDT.compareAndSet(true, false)) {

                            wakeupEDT();

                        }

                    }

                }, interval);

            }

            // Dispose SequencedEvent we are dispatching on the the current

            // AppContext, to prevent us from hang - see 4531693 for details

            SequencedEvent currentSE = KeyboardFocusManager.

                getCurrentKeyboardFocusManager().getCurrentSequencedEvent();

            if (currentSE != null) {

                log.fine("Dispose current SequencedEvent: " + currentSE);

                currentSE.dispose();

            }

            // In case the exit() method is called before starting

            // new event pump it will post the waking event to EDT.

            // The event will be handled after the the new event pump

            // starts. Thus, the enter() method will not hang.

            //

            // Event pump should be privileged. See 6300270.

            AccessController.doPrivileged(new PrivilegedAction() {

                public Object run() {

                    run.run();

                    return null;

                }

            });

        } else {

            log.finest("On non-dispatch thread: " + currentThread);

            synchronized (getTreeLock()) {

                if (filter != null) {

                    dispatchThread.addEventFilter(filter);

                }

                try {

                    EventQueue eq = dispatchThread.getEventQueue();

                    eq.postEvent(new PeerEvent(this, run, PeerEvent.PRIORITY_EVENT));

                    keepBlockingCT.set(true);

                    if (interval > 0) {

                        long currTime = System.currentTimeMillis();

                        while (keepBlockingCT.get() &&

                               ((extCondition != null) ? extCondition.evaluate() : true) &&

                               (currTime + interval > System.currentTimeMillis()))

                        {

                            getTreeLock().wait(interval);

                        }

                    } else {

                        while (keepBlockingCT.get() &&

                               ((extCondition != null) ? extCondition.evaluate() : true))

                        {

                            getTreeLock().wait();

                        }

                    }

                    log.fine("waitDone " + keepBlockingEDT.get() + " " + keepBlockingCT.get());

                } catch (InterruptedException e) {

                    log.fine("Exception caught while waiting: " + e);

                } finally {

                    if (filter != null) {

                        dispatchThread.removeEventFilter(filter);

                    }

                }

                // If the waiting process has been stopped because of the

                // time interval passed or an exception occurred, the state

                // should be changed

                keepBlockingEDT.set(false);

                keepBlockingCT.set(false);

            }

        }

        return true;

    }

    /**

     * @inheritDoc

     */

    public boolean exit() {

        log.fine("exit(): blockingEDT=" + keepBlockingEDT.get() +

                 ", blockingCT=" + keepBlockingCT.get());

        if (keepBlockingEDT.compareAndSet(true, false)) {

            wakeupEDT();

            return true;

        }

        return false;

    }

    private final static Object getTreeLock() {

        return Component.LOCK;

    }

    private final Runnable wakingRunnable = new Runnable() {

        public void run() {

            log.fine("Wake up EDT");

            synchronized (getTreeLock()) {

                keepBlockingCT.set(false);

                getTreeLock().notifyAll();

            }

            log.fine("Wake up EDT done");

        }

    };

    private void wakeupEDT() {

        log.finest("wakeupEDT(): EDT == " + dispatchThread);

        EventQueue eq = dispatchThread.getEventQueue();

        eq.postEvent(new PeerEvent(this, wakingRunnable, PeerEvent.PRIORITY_EVENT));

    }

}