/*******************************************************************************
 * 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.common.internal.resource;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jst.jsf.common.internal.managedobject.IManagedObject;
import org.eclipse.jst.jsf.common.internal.managedobject.ObjectManager;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.EventType;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.ReasonType;

/**
 * An object manager that manages a single instanceof an IManagedObject per
 * resource. The manager takes care of ensuring that a managed object is
 * properly disposed when a resource lifecycle event renders it inaccessible
 * (i.e file is deleted, project is closed or delete).
 * 
 * @author cbateman
 * 
 * @param <RESOURCE>
 * @param <MANAGEDOBJECT>
 */
public abstract class ResourceSingletonObjectManager<MANAGEDOBJECT extends IManagedObject, RESOURCE extends IResource>
        extends ObjectManager<MANAGEDOBJECT, RESOURCE>
{
    // lazily initialized
    private LifecycleListener                          _lifecycleListener;
    final Map<RESOURCE, ManagedResourceObject<MANAGEDOBJECT>> _perResourceObjects;
    private final IWorkspace _workspace;

    /**
     * Default constructor
     * @param workspace 
     */
    protected ResourceSingletonObjectManager(final IWorkspace workspace)
    {
        _workspace = workspace;
        _perResourceObjects = new HashMap<RESOURCE, ManagedResourceObject<MANAGEDOBJECT>>();
    }

    /**
     * @return the workspace
     */
    protected final IWorkspace getWorkspace()
    {
        return _workspace;
    }


    /**
     * @return an unmodifiable view on the map of currently managed objects keyed
     * by the resource they are mapped to.
     */
    protected final Map<RESOURCE, ManagedResourceObject<MANAGEDOBJECT>> getPerResourceObjects()
    {
        return Collections.unmodifiableMap(_perResourceObjects);
    }

    @Override
    public final MANAGEDOBJECT getInstance(final RESOURCE key)
    throws ManagedObjectException
    {
        assertNotDisposed();
        IAdaptable stateObject = null;
        try
        {
            stateObject = unsafeRunBeforeGetInstance(key);
            synchronized(this)
            {
                runBeforeGetInstance(key);
                ManagedResourceObject managedResObject = _perResourceObjects.get(key);
        
                if (managedResObject == null)
                {
                    final MANAGEDOBJECT managedObject = createNewInstance(key);
        
                    if (managedObject == null)
                    {
                        throw new ManagedObjectException(
                                "No object available for resource"); //$NON-NLS-1$
                    }
                    managedResObject = manageResource(key, managedObject);
                }
    
                runAfterGetInstance(key);
                return (MANAGEDOBJECT) managedResObject.getManagedObject();
            }
        }
        finally
        {
            unsafeRunAfterGetInstance(key, stateObject);
        }
    }

    /**
     * @param resource
     * @return a new instance of T associated with S. This operation must not
     *         cache T: a brand new instance is always required. getInstance
     *         will perform caching and resource listening.
     */
    protected abstract MANAGEDOBJECT createNewInstance(RESOURCE resource);

    /**
     * @param resource
     */
    protected void runBeforeGetInstance(final RESOURCE resource)
    {
        // do nothing by default
    }

    /**
     * @param resource
     */
    protected void runAfterGetInstance(final RESOURCE resource)
    {
        // do nothing by default
    }
    
    /**
     * Callback run outside of synchronized code block in getInstance
     * @param resource
     * @return A state object to be passed to unsafeRunAfterGetInstance, or null.
     */
    protected IAdaptable unsafeRunBeforeGetInstance(final RESOURCE resource)
    {
        // do nothing by default
        return null;
    }

    /**
     * Callback run outside of synchronized code block in getInstance
     * @param resource
     * @param adaptable State object returned from unsafeRunBeforeGetInstance call, may be null.
     */
    protected void unsafeRunAfterGetInstance(final RESOURCE resource, final IAdaptable adaptable)
    {
        // do nothing by default
    }

    /**
     * @param resource
     * @return true if there already exists a managed object associated with
     * the resource
     */
    public synchronized boolean isInstance(RESOURCE resource)
    {
        assertNotDisposed();
        return _perResourceObjects.containsKey(resource);
    }

    /**
     * @return a copy of the current set of RESOURCE object keys that we
     * are managing singletons for.  Collection is mutable, but as a copy,
     * changes to it do not effect thie object manager.
     */
    public synchronized Collection<RESOURCE> getManagedResources()
    {
        assertNotDisposed();
        return new HashSet(_perResourceObjects.keySet());
    }
    /**
     * Should be called by concrete classes to indicate they have created a new
     * managed object for resource, for which they want to track lifecycle
     * changes.
     * 
     * @param resource
     * @param managedObject
     */
    private synchronized ManagedResourceObject manageResource(final RESOURCE resource,
            final MANAGEDOBJECT managedObject)
    {
        final LifecycleListener listener = lazilyGetLifecycleListener();
        listener.addResource(resource);
        final MyLifecycleEventListener<RESOURCE, MANAGEDOBJECT> eventListener = 
            new MyLifecycleEventListener<RESOURCE, MANAGEDOBJECT>(
                this, managedObject, resource);
        listener.addListener(eventListener);

        final ManagedResourceObject<MANAGEDOBJECT> managedResourceObject = new ManagedResourceObject<MANAGEDOBJECT>(
                managedObject, eventListener);
        _perResourceObjects.put(resource, managedResourceObject);
        return managedResourceObject;
    }

    /**
     * Stop managing the resource. If resource is the last one, the resource
     * change listener will be removed (it will be added again when next
     * manageResource is called).
     * 
     * @param resource
     * @return the managed object that has just be disassociated from the resource.
     * The object is not disposed, destroyed or checkpointed before being returned.
     */
    protected final synchronized MANAGEDOBJECT unmanageResource(final RESOURCE resource)
    {
        final ManagedResourceObject managedResourceObject =
            _perResourceObjects.remove(resource);
        final LifecycleListener listener = lazilyGetLifecycleListener();

        if (managedResourceObject != null)
        {
            listener.removeListener(managedResourceObject.getEventListener());
        }

        listener.removeResource(resource);
        return (MANAGEDOBJECT) managedResourceObject.getManagedObject();
    }

    /**
     * Call to register a listener
     * 
     * @param listener
     */
    protected final void addLifecycleEventListener(
            final IResourceLifecycleListener listener)
    {
        assertNotDisposed();
        final LifecycleListener lifecycleListener = lazilyGetLifecycleListener();
        lifecycleListener.addListener(listener);
    }

    /**
     * Call to remove a listener
     * 
     * @param listener
     */
    protected final void removeLifecycleEventListener(
            final IResourceLifecycleListener listener)
    {
        final LifecycleListener lifecycleListener = lazilyGetLifecycleListener();
        lifecycleListener.removeListener(listener);
    }

    /**
     * Add additional resources to the set to listen to.
     * 
     * @param res
     */
    protected final void addResource(final IResource res)
    {
        final LifecycleListener lifecycleListener = lazilyGetLifecycleListener();
        lifecycleListener.addResource(res);
    }

    /**
     * Remove a resource that is being listened to.  Must not be used to remove
     * internally added resources (i.e. only use this if you called addResource(res).
     * 
     * @param res
     */
    protected final void removeResource(final IResource res)
    {
        synchronized(this)
        {
            if (_perResourceObjects.keySet().contains(res))
            {
                throw new IllegalArgumentException("Can't remove managed resources with this method"); //$NON-NLS-1$
            }
        }
        final LifecycleListener lifecycleListener = lazilyGetLifecycleListener();
        lifecycleListener.removeResource(res);
    }

    private synchronized LifecycleListener lazilyGetLifecycleListener()
    {
        if (_lifecycleListener == null)
        {
            _lifecycleListener = new LifecycleListener(_workspace);
        }
        return _lifecycleListener;
    }

    /**
     * @author cbateman
     * 
     * @param <MANAGEDOBJECT>
     */
    protected final static class ManagedResourceObject<MANAGEDOBJECT extends IManagedObject>
    {
        private final MANAGEDOBJECT _managedObject;
        private final MyLifecycleEventListener _eventListener;

        private ManagedResourceObject(final MANAGEDOBJECT managedObject,
                final MyLifecycleEventListener eventListener)
        {
            _managedObject = managedObject;
            _eventListener = eventListener;
        }

        /**
         * @return the managed object
         */
        public MANAGEDOBJECT getManagedObject()
        {
            return _managedObject;
        }

        /**
         * @return the event listener
         */
        public MyLifecycleEventListener getEventListener()
        {
            return _eventListener;
        }
    }

    private static  class MyLifecycleEventListener<RESOURCE extends IResource, MANAGEDOBJECT extends IManagedObject> implements
    IResourceLifecycleListener
    {
        private final RESOURCE      _resource;
        private final MANAGEDOBJECT _managedObject;
        private final ResourceSingletonObjectManager<MANAGEDOBJECT, RESOURCE>  _target;

        private MyLifecycleEventListener(final ResourceSingletonObjectManager<MANAGEDOBJECT, RESOURCE> target,
                final MANAGEDOBJECT managedObject,
                final RESOURCE resource)
        {
            _resource = resource;
            _managedObject = managedObject;
            _target = target;
        }

        public EventResult acceptEvent(final ResourceLifecycleEvent event)
        {
            final EventResult result = EventResult.getDefaultEventResult();

            // not interested
            if (!_resource.equals(event.getAffectedResource()))
            {
                return EventResult.getDefaultEventResult();
            }

            if (event.getEventType() == EventType.RESOURCE_INACCESSIBLE)
            {
                try
                {
                    if (event.getReasonType() == ReasonType.RESOURCE_DELETED
                            || event.getReasonType() == ReasonType.RESOURCE_PROJECT_DELETED)
                    {
                        _managedObject.destroy();
                    }
                    else
                    {
                        _managedObject.dispose();
                    }
                }
                // dispose/destroy is external code out our control, so make sure
                // unmanage gets called if it blows up.
                finally
                {
                    _target.unmanageResource(_resource);
                }
            }
            return result;
        }
    }

    
    /** 
     * Unmanages all resources and calls checkpoint and dispose on all managed
     * objects.  After this call, other methods my throw exception is called.
     * 
     * Sub-class may override, but should always call dispose after disposing 
     * their own specialized state.
     */
    @Override
    public void dispose()
    {
        if (_isDisposed.compareAndSet(false, true))
        {
            // TODO: implement a better lock strategy on resource manager
            synchronized (this)
            {
                Map<RESOURCE, ManagedResourceObject<MANAGEDOBJECT>> copy = new HashMap<RESOURCE, ManagedResourceObject<MANAGEDOBJECT>>(
                        getPerResourceObjects());
    
                for (Map.Entry<RESOURCE, ManagedResourceObject<MANAGEDOBJECT>> entry : copy.entrySet())
                {
                    RESOURCE res = entry.getKey();
                    MANAGEDOBJECT unmanagedResource = unmanageResource(res);
                    unmanagedResource.checkpoint();
                    unmanagedResource.dispose();
                }
                _perResourceObjects.clear();
                if (_lifecycleListener != null)
                {
                    _lifecycleListener.dispose();
                }
            }
        }
    }

    @Override
    public void destroy()
    {
        // do nothing by default
    }

    @Override
    public void checkpoint()
    {
        // do nothing by default
    }
}