/*******************************************************************************
 * Copyright (c) 2001, 2008 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.validation.internal.operations;


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

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.wst.validation.internal.FilterUtil;
import org.eclipse.wst.validation.internal.InternalValidatorManager;
import org.eclipse.wst.validation.internal.RegistryConstants;
import org.eclipse.wst.validation.internal.ResourceConstants;
import org.eclipse.wst.validation.internal.ResourceHandler;
import org.eclipse.wst.validation.internal.ValidationRegistryReader;
import org.eclipse.wst.validation.internal.ValidatorMetaData;


/**
 * Run some validators on a given IProject. Any validators which cannot be loaded or which are not
 * registered against this type of project will be ignored.
 * 
 * This operation is not intended to be subclassed outside of the validation framework.
 */
public class ValidatorSubsetOperation extends ValidationOperation {
	// By default, assume that there is no default fallback extension
	protected static final String DEFAULT_DEFAULTEXTENSION = null; 

	/**
	 * Create an operation that runs a full validation on the named validators either if validation
	 * needs to (@see ValidatorSubsetOperation(IProject)) or if <code>force</code> is true.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, boolean force, boolean async) {
		this(project, force, RegistryConstants.ATT_RULE_GROUP_DEFAULT, async);
	}

	/**
	 * Create an operation that runs a full validation on the named validators using the
	 * <code>ruleGroup</code> pass. Use this constructor only if you want to run a validator that
	 * supports the two passes: FAST and FULL.
	 * 
	 * If force is true, validation is run whether or not it needs to.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, IWorkbenchContext aWorkenchContext, boolean force, int ruleGroup, boolean async) {
		super(project, aWorkenchContext, null, null, ruleGroup, force, async);
	}
	

	/**
	 * Create an operation that runs a full validation on the named validators using the
	 * <code>ruleGroup</code> pass. Use this constructor only if you want to run a validator that
	 * supports the two passes: FAST and FULL.
	 * 
	 * If force is true, validation is run whether or not it needs to.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, boolean force, int ruleGroup, Object[] changedResources, boolean async) {
		super(project, null, null, ruleGroup, force, async);
		setEnabledValidators(ValidatorManager.getManager().getManualEnabledValidators(project));
		setFileDeltas(FilterUtil.getFileDeltas(getEnabledValidators(), changedResources, false));
	}
	
	/**
	 * Create an operation that runs a full validation on the named validators using the
	 * <code>ruleGroup</code> pass. Use this constructor only if you want to run a validator that
	 * supports the two passes: FAST and FULL.
	 * 
	 * If force is true, validation is run whether or not it needs to.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, boolean force, int ruleGroup, boolean async) {
		super(project, null, null, ruleGroup, force, async);
	}

	/**
	 * The fileExtension parameter must be ".X", where X is the extension. Do not type "*.X" or "X"
	 * (i.e., without the dot). The parameter could also be the file name, e.g. "foo.X".
	 * 
	 * This constructor should be used when the invoker wishes to force validation on certain
	 * resources, without waiting for the user to save their changes.
	 * 
	 * An IllegalArgumentException is thrown if there are no validators registered for the
	 * fileExtension on the given IProject.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, String fileExtension, Object[] changedResources, boolean async) throws IllegalArgumentException {
		this(project, fileExtension, DEFAULT_DEFAULTEXTENSION, changedResources, async);
	}

	/**
	 * The fileExtension parameter must be ".X", where X is the extension. Do not type "*.X" or "X"
	 * (i.e., without the dot). The parameter could also be the file name, e.g. "foo.X".
	 * 
	 * This constructor should be used when the invoker wishes to force validation on certain
	 * resources, without waiting for the user to save their changes.
	 * 
	 * If there are no validators configured on files named ".X", then use the validators configured
	 * on validators named ".Y", where defaultExtension identifies the fallback extension to use.
	 * defaultExtension follows the same syntax as fileExtension.
	 * 
	 * An IllegalArgumentException is thrown if there are no validators registered for the
	 * fileExtension or defaultExtension on the given IProject.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, String fileExtension, String defaultExtension, Object[] changedResources, boolean async) throws IllegalArgumentException {
		super(project, shouldForce(changedResources), async);

		// force the resources to be filtered in even if the validator doesn't normally take them?
		boolean filterIn = false; 
		
		// a list of validators which are configured to run on files with that extension.
		// A validator will be in the list whether it has been enabled or disabled by the user.
		ValidatorMetaData[] vmds = InternalValidatorManager.getManager().getValidatorsForExtension(project, fileExtension);
		if ((defaultExtension != null) && ((vmds == null) || (vmds.length == 0))) {
			filterIn = true;
			vmds = InternalValidatorManager.getManager().getValidatorsForExtension(project, defaultExtension);
		}

		if ((vmds == null) || (vmds.length == 0)) {
			throw new IllegalArgumentException();
		}

		setEnabledValidators(InternalValidatorManager.wrapInSet(vmds));

		// construct an array of IFileDelta[] to wrap the Object[];
		// one IFileDelta for each Object in the array
		setFileDeltas(FilterUtil.getFileDeltas(getEnabledValidators(), changedResources, filterIn));
	}

	/**
	 * This constructor is provided for the validation async testing, and is not intended to be
	 * called outside the validation framework.
	 * 
	 * Run validation on the changed resources with the given validators. All resources must be from
	 * the same project; if they're not, an IllegalArgumentException will be thrown. All validators
	 * must be able to run on the resources' project; if not, an IllegalArgumentException will be
	 * thrown. If the vmds are either empty or null, an IllegalArgumentExeption will be thrown. If
	 * the project is closed or doesn't exist then an IllegalArgumentException will be thrown.
	 * 
	 * The ifileDeltaType is one of the IFileDelta constants: ADDED, CHANGED, or DELETED.
	 * 
	 * IProject must exist and be open.
	 * 
	 * If async is true, the validation will run all thread-safe validators in the background
	 * validation thread, and all other validators in the main thread. If async is false, all
	 * validators will run in in the main thread.
	 */
	public ValidatorSubsetOperation(IProject project, ValidatorMetaData[] vmds, IResource[] changedResources, int ifileDeltaType, boolean force, boolean async) throws IllegalArgumentException {
		// Have to have the IProject as a parameter because ValidationOperation needs the IProject,
		// and the super(..)
		// must be called before anything else in this constructor is called.
		super(project, force, async);

		if ((vmds == null) || (vmds.length == 0)) {
			throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_BADVMD));
		}

		if (!project.isOpen()) {
			throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_OPENPRJ, new String[]{project.getName()}));
		}
		if (!project.exists()) {
			throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_EXISTPRJ, new String[]{project.getName()}));
		}

		if ((changedResources != null) && (changedResources.length > 0)) {
			Set<IProject> tempSet = new HashSet<IProject>();
			for (int i = 0; i < changedResources.length; i++) {
				IProject p = changedResources[i].getProject();
				if (!p.isOpen()) {
					throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_OPENPRJ, new String[]{p.getName()}));
				}
				if (!p.exists()) {
					throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_EXISTPRJ, new String[]{p.getName()}));
				}
				tempSet.add(project);
			}

			if (!tempSet.contains(project)) {
				throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_BADPRJ, new String[]{project.getName()}));
			}
			if (tempSet.size() != 1) {
				StringBuffer buffer = new StringBuffer("\n"); //$NON-NLS-1$
				Iterator<IProject> iterator = tempSet.iterator();
				while (iterator.hasNext()) {
					IProject p = iterator.next();
					buffer.append("\t"); //$NON-NLS-1$
					buffer.append(p.getName());
					if (iterator.hasNext()) {
						buffer.append(", "); //$NON-NLS-1$
					}
				}
				throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_MULTIPRJ, new String[]{buffer.toString()}));
			}
		}

		for (int i = 0; i < vmds.length; i++) {
			ValidatorMetaData vmd = vmds[i];
			if (!ValidationRegistryReader.getReader().isConfiguredOnProject(vmd, project)) {
				throw new IllegalArgumentException(ResourceHandler.getExternalizedMessage(ResourceConstants.VBF_EXC_BADVAL, new String[]{vmd.getValidatorDisplayName(), project.getName()}));
			}
		}

		setEnabledValidators(InternalValidatorManager.wrapInSet(vmds));
		setFileDeltas(FilterUtil.getFileDeltas(getEnabledValidators(), changedResources, ifileDeltaType)); // construct
		// an array of IFileDelta[] to wrap the IResource[]; one IFileDelta for each IResource in the array
	}

	/**
	 * Given an array of fully-qualified class names of validators, create the list of validators to
	 * be run. The array is not checked for duplicates or for invalid validators (i.e., a validator
	 * of that class type is not loaded, or the validator is loaded but cannot run against this type
	 * of IProject.)
	 */
	public void setValidators(String[] validatorNames) throws IllegalArgumentException {
		Set<ValidatorMetaData> enabled = new HashSet<ValidatorMetaData>();
		for (String name : validatorNames) {
			ValidatorMetaData vmd = ValidationRegistryReader.getReader().getValidatorMetaData(name);
			if (vmd == null) {
				// No validator, with that plug-in id, can be run on that project.
				// Either the validator isn't installed, or the IProject passed in
				// doesn't have the necessary nature.
				throw new IllegalArgumentException(name);
			}
			enabled.add(vmd);
		}
		setEnabledValidators(enabled);
	}

	/**
	 * @deprecated Will be removed in Milestone 3. Use setForce(boolean)
	 */
	public void setAlwaysRun(boolean force) {
		setForce(force);
	}
}