/*

 * Copyright (c) 1998, 2006, 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 com.sun.tools.jdi;

import com.sun.jdi.*;

import com.sun.jdi.event.EventQueue;

import com.sun.jdi.event.EventSet;

import java.util.*;

public class EventQueueImpl extends MirrorImpl implements EventQueue {

    /*

     * Note this is not a synchronized list. Iteration/update should be

     * protected through the 'this' monitor.

     */

    LinkedList<EventSet> eventSets = new LinkedList<EventSet>();

    TargetVM target;

    boolean closed = false;

    EventQueueImpl(VirtualMachine vm, TargetVM target) {

        super(vm);

        this.target = target;

        target.addEventQueue(this);

    }

    /*

     * Override superclass back to default equality

     */

    public boolean equals(Object obj) {

        return this == obj;

    }

    public int hashCode() {

        return System.identityHashCode(this);

    }

    synchronized void enqueue(EventSet eventSet) {

        eventSets.add(eventSet);

        notifyAll();

    }

    synchronized int size() {

        return eventSets.size();

    }

    synchronized void close() {

        if (!closed) {

            closed = true; // OK for this the be first since synchronized

            // place VMDisconnectEvent into queue

            enqueue(new EventSetImpl(vm,

                                     (byte)JDWP.EventKind.VM_DISCONNECTED));

        }

    }

    public EventSet remove() throws InterruptedException {

        return remove(0);

    }

    /**

     * Filter out events not for user's eyes.

     * Then filter out empty sets.

     */

    public EventSet remove(long timeout) throws InterruptedException {

        if (timeout < 0) {

            throw new IllegalArgumentException("Timeout cannot be negative");

        }

        EventSet eventSet;

        while (true) {

            EventSetImpl fullEventSet = removeUnfiltered(timeout);

            if (fullEventSet == null) {

                eventSet = null;  // timeout

                break;

            }

            /*

             * Remove events from the event set for which

             * there is no corresponding enabled request (

             * this includes our internally requested events.)

             * This never returns null

             */

            eventSet = fullEventSet.userFilter();

            if (!eventSet.isEmpty()) {

                break;

            }

        }

        if ((eventSet != null) && (eventSet.suspendPolicy() == JDWP.SuspendPolicy.ALL)) {

            vm.notifySuspend();

        }

        return eventSet;

    }

    EventSet removeInternal() throws InterruptedException {

        EventSet eventSet;

        do {

            // Waiting forever, so removeUnfiltered() is never null

            eventSet = removeUnfiltered(0).internalFilter();

        } while (eventSet == null || eventSet.isEmpty());

        /*

         * Currently, no internal events are requested with a suspend

         * policy other than none, so we don't check for notifySuspend()

         * here. If this changes in the future, there is much

         * infrastructure that needs to be updated.

         */

        return eventSet;

    }

    private TimerThread startTimerThread(long timeout) {

        TimerThread thread = new TimerThread(timeout);

        thread.setDaemon(true);

        thread.start();

        return thread;

    }

    private boolean shouldWait(TimerThread timerThread) {

        return !closed && eventSets.isEmpty() &&

               ((timerThread == null) ? true : !timerThread.timedOut());

    }

    private EventSetImpl removeUnfiltered(long timeout)

                                               throws InterruptedException {

        EventSetImpl eventSet = null;

        /*

         * Make sure the VM has completed initialization before

         * trying to build events.

         */

        vm.waitInitCompletion();

        synchronized(this) {

            if (!eventSets.isEmpty()) {

                /*

                 * If there's already something there, no need

                 * for anything elaborate.

                 */

                eventSet = (EventSetImpl)eventSets.removeFirst();

            } else {

                /*

                 * If a timeout was specified, create a thread to

                 * notify this one when a timeout

                 * occurs. We can't use the timed version of wait()

                 * because it is possible for multiple enqueue() calls

                 * before we see something in the eventSet queue

                 * (this is possible when multiple threads call

                 * remove() concurrently -- not a great idea, but

                 * it should be supported). Even if enqueue() did a

                 * notify() instead of notifyAll() we are not able to

                 * use a timed wait because there's no way to distinguish

                 * a timeout from a notify.  That limitation implies a

                 * possible race condition between a timed out thread

                 * and a notified thread.

                 */

                TimerThread timerThread = null;

                try {

                    if (timeout > 0) {

                        timerThread = startTimerThread(timeout);

                    }

                    while (shouldWait(timerThread)) {

                        this.wait();

                    }

                } finally {

                    if ((timerThread != null) && !timerThread.timedOut()) {

                        timerThread.interrupt();

                    }

                }

                if (eventSets.isEmpty()) {

                    if (closed) {

                        throw new VMDisconnectedException();

                    }

                } else {

                    eventSet = (EventSetImpl)eventSets.removeFirst();

                }

            }

        }

        // The build is synchronized on the event set, don't hold

        // the queue lock.

        if (eventSet != null) {

            target.notifyDequeueEventSet();

            eventSet.build();

        }

        return eventSet;

    }

    private class TimerThread extends Thread {

        private boolean timedOut = false;

        private long timeout;

        TimerThread(long timeout) {

            super(vm.threadGroupForJDI(), "JDI Event Queue Timer");

            this.timeout = timeout;

        }

        boolean timedOut() {

            return timedOut;

        }

        public void run() {

            try {

                Thread.sleep(timeout);

                EventQueueImpl queue = EventQueueImpl.this;

                synchronized(queue) {

                    timedOut = true;

                    queue.notifyAll();

                }

            } catch (InterruptedException e) {

                // Exit without notifying

            }

        }

    }

}