/*******************************************************************************
 * 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.List;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceChangeEvent;
import org.eclipse.core.resources.IResourceChangeListener;
import org.eclipse.core.resources.IResourceDelta;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.jst.jsf.common.internal.ITestTracker;
import org.eclipse.jst.jsf.common.internal.ITestTracker.Event;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.EventType;
import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.ReasonType;

/**
 * Listens to resource changes and fires lifecycle events
 * 
 * @author cbateman
 * 
 */
public class LifecycleListener extends
        AbstractLifecycleListener<ResourceLifecycleEvent, IResourceLifecycleListener, IResource>
        implements IResourceChangeListener
{
    private static boolean ENABLE_TEST_TRACKING = false;
    private static long _seqId;
    private ITestTracker _testTracker; // ==
    final IWorkspace _workspace;

    // null;
    // initialized
    // by
    // setter
    // injection
    /**
     * Initialize an inactive lifecycle listener. A workspace listener will not
     * be installed by this constructor. The object created using this
     * constructor will not fire any events until addResource is called at least
     * once to add a target resource
     * 
     * @param workspace
     *            the workspace to listen to for changes.
     * @throws NullPointerException
     *             if workspace is null.
     */
    public LifecycleListener(final IWorkspace workspace)
    {
        super();
        if (workspace == null)
        {
            throw new NullPointerException(CANNOT_ADD_NULL_RESOURCE);
        }
        _workspace = workspace;
    }

    /**
     * Create a new lifecycle listener for the res
     * 
     * @param res
     * @param workspace
     *            the workspace to listen to for changes.
     * @throws NullPointerException
     *             if res or workspace is null.
     */
    public LifecycleListener(final IResource res, final IWorkspace workspace)
    {
        this(workspace);
        if (res == null)
        {
            throw new NullPointerException(CANNOT_ADD_NULL_RESOURCE);
        }
        addResource(res);
    }

    /**
     * @param resources
     * @param workspace
     *            the workspace to listen to for changes.
     * @throws NullPointerException
     *             if resources, a member of resources or workspace is null.
     */
    public LifecycleListener(final List<IResource> resources,
            final IWorkspace workspace)
    {
        this(workspace);
        for (final IResource resource : resources)
        {
            if (resource != null)
            {
                addResource(resource);
            } else
            {
                throw new NullPointerException(CANNOT_ADD_NULL_RESOURCE);
            }
        }
    }

    @Override
    protected void addSystemChangeListener()
    {
        _workspace.addResourceChangeListener(this);
    }

    @Override
    protected void removeSystemChangeListener()
    {
        _workspace.removeResourceChangeListener(this);
    }

    /**
     * @param testTracker
     */
    public final void setTestTracker(final ITestTracker testTracker)
    {
        _testTracker = testTracker;
    }

    /**
     * @param newValue
     */
    protected final void setEnableTracing(final boolean newValue)
    {
        ENABLE_TEST_TRACKING = newValue;
    }

    /**
     * @param res
     *            a resource you want to receive events for. MUST NOT BE NULL.
     * @throw {@link NullPointerException} if res is null
     */
    public void addResource(final IResource res)
    {
        addLifecycleObject(res);
    }

    public void resourceChanged(final IResourceChangeEvent event)
    {
        final long seqId = _seqId++;
        if (_testTracker != null && ENABLE_TEST_TRACKING)
        {
            _testTracker.fireEvent(Event.START_TRACKING, seqId,
                    "trackMethod_resourceChanged"); //$NON-NLS-1$
        }
        assert (!isDisposed());
        switch (event.getType())
        {
            case IResourceChangeEvent.PRE_CLOSE:
            {
                final IProject proj = (IProject) event.getResource();
                // must use iterator to ensure copy on write behaviour
                for (final IResource res : getLifecycleObjects())
                {
                    if (proj == res || proj == res.getProject())
                    {
                        fireLifecycleEvent(new ResourceLifecycleEvent(this,
                                res, EventType.RESOURCE_INACCESSIBLE,
                                ReasonType.RESOURCE_PROJECT_CLOSED));
                    }
                }
            }
            break;
            case IResourceChangeEvent.PRE_DELETE:
            {
                final IProject proj = (IProject) event.getResource();
                // must use iterator to ensure copy on write behaviour
                for (final IResource res : getLifecycleObjects())
                {
                    // if the resource being tracked is the resource being
                    // deleted,
                    // then fire a resource delete event
                    if (proj == res)
                    {
                        fireLifecycleEvent(new ResourceLifecycleEvent(this,
                                res, EventType.RESOURCE_INACCESSIBLE,
                                ReasonType.RESOURCE_DELETED));
                    }
                    // if the resource being tracked is a resource in the
                    // project being
                    // deleted, then fire a project deleted event
                    else if (proj == res.getProject())
                    {
                        fireLifecycleEvent(new ResourceLifecycleEvent(this,
                                res, EventType.RESOURCE_INACCESSIBLE,
                                ReasonType.RESOURCE_PROJECT_DELETED));
                    }
                }
            }
            break;
            case IResourceChangeEvent.POST_CHANGE:
            {
                for (final IResource res : getLifecycleObjects())
                {
                    IResourceDelta delta = event.getDelta();
                    // only care about post change events to resources
                    // that we are tracking
                    if (delta != null)
                    {
                        delta = delta.findMember(res.getFullPath());
                        if (delta != null)
                        {
                            visit(delta);
                        }
                    }
                }
            }
            break;
            default:
                // do nothing
                // we only handle these three
        }
        if (ENABLE_TEST_TRACKING && _testTracker != null)
        {
            _testTracker.fireEvent(Event.STOP_TRACKING, seqId,
                    "trackMethod_resourceChanged"); //$NON-NLS-1$
        }
    }

    private void visit(final IResourceDelta delta)
    {
        assert (!isDisposed());
        final IResource res = delta.getResource();
        // the wkspace root is a special case since even though
        // it is registered as the target resource, we are interested
        // in new projects created in the root
        if (res.getType() == IResource.ROOT)
        {
            handleWorkspaceRoot(delta);
        } else if (res instanceof IContainer)
        {
            handleContainer(delta, res);
        } else
        {
            handleFile(delta, res);
        }
    }

    private void handleContainer(final IResourceDelta delta, IResource container)
    {
        handleChange(delta, container, container);
        for (final IResourceDelta childDelta : delta.getAffectedChildren())
        {
            if (childDelta.getResource().getType() == IResource.FILE
                    || childDelta.getResource().getType() == IResource.FOLDER)
            {
                handleChange(childDelta, childDelta.getResource(), container);
            }
        }
    }

    private void handleFile(final IResourceDelta delta, final IResource res)
    {
        switch (delta.getKind())
        {
            case IResourceDelta.ADDED:
            case IResourceDelta.REMOVED:
            {
                handleChange(delta, res, res);
            }
            break;
            case IResourceDelta.CHANGED:
            {
                // the contents of the file have changed
                if ((delta.getFlags() & IResourceDelta.CONTENT) != 0)
                {
                    fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                            EventType.RESOURCE_CHANGED,
                            ReasonType.RESOURCE_CHANGED_CONTENTS));
                }
            }
            break;
        }
    }

    private void handleChange(final IResourceDelta delta, final IResource res,
            final IResource interestedResource)
    {
        switch (delta.getKind())
        {
            case IResourceDelta.ADDED:
            {
                handleAdd(delta, res, interestedResource);
            }
            break;
            case IResourceDelta.REMOVED:
            {
                handleRemove(delta, res, interestedResource);
            }
            break;
        }
    }

    private void handleRemove(final IResourceDelta delta, final IResource res,
            final IResource interestedResource)
    {
        if ((delta.getFlags() & IResourceDelta.MOVED_TO) != 0)
        {
            if (res.equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_INACCESSIBLE,
                        ReasonType.RESOURCE_MOVED));
            } else if (res.getParent().equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_INACCESSIBLE,
                        ReasonType.RESOURCE_MOVED_CONTAINER));
            }
        } else
        {
            if (res.equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_INACCESSIBLE,
                        ReasonType.RESOURCE_DELETED));
            } else if (res.getParent().equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_INACCESSIBLE,
                        ReasonType.RESOURCE_DELETED_FROM_CONTAINER));
            }
        }
    }

    private void handleAdd(final IResourceDelta delta, final IResource res,
            final IResource interestedResource)
    {
        if ((delta.getFlags() & IResourceDelta.MOVED_FROM) != 0)
        {
            if (res.equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_ADDED, ReasonType.RESOURCE_MOVED));
            } else if (res.getParent().equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_ADDED,
                        ReasonType.RESOURCE_MOVED_CONTAINER));
            }
        } else
        {
            if (res.equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_ADDED, ReasonType.RESOURCE_ADDED));
            } else if (res.getParent().equals(interestedResource))
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_ADDED,
                        ReasonType.RESOURCE_ADDED_TO_CONTAINER));
            }
        }
    }

    private void handleWorkspaceRoot(final IResourceDelta delta)
    {
        for (final IResourceDelta childDelta : delta
                .getAffectedChildren(IResourceDelta.ADDED|IResourceDelta.CHANGED))
        {
            final IResource res = childDelta.getResource();
            if ((childDelta.getFlags() & IResourceDelta.OPEN) != 0 &&
            // project was just opened
                    res.getType() == IResource.PROJECT)
            {
                fireLifecycleEvent(new ResourceLifecycleEvent(this, res,
                        EventType.RESOURCE_ADDED, ReasonType.PROJECT_OPENED));
            }
        }
    }
}