/*******************************************************************************
 * Copyright (c) 2001, 2008 Oracle Corporation and others.
 * 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:
 *     Oracle Corporation - initial API and implementation
 *******************************************************************************/
/**
 * 
 */
package org.eclipse.jst.jsf.designtime.context;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IResource;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.designtime.internal.view.DTUIViewRoot;
import org.eclipse.jst.jsf.designtime.internal.view.IDTViewHandler;
import org.eclipse.jst.jsf.designtime.internal.view.IViewRootHandle;
import org.eclipse.jst.jsf.designtime.internal.view.DTUIViewRoot.StalenessListener;
import org.eclipse.jst.jsf.designtime.internal.view.IDTViewHandler.ViewHandlerException;

/* package */ final class ViewRootHolder implements IViewRootHandle, Cloneable
{
    private final Object         _recalcViewRootExclusion;
    private final DTFacesContext _facesContext;
    private DTUIViewRoot         _viewRoot;
    private final List<StalenessListener>  _waitingToAdd;
    private final List<StalenessListener>  _waitingToRemove;

    public ViewRootHolder(final DTFacesContext facesContext, final Object recalcViewRootExclusion)
    {
        _facesContext = facesContext;
        _recalcViewRootExclusion = recalcViewRootExclusion;
        _waitingToAdd = new ArrayList<StalenessListener>();
        _waitingToRemove = new ArrayList<StalenessListener>();
    }

    private ViewRootHolder(ViewRootHolder cloneFrom)
    {
        _recalcViewRootExclusion = cloneFrom._recalcViewRootExclusion;
        _facesContext = cloneFrom._facesContext;
        _viewRoot = cloneFrom.getCachedViewRoot();

        // create brand new copies
        _waitingToAdd = new ArrayList<StalenessListener>();
        _waitingToRemove = new ArrayList<StalenessListener>();
    }

    public synchronized DTUIViewRoot getCachedViewRoot()
    {
        return _viewRoot;
    }

    public DTUIViewRoot updateViewRoot()
    {
        DTUIViewRoot viewRoot = null;
        final IResource contextResource = _facesContext.adaptContextObject();
        
        // we create this additional exclusion so that we avoid a
        // situation
        // where two threads enter and start recalculating the same view
        // root in parallel. Only one thread may be working on creating
        // a new view root for a particular view at any given time. Note
        // that due to read/write lock on the value, there is nothing
        // to stop readers from simultaneous getting the old value until
        // the new value is ready and has been set.
        synchronized (_recalcViewRootExclusion)
        {
            viewRoot = getCachedViewRoot();

            if (viewRoot == null || viewRoot.isStale())
            {
                // if the view root hasn't been created, then do so
                // and populate it
                final IDTViewHandler viewHandler = _facesContext
                        .getViewHandler(contextResource);

                if (viewHandler != null)
                {
                    final String viewId = viewHandler.getViewId(
                            _facesContext, contextResource);

                    try
                    {
                        viewRoot = viewHandler.createView(_facesContext,
                                viewId);
                        if (viewRoot != null)
                        {
                            setCachedViewRoot(viewRoot);
                        }
                        
                        // do adds first, let remove trump all
                        for (final StalenessListener addListener : _waitingToAdd)
                        {
                            viewRoot.addListener(addListener);
                        }
                        
                        for (final StalenessListener removeListener : _waitingToRemove)
                        {
                            viewRoot.removeListener(removeListener);
                        }
                    }
                    catch (final ViewHandlerException e)
                    {
                        JSFCorePlugin.log(e,
                                "While creating dt viewroot for viewId: "
                                        + viewId);
                    }
                }
            }
        }
        // return the copy. NEVER return _viewRoot directly since we are not
        // synchronized here.
        return viewRoot;
    }

    private synchronized void setCachedViewRoot(
            final DTUIViewRoot newViewRoot)
    {
        if (!Thread.holdsLock(_recalcViewRootExclusion))
        {
            throw new IllegalStateException(
                    "Must hold _recalcViewRootExclusion to modify view root");
        }
        _viewRoot = newViewRoot;
    }

    @Override
    protected synchronized IViewRootHandle clone()
    {
        return new ViewRootHolder(this);
    }

    public void addListener(StalenessListener listener)
    {
        if (_viewRoot != null)
        {
            synchronized(this)
            {
                _viewRoot.addListener(listener);
            }
        }
        else
        {
            // ensure that if we calculating a new view root, then there isn't
            // an issue.
            synchronized(_recalcViewRootExclusion)
            {
                synchronized(this)
                {
                    _waitingToAdd.add(listener);
                }
            }
        }
    }

    public void removeListener(StalenessListener listener)
    {
        DTUIViewRoot viewRoot = null;
        
        synchronized(this)
        {
            viewRoot = _viewRoot;
        }

        if (viewRoot != null)
        {
            synchronized(this)
            {
                viewRoot.removeListener(listener);
            }
        }
        else
        {
            // ensure that if we calculating a new view root, then there isn't
            // an issue.
            // always acquire the recalcViewRootExclusion first
            synchronized(_recalcViewRootExclusion)
            {
                synchronized(this)
                {
                    _waitingToAdd.add(listener);
                }
            }
        }
    }
}