/*

 * 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.

 */

/*

 * This source code is provided to illustrate the usage of a given feature

 * or technique and has been deliberately simplified. Additional steps

 * required for a production-quality application, such as security checks,

 * input validation and proper error handling, might not be present in

 * this sample code.

 */

package com.sun.tools.example.debug.tty;

import com.sun.jdi.ThreadReference;

import com.sun.jdi.ThreadGroupReference;

import com.sun.jdi.IncompatibleThreadStateException;

import com.sun.jdi.StackFrame;

import java.util.List;

import java.util.ArrayList;

import java.util.Collections;

class ThreadInfo {

    // This is a list of all known ThreadInfo objects. It survives

    // ThreadInfo.invalidateAll, unlike the other static fields below.

    private static List<ThreadInfo> threads = Collections.synchronizedList(new ArrayList<ThreadInfo>());

    private static boolean gotInitialThreads = false;

    private static ThreadInfo current = null;

    private static ThreadGroupReference group = null;

    private final ThreadReference thread;

    private int currentFrameIndex = 0;

    private ThreadInfo(ThreadReference thread) {

        this.thread = thread;

        if (thread == null) {

            MessageOutput.fatalError("Internal error: null ThreadInfo created");

        }

    }

    private static void initThreads() {

        if (!gotInitialThreads) {

            for (ThreadReference thread : Env.vm().allThreads()) {

                threads.add(new ThreadInfo(thread));

            }

            gotInitialThreads = true;

        }

    }

    static void addThread(ThreadReference thread) {

        synchronized (threads) {

            initThreads();

            ThreadInfo ti = new ThreadInfo(thread);

            // Guard against duplicates. Duplicates can happen during

            // initialization when a particular thread might be added both

            // by a thread start event and by the initial call to threads()

            if (getThreadInfo(thread) == null) {

                threads.add(ti);

            }

        }

    }

    static void removeThread(ThreadReference thread) {

        if (thread.equals(ThreadInfo.current)) {

            // Current thread has died.

            // Be careful getting the thread name. If its death happens

            // as part of VM termination, it may be too late to get the

            // information, and an exception will be thrown.

            String currentThreadName;

            try {

               currentThreadName = "\"" + thread.name() + "\"";

            } catch (Exception e) {

               currentThreadName = "";

            }

            setCurrentThread(null);

            MessageOutput.println();

            MessageOutput.println("Current thread died. Execution continuing...",

                                  currentThreadName);

        }

        threads.remove(getThreadInfo(thread));

    }

    static List<ThreadInfo> threads() {

        synchronized(threads) {

            initThreads();

            // Make a copy to allow iteration without synchronization

            return new ArrayList<ThreadInfo>(threads);

        }

    }

    static void invalidateAll() {

        current = null;

        group = null;

        synchronized (threads) {

            for (ThreadInfo ti : threads()) {

                ti.invalidate();

            }

        }

    }

    static void setThreadGroup(ThreadGroupReference tg) {

        group = tg;

    }

    static void setCurrentThread(ThreadReference tr) {

        if (tr == null) {

            setCurrentThreadInfo(null);

        } else {

            ThreadInfo tinfo = getThreadInfo(tr);

            setCurrentThreadInfo(tinfo);

        }

    }

    static void setCurrentThreadInfo(ThreadInfo tinfo) {

        current = tinfo;

        if (current != null) {

            current.invalidate();

        }

    }

    /**

     * Get the current ThreadInfo object.

     *

     * @return the ThreadInfo for the current thread.

     */

    static ThreadInfo getCurrentThreadInfo() {

        return current;

    }

    /**

     * Get the thread from this ThreadInfo object.

     *

     * @return the Thread wrapped by this ThreadInfo.

     */

    ThreadReference getThread() {

        return thread;

    }

    static ThreadGroupReference group() {

        if (group == null) {

            // Current thread group defaults to the first top level

            // thread group.

            setThreadGroup(Env.vm().topLevelThreadGroups().get(0));

        }

        return group;

    }

    static ThreadInfo getThreadInfo(long id) {

        ThreadInfo retInfo = null;

        synchronized (threads) {

            for (ThreadInfo ti : threads()) {

                if (ti.thread.uniqueID() == id) {

                   retInfo = ti;

                   break;

                }

            }

        }

        return retInfo;

    }

    static ThreadInfo getThreadInfo(ThreadReference tr) {

        return getThreadInfo(tr.uniqueID());

    }

    static ThreadInfo getThreadInfo(String idToken) {

        ThreadInfo tinfo = null;

        if (idToken.startsWith("t@")) {

            idToken = idToken.substring(2);

        }

        try {

            long threadId = Long.decode(idToken).longValue();

            tinfo = getThreadInfo(threadId);

        } catch (NumberFormatException e) {

            tinfo = null;

        }

        return tinfo;

    }

    /**

     * Get the thread stack frames.

     *

     * @return a <code>List</code> of the stack frames.

     */

    List<StackFrame> getStack() throws IncompatibleThreadStateException {

        return thread.frames();

    }

    /**

     * Get the current stackframe.

     *

     * @return the current stackframe.

     */

    StackFrame getCurrentFrame() throws IncompatibleThreadStateException {

        if (thread.frameCount() == 0) {

            return null;

        }

        return thread.frame(currentFrameIndex);

    }

    /**

     * Invalidate the current stackframe index.

     */

    void invalidate() {

        currentFrameIndex = 0;

    }

    /* Throw IncompatibleThreadStateException if not suspended */

    private void assureSuspended() throws IncompatibleThreadStateException {

        if (!thread.isSuspended()) {

            throw new IncompatibleThreadStateException();

        }

    }

    /**

     * Get the current stackframe index.

     *

     * @return the number of the current stackframe.  Frame zero is the

     * closest to the current program counter

     */

    int getCurrentFrameIndex() {

        return currentFrameIndex;

    }

    /**

     * Set the current stackframe to a specific frame.

     *

     * @param nFrame    the number of the desired stackframe.  Frame zero is the

     * closest to the current program counter

     * @exception IllegalAccessError when the thread isn't

     * suspended or waiting at a breakpoint

     * @exception ArrayIndexOutOfBoundsException when the

     * requested frame is beyond the stack boundary

     */

    void setCurrentFrameIndex(int nFrame) throws IncompatibleThreadStateException {

        assureSuspended();

        if ((nFrame < 0) || (nFrame >= thread.frameCount())) {

            throw new ArrayIndexOutOfBoundsException();

        }

        currentFrameIndex = nFrame;

    }

    /**

     * Change the current stackframe to be one or more frames higher

     * (as in, away from the current program counter).

     *

     * @param nFrames   the number of stackframes

     * @exception IllegalAccessError when the thread isn't

     * suspended or waiting at a breakpoint

     * @exception ArrayIndexOutOfBoundsException when the

     * requested frame is beyond the stack boundary

     */

    void up(int nFrames) throws IncompatibleThreadStateException {

        setCurrentFrameIndex(currentFrameIndex + nFrames);

    }

    /**

     * Change the current stackframe to be one or more frames lower

     * (as in, toward the current program counter).     *

     * @param nFrames   the number of stackframes

     * @exception IllegalAccessError when the thread isn't

     * suspended or waiting at a breakpoint

     * @exception ArrayIndexOutOfBoundsException when the

     * requested frame is beyond the stack boundary

     */

    void down(int nFrames) throws IncompatibleThreadStateException {

        setCurrentFrameIndex(currentFrameIndex - nFrames);

    }

}