/***************************************************************************************************
 * Copyright (c) 2003, 2004 IBM 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: IBM Corporation - initial API and implementation
 **************************************************************************************************/
package org.eclipse.wst.common.componentcore.internal.resources;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

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.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.internal.ComponentResource;
import org.eclipse.wst.common.componentcore.internal.StructureEdit;
import org.eclipse.wst.common.componentcore.internal.WorkbenchComponent;
import org.eclipse.wst.common.componentcore.internal.impl.ResourceTreeNode;
import org.eclipse.wst.common.componentcore.internal.impl.ResourceTreeRoot;
import org.eclipse.wst.common.componentcore.resources.ComponentHandle;
import org.eclipse.wst.common.componentcore.resources.IVirtualContainer;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;

public abstract class VirtualContainer extends VirtualResource implements
		IVirtualContainer {

	public VirtualContainer(IProject aProject, String aName, IPath aRuntimePath) {
		super(aProject, aName, aRuntimePath);
	}

	public VirtualContainer(ComponentHandle aComponentHandle, IPath aRuntimePath) {
		super(aComponentHandle, aRuntimePath);
	}

	// TODO WTP:Implement this method
	public boolean exists(IPath path) {
		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$

	}

	/**
	 * @see IContainer#findMember(java.lang.String)
	 */
	public IVirtualResource findMember(String aChildName) {
		return findMember(new Path(aChildName), 0);
	}

	/**
	 * @see IContainer#findMember(java.lang.String, boolean)
	 */
	public IVirtualResource findMember(String aChildName, int searchFlags) {
		return findMember(new Path(aChildName), searchFlags);
	}

	/**
	 * @see IContainer#findMember(org.eclipse.core.runtime.IPath)
	 */
	public IVirtualResource findMember(IPath aChildPath) {
		return findMember(aChildPath, 0);
	}

	public IVirtualResource findMember(IPath aPath, int theSearchFlags) {

		StructureEdit structureEdit = null;
		Set virtualResources = null;
		try {

			structureEdit = StructureEdit.getStructureEditForRead(getProject());
			WorkbenchComponent component = structureEdit
					.findComponentByName(getComponentHandle().getName());
			ResourceTreeRoot root = ResourceTreeRoot
					.getDeployResourceTreeRoot(component);
			ComponentResource[] resources = root.findModuleResources(
					getRuntimePath().append(aPath),
					ResourceTreeNode.CREATE_NONE);

			if (resources.length != 0) {

				IResource platformResource = StructureEdit
						.getEclipseResource(resources[0]);
				if (platformResource != null) {
					switch (platformResource.getType()) {
					case IResource.FOLDER:
						return new VirtualFolder(getComponentHandle(),
								getRuntimePath().append(aPath));
					case IResource.FILE:
						return new VirtualFile(getComponentHandle(),
								getRuntimePath().append(aPath));
					}
				}
			}
		} finally {
			if (structureEdit != null)
				structureEdit.dispose();
		}
		return null;
	}

	/**
	 * @see IContainer#getFile(org.eclipse.core.runtime.IPath)
	 */
	public IVirtualFile getFile(IPath aPath) {
		return new VirtualFile(getComponentHandle(), getRuntimePath().append(
				aPath));
	}

	/**
	 * @see IContainer#getFolder(org.eclipse.core.runtime.IPath)
	 */
	public IVirtualFolder getFolder(IPath aPath) {
		return new VirtualFolder(getComponentHandle(), getRuntimePath().append(
				aPath));
	}

	/**
	 * @see IFolder#getFile(java.lang.String)
	 */
	public IVirtualFile getFile(String name) {
		return new VirtualFile(getComponentHandle(), getRuntimePath().append(
				name));
	}

	/**
	 * @see IFolder#getFolder(java.lang.String)
	 */
	public IVirtualFolder getFolder(String name) {
		return new VirtualFolder(getComponentHandle(), getRuntimePath().append(
				name));
	}

	/**
	 * @see IContainer#members()
	 */
	public IVirtualResource[] members() throws CoreException {
		return members(IResource.NONE);
	}

	/**
	 * @see IContainer#members(boolean)
	 */
	public IVirtualResource[] members(boolean includePhantoms)
			throws CoreException {
		return members(includePhantoms ? IGNORE_EXCLUSIONS : IResource.NONE);
	}

	/**
	 * @see IContainer#members(int)
	 */
	public IVirtualResource[] members(int memberFlags) throws CoreException {

		StructureEdit moduleCore = null;
		Set virtualResources = new HashSet();
		try {

			moduleCore = StructureEdit
					.getStructureEditForRead(getComponentHandle().getProject());
			WorkbenchComponent wbComponent = moduleCore
					.findComponentByName(getComponentHandle().getName());
			if (wbComponent != null) {
				ResourceTreeRoot root = ResourceTreeRoot
						.getDeployResourceTreeRoot(wbComponent);
				ComponentResource[] componentResources = root
						.findModuleResources(getRuntimePath(),
								ResourceTreeNode.CREATE_NONE);

				IResource realResource = null;
				IPath fullRuntimePath = null;
				IPath newRuntimePath = null;

				for (int componentResourceIndex = 0; componentResourceIndex < componentResources.length; componentResourceIndex++) {
					fullRuntimePath = componentResources[componentResourceIndex]
							.getRuntimePath();

					// exact match
					if (fullRuntimePath.equals(getRuntimePath())) {

						realResource = StructureEdit
								.getEclipseResource(componentResources[componentResourceIndex]);
						if (realResource.getType() == IResource.FOLDER) {
							IFolder realFolder = (IFolder) realResource;
							IResource[] realChildResources = realFolder
									.members(memberFlags);
							for (int realResourceIndex = 0; realResourceIndex < realChildResources.length; realResourceIndex++) {
								newRuntimePath = getRuntimePath().append(
										realChildResources[realResourceIndex]
												.getName());
								addVirtualResource(virtualResources,
										realChildResources[realResourceIndex],
										newRuntimePath);
							}
						} // An IResource.FILE would be an error condition (as
						// this is a container)

					} else { // fuzzy match
						newRuntimePath = getRuntimePath().append(
								fullRuntimePath.segment(getRuntimePath()
										.segmentCount()));

						if (fullRuntimePath.segmentCount() == 1) {
							realResource = StructureEdit
									.getEclipseResource(componentResources[componentResourceIndex]);
							if (realResource != null)
								addVirtualResource(virtualResources,
										realResource, newRuntimePath);
						} else if (fullRuntimePath.segmentCount() > 1) {
							virtualResources.add(new VirtualFolder(
									getComponentHandle(), newRuntimePath));
						}
					}

				}
			}

		} catch (Exception e) {
			if (virtualResources == null)
				return new IVirtualResource[0];
		} finally {
			if (moduleCore != null)
				moduleCore.dispose();
		}
		return (IVirtualResource[]) virtualResources
				.toArray(new IVirtualResource[virtualResources.size()]);
	}

	public IVirtualFile[] findDeletedMembersWithHistory(int depth,
			IProgressMonitor monitor) throws CoreException {
		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$
		// return null;
	}

	/**
	 * @see IFolder#createLink(org.eclipse.core.runtime.IPath, int,
	 *      org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void createLink(IPath aProjectRelativeLocation, int updateFlags,
			IProgressMonitor monitor) throws CoreException {

		StructureEdit moduleCore = null;
		boolean isRootFolder = false;
		try {
			IContainer resource = null;
			if (aProjectRelativeLocation.isRoot()) {
				resource = getProject();
			} else {
				resource = getProject().getFolder(aProjectRelativeLocation);
			}

			moduleCore = StructureEdit.getStructureEditForWrite(getProject());
			WorkbenchComponent component = moduleCore
					.findComponentByName(getComponent().getName());

			ResourceTreeRoot root = ResourceTreeRoot
					.getDeployResourceTreeRoot(component);
			ComponentResource[] resources = root.findModuleResources(
					getRuntimePath(), ResourceTreeNode.CREATE_NONE);

			if (resources.length == 0) {
				ComponentResource componentResource = moduleCore
						.createWorkbenchModuleResource(resource);
				componentResource.setRuntimePath(getRuntimePath());
				component.getResources().add(componentResource);
			} else {
				boolean foundMapping = false;
				for (int resourceIndx = 0; resourceIndx < resources.length
						&& !foundMapping; resourceIndx++) {
					if (aProjectRelativeLocation.equals(resources[resourceIndx]
							.getSourcePath()))
						foundMapping = true;
				}
				if (!foundMapping) {
					ComponentResource componentResource = moduleCore
							.createWorkbenchModuleResource(resource);
					componentResource.setRuntimePath(getRuntimePath());
					component.getResources().add(componentResource);
				}
			}
			createResource(resource, updateFlags, monitor);

		} finally {
			if (moduleCore != null) {
				moduleCore.saveIfNecessary(monitor);
				moduleCore.dispose();
			}
		}
	}

	public int getType() {
		return IVirtualResource.COMPONENT;
	}

	public IResource getUnderlyingResource() {
		return null;
	}

	public IResource[] getUnderlyingResources() {
		return NO_RESOURCES;
	}

	protected void doDeleteMetaModel(int updateFlags, IProgressMonitor monitor) {
		StructureEdit moduleCore = null;
		try {
			moduleCore = StructureEdit
					.getStructureEditForWrite(getComponentHandle().getProject());
			WorkbenchComponent component = moduleCore
					.findComponentByName(getComponentHandle().getName());
			moduleCore.getComponentModelRoot().getComponents()
					.remove(component);
		} finally {
			if (moduleCore != null) {
				moduleCore.saveIfNecessary(monitor);
				moduleCore.dispose();
			}
		}
	}

	protected void doDeleteRealResources(int updateFlags,
			IProgressMonitor monitor) throws CoreException {
		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$
	}

	/**
	 * @param virtualResources
	 * @param realResource
	 * @param newRuntimePath
	 */
	private void addVirtualResource(Set virtualResources,
			IResource realResource, IPath newRuntimePath) {
		if (realResource.getType() == IResource.FOLDER)
			virtualResources.add(new VirtualFolder(getComponentHandle(),
					newRuntimePath));
		else
			virtualResources.add(new VirtualFile(getComponentHandle(),
					newRuntimePath));
	}

	public IVirtualResource[] getResources(String aResourceType) {
		StructureEdit core = null;
		try {
			core = StructureEdit.getStructureEditForRead(getProject());
			String name = getComponentHandle().getName();
			WorkbenchComponent component = core.findComponentByName(name);
			List currentResources = component.getResources();
			List foundResources = new ArrayList();

			if (aResourceType != null) {
				for (Iterator iter = currentResources.iterator(); iter
						.hasNext();) {
					ComponentResource resource = (ComponentResource) iter
							.next();
					if (aResourceType.equals(resource.getResourceType())) {
						IVirtualResource vres = createVirtualResource(resource);
						if (vres != null)
							foundResources.add(vres);
					}
				}
			}
			return (IVirtualResource[]) foundResources
					.toArray(new IVirtualResource[foundResources.size()]);
		} finally {
			if (core != null)
				core.dispose();
		}
	}

	private IVirtualResource createVirtualResource(
			ComponentResource aComponentResource) {
		IResource resource = StructureEdit
				.getEclipseResource(aComponentResource);
		switch (resource.getType()) {
		case IResource.FILE:
			return ComponentCore.createFile(getProject(), getName(),
					aComponentResource.getRuntimePath());
		case IResource.FOLDER:
			return ComponentCore.createFolder(getProject(), getName(),
					aComponentResource.getRuntimePath());
		}
		return null;
	}
}