/*******************************************************************************
 * 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.ApplicationUIListener;
import org.eclipse.swt.internal.qt.midp.UIThreadLauncher;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Internal_PackageSupport;
import org.eclipse.swt.widgets.Shell;

/**
 * A class that manages the UI thread hand-over from the internal UI event 
 * loop to the application. 
 */
public final class UIThreadHandOverManager {
    private static Object lock = new Object();
    private static boolean threadWaitingForApplication;
    private static Runnable applicationRunnable;
    private static ApplicationUIListener applicationUIListener;
    
    /**
     * Pass the control of the thread to the application by calling a Runnable
     * provided by the application. If the Runnable has not yet been provided
     * then the thread waits until it becomes available, or the wait is aborted
     * by calling <code>abortWait()</code>. 
     */
    public static void runApplicationUI() {
        synchronized(lock) {
            if(!applicationWaiting()) {
                waitForApplication();
            } else {
                // Release the waiting application thread
                lock.notify();
            }
        }
        callback();
    }

    /**
     * If the UI thread is waiting for the application to request the callback
     * in the UI thread then calling this will abort the wait and make the UI
     * thread to return back from the <code>runApplicationUI()</code>.
     */
    public static void abortWait() {
        synchronized(lock) {
            if(threadWaitingForApplication) {
                lock.notify();
            }
        }
    }

    /**
     * Called indirectly by the application when it's requesting the UI thread. 
     * Application will pass a Runnable as a parameter and expects it to get called
     * in the UI thread. 
     * 
     * @param runnable
     *            The Runnable to call in the UI thread.
     * @return True if obtaining the UI thread was successful and the runnable
     *         will be called.
     */
    public static boolean startInUIThread(Runnable runnable) {
        // Make sure that the internal event loop is started. 
        EventLoop.getInternalDisplay();
        
        synchronized(lock) {
            applicationRunnable = runnable;
            if(threadWaitingForApplication) {
                lock.notify();
            } else {
                if(!waitForUIThread()) {
                    // If the internal UI has not been created then it can't be
                    // signaled and we can't wait for it. This must mean there's
                    // no UI thread yet in the process and we can create it here.
                    if(!UIThreadLauncher.startInUIThread(runnable)) {
                        return false;
                    }   
                }
            }
        }
        return true;
    }
    
    /**
     * Sets the listener that will be notified of the state of the UI during its
     * life-time.
     */
    public static void setApplicationUIListener(ApplicationUIListener listener) {
        synchronized(lock) {
            applicationUIListener = listener;
        }
    }
    
    /*
     * Signal the internal UI loop and wait until it passes the control of the
     * UI thread into runApplicationUI(). Return false if the internal UI can't
     * be signaled. 
     */
    private static boolean waitForUIThread() {
        if(signalUIThreadRequest()) {
            try {
                lock.wait();
            } catch(InterruptedException e) {
                // Nothing to do
            }
            return true;
        }
        return false;
    }

    /*
     * Wait until signaled by the application requesting the callback to its
     * Runnable, or by abortWait().
     */
    private static void waitForApplication() {
        threadWaitingForApplication = true;
        try {
            lock.wait();
        } catch(InterruptedException e) {
            // Nothing to do
        } finally {
            threadWaitingForApplication = false;
        }       
    }
    
    /*
     * Returns true if application has provided the Runnable and is thus waiting
     * for the callback.
     */
    private static boolean applicationWaiting() {
        return (applicationRunnable != null);
    }
    
    /*
     * Post an event to the internal Display to request the control of the UI
     * thread. After this runApplication() should get called in the UI thread.
     */
    private static boolean signalUIThreadRequest() {
        Display internalDisplay = Internal_PackageSupport.getInternalDisplayInstance();
        if(internalDisplay != null) {
            if(applicationUIListener != null) {
                applicationUIListener.applicationUIThreadRequest();
            }
            return true;
        }
        return false;
    }

    /*
     * Call back the application's runnable
     */
    private static void callback() {
        try {
            boolean runnableOk;
            synchronized(lock) {
                runnableOk = (applicationRunnable != null);
            }
            if(runnableOk) {
                flushInternals();
                applicationRunnable.run();
            }
        } finally {
            synchronized(lock) {
                applicationRunnable = null;
            }
        }
    }
    
    /*
     * Clear any events or other items possibly left over by any previous usage
     * of the UI resources. There must not be anything that can interfere with
     * the application. It must appear as the application starts with an
     * uninitialized UI.
     */
    private static void flushInternals() {
        Display internalDisplay = Internal_PackageSupport.getInternalDisplayInstance();
        
        // Dispose all widgets
        Shell[] shells = internalDisplay.getShells();
        for(int i = 0; i < shells.length; ++i) {
            if(shells[i] != null && !shells[i].isDisposed()) {
                shells[i].dispose();
            }
        }
        
        // Flush the event queue
        while(internalDisplay.readAndDispatch()) {}
    }
}