/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.ddmlib;

import java.io.IOException;
import java.nio.ByteBuffer;

/**
 * Handle thread status updates.
 */
final class HandleThread extends ChunkHandler {

    public static final int CHUNK_THEN = type("THEN");
    public static final int CHUNK_THCR = type("THCR");
    public static final int CHUNK_THDE = type("THDE");
    public static final int CHUNK_THST = type("THST");
    public static final int CHUNK_THNM = type("THNM");
    public static final int CHUNK_STKL = type("STKL");

    private static final HandleThread mInst = new HandleThread();

    // only read/written by requestThreadUpdates()
    private static volatile boolean mThreadStatusReqRunning = false;
    private static volatile boolean mThreadStackTraceReqRunning = false;

    private HandleThread() {}


    /**
     * Register for the packets we expect to get from the client.
     */
    public static void register(MonitorThread mt) {
        mt.registerChunkHandler(CHUNK_THCR, mInst);
        mt.registerChunkHandler(CHUNK_THDE, mInst);
        mt.registerChunkHandler(CHUNK_THST, mInst);
        mt.registerChunkHandler(CHUNK_THNM, mInst);
        mt.registerChunkHandler(CHUNK_STKL, mInst);
    }

    /**
     * Client is ready.
     */
    @Override
    public void clientReady(Client client) throws IOException {
        Log.d("ddm-thread", "Now ready: " + client);
        if (client.isThreadUpdateEnabled())
            sendTHEN(client, true);
    }

    /**
     * Client went away.
     */
    @Override
    public void clientDisconnected(Client client) {}

    /**
     * Chunk handler entry point.
     */
    @Override
    public void handleChunk(Client client, int type, ByteBuffer data, boolean isReply, int msgId) {

        Log.d("ddm-thread", "handling " + ChunkHandler.name(type));

        if (type == CHUNK_THCR) {
            handleTHCR(client, data);
        } else if (type == CHUNK_THDE) {
            handleTHDE(client, data);
        } else if (type == CHUNK_THST) {
            handleTHST(client, data);
        } else if (type == CHUNK_THNM) {
            handleTHNM(client, data);
        } else if (type == CHUNK_STKL) {
            handleSTKL(client, data);
        } else {
            handleUnknownChunk(client, type, data, isReply, msgId);
        }
    }

    /*
     * Handle a thread creation message.
     *
     * We should be tolerant of receiving a duplicate create message.  (It
     * shouldn't happen with the current implementation.)
     */
    private void handleTHCR(Client client, ByteBuffer data) {
        int threadId, nameLen;
        String name;

        threadId = data.getInt();
        nameLen = data.getInt();
        name = getString(data, nameLen);

        Log.v("ddm-thread", "THCR: " + threadId + " '" + name + "'");

        client.getClientData().addThread(threadId, name);
        client.update(Client.CHANGE_THREAD_DATA);
    }

    /*
     * Handle a thread death message.
     */
    private void handleTHDE(Client client, ByteBuffer data) {
        int threadId;

        threadId = data.getInt();
        Log.v("ddm-thread", "THDE: " + threadId);

        client.getClientData().removeThread(threadId);
        client.update(Client.CHANGE_THREAD_DATA);
    }

    /*
     * Handle a thread status update message.
     *
     * Response has:
     *  (1b) header len
     *  (1b) bytes per entry
     *  (2b) thread count
     * Then, for each thread:
     *  (4b) threadId (matches value from THCR)
     *  (1b) thread status
     *  (4b) tid
     *  (4b) utime
     *  (4b) stime
     */
    private void handleTHST(Client client, ByteBuffer data) {
        int headerLen, bytesPerEntry, extraPerEntry;
        int threadCount;

        headerLen = (data.get() & 0xff);
        bytesPerEntry = (data.get() & 0xff);
        threadCount = data.getShort();

        headerLen -= 4;     // we've read 4 bytes
        while (headerLen-- > 0)
            data.get();

        extraPerEntry = bytesPerEntry - 18;     // we want 18 bytes

        Log.v("ddm-thread", "THST: threadCount=" + threadCount);

        /*
         * For each thread, extract the data, find the appropriate
         * client, and add it to the ClientData.
         */
        for (int i = 0; i < threadCount; i++) {
            int threadId, status, tid, utime, stime;
            boolean isDaemon = false;

            threadId = data.getInt();
            status = data.get();
            tid = data.getInt();
            utime = data.getInt();
            stime = data.getInt();
            if (bytesPerEntry >= 18)
                isDaemon = (data.get() != 0);

            Log.v("ddm-thread", "  id=" + threadId
                + ", status=" + status + ", tid=" + tid
                + ", utime=" + utime + ", stime=" + stime);

            ClientData cd = client.getClientData();
            ThreadInfo threadInfo = cd.getThread(threadId);
            if (threadInfo != null)
                threadInfo.updateThread(status, tid, utime, stime, isDaemon);
            else
                Log.i("ddms", "Thread with id=" + threadId + " not found");

            // slurp up any extra
            for (int slurp = extraPerEntry; slurp > 0; slurp--)
                data.get();
        }
        
        client.update(Client.CHANGE_THREAD_DATA);
    }

    /*
     * Handle a THNM (THread NaMe) message.  We get one of these after
     * somebody calls Thread.setName() on a running thread.
     */
    private void handleTHNM(Client client, ByteBuffer data) {
        int threadId, nameLen;
        String name;

        threadId = data.getInt();
        nameLen = data.getInt();
        name = getString(data, nameLen);

        Log.v("ddm-thread", "THNM: " + threadId + " '" + name + "'");

        ThreadInfo threadInfo = client.getClientData().getThread(threadId);
        if (threadInfo != null) {
            threadInfo.setThreadName(name);
            client.update(Client.CHANGE_THREAD_DATA);
        } else {
            Log.i("ddms", "Thread with id=" + threadId + " not found");
        }
    }


    /**
     * Parse an incoming STKL.
     */
    private void handleSTKL(Client client, ByteBuffer data) {
        StackTraceElement[] trace;
        int i, threadId, stackDepth;
        @SuppressWarnings("unused")
        int future;

        future = data.getInt();
        threadId = data.getInt();

        Log.v("ddms", "STKL: " + threadId);

        /* un-serialize the StackTraceElement[] */
        stackDepth = data.getInt();
        trace = new StackTraceElement[stackDepth];
        for (i = 0; i < stackDepth; i++) {
            String className, methodName, fileName;
            int len, lineNumber;

            len = data.getInt();
            className = getString(data, len);
            len = data.getInt();
            methodName = getString(data, len);
            len = data.getInt();
            if (len == 0) {
                fileName = null;
            } else {
                fileName = getString(data, len);
            }
            lineNumber = data.getInt();

            trace[i] = new StackTraceElement(className, methodName, fileName,
                        lineNumber);
        }

        ThreadInfo threadInfo = client.getClientData().getThread(threadId);
        if (threadInfo != null) {
            threadInfo.setStackCall(trace);
            client.update(Client.CHANGE_THREAD_STACKTRACE);
        } else {
            Log.d("STKL", String.format(
                    "Got stackcall for thread %1$d, which does not exists (anymore?).", //$NON-NLS-1$
                    threadId));
        }
    }


    /**
     * Send a THEN (THread notification ENable) request to the client.
     */
    public static void sendTHEN(Client client, boolean enable)
        throws IOException {

        ByteBuffer rawBuf = allocBuffer(1);
        JdwpPacket packet = new JdwpPacket(rawBuf);
        ByteBuffer buf = getChunkDataBuf(rawBuf);

        if (enable)
            buf.put((byte)1);
        else
            buf.put((byte)0);

        finishChunkPacket(packet, CHUNK_THEN, buf.position());
        Log.d("ddm-thread", "Sending " + name(CHUNK_THEN) + ": " + enable);
        client.sendAndConsume(packet, mInst);
    }


    /**
     * Send a STKL (STacK List) request to the client.  The VM will suspend
     * the target thread, obtain its stack, and return it.  If the thread
     * is no longer running, a failure result will be returned.
     */
    public static void sendSTKL(Client client, int threadId)
        throws IOException {

        if (false) {
            Log.i("ddm-thread", "would send STKL " + threadId);
            return;
        }

        ByteBuffer rawBuf = allocBuffer(4);
        JdwpPacket packet = new JdwpPacket(rawBuf);
        ByteBuffer buf = getChunkDataBuf(rawBuf);

        buf.putInt(threadId);

        finishChunkPacket(packet, CHUNK_STKL, buf.position());
        Log.d("ddm-thread", "Sending " + name(CHUNK_STKL) + ": " + threadId);
        client.sendAndConsume(packet, mInst);
    }


    /**
     * This is called periodically from the UI thread.  To avoid locking
     * the UI while we request the updates, we create a new thread.
     *
     */
    static void requestThreadUpdate(final Client client) {
        if (client.isDdmAware() && client.isThreadUpdateEnabled()) {
            if (mThreadStatusReqRunning) {
                Log.w("ddms", "Waiting for previous thread update req to finish");
                return;
            }

            new Thread("Thread Status Req") {
                @Override
                public void run() {
                    mThreadStatusReqRunning = true;
                    try {
                        sendTHST(client);
                    } catch (IOException ioe) {
                        Log.i("ddms", "Unable to request thread updates from "
                                + client + ": " + ioe.getMessage());
                    } finally {
                        mThreadStatusReqRunning = false;
                    }
                }
            }.start();
        }
    }
    
    static void requestThreadStackCallRefresh(final Client client, final int threadId) {
        if (client.isDdmAware() && client.isThreadUpdateEnabled()) {
            if (mThreadStackTraceReqRunning ) {
                Log.w("ddms", "Waiting for previous thread stack call req to finish");
                return;
            }

            new Thread("Thread Status Req") {
                @Override
                public void run() {
                    mThreadStackTraceReqRunning = true;
                    try {
                        sendSTKL(client, threadId);
                    } catch (IOException ioe) {
                        Log.i("ddms", "Unable to request thread stack call updates from "
                                + client + ": " + ioe.getMessage());
                    } finally {
                        mThreadStackTraceReqRunning = false;
                    }
                }
            }.start();
        }
        
    }

    /*
     * Send a THST request to the specified client.
     */
    private static void sendTHST(Client client) throws IOException {
        ByteBuffer rawBuf = allocBuffer(0);
        JdwpPacket packet = new JdwpPacket(rawBuf);
        ByteBuffer buf = getChunkDataBuf(rawBuf);

        // nothing much to say

        finishChunkPacket(packet, CHUNK_THST, buf.position());
        Log.d("ddm-thread", "Sending " + name(CHUNK_THST));
        client.sendAndConsume(packet, mInst);
    }
}

