/*******************************************************************************
 * 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.jst.j2ee.internal.validation;


import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.URIConverter;
import org.eclipse.jst.j2ee.application.EjbModule;
import org.eclipse.jst.j2ee.application.Module;
import org.eclipse.jst.j2ee.application.WebModule;
import org.eclipse.jst.j2ee.applicationclient.creation.ApplicationClientNatureRuntime;
import org.eclipse.jst.j2ee.applicationclient.creation.IApplicationClientNatureConstants;
import org.eclipse.jst.j2ee.common.EjbRef;
import org.eclipse.jst.j2ee.common.MessageDestinationRef;
import org.eclipse.jst.j2ee.common.ResourceEnvRef;
import org.eclipse.jst.j2ee.common.ResourceRef;
import org.eclipse.jst.j2ee.common.SecurityRoleRef;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
import org.eclipse.jst.j2ee.commonarchivecore.internal.ModuleFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.ValidateXmlCommand;
import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveConstants;
import org.eclipse.jst.j2ee.commonarchivecore.internal.strategy.LoadStrategy;
import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
import org.eclipse.jst.j2ee.internal.J2EEConstants;
import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
import org.eclipse.jst.j2ee.internal.archive.operations.J2EEImportConstants;
import org.eclipse.jst.j2ee.internal.archive.operations.J2EELoadStrategyImpl;
import org.eclipse.jst.j2ee.internal.earcreation.EAREditModel;
import org.eclipse.jst.j2ee.internal.earcreation.EARNatureRuntime;
import org.eclipse.jst.j2ee.internal.earcreation.IEARNatureConstants;
import org.eclipse.jst.j2ee.internal.earcreation.ModuleMapHelper;
import org.eclipse.jst.j2ee.internal.earcreation.modulemap.ModuleMapping;
import org.eclipse.jst.j2ee.internal.earcreation.modulemap.UtilityJARMapping;
import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin;
import org.eclipse.jst.j2ee.internal.project.IEJBNatureConstants;
import org.eclipse.jst.j2ee.internal.project.IWebNatureConstants;
import org.eclipse.jst.j2ee.internal.project.J2EENature;
import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities;
import org.eclipse.jst.j2ee.model.internal.validation.EarValidator;
import org.eclipse.jst.j2ee.moduleextension.EarModuleManager;
import org.eclipse.jst.j2ee.moduleextension.WebModuleExtension;
import org.eclipse.jst.j2ee.webservice.wsclient.ServiceRef;
import org.eclipse.wst.common.internal.emfworkbench.WorkbenchResourceHelper;
import org.eclipse.wst.server.core.IRuntime;
import org.eclipse.wst.server.core.ServerCore;
import org.eclipse.wst.validation.core.IFileDelta;
import org.eclipse.wst.validation.core.IHelper;
import org.eclipse.wst.validation.core.IMessage;
import org.eclipse.wst.validation.core.IReporter;
import org.eclipse.wst.validation.core.Message;
import org.eclipse.wst.validation.core.MessageLimitException;
import org.eclipse.wst.validation.core.SeverityEnum;
import org.eclipse.wst.validation.core.ValidationException;

import com.ibm.wtp.common.logger.proxy.Logger;
import com.ibm.wtp.emf.workbench.ProjectUtilities;
import com.ibm.wtp.emf.workbench.WorkbenchURIConverter;


/**
 * Insert the type's description here. Creation date: (9/10/2001 2:11:02 PM)
 * 
 * @author: Administrator
 */
public class UIEarValidator extends EarValidator implements UIEarMessageConstants {
	public static final String VALIDATOR_ID = "org.eclipse.jst.j2ee.internal.validation.UIEarValidator"; //$NON-NLS-1$
	public static final String MANIFEST_GROUP_NAME = "WSAD.EAR.MANIFEST"; //$NON-NLS-1$
	protected UIEarHelper earHelper;
	protected EAREditModel earEditModel;
	private EARNatureRuntime earNature;

	/**
	 * UIEarValidator constructor comment.
	 */
	public UIEarValidator() {
		super();
	}

	public Command createValidateXMLCommand() {

		ValidateXmlCommand cmd = (ValidateXmlCommand) super.createValidateXMLCommand();
		cmd.setValidateNested(false);
		return cmd;
	}

	protected String getResourceName() {
		return ((EarHelper) _helper).getProject().getName();
	}

	protected void duplicateProjectMapError(String earProjectName, String moduleUri, String projectName) {

		String[] params = new String[3];
		params[0] = projectName;
		params[1] = earProjectName;
		params[2] = moduleUri;
		addError(getBaseName(), DUPLICATE_MODULE_FOR_PROJECT_NAME_ERROR_, params, appDD);
	}

	public EAREditModel getEAREditModel(IProject earProject) {
		EARNatureRuntime nature = getEarNature(earProject);
		setEarNature(nature);
		if (nature != null)
			return nature.getEarEditModelForRead(this);
		return null;
	}

	/**
	 *  
	 */
	protected void cleanUpSubTaskMessages(EObject ref) {
		String groupName = EJB_REF_GROUP_NAME;
		if (ref instanceof EjbRef)
			ref = (EjbRef) ref;
		else if (ref instanceof ResourceRef) {
			ref = (ResourceRef) ref;
			groupName = RES_REF_GROUP_NAME;
		} else if (ref instanceof ServiceRef) {
			ref = (ServiceRef) ref;
			groupName = SERVICE_REF_GROUP_NAME;
		} else if (ref instanceof ResourceEnvRef) {
			ref = (ResourceEnvRef) ref;
			groupName = RES_ENV_REF_GROUP_NAME;
		} else if (ref instanceof SecurityRoleRef) {
			ref = (SecurityRoleRef) ref;
			groupName = SEC_ROLE_REF_GROUP_NAME;
		} else if (ref instanceof MessageDestinationRef) {
			ref = (MessageDestinationRef) ref;
			groupName = MESSAGE_REF_GROUP_NAME;
		}
		Resource res = ref.eResource();
		if (res != null) {
			IFile file = WorkbenchResourceHelper.getFile(res);
			if (file != null)
				_reporter.removeMessageSubset(this, file, groupName);
		}
	}

	protected void cleanUpAllRefSubTaskMessages(Resource res) {
		if (res != null) {
			IFile file = WorkbenchResourceHelper.getFile(res);
			if (file != null)
				_reporter.removeMessageSubset(this, file, EJB_REF_GROUP_NAME);
			_reporter.removeMessageSubset(this, file, RES_REF_GROUP_NAME);
			_reporter.removeMessageSubset(this, file, SERVICE_REF_GROUP_NAME);
			_reporter.removeMessageSubset(this, file, SEC_ROLE_REF_GROUP_NAME);
			_reporter.removeMessageSubset(this, file, MESSAGE_REF_GROUP_NAME);
			_reporter.removeMessageSubset(this, file, RES_ENV_REF_GROUP_NAME);
		}
	}

	/**
	 * Gets the ear nature.
	 * 
	 * @param IProject
	 *            earProject - The current ear project.
	 * @return EARNatureRuntime
	 */
	public EARNatureRuntime getEarNature(IProject earProject) {
		return EARNatureRuntime.getRuntime(earProject);
	}// EARNatureRuntime

	/**
	 * Insert the method's description here. Creation date: (9/10/2001 2:56:32 PM)
	 * 
	 * @return org.eclipse.wst.validation.internal.core.core.ear.workbenchimpl.UIEarHelper
	 */
	public org.eclipse.jst.j2ee.internal.validation.UIEarHelper getEarHelper() {
		return earHelper;
	}

	protected void invalidClassPathEntryWarning(String entry, Archive anArchive) {
		String[] params = new String[2];
		params[0] = anArchive.getURI();
		params[1] = entry;
		addWarning(getBaseName(), INVALID_MANIFEST_CLASSPATH_ONE_WARN_, params, getManifestFile(anArchive), MANIFEST_GROUP_NAME);
	}

	protected void invalidClassPathEntryWarning(String entry, String resolvedEntry, Archive anArchive) {
		String[] params = new String[3];
		params[0] = anArchive.getURI();
		params[1] = entry;
		params[2] = resolvedEntry;
		addWarning(getBaseName(), INVALID_MANIFEST_CLASSPATH_TWO_WARN_, params, getManifestFile(anArchive), MANIFEST_GROUP_NAME);
	}

	protected void invalidDepedencyWarning(String entry, Archive anArchive, ModuleFile m) {
		String[] params = new String[3];
		params[0] = m.getURI();
		params[1] = entry;
		params[2] = anArchive.getURI();
		addWarning(getBaseName(), INVALID_MANIFEST_CLASSPATH_DEPENDENCY_WARN_, params, getManifestFile(anArchive), MANIFEST_GROUP_NAME);
	}

	/**
	 * Insert the method's description here. Creation date: (9/10/2001 2:56:32 PM)
	 * 
	 * @param newEarHelper
	 *            org.eclipse.wst.validation.internal.core.core.ear.workbenchimpl.UIEarHelper
	 */
	public void setEarHelper(org.eclipse.jst.j2ee.internal.validation.UIEarHelper newEarHelper) {
		earHelper = newEarHelper;
	}

	public void validate(IHelper inHelper, IReporter inReporter, IFileDelta[] changedFiles) throws ValidationException {
		inReporter.removeAllMessages(this);
		earHelper = (UIEarHelper) inHelper;
		earEditModel = null;
		try {
			earEditModel = getEAREditModel(earHelper.getProject());
			if (earEditModel != null) {
				super.validate(earHelper, inReporter, changedFiles);
				validateModuleMaps();
				validateManifests();
				validateUtilJarMaps();
				validateUriAlreadyExistsInEar();
				validateDocType();
			}

		} catch (ValidationException ex) {
			throw ex;
		} catch (Exception e) {
			String[] param = new String[1];
			IProject project = earHelper.getProject();
			if (project != null)
				param[0] = project.getName();
			Logger.getLogger().logError(e);
			IMessage errorMsg = new Message(getBaseName(), SeverityEnum.HIGH_SEVERITY, EAR_VALIDATION_INTERNAL_ERROR_UI_, param);
			throw new ValidationException(errorMsg, e);
		} finally {
			if (earEditModel != null)
				earEditModel.releaseAccess(this);
			//Shouldn't this be done in the super class?
			if (earFile != null)
				earFile.close();
		}
	}

	protected IProject getProject(Archive anArchive, EARFile earFileParam) {
		LoadStrategy loader = anArchive.getLoadStrategy();
		if (!(loader instanceof J2EELoadStrategyImpl))
			return ModuleMapHelper.getProject(anArchive.getURI(), earFileParam);

		return ((J2EELoadStrategyImpl) loader).getProject();
	}

	public void validateManifests() throws ValidationException {
		if (earFile == null)
			return;

		List archives = earFile.getArchiveFiles();
		for (int i = 0; i < archives.size(); i++) {
			try {
				Archive anArchive = (Archive) archives.get(i);
				IProject project = getProject(anArchive, earFile);
				if (project != null && project.isAccessible()) {
					IFile target = getManifestFile(anArchive);
					if (target != null)
						_reporter.removeMessageSubset(this, target, MANIFEST_GROUP_NAME);
					validateManifestCase(anArchive);
					validateManifestLines(anArchive);
					validateManifestClasspath(anArchive);
				}
			} catch (MessageLimitException me) {
			}
		}
	}

	public void validateManifestCase(Archive anArchive) {
		String mfuri = ArchiveConstants.MANIFEST_URI;

		//Indicates a manifest file with the valid name exists,
		//nothing left to do
		if (anArchive.containsFile(mfuri))
			return;

		//Otherwise iterate the list of files
		//Ensure the archive is read-only first
		anArchive.getOptions().setIsReadOnly(true);
		List files = anArchive.getFiles();
		String uri = null;
		for (int i = 0; i < files.size(); i++) {
			File aFile = (File) files.get(i);
			uri = aFile.getURI();
			if (mfuri.equalsIgnoreCase(uri) && !mfuri.equals(uri)) {
				String[] params = {uri, anArchive.getURI()};
				IResource target = earHelper.getProject().getFile(J2EEConstants.MANIFEST_URI);
				addError(getBaseName(), INVALID_CASE_FOR_MANIFEST_ERROR_, params, target);
			}
		}

	}

	public void validateManifestClasspath(Archive anArchive) throws ValidationException {

		String[] cp = anArchive.getManifest().getClassPathTokenized();
		for (int i = 0; i < cp.length; i++) {
			String uri = ArchiveUtil.deriveEARRelativeURI(cp[i], anArchive);
			if (uri == null) {
				invalidClassPathEntryWarning(cp[i], anArchive);
				continue;
			}
			File f = null;
			IFile rf = null;
			try {
				if (uri.endsWith(J2EEImportConstants.IMPORTED_JAR_SUFFIX)) {
					J2EENature projectNature = earEditModel.getEARNature().getModuleProject(anArchive.getURI());
					if (projectNature != null) {
						rf = projectNature.getProject().getFile(uri);
						if (rf == null || !rf.exists()) {
							invalidClassPathEntryWarning(cp[i], uri, anArchive);
						}
					}
				} else
					f = earFile.getFile(uri);
			} catch (java.io.FileNotFoundException ex) {
				invalidClassPathEntryWarning(cp[i], earFile.getURI(), anArchive);
				continue;
			}
			if (f != null && f.isArchive() && anArchive.isModuleFile()) {
				Archive archive = (Archive) f;
				ModuleFile m = (ModuleFile) anArchive;
				if (!ArchiveUtil.isValidDependency(archive, m))
					invalidDepedencyWarning(cp[i], archive, m);
			}
		}
	}


	protected void validateManifestLines(Archive anArchive) throws ValidationException {
		if (anArchive == null)
			return;
		InputStream is = null;
		try {
			is = anArchive.getInputStream(ArchiveConstants.MANIFEST_URI);
			ManifestLineValidator lineVal = new ManifestLineValidator(is);
			lineVal.validate();
			addErrorsIfNecessary(anArchive, lineVal);
		} catch (FileNotFoundException ex) {
			return;
		} catch (IOException ex) {
			handleManifestException(ex, anArchive);
		} finally {
			if (is != null)
				try {
					is.close();
				} catch (IOException ex) {
					handleManifestException(ex, anArchive);
				}
		}
	}

	protected void addErrorsIfNecessary(Archive anArchive, ManifestLineValidator mfVal) {
		if (!mfVal.hasErrors())
			return;
		IFile target = getManifestFile(anArchive);
		if (!mfVal.endsWithLineBreak())
			addFileEndError(anArchive, mfVal, target);
		int[] lines = mfVal.getLineNumbersExceedingLimit();
		for (int i = 0; i < lines.length; i++) {
			addLineLengthError(anArchive, target, lines[i]);
		}
	}

	protected void addLineLengthError(Archive anArchive, IFile target, int lineNo) {
		String[] args = new String[2];
		args[0] = Integer.toString(lineNo);
		args[1] = anArchive.getURI();
		if (target != null)
			addError(getBaseName(), MANIFEST_LINE_EXCEEDS_LENGTH_ERROR_, args, target, MANIFEST_GROUP_NAME, lineNo);
		else
			addError(getBaseName(), MANIFEST_LINE_EXCEEDS_LENGTH_ERROR_, args, null, MANIFEST_GROUP_NAME);
	}

	protected void addFileEndError(Archive anArchive, ManifestLineValidator mfVal, IFile target) {
		String[] args = new String[]{anArchive.getURI()};
		if (target != null)
			addError(getBaseName(), MANIFEST_LINE_END_ERROR_, args, getManifestFile(anArchive), MANIFEST_GROUP_NAME, mfVal.getLineCount());
		else
			addError(getBaseName(), MANIFEST_LINE_END_ERROR_, args, MANIFEST_GROUP_NAME);
	}

	protected void handleManifestException(IOException ex, Archive anArchive) throws ValidationException {
		Logger.getLogger().logError(ex);
		IMessage message = new Message(getBaseName(), SeverityEnum.HIGH_SEVERITY, ERROR_READING_MANIFEST_ERROR_, new String[]{anArchive.getURI()});
		throw new ValidationException(message, ex);
	}

	/**
	 * Validates utiljar maps
	 */
	public void validateUtilJarMaps() {

		List utilJarModules = earEditModel.getUtilityJARMappings();

		if (!utilJarModules.isEmpty() || !utilJarModules.isEmpty()) {
			for (int i = 0; i < utilJarModules.size(); i++) {

				UtilityJARMapping aUtilJar = (UtilityJARMapping) utilJarModules.get(i);

				if (aUtilJar != null) {
					IProject project = J2EEPlugin.getWorkspace().getRoot().getProject(aUtilJar.getProjectName());
					if (project != null) {
						if (!project.exists()) {
							String[] params = new String[]{project.getName(), aUtilJar.getUri(), earHelper.getProject().getName()};
							addWarning(getBaseName(), PROJECT_DOES_NOT_EXIST_WARN_, params);
						} else {
							validateModuleProjectForValidServerTarget(project);
							if (!project.isOpen()) {
								String[] params = new String[]{project.getName()};
								addWarning(getBaseName(), PROJECT_IS_CLOSED_WARN_, params);
							}

						}// if

					}// if
				}// if
			}// for
		}// if
		validateDuplicateUtilJars(earEditModel);
		validateUtilJarNameCollision(earEditModel);
		validateUtilJarContainsNoSpaces(earEditModel);
	}// validateUtilJarMaps

	/**
	 * Checks if the util jar contains spaces or not.
	 * 
	 * @param EAREditModel
	 *            earEditModel - The ear editmodel.
	 */
	protected void validateUtilJarContainsNoSpaces(EAREditModel earEditModelParam) {
		List utilJars = earEditModelParam.getUtilityJARMappings();

		if (utilJars == null)
			return;

		for (int i = 0; i < utilJars.size(); i++) {
			UtilityJARMapping utilModule = (UtilityJARMapping) utilJars.get(i);

			if (utilModule != null) {
				if (utilModule.getUri() != null && utilModule.getUri().indexOf(" ") != -1) { //$NON-NLS-1$
					String[] params = new String[1];
					params[0] = utilModule.getUri();
					addError(getBaseName(), URI_CONTAINS_SPACES_ERROR_, params, appDD);
				}// if
			}// if
		}// for

	}// validateUtilJarContainsNoSpaces

	/**
	 * Validates if the a util jar has the same name as another module.
	 * 
	 * @param EAREditModel
	 *            earEditModel - The ear editmodel.
	 */
	protected void validateUtilJarNameCollision(EAREditModel earEditModelParam) {
		List utilJars = earEditModelParam.getUtilityJARMappings();

		if (utilJars == null)
			return;

		for (int i = 0; i < utilJars.size(); i++) {
			UtilityJARMapping utilModule = (UtilityJARMapping) utilJars.get(i);

			if (utilModule != null) {
				if (earEditModelParam.moduleMappingExists(utilModule.getUri())) {

					String[] params = new String[]{utilModule.getUri(), earEditModelParam.getEARNature().getProject().getName()};
					addError(getBaseName(), MESSAGE_UTIL_URI_NAME_COLLISION_ERROR_, params);

				} else if (utilModule.getProjectName() != null || utilModule.getProjectName().length() != 0) {
					if (earEditModelParam.moduleMappingExists(utilModule.getProjectName())) {
						String[] params = new String[]{utilModule.getUri(), utilModule.getProjectName()};
						addError(getBaseName(), MESSAGE_UTIL_PROJECT_NAME_COLLISION_ERROR_, params);
					}// if
				}// if
			}// if
		}// for

	}// validateUtilJarNameCollision


	/**
	 * validate is there are duplicate util jars.
	 * 
	 * @param EAREditModel
	 *            earEditModel - The ear editmodel
	 */
	protected void validateDuplicateUtilJars(EAREditModel earEditModelParam) {
		List utilJars = earEditModelParam.getUtilityJARMappings();
		Set visitedUtilUri = new HashSet();
		if (utilJars == null)
			return;
		for (int i = 0; i < utilJars.size(); i++) {
			UtilityJARMapping utilModule = (UtilityJARMapping) utilJars.get(i);
			if (utilModule != null) {
				if (visitedUtilUri.contains(utilModule.getUri())) {
					String projectName = utilModule.getProjectName();
					duplicateUtilError(earEditModelParam.getEARNature().getProject().getName(), utilModule.getUri(), projectName);
				} else
					visitedUtilUri.add(utilModule.getUri());
			} // if
		} // for
	} // validateModuleMapsDuplicateUtil

	/**
	 * Creates an error for duplicate util jars.
	 * 
	 * @param String
	 *            earProjectName - The ears project name.
	 * @param String
	 *            moduleUri - The modules uri.
	 * @param String
	 *            projectName - The project name.
	 */
	protected void duplicateUtilError(String earProjectName, String moduleUri, String projectName) {
		String[] params = new String[3];
		params[0] = projectName;
		params[1] = earProjectName;
		params[2] = moduleUri;
		addError(getBaseName(), DUPLICATE_UTILJAR_FOR_PROJECT_NAME_ERROR_, params);
	}// duplicateUtilError

	public void validateModuleMaps() {
		EList modules = appDD.getModules();
		if (!modules.isEmpty()) {
			for (int i = 0; i < modules.size(); i++) {
				Module module = (Module) modules.get(i);
				ModuleMapping modMap = earEditModel.getModuleMapping(module);
				if (modMap == null) {
					String[] params = new String[]{module.getUri(), earHelper.getProject().getName()};
					addWarning(getBaseName(), MISSING_PROJECT_FORMODULE_WARN_, params);
				} else {
					String projectName = modMap.getProjectName();
					if (projectName == null || projectName.length() == 0) {
						String[] params = new String[]{module.getUri(), earHelper.getProject().getName()};
						addWarning(getBaseName(), MISSING_PROJECT_FORMODULE_WARN_, params);
					} else {
						IProject project = J2EEPlugin.getWorkspace().getRoot().getProject(projectName);
						if (!project.exists()) {
							String[] params = new String[]{project.getName(), module.getUri(), earHelper.getProject().getName()};
							addWarning(getBaseName(), PROJECT_DOES_NOT_EXIST_WARN_, params);
						} else if (!project.isOpen()) {
							String[] params = new String[]{project.getName()};
							addWarning(getBaseName(), PROJECT_IS_CLOSED_WARN_, params);
						} else {
							validateModuleProjectsForValidNature(module, project);
							validateModuleProjectForValidServerTarget(project);
						}
					}
				}
				validateModuleURIExtension(module);
			}
		}
		//validateEARServerTargetJ2EESpecLevel(earEditModel);
		validateModuleMapsDuplicateProjects(earEditModel);
	}


	/**
	 * @param project
	 */
	private void validateModuleProjectForValidServerTarget(IProject project) {
		IRuntime runtime = ServerCore.getProjectProperties(project).getRuntimeTarget();

		EARNatureRuntime nature = earEditModel.getEARNature();
		IProject earProject = nature.getProject();
		IRuntime earRuntime = ServerCore.getProjectProperties(earProject).getRuntimeTarget();
		if (earRuntime != null) {
			if (runtime != null) {
				if (runtime.getId() != earRuntime.getId())
					unmatachedServerTargetOnModuleWarning(project, earProject);
				//validateModuleServerTargetJ2EESpecLevel(project, runtime);
			} else {
				missingServerTargetOnModuleWarning(project, earProject);
			}
		} else if (runtime != null) {
			missingServerTargetOnEARWarning(project, earProject);
		}
	}

	private void missingServerTargetOnEARWarning(IProject project, IProject earProject) {
		String[] params = new String[]{earProject.getName(), project.getName()};
		addWarning(getBaseName(), NO_SERVER_TARGET_ON_EAR_WITH_MODULE_SERVER_TARGETS, params);
	}

	private void unmatachedServerTargetOnModuleWarning(IProject project, IProject earProject) {
		String[] params = new String[]{project.getName(), earProject.getName()};
		addWarning(getBaseName(), PROJECT_SERVER_TARGET_DOES_NOT_MATCH_EAR, params);
	}

	private void missingServerTargetOnModuleWarning(IProject project, IProject earProject) {
		String[] params = new String[]{project.getName(), earProject.getName()};
		addWarning(getBaseName(), NO_SERVER_TARGET_MODULE_IN_EAR_WITH_SERVER_TARGET, params);
	}

	/**
	 * @param earProject
	 *            TODO This validation is RAD specific hence needs to be moved to a the RAD layered
	 *            plugin references to this method are commented out
	 */
	private void validateEARServerTargetJ2EESpecLevel(EAREditModel editModel) {
		EARNatureRuntime nature = earEditModel.getEARNature();
		IProject earProject = nature.getProject();
		IRuntime earRuntime = ServerCore.getProjectProperties(earProject).getRuntimeTarget();
		if (earRuntime != null) {
			try {
				if (earProject.hasNature(IEARNatureConstants.NATURE_ID) && nature.getModuleVersion() == J2EEVersionConstants.J2EE_1_4_ID && !earRuntime.getRuntimeType().getVersion().equals("6.0")) { //$NON-NLS-1$
					String[] params = new String[]{earProject.getName(), earRuntime.getName()};
					addError(getBaseName(), INVALID_EAR_SERVER_TARGET_FOR_14_SPEC_LEVEL, params, earProject);
				}
			} catch (CoreException ce) {
				Logger.getLogger().logError(ce);
			}
		}
	}

	/**
	 * @param project
	 *            TODO This validation is RAD specific hence needs to be moved to a the RAD layered
	 *            plugin references to this method are commented out
	 */
	private void validateModuleServerTargetJ2EESpecLevel(IProject project, IRuntime runtime) {
		boolean is14SpecLevelProject = false;
		if (J2EENature.hasRuntime(project, new String[]{IWebNatureConstants.J2EE_NATURE_ID, IEJBNatureConstants.NATURE_ID, IApplicationClientNatureConstants.NATURE_ID})) {
			J2EENature j2eeNature = J2EENature.getRegisteredRuntime(project);
			is14SpecLevelProject = j2eeNature.getJ2EEVersion() == J2EEVersionConstants.J2EE_1_4_ID;
			if (is14SpecLevelProject && !runtime.getRuntimeType().getVersion().equals("6.0")) { //$NON-NLS-1$
				String[] params = new String[]{project.getName(), runtime.getName()};
				addError(getBaseName(), INVALID_MODULE_SERVER_TARGET_FOR_14_SPEC_LEVEL, params);
			}
		}
	}

	protected void validateModuleMapsDuplicateProjects(EAREditModel earEditModelParam) {
		java.util.List moduleMaps = earEditModelParam.getModuleMappings();
		java.util.Set visitedProjectNames = new java.util.HashSet();
		for (int i = 0; i < moduleMaps.size(); i++) {
			ModuleMapping map = (ModuleMapping) moduleMaps.get(i);
			if (map.getModule() != null) {
				String moduleUri = map.getModule().getUri();
				String earProjectName = earEditModelParam.getEARNature().getProject().getName();
				String projectName = map.getProjectName();
				if (visitedProjectNames.contains(projectName))
					duplicateProjectMapError(earProjectName, moduleUri, projectName);
				else
					visitedProjectNames.add(projectName);
			}
		}
	}

	protected void validateModuleURIExtension(Module module) {
		String newUri = module.getUri();
		if (newUri != null && newUri.length() > 0) {
			if (module instanceof EjbModule && !newUri.endsWith(".jar")) { //$NON-NLS-1$
				String[] params = new String[1];
				params[0] = module.getUri();
				IResource target = earHelper.getProject().getFile(ArchiveConstants.APPLICATION_DD_URI);
				addError(getBaseName(), INVALID_URI_FOR_MODULE_ERROR_, params, target);
			} else if (module instanceof WebModule && !newUri.endsWith(".war")) { //$NON-NLS-1$
				String[] params = new String[1];
				params[0] = module.getUri();
				IResource target = earHelper.getProject().getFile(ArchiveConstants.APPLICATION_DD_URI);
				addError(getBaseName(), INVALID_URI_FOR_MODULE_ERROR_, params, target);
			}
		}
	}

	public void validateModuleProjectsForValidNature(Module module, IProject project) {

		try {
			if (module.isWebModule()) {
				if (!project.hasNature(IWebNatureConstants.J2EE_NATURE_ID)) {
					String[] params = new String[2];
					params[0] = project.getName();
					params[1] = earHelper.getProject().getName();
					addWarning(getBaseName(), MISSING_WEBNATURE_FORMODULE_WARN_, params, appDD);
				} else {
					WebModuleExtension webExt = EarModuleManager.getWebModuleExtension();
					if (webExt != null && !(webExt.compareWebContextRoot(module, project))) {
						String[] params = new String[3];
						params[0] = module.getUri();
						params[1] = earHelper.getProject().getName();
						params[2] = project.getName();
						addWarning(getBaseName(), INVALID_CONTEXTROOT_WEBMODULE_WARN_, params, appDD);
					}
				}

			} else if (module.isEjbModule()) {
				if (!project.hasNature(IEJBNatureConstants.NATURE_ID)) {
					String[] params = new String[2];
					params[0] = project.getName();
					params[1] = earHelper.getProject().getName();
					addWarning(getBaseName(), MISSING_EJBNATURE_FORMODULE_WARN_, params);
				}
			} else if (module.isJavaModule()) {
				if (!ApplicationClientNatureRuntime.hasRuntime(project)) {
					String[] params = new String[2];
					params[0] = project.getName();
					params[1] = earHelper.getProject().getName();
					addWarning(getBaseName(), MISSING_CLIENTNATURE_FORMODULE_WARN_, params);
				}
			}
		} catch (org.eclipse.core.runtime.CoreException ce) {
			com.ibm.wtp.common.logger.proxy.Logger.getLogger().logError(ce);
		}

	}

	/*
	 * @see J2EEValidator#cleanup()
	 */
	public void cleanup() {
		if (earHelper != null)
			earHelper.closeEARFile();
	}

	protected IFile getManifestFile(Archive anArchive) {
		URIConverter conv = anArchive.getResourceSet().getURIConverter();
		if (conv instanceof WorkbenchURIConverter) {
			WorkbenchURIConverter wbConv = (WorkbenchURIConverter) conv;
			IContainer input = wbConv.getInputContainer();
			if (input == null)
				return null;
			IProject p = input.getProject();
			if (p == null || ProjectUtilities.isBinaryProject(p))
				return null;
			IFile result = J2EEProjectUtilities.getManifestFile(p);
			if (result != null && result.exists())
				return result;
		}
		return null;
	}

	/**
	 * Checks if the nature is consistent with doc type.
	 */
	protected void validateDocType() {
		//EARNatureRuntime nature = getEarNature(earHelper.getProject());
		EARNatureRuntime nature = getEarNature();
		if (nature == null)
			return;
		if (nature.getJ2EEVersion() >= J2EEVersionConstants.J2EE_1_3_ID && appDD.getVersionID() < J2EEVersionConstants.J2EE_1_3_ID) {
			String[] params = new String[3];
			params[0] = DOCTYPE_1_2;
			params[1] = getResourceName();
			params[2] = DOCTYPE_1_3;
			addError(getBaseName(), EAR_INVALID_DOC_TYPE_ERROR_, params, appDD);
		} else if (nature.getJ2EEVersion() < J2EEVersionConstants.J2EE_1_3_ID && appDD.getVersionID() >= J2EEVersionConstants.J2EE_1_3_ID) {
			String[] params = new String[3];
			params[0] = DOCTYPE_1_3;
			params[1] = getResourceName();
			params[2] = DOCTYPE_1_2;
			addError(getBaseName(), EAR_INVALID_DOC_TYPE_ERROR_, params, appDD);
		}// if
	}// validateDocType

	/**
	 * Validates that conflicting jar does not exist in the ear project.
	 */
	public void validateUriAlreadyExistsInEar() {

		List utilJars = earEditModel.getUtilityJARMappings();

		if (utilJars == null)
			return;

		for (int i = 0; i < utilJars.size(); i++) {
			UtilityJARMapping utilModule = (UtilityJARMapping) utilJars.get(i);

			if (utilModule != null && utilModule.getUri() != null) {
				IProject currentEARProject = earHelper.getProject();

				try {
					IFile exFile = currentEARProject.getFile(utilModule.getUri());
					if (exFile != null && exFile.exists()) {
						String[] params = new String[2];
						params[0] = utilModule.getUri();
						params[1] = currentEARProject.getName();
						addWarning(getBaseName(), URI_ALREADY_EXISTS_IN_EAR_WARN_, params, appDD);
					}// if
				} catch (IllegalArgumentException iae) {
					Logger.getLogger().logError(iae);
				}// try
			}// if
		}// for

	}// validateUriAlreadyExistsInEar

	private EARNatureRuntime getEarNature() {
		return earNature;
	}

	private void setEarNature(EARNatureRuntime runtime) {
		earNature = runtime;
	}

}// UIEarValidator