/*
* Copyright (C) 2012 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.motorola.studio.android.emulator.logic;

import static com.motorola.studio.android.common.log.StudioLogger.debug;
import static com.motorola.studio.android.common.log.StudioLogger.error;
import static com.motorola.studio.android.common.log.StudioLogger.info;
import static com.motorola.studio.android.common.log.StudioLogger.warn;

import java.io.IOException;
import java.util.Collection;
import java.util.HashSet;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.sequoyah.vnc.protocol.PluginProtocolActionDelegate;
import org.eclipse.sequoyah.vnc.protocol.lib.IProtocolExceptionHandler;
import org.eclipse.sequoyah.vnc.protocol.lib.ProtocolHandle;
import org.eclipse.sequoyah.vnc.protocol.lib.exceptions.InvalidDefinitionException;
import org.eclipse.sequoyah.vnc.protocol.lib.exceptions.InvalidInputStreamDataException;
import org.eclipse.sequoyah.vnc.protocol.lib.exceptions.InvalidMessageException;
import org.eclipse.sequoyah.vnc.protocol.lib.exceptions.MessageHandleException;
import org.eclipse.sequoyah.vnc.protocol.lib.exceptions.ProtocolHandshakeException;
import org.eclipse.sequoyah.vnc.protocol.lib.exceptions.ProtocolRawHandlingException;

import com.motorola.studio.android.adt.ISerialNumbered;
import com.motorola.studio.android.common.utilities.EclipseUtils;
import com.motorola.studio.android.emulator.core.exception.InstanceNotFoundException;
import com.motorola.studio.android.emulator.core.exception.InstanceStopException;
import com.motorola.studio.android.emulator.core.model.IAndroidEmulatorInstance;
import com.motorola.studio.android.emulator.core.utils.EmulatorCoreUtils;
import com.motorola.studio.android.emulator.i18n.EmulatorNLS;
import com.motorola.studio.android.emulator.logic.AbstractStartAndroidEmulatorLogic.LogicMode;

/**
 * DESCRIPTION:
 * Class that defines how to handle internal protocol exceptions
 * 
 * RESPONSABILITY:
 * Handle internal protocol exceptions
 * 
 * COLABORATORS:
 * None.
 * 
 * USAGE:
 * This class shall be used by Eclipse only
 */
public class AndroidExceptionHandler implements IProtocolExceptionHandler
{
    private int handlingLevel = 1;

    private boolean checkThreadRunning = false;

    private Lock lock = new ReentrantReadWriteLock().writeLock();

    private static Collection<String> stoppedWithFailure = new HashSet<String>();

    static
    {

        IJobManager manager = Job.getJobManager();
        manager.addJobChangeListener(new JobChangeAdapter()
        {
            @Override
            public void done(IJobChangeEvent event)
            {
                Job job = event.getJob();
                if (job.belongsTo(StartVncServerLogic.VNC_SERVER_JOB_FAMILY))
                {
                    IStatus result = event.getResult();
                    if (!result.isOK() && !(result.getSeverity() == IStatus.CANCEL))
                    {
                        stoppedWithFailure.add(job.getName());
                    }
                }
            }

            @Override
            public void scheduled(IJobChangeEvent event)
            {
                Job job = event.getJob();
                if (job.belongsTo(StartVncServerLogic.VNC_SERVER_JOB_FAMILY))
                {
                    stoppedWithFailure.remove(job.getName());
                }
            }
        });
    }

    /**
     * Handles internal IOExceptions caught by the protocol plugin during its execution.
     *  
     * @see IProtocolExceptionHandler#handleIOException(ProtocolHandle, IOException) 
     */
    public void handleIOException(ProtocolHandle handle, IOException e)
    {
        error("A socket was broken while communicating to server. Cause: " + e.getMessage());
        handleException(handle);
    }

    /**
     * Handles exceptions thrown by the protocol plugin when it detects an invalid message
     * definition provided by the plugin which is extending it (in this case, the core plugin).
     *  
     * @see IProtocolExceptionHandler#handleInvalidDefinitionException(ProtocolHandle, InvalidDefinitionException) 
     */
    public void handleInvalidDefinitionException(ProtocolHandle handle, InvalidDefinitionException e)
    {
        // This exception should not happen, because the message definitions are provided
        // by the development team.
        warn("An invalid message definition was detected. Cause: " + e.getMessage());
        handleException(handle);
    }

    /**
     * Handles exceptions thrown by the protocol plugin when it detects that the data retrieved from
     * the connection does not match the format defined in the message definition.
     *  
     * @see IProtocolExceptionHandler#handleInvalidInputStreamDataException(ProtocolHandle, InvalidInputStreamDataException) 
     */
    public void handleInvalidInputStreamDataException(ProtocolHandle handle,
            InvalidInputStreamDataException e)
    {
        // If the data retrieved from the connection is not as expected (considering 
        // the message definition provided), there is a high chance of errors to happen.
        // It is likely that the data from stream is no longer synchronized, so the
        // exception handling for this case is to restart connection.

        error("Some received data is not compatible with the expected definition. Restarting the protocol for synchronization.");
        handleException(handle);
    }

    /**
     * Handles exceptions thrown by the protocol plugin when it detects that the message
     * provided for sending does not have enough or valid information, given a corresponding
     * message definition
     *  
     * @see IProtocolExceptionHandler#handleInvalidMessageException(ProtocolHandle, InvalidMessageException) 
     */
    public void handleInvalidMessageException(ProtocolHandle handle, InvalidMessageException e)
    {
        // This exception should not happen, because the message object data is provided
        // by the development team. Log only.
        warn("A message was not constructed according to its definition. Cause: " + e.getMessage());
        handleException(handle);
    }

    /**
     * Handles exceptions thrown by any message handler when they discovers that it
     * is not possible to handle the message and it is a fatal error for the protocol. 
     *  
     * @see IProtocolExceptionHandler#handleMessageHandleException(ProtocolHandle, MessageHandleException) 
     */
    public void handleMessageHandleException(ProtocolHandle handle, MessageHandleException e)
    {
        // If a message handler throws a MessageHandleException, that means that it cannot
        // continue. Restart the protocol to guarantee the synchronization.
        error("A message handler has ended in error and has thrown an exception meaning the protocol cannot continue.");
        handleException(handle);
    }

    /**
     * Handles exceptions thrown by the protocol plugin when it is not possible to
     * init the protocol, for example because the handshaking procedure has failed. 
     *  
     * @see IProtocolExceptionHandler#handleProtocolHandshakeException(ProtocolHandle, ProtocolHandshakeException) 
     */
    public void handleProtocolHandshakeException(ProtocolHandle handle, ProtocolHandshakeException e)
    {
        error("Could not initialize the protocol.");
        handleException(handle);
    }

    /**
     * Handles exceptions thrown by any raw field handler when they discovers that it
     * is not possible to handle the field and it is a fatal error for the protocol. 
     *  
     * @see IProtocolExceptionHandler#handleProtocolRawHandlingException(ProtocolHandle, ProtocolRawHandlingException) 
     */
    public void handleProtocolRawHandlingException(ProtocolHandle handle,
            ProtocolRawHandlingException e)
    {
        // This message should be thrown by raw field handlers when they cannot handle the 
        // raw field and need to abort the protocol execution. Restart the protocol to 
        // guarantee the synchronization.
        error("A raw field handler has ended in error and has thrown an exception meaning the protocol cannot continue.");
        handleException(handle);
    }

    /**
     * This method will be called whenever an exception happens. It is important to find
     * out if the failure happened during an start or restart procedure, so that we can
     * do appropriate handling to each situation. 
     * 
     * @param handle The object that identifies the protocol instance
     */
    private void handleException(ProtocolHandle handle)
    {
        IAndroidEmulatorInstance instance = null;
        if (lock.tryLock())
        {
            try
            {
                instance = EmulatorCoreUtils.getAndroidInstanceByHandle(handle);

                try
                {
                    debug("Check if device is online: " + instance);
                    if (instance instanceof ISerialNumbered)
                    {
                        String serialNumber = ((ISerialNumbered) instance).getSerialNumber();
                        AndroidLogicUtils.testDeviceStatus(serialNumber);
                    }
                }
                catch (Exception e)
                {
                    error("Device is not online. Abort VNC session...");
                    abort(instance);
                }

                if ((handlingLevel == 3) && canRestartServer(instance))
                {
                    handlingLevel--;
                }

                // Firstly, try to restart only the VNC client. If restarting the VNC client 
                // is not possible, try to restart the VNC server at the device and to connect
                // to it again. If the start logic cannot be retrieved, delegate the decision 
                // to the user. 

                if (handlingLevel == 1)
                {
                    restartClientOnly(handle);
                    handlingLevel++;
                }
                else if (handlingLevel == 2)
                {
                    restartServerAndClient(instance, handle);
                    handlingLevel++;
                }
                else
                {
                    if (delegateDecisionToUser(handle))
                    {
                        abort(instance);
                    }
                }
            }
            catch (InstanceNotFoundException e)
            {
                // If the instance is not found, it means that the instance is stopped.
                // In this case, a restart is not applicable.
            }
            finally
            {
                lock.unlock();
            }
        }
    }

    private boolean canRestartServer(IAndroidEmulatorInstance instance)
    {
        String name = StartVncServerLogic.VNC_SERVER_JOB_PREFIX + instance.getName();
        return !stoppedWithFailure.contains(name);
    }

    private void restartClientOnly(final ProtocolHandle handle)
    {
        PluginProtocolActionDelegate.requestRestartProtocol(handle);

        if (!checkThreadRunning)
        {
            Runnable r = new Runnable()
            {
                public void run()
                {
                    checkThreadRunning = true;
                    while (checkThreadRunning)
                    {
                        if (PluginProtocolActionDelegate.isProtocolRunning(handle))
                        {
                            handlingLevel = 1;
                            checkThreadRunning = false;
                        }

                        try
                        {
                            Thread.sleep(500);
                        }
                        catch (InterruptedException e)
                        {
                            // Do nothing.
                        }
                    }
                }
            };
            (new Thread(r)).start();
        }
    }

    private void restartServerAndClient(IAndroidEmulatorInstance instance, ProtocolHandle handle)
    {
        try
        {
            if (instance instanceof IAndroidLogicInstance)
            {
                IAndroidLogicInstance logicInstance = (IAndroidLogicInstance) instance;
                AbstractStartAndroidEmulatorLogic logic = logicInstance.getStartLogic();
                logic.execute(logicInstance, LogicMode.TRANSFER_AND_CONNECT_VNC, logicInstance
                        .getTimeout(), new NullProgressMonitor());
                try
                {
                    Thread.sleep(1500);
                }
                catch (InterruptedException e)
                {
                    // Do nothing.
                }
                PluginProtocolActionDelegate.requestRestartProtocol(handle);
            }
            else
            {
                handlingLevel = 3;
            }
        }
        catch (Exception e1)
        {
            handlingLevel = 3;
        }
    }

    /**
     * In this method, the user is asked whether to retry or not. While the user does not
     * give up, the instance retries to connect to the emulator. When the user gives up,
     * the instance is stopped.
     * 
     * @param handle The object that identifies the protocol instance
     */
    private boolean delegateDecisionToUser(ProtocolHandle handle)
    {
        boolean abort = true;
        error("Cannot reconnect to VM. Asking to the user if he/she wants to retry.");
        if (EclipseUtils.showQuestionDialog(EmulatorNLS.GEN_Question,
                EmulatorNLS.QUESTION_AndroidExceptionHandler_ImpossibleToReconnect))
        {
            info("User chose to retry to reconnect to emulator VNC server.");
            PluginProtocolActionDelegate.requestRestartProtocol(handle);
            handlingLevel = 2;
            abort = false;
        }
        return abort;
    }

    /**
     *
     */
    private void abort(IAndroidEmulatorInstance instance)
    {
        info("User chose to stop the instance.");
        try
        {
            checkThreadRunning = false;
            instance.stop(true);
        }
        catch (InstanceStopException e1)
        {
            error("Error while running service for stopping virtual machine");
            EclipseUtils.showErrorDialog(EmulatorNLS.GEN_Error,
                    EmulatorNLS.EXC_AndroidExceptionHandler_CannotRunStopService);
        }
    }

}