/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Use is subject to license terms.

 */

package org.opensolaris.os.vp.panel.common.control;

import java.util.*;

import java.util.concurrent.*;

import java.util.regex.Pattern;

public class Navigator {

    //

    // Static data

    //

    public static final String PATH_SEPARATOR = "/";

    public static final String PARENT_ID = "..";

    //

    // Instance data

    //

    private Thread dispatchThread;

    private ThreadPoolExecutor threadPool;

    private LinkedList<Control> stack = new LinkedList<Control>();

    private NavigationListeners listeners = new NavigationListeners(false);

    private String name;

    //

    // Constructors

    //

    public Navigator(String name) {

	this.name = name;

	String tName = String.format("%s-%s-",

	    TextUtil.getClassBaseName(getClass()), name);

	ThreadFactory factory =

	    new NamedThreadFactory(tName) {

		@Override

		public Thread newThread(Runnable r) {

		    dispatchThread = super.newThread(r);

		    return dispatchThread;

		}

	    };

	// Unbounded

	BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();

	// Use a thread pool with a single core thread to autmatically handle

	// uncaught exceptions and queued requests

	threadPool = new ThreadPoolExecutor(

	    1, 1, 10, TimeUnit.MINUTES, queue, factory);

	threadPool.allowCoreThreadTimeOut(true);

    }

    //

    // Navigator methods

    //

    /**

     * Adds a {@link NavigationListener} to be notified when navigation is

     * stopped and started.

     */

    public void addNavigationListener(NavigationListener l) {

	listeners.add(l);

    }

    /**

     * Runs the given {@code Runnable} asynchronously on this {@code

     * Navigator}'s navigation thread.	This thread is intended to be used

     * specifically for navigation; the given {@code Runnable} should thus be

     * limited to calling {@link #goTo(Control,Navigable...)} and (briefly)

     * handling any thrown exceptions.

     * <p/>

     * Note: If this method is called when the navigation thread is busy, the

     * given {@code Runnable} will be queued and run when the thread is

     * available.

     *

     * @param	    r

     *		    the {@code Runnable} to run and handle any resulting

     *		    exceptions

     */

    public void asyncExec(Runnable r) {

	threadPool.execute(r);

    }

    /**

     * Runs the given {@link NavRunnable} on this {@code Navigator}'s navigation

     * thread and waits for it to complete.  Any exceptions thrown by {@code r}

     * are thrown here.

     * <p/>

     * See {@link #asyncExec}.

     *

     * @param	    r

     *		    the {@link NavRunnable} to run

     */

    public void asyncExecAndWait(final NavRunnable r)

	throws NavigationAbortedException, InvalidAddressException,

	MissingParameterException, InvalidParameterException {

	if (isDispatchThread()) {

	    r.run();

	    return;

	}

	final boolean[] done = {false};

	final Throwable[] throwable = {null};

	asyncExec(

	    new Runnable() {

		@Override

		public void run() {

		    try {

			r.run();

		    } catch (Throwable t) {

			throwable[0] = t;

		    }

		    synchronized (done) {

			done[0] = true;

			done.notify();

		    }

		}

	    });

	// Sleep until nav thread is done

	synchronized (done) {

	    while (!done[0]) {

		try {

		    done.wait();

		} catch (InterruptedException ignore) {

		}

	    }

	}

	Throwable t = throwable[0];

	if (t != null) {

	    if (t instanceof NavigationAbortedException)

		throw (NavigationAbortedException)t;

	    if (t instanceof InvalidAddressException)

		throw (InvalidAddressException)t;

	    if (t instanceof MissingParameterException)

		throw (MissingParameterException)t;

	    if (t instanceof InvalidParameterException)

		throw (InvalidParameterException)t;

	    if (t instanceof RuntimeException)

		throw (RuntimeException)t;

	    if (t instanceof Error)

		throw (Error)t;

	    // All Throwables should be accounted for

	    assert false;

	}

    }

    /**

     * Notifies all registered {@link NavigationListener}s that a navigation has

     * begun.

     */

    protected void fireNavigationStarted(NavigationEvent e) {

	listeners.navigationStarted(e);

    }

    /**

     * Notifies all registered {@link NavigationListener}s that a navigation has

     * stopped.

     */

    protected void fireNavigationStopped(NavigationEvent e) {

	listeners.navigationStopped(e);

    }

    /**

     * Returns the current {@link Control}, or {@code null} if the root element

     * of the navigation stack has not yet been set.

     */

    public Control getCurrentControl() {

	synchronized (stack) {

	    return stack.peekLast();

	}

    }

    public String getName() {

	return name;

    }

    /**

     * Gets a list of the elements of the current path, with the root element at

     * the beginning of the list.  This method is not thread-safe; it is up to

     * callers to ensure the that navigation is not currently modifying this

     * path.

     */

    @SuppressWarnings({"unchecked"})

    public List<Control> getPath() {

	return (List<Control>)stack.clone();

    }

    /**

     * Gets the current path as a {@code String}.  This method is not

     * thread-safe; it is up to callers to ensure the that navigation is not

     * currently modifying this path.

     */

    public String getPathString() {

	return getPathString(stack);

    }

    /**

     * Navigates to the {@link Control} identified by the given path.

     *

     * @param	    relativeTo

     *		    a {@link Control} within the navigation stack to which

     *		    {@code path} is relative, or {@code null} if {@code path} is

     *		    absolute

     *

     * @param	    path

     *		    the path (relative to {@code relativeTo}), or unspecified to

     *		    navigate up the stack to {@code relativeTo}; if the root of

     *		    this {@code Navigator} has not yet been set, the first

     *		    element of this path <strong>must</strong> be a {@link

     *		    Control}

     *

     * @return	    the previously current {@link Control}, or {@code null} if

     *		    the root {@link Control} of the navigation stack has not yet

     *		    been set

     *

     * @exception   NavigationAbortedException

     *		    if the navigation is vetoed

     *

     * @exception   InvalidAddressException

     *		    if {@code path} does not refer to a valid address

     *

     * @exception   MissingParameterException

     *		    if some {@link Control} in the process of navigation could

     *		    not be {@link Control#start started} due to a missing

     *		    intialization parameter

     *

     * @exception   InvalidParameterException

     *		    if some {@link Control} in the process of navigation could

     *		    not be {@link Control#start started} due to an invalid

     *		    intialization parameter

     *

     * @exception   IllegalArgumentException

     *		    if {@code relativeTo} is not in the navigation stack

     */

    public Control goTo(Control relativeTo, Navigable... path)

	throws NavigationAbortedException, InvalidAddressException,

	MissingParameterException, InvalidParameterException {

	assert isDispatchThread();

	synchronized (stack) {

	    // Last absolute path

	    LinkedList<Navigable> laPath = new LinkedList<Navigable>();

	    laPath.addAll(stack);

	    while (true) {

		// Current absolute path

		LinkedList<Navigable> caPath = new LinkedList<Navigable>();

		if (relativeTo != null) {

		    caPath.addAll(laPath);

		    try {

			// Remove path elements until relativeTo is at the top

			while (!((HasControl)caPath.getLast()).getControl().

			    equals(relativeTo)) {

			    caPath.removeLast();

			}

		    } catch (NoSuchElementException e) {

			throw new IllegalArgumentException(String.format(

			    "Control not in navigation path: %s (%s)",

			    relativeTo.getClass().getName(),

			    relativeTo.getId()));

		    }

		}

		if (path.length != 0) {

		    CollectionUtil.addAll(caPath, path);

		    // Remove unnecessary ".." segments

		    normalize(caPath);

		}

		List<Navigable> rPath = getRelativePath(laPath, caPath);

		if (rPath.isEmpty()) {

		    break;

		}

		// Iterate through rPath, adding/removing elements to/from

		// laPath as appropriate

		for (Navigable nav : rPath) {

		    if (nav.getId().equals(PARENT_ID)) {

			try {

			    laPath.removeLast();

			} catch (NoSuchElementException e) {

			    throw new IllegalArgumentException(

				"\"..\" encountered with empty navigation " +

				"stack");

			}

		    } else {

			Control newControl;

			// If the Navigation stack has no root...

			if (laPath.isEmpty()) {

			    try {

				newControl = (Control)nav;

			    } catch (ClassCastException e) {

				throw new IllegalArgumentException(

				    "root-level Navigable \"" + nav.getName() +

				    "\" must be a Control");

			    }

			} else {

			    String id = nav.getId();

			    Object last = laPath.getLast();

			    // laPath elements are Controls or PendingControls

			    Control curControl =

				((HasControl)last).getControl();

			    newControl = curControl.getChildControl(id);

			    if (newControl == null) {

				throw new InvalidAddressException(String.format(

				    "%s%s%s", getPathString(laPath),

				    PATH_SEPARATOR, id));

			    }

			}

			PendingControl pair =

			    new PendingControl(newControl, nav.getParameters());

			laPath.add(pair);

		    }

		}

		try {

		    Control control =

			((HasControl)laPath.getLast()).getControl();

		    String forward = control.getForwardingPath();

		    if (forward == null) {

			break;

		    }

		    path = toArray(forward);

		    relativeTo = isAbsolute(forward) ? null : control;

		} catch (NoSuchElementException ignore) {

		    // No root Control

		}

	    }

	    // The original Control, before navigation

	    Control orig = getCurrentControl();

	    @SuppressWarnings({"unchecked"})

	    List<PendingControl> rPath =

		(List<PendingControl>)(List)getRelativePath(stack, laPath);

	    if (!rPath.isEmpty()) {

		NavigationEvent event = new NavigationEvent(this,

		    Collections.unmodifiableList(rPath));

		fireNavigationStarted(event);

		try {

		    for (PendingControl pend : rPath) {

			Control curControl = getCurrentControl();

			if (pend.getId().equals(PARENT_ID)) {

			    curControl.stop();

			    stack.removeLast();

			    Control newCurControl = getCurrentControl();

			    if (newCurControl != null) {

				newCurControl.childStopped(curControl);

			    }

			} else {

			    Control newControl = pend.getControl();

			    newControl.start(this, pend.getParameters());

			    stack.add(newControl);

			    if (curControl != null) {

				curControl.childStarted(newControl);

			    }

			}

			if (System.getProperty("vpanels.debug.navigator") !=

			    null) {

			    System.out.printf("%s\n", getPathString());

			}

		    }

		} finally {

		    fireNavigationStopped(event);

		}

	    }

	    return orig;

	}

    }

    /**

     * Asynchronously navigates to the {@link Control} identified by the

     * given path.  A wrapper around {@link #goTo(Control,Navigable...)}

     * that is run asynchronously using {@link #asyncExec}.

     */

    public void goToAsync(final Control relativeTo, final Navigable... path) {

	asyncExec(

	    new Runnable() {

		@Override

		public void run() {

		    try {

			goTo(relativeTo, path);

		    } catch (NavigationException ignore) {

		    }

		}

	    });

    }

    /**

     * Asynchronously navigates to the {@link Control} identified by the given

     * path, returning only when navigation is complete.  A wrapper around

     * {@link #goTo(Control,Navigable...)} that is run asynchronously using

     * {@link #asyncExecAndWait}.

     */

    public void goToAsyncAndWait(

	final Control relativeTo, final Navigable... path)

	throws NavigationAbortedException, InvalidAddressException,

	MissingParameterException, InvalidParameterException {

	asyncExecAndWait(

	    new NavRunnable() {

		@Override

		public void run()

		    throws NavigationAbortedException, InvalidAddressException,

		    MissingParameterException, InvalidParameterException {

		    goTo(relativeTo, path);

		}

	    });

    }

    /**

     * Shortcut for:

     * <p>

     *	 <code>

     *	   {@link #goTo(Control,Navigable...) goTo}(relativeTo,

     *	   new {@link SimpleNavigable#SimpleNavigable(String,Map)

     *	   SimpleNavigable}(id, {@link Navigable.Util#toMap

     *	   Navigable.Util.toMap}(parameters)));

     *	 </code>

     * </p>

     */

    public Control goTo(Control relativeTo, String id,

	String... parameters) throws NavigationAbortedException,

	InvalidAddressException, MissingParameterException,

	InvalidParameterException {

	return goTo(relativeTo,

	    new SimpleNavigable(id, Navigable.Util.toMap(parameters)));

    }

    /**

     * A wrapper around {@link #goTo(Control,String,String...)}

     * that is run asynchronously using {@link #asyncExec}.

     */

    public void goToAsync(final Control relativeTo, final String id,

	final String... parameters) {

	    asyncExec(

		new Runnable() {

		    @Override

		    public void run() {

			try {

			    goTo(relativeTo, id, parameters);

			} catch (NavigationException ignore) {

			}

		    }