package org.eclipse.jst.jsf.designtime.internal.resources;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.jst.jsf.common.internal.componentcore.AbstractVirtualComponentQuery;
import org.eclipse.jst.jsf.common.internal.finder.AbstractMatcher.AlwaysMatcher;
import org.eclipse.jst.jsf.common.internal.finder.VisitorMatcher;
import org.eclipse.jst.jsf.common.internal.finder.acceptor.FileMatchingAcceptor;
import org.eclipse.jst.jsf.common.internal.resource.ContentTypeResolver;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.ReasonType;
import org.eclipse.jst.jsf.common.internal.resource.ResourceManager;
import org.eclipse.jst.jsf.common.internal.resource.ResourceTracker;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.designtime.internal.resources.JSFResourceChangeListener.JSFResourceChangedEvent;
import org.eclipse.jst.jsf.designtime.internal.resources.JSFResourceChangeListener.JSFResourceChangedEvent.CHANGE_TYPE;
import org.eclipse.jst.jsf.designtime.internal.resources.ResourceIdentifierFactory.InvalidIdentifierException;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;

/**
 * Resource Manager that tracks JSF resources in a workspace.
 * 
 * @author cbateman
 * 
 */
public class WorkspaceResourceManager extends ResourceManager<IResource>
{
    private final AbstractVirtualComponentQuery _vcQuery;
    private final IProject _project;
    private final AbstractJSFResourceLocator _locator;
    private final ContentTypeResolver _contentTypeResolver;
    private final ResourceIdentifierFactory _factory;

    /**
     * @param project
     * @param vcQuery
     * @param locator
     * @param contentTypeResolver
     */
    public WorkspaceResourceManager(final IProject project,
            final AbstractVirtualComponentQuery vcQuery,
            final AbstractJSFResourceLocator locator,
            final ContentTypeResolver contentTypeResolver)
    {
        super(project.getWorkspace());
        _project = project;
        _vcQuery = vcQuery;
        _locator = locator;
        _contentTypeResolver = contentTypeResolver;
        _factory = new ResourceIdentifierFactory();
    }

    @Override
    protected JSFResourceTracker createNewInstance(final IResource resource)
    {
        final boolean isJSFResource = !getRootResourceFolder().getParent()
                .equals(resource);
        return new JSFResourceTracker(resource, isJSFResource);
    }

    @Override
    public void initResources()
    {
        final IFolder folder = getRootResourceFolder();
        if (folder != null)
        {
            try
            {
                track(folder.getParent());
                track(folder);
            } catch (final Exception e1)
            {
                JSFCorePlugin
                        .log(e1,
                                "While trying to locate JSF resources in the workspace"); //$NON-NLS-1$
            }
            if (folder.isAccessible())
            {
                trackAllInFolder(folder);
            }
        }
    }

    private List<IWorkspaceJSFResourceFragment> trackAllInFolder(
            final IContainer folder)
    {
        final VisitorMatcher<IContainer, IResource, String> matcher = new VisitorMatcher<IContainer, IResource, String>(
                "", "", //$NON-NLS-1$ //$NON-NLS-2$
                new FileMatchingAcceptor(),
                Collections.singletonList(new AlwaysMatcher()));
        final List<IWorkspaceJSFResourceFragment> newFragments = new ArrayList<IWorkspaceJSFResourceFragment>();
        try
        {
            final Collection<? extends IResource> foundResources = matcher
                    .find(folder);
            for (final IResource res : foundResources)
            {
                try
                {
                    newFragments.add(track(res));
                } catch (final InvalidIdentifierException e)
                {
                    JSFCorePlugin.log(IStatus.INFO,
                        "Ignoring invalid JSF resource: "+res); //$NON-NLS-1$
                }
                catch (final ManagedObjectException e)
                {
                    JSFCorePlugin.log(e,
                        "Problem adding managed object for resource: "+res); //$NON-NLS-1$
                }
            }
        } catch (final Exception e)
        {
            JSFCorePlugin.log(e,
                    "While trying to locate JSF resources in the workspace"); //$NON-NLS-1$
        }
        return newFragments;
    }

    private IWorkspaceJSFResourceFragment track(final IResource res)
            throws ManagedObjectException, InvalidIdentifierException
    {
        final IPath fullPath = res.getFullPath().makeRelativeTo(
                getRootResourceFolder().getFullPath());
        // cause the resource to get tracked
        final JSFResourceTracker tracker = (JSFResourceTracker) getInstance(res);
        IWorkspaceJSFResourceFragment jsfRes = null;
        if (res.getType() == IResource.FILE)
        {
        	try
        	{
	            jsfRes = new WorkspaceJSFResource(
	                    _factory.createLibraryResource(fullPath.toString()), res,
	                    _contentTypeResolver);
        	}
        	catch (InvalidIdentifierException e)
        	{
        		// ensure that the tracker gets released before we throw the exception.
        		unmanageResource(res);
        		tracker.dispose();
        		throw e;
        	}
        } else
        {
            jsfRes = new WorkspaceJSFResourceContainer(
                    _factory.createLibraryFragment(fullPath.toString()),
                    (IContainer) res);
        }
        tracker.setJsfResource(jsfRes);
        addLifecycleEventListener(tracker);
        return jsfRes;
    }

    /**
     * @return the root folder for resources in the workspace.
     */
    public IFolder getRootResourceFolder()
    {
        final IVirtualFolder webContentFolder = _vcQuery
                .getWebContentFolder(_project);
        if (webContentFolder != null
                && webContentFolder.getUnderlyingFolder().isAccessible())
        {
            return webContentFolder.getUnderlyingFolder().getFolder(
                    new Path("resources")); //$NON-NLS-1$
        }
        return null;
    }

    @Override
    public List<IResource> getResources()
    {
        return new ArrayList(getManagedResources());
    }

    /**
     * @return the jsf resource currently known. List is a copy but the
     *         contained JSFResource references are not.
     */
    public List<IJSFResourceFragment> getJSFResources()
    {
        final List<IJSFResourceFragment> jsfResources = new ArrayList<IJSFResourceFragment>();
        final Map<IResource, ManagedResourceObject<ResourceTracker<IResource>>> jsfResourceTrackers = getPerResourceObjects();
        for (final Map.Entry<IResource, ManagedResourceObject<ResourceTracker<IResource>>> entry : jsfResourceTrackers
                .entrySet())
        {
            final JSFResourceTracker jsfResourceTracker = (JSFResourceTracker) entry
                    .getValue().getManagedObject();
            if (jsfResourceTracker.isJSFResource())
            {
                jsfResources.add(jsfResourceTracker.getJsfResource());
            }
        }
        return jsfResources;
    }

    private class JSFResourceTracker extends ResourceTracker<IResource>
    {
        private IWorkspaceJSFResourceFragment _jsfResource;
        private final boolean _isJSFResource;

        /**
         * @param resource
         * @param isJSFResource
         *            if false, indicates that the resource being tracked is
         *            related to JSF resources but not an actual JSF resource
         *            (i.e. web root).
         */
        public JSFResourceTracker(final IResource resource,
                final boolean isJSFResource)
        {
            super(resource);
            _isJSFResource = isJSFResource;
        }

        public boolean isJSFResource()
        {
            return _isJSFResource;
        }

        @Override
        protected void fireResourceInAccessible(
                final IResource affectedResource, final ReasonType reasonType)
        {
            if (reasonType == ReasonType.RESOURCE_DELETED_FROM_CONTAINER
                    || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER)
            {
                try
                {
                    final List<JSFResourceTracker> trackers = getTrackers(affectedResource);
                    for (final JSFResourceTracker tracker : trackers)
                    {
                        final IWorkspaceJSFResourceFragment jsfResource = tracker
                                .getJsfResource();
                        removeLifecycleEventListener(tracker);
                        _locator.fireChangeEvent(new JSFResourceChangedEvent(
                                _locator, jsfResource, null,
                                CHANGE_TYPE.REMOVED));
                    }
                } catch (final ManagedObjectException e)
                {
                    JSFCorePlugin.log(e,
                            "Processing an inaccessible resource event"); //$NON-NLS-1$
                }
            }
        }

        private List<JSFResourceTracker> getTrackers(final IResource res)
                throws ManagedObjectException
        {
            final JSFResourceTracker tracker = (JSFResourceTracker) getInstance(res);
            final List<JSFResourceTracker> allChildren = new ArrayList<JSFResourceTracker>();
            allChildren.add(tracker);
            if (res instanceof IContainer)
            {
                final IPath parentPath = res.getFullPath();
                for (final Entry<IResource, ManagedResourceObject<ResourceTracker<IResource>>> trackerEntry : getPerResourceObjects()
                        .entrySet())
                {
                    final IPath trackerPath = trackerEntry.getKey()
                            .getFullPath();
                    if (parentPath.isPrefixOf(trackerPath)
                            && !parentPath.equals(trackerPath))
                    {
                        allChildren.add((JSFResourceTracker) trackerEntry
                                .getValue().getManagedObject());
                    }
                }
            }
            return allChildren;
        }

        @Override
        protected void fireResourceChanged(final IResource affectedResource,
                final ReasonType reasonType)
        {
            _locator.fireChangeEvent(new JSFResourceChangedEvent(_locator,
                    _jsfResource, _jsfResource, CHANGE_TYPE.CHANGED));
        }

        @Override
        protected void fireResourceAdded(final IResource affectedResource,
                final ReasonType reasonType)
        {
            if (reasonType == ReasonType.RESOURCE_ADDED_TO_CONTAINER
                    || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER)
            {
                final IContainer parent = affectedResource.getParent();
                if (parent != null && parent.isAccessible())
                {
                    try
                    {
                        final IWorkspaceJSFResourceFragment newJsfRes = track(affectedResource);
                        fireNewJSFResourceEvent(newJsfRes);
                        if (reasonType == ReasonType.RESOURCE_MOVED_CONTAINER
                                && affectedResource instanceof IContainer)
                        {
                            final List<IWorkspaceJSFResourceFragment> newFragments = trackAllInFolder((IContainer) affectedResource);
                            for (final IWorkspaceJSFResourceFragment frag : newFragments)
                            {
                                fireNewJSFResourceEvent(frag);
                            }
                        }
                    } catch (final ManagedObjectException e)
                    {
                        JSFCorePlugin
                                .log(e,
                                        "While adding new resource " + affectedResource); //$NON-NLS-1$
                    } catch (final InvalidIdentifierException e)
                    {
                        JSFCorePlugin
                                .log(IStatus.INFO,
                                        "While adding new resource " + affectedResource); //$NON-NLS-1$
                    }
                }
            }
        }

        private void fireNewJSFResourceEvent(
                final IWorkspaceJSFResourceFragment newJsfRes)
        {
            final JSFResourceChangedEvent event = new JSFResourceChangedEvent(
                    _locator, null, newJsfRes, CHANGE_TYPE.ADDED);
            _locator.fireChangeEvent(event);
        }

        @Override
        protected boolean isInteresting(final ResourceLifecycleEvent event)
        {
            boolean isInteresting = false;
            final ReasonType reasonType = event.getReasonType();
            switch (event.getEventType())
            {
                case RESOURCE_ADDED:
                {
                    final IResource resource = getResource();
                    isInteresting = (reasonType == ReasonType.RESOURCE_ADDED_TO_CONTAINER || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER)
                            && event.getAffectedResource().getParent()
                                    .equals(resource);
                    // ignore if my resource is web content and this is trying
                    // to add something other than resources folder
                    if (resource.equals(_vcQuery.getWebContentFolder(_project)
                            .getUnderlyingFolder()))
                    {
                        isInteresting &= event.getAffectedResource().equals(
                                getRootResourceFolder());
                    }
                }
                break;
                case RESOURCE_INACCESSIBLE:
                {
                    final IResource resource = getResource();
                    // if the resource made inaccessible was deleted or moved
                    // from its container
                    // and it's parent is me, then it is interesting.
                    isInteresting = (reasonType == ReasonType.RESOURCE_DELETED_FROM_CONTAINER || reasonType == ReasonType.RESOURCE_MOVED_CONTAINER)
                            && event.getAffectedResource().getParent()
                                    .equals(resource);
                    // ignore if my resource is web content and this is trying
                    // to add something other than resources folder
                    if (resource.equals(_vcQuery.getWebContentFolder(_project)
                            .getUnderlyingFolder()))
                    {
                        isInteresting &= event.getAffectedResource().equals(
                                getRootResourceFolder());
                    }
//                    isInteresting &= (_isJSFResource || (resource.getType() == IResource.FOLDER && "resources".equals(resource.getName()))); //$NON-NLS-1$
                    // or if the resource being delted or moved is the root
                    // folder and that is my resource.
                    // isInteresting |= (reasonType ==
                    // ReasonType.RESOURCE_DELETED || reasonType ==
                    // ReasonType.RESOURCE_MOVED_CONTAINER)
                    // && (resource.equals(event.getAffectedResource()) &&
                    // resource.equals(getRootResourceFolder()));
                }
                break;
                default:
                    isInteresting = super.isInteresting(event);
            }
            return isInteresting;
        }

        public final IWorkspaceJSFResourceFragment getJsfResource()
        {
            return _jsfResource;
        }

        public final void setJsfResource(
                final IWorkspaceJSFResourceFragment jsfResource)
        {
            _jsfResource = jsfResource;
        }
    }
}