/*******************************************************************************

 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - initial implementation

 *******************************************************************************/

package org.eclipse.swt.internal.qt;

import org.eclipse.swt.internal.qt.midp.UIThreadLauncher;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Internal_PackageSupport;

import com.nokia.mj.impl.rt.support.ApplicationUtils;

import com.nokia.mj.impl.rt.support.ShutdownListener;

/**

 * The internal event loop which will run until the application requests the UI 

 * thread. Then UI thread is handed over to the application which will continue

 * running the loop as it pleases. If the application exits cleanly the UI 

 * thread will return back to here and the event loop can continue to run

 * until the runtime signals shutdown. 

 * 

 * This class is the owner of the internal Display instance. 

 */

public final class EventLoop {

    /*

     * The internal Display instance. Owned by this class. 

     */

    private static Display internalDisplay;

    /*

     * Event loop can run here before the application's loop and after the UI

     * thread exits from the application's loop. These states are identifying

     * which of the two loops is currently running. 

     */

    private static final int PRE_APPLICATION = 0;

    private static final int POST_APPLICATION = 1;

    /*

     * Boolean used to detect when application has requested the UI thread and

     * the hand-over must begin. 

     */

    private static volatile boolean applicationRequestedUIThread;

    /*

     * Boolean used to detect when the runtime wants to bring the UI down and

     * the event loop must come down also. 

     */

    private static volatile boolean shuttingDownReceived;

    /*

     * Boolean used to store if starting has been attempted already. 

     */

    private static boolean started;

    /*

     * Runnable that gets called in the UI thread when starting up. Named 

     * class declared to be able to make it static. 

     */

    private static final class LoopRunner implements Runnable {

        public void run() {

            EventLoop.run();

        }       

    }

    /*

     * Not to be instantiated. 

     */

    private EventLoop() {

    }

    /**

     * Returns the internal Display owned by the EventLoop class. Caller must 

     * not dispose it. 

     * @return The internal Display instance

     * @throws RuntimeException

     */

    public static Display getInternalDisplay() {

        synchronized(EventLoop.class) {

            ensureStartedOrThrow();

            return internalDisplay;

        }

    }

    /*

     * Starts the event loop. If this returns without throwing then the 

     * internal Display instance has been successfully created and can be 

     * asked with getInternalDisplay().

     * 

     * Any calls after the first successful call are ignored. Any calls after

     * the first failed call will not retry but will throw.

     */

    private static void ensureStartedOrThrow() {

        // This is called synchronized with the Display creation that takes 

        // place in the UI thread. 

        if(!started) {

            started = true;

            // Start the UI thread

            if(!UIThreadLauncher.startInUIThread(new LoopRunner())) {

                // Failed to create the UI thread, release the starting thread

                EventLoop.class.notify();

            }

            // Wait until the Display gets created in the UI thread

            try {

                EventLoop.class.wait();

            } catch(InterruptedException e) {

                // Nothing to do

            }

        }

        // Check Display creation status

        if(internalDisplay == null) {

            throw new RuntimeException("Failed to start");

        }

    }

    /*

     * Start listening for the application requesting the UI thread via the

     * eSWT's UIThreadSupport API. 

     */

    private static void listenApplicationUIThreadRequest() {

        UIThreadHandOverManager.setApplicationUIListener(new ApplicationUIListener() {

            /*

             * Can get called in any thread but the UI thread. 

             */

            public void applicationUIThreadRequest() {

                // Synchronized with the Display creation and destruction

                synchronized(EventLoop.class) {

                    applicationRequestedUIThread = true;

                    // It's ok to skip wake if Display has not been created yet

                    if(internalDisplay != null && !internalDisplay.isDisposed()) {

                        internalDisplay.wake();

                    }

                }

            }

        });

    }

    /*

     * Start listening for the runtime's shutting down message. 

     */

    private static void listenRuntimeShutdownRequest() {

        ApplicationUtils.getInstance().addShutdownListener(

            /*

             * Can get called in any thread but the UI thread. 

             */

            new ShutdownListener() {

                public void shuttingDown() {

                    // Synchronized with the Display creation and destruction

                    synchronized(EventLoop.class) {

                        shuttingDownReceived = true;

                        // It's ok to skip wake if Display has not been created yet

                        if(internalDisplay != null && !internalDisplay.isDisposed()) {

                            internalDisplay.wake();

                        }       

                    }

                }

            });

    }

    /*

     * Creates the internal Display and runs the event loop. Called in the UI 

     * thread. 

     */

    private static void run() {

        try {

            // Add the appropriate listeners. 

            listenRuntimeShutdownRequest();

            listenApplicationUIThreadRequest();

            // Create the internal Display. 

            createInternalDisplay();

            // Run event loop until the application wants to take over or the 

            // runtime signals shutdown. In the latter case exit from the UI 

            // thread immediately. 

            loop(PRE_APPLICATION);

            if(shuttingDownReceived) {

                return;

            }

            // Hand over the UI thread to the application. The application is

            // responsible of the event loop until it allows the UI thread to

            // return back here. 

            UIThreadHandOverManager.runApplicationUI();

            // Application allowed its event loop to exit. Continue 

            // dispatching the events until the runtime wants to shut down. 

            loop(POST_APPLICATION);

        } finally {

            destroy();

        }

    }

    /* 

     * Creates the Display. Synchronized with the starting thread that 

     * waits until the Display has been created. 

     */

    private static void createInternalDisplay() {

        synchronized(EventLoop.class) {

            try {

                // Will throw if fails

                internalDisplay = Internal_PackageSupport.internalInstance();

            } finally {

                // Release the starting thread

                EventLoop.class.notify();

            }

        }

    }

    /*

     * Frees all the owned resources when shutting down. Ideally this would be

     * executed only after all the application's threads have been finalized. 

     * If the application's threads are still running it's possible that 

     * someone would try to access the internal Display after this. This would 

     * cause an exception with "device is disposed".

     */

    private static void destroy() {

        // Synchronized with the shutting down message and the application UI 

        // thread request. 

        synchronized(EventLoop.class) {

            if(internalDisplay != null) {

                // If this throws then Display.dispose() was called on the 

                // internal Display by someone who doesn't own it. 

                if(internalDisplay.isDisposed()) {

                    throw new RuntimeException(

                            "Internal Display has been disposed by someone who " +

                            "doesn't own it");

                }

                // If the application's Display has been disposed then 

                // disposing also the internal Display here would destroy the 

                // QApplication and all the UI resources tied to it. Disposing 

                // is not done but the resources are allowed to leak on 

                // purpose:

                //

                // In MIDP many of the related APIs are thread-safe and are 

                // exclusively using garbage collection for memory management. 

                // Disposing the UI resources of API objects that still may be 

                // referenced would create a deviation from the pattern and 

                // that would need special handling all around the API 

                // implementations. That handling is not attempted but instead 

                // the internal Display instance is allowed to live until the 

                // process terminates. 

            }

        }

    }

    /*

     * The event loop that can run before and after the application's loop. 

     * State parameter tells which one of the two this is. The exit 

     * condition depends on the state. 

     */

    private static void loop(final int state) {

        while(!loopExitCondition(state)) {

            if(!internalDisplay.readAndDispatch()) {

                internalDisplay.sleep();

            }

        }

    }

    /*

     * Checks if the loop exit condition is met. The condition is different

     * depending on if the loop is running before or after the application's

     * loop.

     */

    private static boolean loopExitCondition(final int state) {

        switch(state) {

        case PRE_APPLICATION:

            return shuttingDownReceived || applicationRequestedUIThread;

        case POST_APPLICATION:

            return shuttingDownReceived;

        default:

            return true;

        }

    }

}