/*******************************************************************************
 * Copyright (c) 2003, 2007 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.jst.j2ee.componentcore.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyComponent;
import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyReceiver;
import org.eclipse.jst.common.jdt.internal.javalite.JavaCoreLite;
import org.eclipse.jst.j2ee.classpathdep.ClasspathDependencyUtil;
import org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants.DependencyAttributeType;
import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualArchiveComponent;
import org.eclipse.jst.j2ee.internal.common.classpath.J2EEComponentClasspathInitializer;
import org.eclipse.jst.j2ee.internal.common.classpath.J2EEComponentClasspathUpdater;
import org.eclipse.jst.j2ee.internal.modulecore.util.DummyClasspathDependencyContainerVirtualComponent;
import org.eclipse.jst.j2ee.internal.plugin.IJ2EEModuleConstants;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.jee.application.ICommonModule;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.ModuleCoreNature;
import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualFolder;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualReference;
import org.eclipse.wst.common.componentcore.internal.util.IComponentImplFactory;
import org.eclipse.wst.common.componentcore.internal.util.VirtualReferenceUtilities;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;

public class EARVirtualComponent extends VirtualComponent implements IComponentImplFactory, IClasspathDependencyReceiver {
	public static String [] EXTENSIONS_TO_IGNORE = new String [] {IJ2EEModuleConstants.JAR_EXT, ".zip", IJ2EEModuleConstants.RAR_EXT, IJ2EEModuleConstants.WAR_EXT };  //$NON-NLS-1$

	private IVirtualReference[] cachedReferences;
	private long depGraphModStamp;
	
	public EARVirtualComponent() {
		super();
	}

	public EARVirtualComponent(IProject aProject, IPath aRuntimePath) {
		super(aProject, aRuntimePath);
	}

	public IVirtualComponent createArchiveComponent(IProject aProject, String archiveLocation, IPath aRuntimePath) {
		return new J2EEModuleVirtualArchiveComponent(aProject, archiveLocation, aRuntimePath);
	}
	
	public IVirtualComponent createComponent(IProject aProject) {
		return new EARVirtualComponent(aProject, new Path("/")); //$NON-NLS-1$
	}

	public IVirtualFolder createFolder(IProject aProject, IPath aRuntimePath) {
		return new VirtualFolder(aProject, aRuntimePath);
	}

	@Override
	protected boolean shouldCacheReferences() {
		return true;
	}
	
	private List<IVirtualReference> getHardReferences(IVirtualComponent earComponent) {
		IVirtualReference[] comparison = super.getReferences(new HashMap<String, Object>());
		ArrayList<IVirtualReference> refs2 = new ArrayList<IVirtualReference>();
		refs2.addAll(Arrays.asList(comparison));
		return refs2;
	}

	@Override
	protected void customizeCreatedReference(IVirtualReference reference, Object dependentObject) {
		if( dependentObject instanceof ICommonModule )
			reference.setArchiveName(((ICommonModule) dependentObject).getUri());
		else 
			VirtualReferenceUtilities.INSTANCE.ensureReferencesHaveNames(new IVirtualReference[]{reference});
	}

	
	/**
	 * Returns the resulting list of referenced components based off the hard references and archives mapping to the root folder.
	 * 
	 * @param earComponent
	 * @param hardReferences
	 * @param membersToIgnore
	 * @return
	 */
	private static List getLooseArchiveReferences(EARVirtualComponent earComponent, List hardReferences) {
		return  getLooseArchiveReferences(earComponent, hardReferences, null, earComponent.getRootFolder());
	}
	
	private static List getLooseArchiveReferences(EARVirtualComponent earComponent, List hardReferences, List dynamicReferences, IVirtualFolder folder) {
		Map<EARVirtualComponent, List> cache = J2EEComponentClasspathInitializer.getLooseConfigCache();
		if (cache != null) {
			List list = cache.get(earComponent);
			if (list != null) {
				return list;
			}
		}
		List list = getLooseArchiveReferences2(earComponent, hardReferences, null, folder);
		if (cache != null) {
			cache.put(earComponent, list);
		}
		return list;
	}	
	
	private static List getLooseArchiveReferences2(EARVirtualComponent earComponent, List hardReferences, List dynamicReferences, IVirtualFolder folder) {
		List innerDynamicReferences = dynamicReferences;
		try {
			IVirtualResource[] members = folder.members();
			for (int i = 0; i < members.length; i++) {
				if (IVirtualResource.FILE == members[i].getType()) {
					if(isDynamicComponent((IVirtualFile)members[i])){
						IPath archiveFullPath = new Path(members[i].getRuntimePath().toString());
						boolean shouldInclude = true;
						for (int j = 0; j < hardReferences.size() && shouldInclude; j++) {
							IVirtualReference tmpRef = ((IVirtualReference) hardReferences.get(j));
							IPath tmpFullPath = tmpRef.getRuntimePath().append(tmpRef.getArchiveName());
							if( tmpFullPath.equals(archiveFullPath))
								shouldInclude = false;
						} 
						if (shouldInclude) {
							IResource iResource = members[i].getUnderlyingResource();
							IVirtualComponent dynamicComponent = ComponentCore.createArchiveComponent(earComponent.getProject(), VirtualArchiveComponent.LIBARCHIVETYPE + iResource.getFullPath().toString());
							IVirtualReference dynamicRef = ComponentCore.createReference(earComponent, dynamicComponent);
							((VirtualReference)dynamicRef).setDerived(true);
							dynamicRef.setArchiveName(archiveFullPath.lastSegment());
							dynamicRef.setRuntimePath(archiveFullPath.removeLastSegments(1));
							if (null == innerDynamicReferences) {
								innerDynamicReferences = new ArrayList();
							}
							innerDynamicReferences.add(dynamicRef);
						}
					}
				} else if(IVirtualResource.FOLDER == members[i].getType()){
					innerDynamicReferences = getLooseArchiveReferences2(earComponent, hardReferences, innerDynamicReferences, (IVirtualFolder)members[i]);
				}
			}
		} catch (CoreException e) {
			J2EEPlugin.logError(e);
		}
		return innerDynamicReferences;
	}
	public static boolean isDynamicComponent(IVirtualFile vFile){
		String archiveName = vFile.getName();
		for(int j = 0; j<EXTENSIONS_TO_IGNORE.length; j++){
			if(J2EEComponentClasspathUpdater.endsWithIgnoreCase(archiveName, EXTENSIONS_TO_IGNORE[j])){
				return true;
			}
		}
		return false;
	}

	@Override
	public IVirtualReference[] getReferences() {
		IVirtualReference[] cached = getCachedReferences();
		if (cached != null)
			return cached;
		List hardReferences = getHardReferences(this);
		List dynamicReferences = getLooseArchiveReferences(this, hardReferences);

		if (dynamicReferences != null) {
			hardReferences.addAll(dynamicReferences);
		}
		cachedReferences = (IVirtualReference[]) hardReferences.toArray(new IVirtualReference[hardReferences.size()]);
		return cachedReferences;
	}
	
	@Override
	public IVirtualReference[] getReferences(Map<String, Object> options) {
		Object refType = options.get(IVirtualComponent.REQUESTED_REFERENCE_TYPE);
		if( refType != null && IVirtualComponent.DISPLAYABLE_REFERENCES.equals(refType)) {
			List<IVirtualReference> hardReferences = getHardReferences(this);
			if( shouldAddClasspathDependencyDerivedReference()) {
					IVirtualComponent imported = 
						new DummyClasspathDependencyContainerVirtualComponent(getProject(), this);
					VirtualReference importedRef = new VirtualReference(this, imported);
					importedRef.setDependencyType(IVirtualReference.DEPENDENCY_TYPE_CONSUMES);
					importedRef.setDerived(true);
					hardReferences.add(importedRef);
			}
			return hardReferences.toArray(new IVirtualReference[hardReferences.size()]);
		}
		
		if( refType != null && (IVirtualComponent.NON_DERIVED_REFERENCES.equals(refType) || 
								IVirtualComponent.HARD_REFERENCES.equals(refType))) {
			List<IVirtualReference> hardReferences = getHardReferences(this);
			return hardReferences.toArray(new IVirtualReference[hardReferences.size()]);
		}
		return getReferences();
	}
	
	protected boolean shouldAddClasspathDependencyDerivedReference() {
		IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
		for( int i = 0; i < projects.length; i++ ) {
			try {
				if( projects[i].hasNature(JavaCoreLite.NATURE_ID) && ModuleCoreNature.isFlexibleProject(projects[i])) {
					Map <IClasspathEntry, IClasspathAttribute> results = 
						ClasspathDependencyUtil.getRawComponentClasspathDependencies(
							JavaCoreLite.create(projects[i]), 
									DependencyAttributeType.CLASSPATH_COMPONENT_DEPENDENCY);
					if( !results.isEmpty())
						return true;
				}
			} catch(CoreException ce) {
			}
		}
		return false;
	}
	
	// Returns cache if still valid or null
	public IVirtualReference[] getCachedReferences() {
		if (cachedReferences != null && checkIfStillValid())
			return cachedReferences;
		depGraphModStamp = IDependencyGraph.INSTANCE.getModStamp();
		return null;
	}

	private boolean checkIfStillValid() {
		return IDependencyGraph.INSTANCE.getModStamp() == depGraphModStamp;
	}
	
	@Override
	protected void clearCache() {
		super.clearCache();
		
		depGraphModStamp = IDependencyGraph.INSTANCE.getModStamp();
		cachedReferences = null;
	}

	public boolean canReceiveClasspathDependencies() {
		return true;
	}

	public IPath getClasspathFolderPath(IClasspathDependencyComponent component) {
		return Path.EMPTY;
	}
}