/*
 * Copyright (C) 2011 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.ide.eclipse.gltrace;

import com.android.ddmlib.AdbCommandRejectedException;
import com.android.ddmlib.AndroidDebugBridge;
import com.android.ddmlib.Client;
import com.android.ddmlib.IDevice;
import com.android.ddmlib.IDevice.DeviceUnixSocketNamespace;
import com.android.ddmlib.IShellOutputReceiver;
import com.android.ddmlib.ShellCommandUnresponsiveException;
import com.android.ddmlib.TimeoutException;
import com.android.ide.eclipse.gltrace.editors.GLFunctionTraceViewer;
import com.google.common.io.Closeables;
import com.google.common.util.concurrent.SimpleTimeLimiter;

import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IURIEditorInput;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkbenchWindowActionDelegate;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.ide.IDE;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.concurrent.Callable;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class CollectTraceAction implements IWorkbenchWindowActionDelegate {
    /** Abstract Unix Domain Socket Name used by the gltrace device code. */
    private static final String GLTRACE_UDS = "gltrace";        //$NON-NLS-1$

    /** Local port that is forwarded to the device's {@link #GLTRACE_UDS} socket. */
    private static final int LOCAL_FORWARDED_PORT = 6039;

    /** Activity name to use for a system activity that has already been launched. */
    private static final String SYSTEM_APP = "system";          //$NON-NLS-1$

    /** Time to wait for the application to launch (seconds) */
    private static final int LAUNCH_TIMEOUT = 15;

    /** Time to wait for the application to die (seconds) */
    private static final int KILL_TIMEOUT = 5;

    private static final int MIN_API_LEVEL = 16;

    @Override
    public void run(IAction action) {
        connectToDevice();
    }

    @Override
    public void selectionChanged(IAction action, ISelection selection) {
    }

    @Override
    public void dispose() {
    }

    @Override
    public void init(IWorkbenchWindow window) {
    }

    private void connectToDevice() {
        Shell shell = Display.getDefault().getActiveShell();
        GLTraceOptionsDialog dlg = new GLTraceOptionsDialog(shell);
        if (dlg.open() != Window.OK) {
            return;
        }

        TraceOptions traceOptions = dlg.getTraceOptions();

        IDevice device = getDevice(traceOptions.device);
        String apiLevelString = device.getProperty(IDevice.PROP_BUILD_API_LEVEL);
        int apiLevel;
        try {
            apiLevel = Integer.parseInt(apiLevelString);
        } catch (NumberFormatException e) {
            apiLevel = MIN_API_LEVEL;
        }
        if (apiLevel < MIN_API_LEVEL) {
            MessageDialog.openError(shell, "GL Trace",
                    String.format("OpenGL Tracing is only supported on devices at API Level %1$d."
                            + "The selected device '%2$s' provides API level %3$s.",
                                    MIN_API_LEVEL, traceOptions.device, apiLevelString));
            return;
        }

        try {
            setupForwarding(device, LOCAL_FORWARDED_PORT);
        } catch (Exception e) {
            MessageDialog.openError(shell, "Setup GL Trace",
                    "Error while setting up port forwarding: " + e.getMessage());
            return;
        }

        try {
            if (!SYSTEM_APP.equals(traceOptions.appToTrace)) {
                startActivity(device, traceOptions.appToTrace, traceOptions.activityToTrace,
                        traceOptions.isActivityNameFullyQualified);
            }
        } catch (Exception e) {
            MessageDialog.openError(shell, "Setup GL Trace",
                    "Error while launching application: " + e.getMessage());
            return;
        }

        // if everything went well, the app should now be waiting for the gl debugger
        // to connect
        startTracing(shell, traceOptions, LOCAL_FORWARDED_PORT);

        // once tracing is complete, remove port forwarding
        disablePortForwarding(device, LOCAL_FORWARDED_PORT);

        // and finally open the editor to view the file
        openInEditor(shell, traceOptions.traceDestination);
    }

    public static void openInEditor(Shell shell, String traceFilePath) {
        final IFileStore fileStore = EFS.getLocalFileSystem().getStore(new Path(traceFilePath));
        if (!fileStore.fetchInfo().exists()) {
            return;
        }

        final IWorkbench workbench = PlatformUI.getWorkbench();
        IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
        if (window == null) {
            return;
        }

        IWorkbenchPage page = window.getActivePage();
        if (page == null) {
            return;
        }

        try {
            workbench.showPerspective("com.android.ide.eclipse.gltrace.perspective", window);
        } catch (WorkbenchException e) {
        }

        // if there is a editor already open, then refresh its model
        GLFunctionTraceViewer viewer = getOpenTraceViewer(page, traceFilePath);
        if (viewer != null) {
            viewer.setInput(shell, traceFilePath);
        }

        // open the editor (if not open), or bring it to foreground if it is already open
        try {
            IDE.openEditorOnFileStore(page, fileStore);
        } catch (PartInitException e) {
            GlTracePlugin.getDefault().logMessage(
                    "Unexpected error while opening gltrace file in editor: " + e);
            return;
        }
    }

    /**
     * Returns the editor part that has the provided file path open.
     * @param page page containing editors
     * @param traceFilePath file that should be open in an editor
     * @return if given trace file is already open, then a reference to that editor part,
     *         null otherwise
     */
    private static GLFunctionTraceViewer getOpenTraceViewer(IWorkbenchPage page,
            String traceFilePath) {
        IEditorReference[] editorRefs = page.getEditorReferences();
        for (IEditorReference ref : editorRefs) {
            String id = ref.getId();
            if (!GLFunctionTraceViewer.ID.equals(id)) {
                continue;
            }

            IEditorInput input = null;
            try {
                input = ref.getEditorInput();
            } catch (PartInitException e) {
                continue;
            }

            if (!(input instanceof IURIEditorInput)) {
                continue;
            }

            if (traceFilePath.equals(((IURIEditorInput) input).getURI().getPath())) {
                return (GLFunctionTraceViewer) ref.getEditor(true);
            }
        }

        return null;
    }

    @SuppressWarnings("resource") // Closeables.closeQuietly
    public static void startTracing(Shell shell, TraceOptions traceOptions, int port) {
        Socket socket = new Socket();
        DataInputStream traceDataStream = null;
        DataOutputStream traceCommandsStream = null;
        try {
            socket.connect(new java.net.InetSocketAddress("127.0.0.1", port)); //$NON-NLS-1$
            socket.setTcpNoDelay(true);
            traceDataStream = new DataInputStream(socket.getInputStream());
            traceCommandsStream = new DataOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            MessageDialog.openError(shell,
                    "OpenGL Trace",
                    "Unable to connect to remote GL Trace Server: " + e.getMessage());
            return;
        }

        // create channel to send trace commands to device
        TraceCommandWriter traceCommandWriter = new TraceCommandWriter(traceCommandsStream);
        try {
            traceCommandWriter.setTraceOptions(traceOptions.collectFbOnEglSwap,
                    traceOptions.collectFbOnGlDraw,
                    traceOptions.collectTextureData);
        } catch (IOException e) {
            MessageDialog.openError(shell,
                    "OpenGL Trace",
                    "Unexpected error while setting trace options: " + e.getMessage());
            closeSocket(socket);
            return;
        }

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(traceOptions.traceDestination, false);
        } catch (FileNotFoundException e) {
            // input path is valid, so this cannot occur
        }

        // create trace writer that writes to a trace file
        TraceFileWriter traceFileWriter = new TraceFileWriter(fos, traceDataStream);
        traceFileWriter.start();

        GLTraceCollectorDialog dlg = new GLTraceCollectorDialog(shell,
                traceFileWriter,
                traceCommandWriter,
                traceOptions);
        dlg.open();

        traceFileWriter.stopTracing();
        traceCommandWriter.close();
        closeSocket(socket);
    }

    private static void closeSocket(Socket socket) {
        try {
            socket.close();
        } catch (IOException e) {
            // ignore error while closing socket
        }
    }

    private void startActivity(IDevice device, String appPackage, String activity,
            boolean isActivityNameFullyQualified)
            throws TimeoutException, AdbCommandRejectedException,
            ShellCommandUnresponsiveException, IOException, InterruptedException {
        killApp(device, appPackage); // kill app if it is already running
        waitUntilAppKilled(device, appPackage, KILL_TIMEOUT);

        StringBuilder activityPath = new StringBuilder(appPackage);
        if (!activity.isEmpty()) {
            activityPath.append('/');
            if (!isActivityNameFullyQualified) {
                activityPath.append('.');
            }
            activityPath.append(activity);
        }
        String startAppCmd = String.format(
                "am start --opengl-trace %s -a android.intent.action.MAIN -c android.intent.category.LAUNCHER", //$NON-NLS-1$
                activityPath.toString());

        Semaphore launchCompletionSempahore = new Semaphore(0);
        StartActivityOutputReceiver receiver = new StartActivityOutputReceiver(
                launchCompletionSempahore);
        device.executeShellCommand(startAppCmd, receiver);

        // wait until shell finishes launch command
        launchCompletionSempahore.acquire();

        // throw exception if there was an error during launch
        String output = receiver.getOutput();
        if (output.contains("Error")) {             //$NON-NLS-1$
            throw new RuntimeException(output);
        }

        // wait until the app itself has been launched
        waitUntilAppLaunched(device, appPackage, LAUNCH_TIMEOUT);
    }

    private void killApp(IDevice device, String appName) {
        Client client = device.getClient(appName);
        if (client != null) {
            client.kill();
        }
    }

    private void waitUntilAppLaunched(final IDevice device, final String appName, int timeout) {
        Callable<Boolean> c = new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                Client client;
                do {
                    client = device.getClient(appName);
                } while (client == null);

                return Boolean.TRUE;
            }
        };
        try {
            new SimpleTimeLimiter().callWithTimeout(c, timeout, TimeUnit.SECONDS, true);
        } catch (Exception e) {
            throw new RuntimeException("Timed out waiting for application to launch.");
        }

        // once the app has launched, wait an additional couple of seconds
        // for it to start up
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // ignore
        }
    }

    private void waitUntilAppKilled(final IDevice device, final String appName, int timeout) {
        Callable<Boolean> c = new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                Client client;
                while ((client = device.getClient(appName)) != null) {
                    client.kill();
                }
                return Boolean.TRUE;
            }
        };
        try {
            new SimpleTimeLimiter().callWithTimeout(c, timeout, TimeUnit.SECONDS, true);
        } catch (Exception e) {
            throw new RuntimeException("Timed out waiting for running application to die.");
        }
    }

    public static void setupForwarding(IDevice device, int i)
            throws TimeoutException, AdbCommandRejectedException, IOException {
        device.createForward(i, GLTRACE_UDS, DeviceUnixSocketNamespace.ABSTRACT);
    }

    public static void disablePortForwarding(IDevice device, int port) {
        try {
            device.removeForward(port, GLTRACE_UDS, DeviceUnixSocketNamespace.ABSTRACT);
        } catch (Exception e) {
            // ignore exceptions;
        }
    }

    private IDevice getDevice(String deviceName) {
        IDevice[] devices = AndroidDebugBridge.getBridge().getDevices();

        for (IDevice device : devices) {
            if (device.getName().equals(deviceName)) {
                return device;
            }
        }

        return null;
    }

    private static class StartActivityOutputReceiver implements IShellOutputReceiver {
        private Semaphore mSemaphore;
        private StringBuffer sb = new StringBuffer(300);

        public StartActivityOutputReceiver(Semaphore s) {
            mSemaphore = s;
        }

        @Override
        public void addOutput(byte[] data, int offset, int length) {
            String d = new String(data, offset, length);
            sb.append(d);
        }

        @Override
        public void flush() {
            mSemaphore.release();
        }

        @Override
        public boolean isCancelled() {
            return false;
        }

        public String getOutput() {
            return sb.toString();
        }
    }
}