/*******************************************************************************
 * Copyright (c) 2005, 2020 Texas Instruments Incorporated and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Texas Instruments - initial API and implementation
 *     IBM Corporation
 *     ArSysOp - rework to typed collections to fix type safety warnings
 *******************************************************************************/

package org.eclipse.cdt.managedbuilder.ui.wizards;

import java.lang.reflect.InvocationTargetException;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.wizard.IWizardPage;

/**
 *   This class is responsible for storing all of the data associated with a given custom wizard page.
 */
public final class MBSCustomPageData {

	private Set<String> natureSet = null;

	private Set<ToolchainData> toolchainSet = null;

	private Set<String> projectTypeSet = null;

	private IWizardPage wizardPage = null;

	private IRunnableWithProgress operation = null;

	private String id = null;

	private boolean isStock = false;

	/**
	 *  Stores data on a particular toolchain that a custom wizard page supports.
	 */
	public class ToolchainData implements Comparable {
		private String id = null;

		private String[] versionsSupported = null;

		/**
		 * @param id The id to set.
		 * @since 3.0
		 */
		public void setId(String id) {
			this.id = id;
		}

		/**
		 * @return Returns the id.
		 * @since 3.0
		 */
		public String getId() {
			return id;
		}

		/**
		 * @param versionsSupported The versionsSupported to set.
		 * @since 3.0
		 */
		public void setVersionsSupported(String[] versionsSupported) {
			this.versionsSupported = versionsSupported;
		}

		/**
		 * @return Returns the versionsSupported.
		 * @since 3.0
		 */
		public String[] getVersionsSupported() {
			return versionsSupported;
		}

		/**
		 *
		 */
		@Override
		public int compareTo(Object arg0) {
			if (arg0 == null || !(arg0 instanceof ToolchainData))
				return 0;
			ToolchainData other = (ToolchainData) arg0;
			return this.id.compareTo(other.id);
		}

		/* (non-Javadoc)
		* @see java.lang.Object#equals(java.lang.Object)
		*/
		@Override
		public boolean equals(Object obj) {
			if (obj == null || !(obj instanceof ToolchainData))
				return false;
			if (this == obj) {
				return true;
			}
			return this.id.equals(((ToolchainData) obj).id);
		}

	}

	/**
	 * Contstructs a custom page data record
	 *
	 * @param id - Unique ID of the page
	 * @param wizardPage - the IWizardPage that is displayed in the wizard
	 * @param operation - the Runnable() that is executed during the wizard's DoRunEpilogue() method, or null if no operation is specified
	 * @param isStock - true if the page is a stock page provided by Managed Build, false otherwise.
	 * @since 3.0
	 */
	public MBSCustomPageData(String id, IWizardPage wizardPage, Runnable operation, boolean isStock) {
		this(id, wizardPage, convertRunnable(operation), isStock);
	}

	/**
	 * Contstructs a custom page data record
	 *
	 * @param id - Unique ID of the page
	 * @param wizardPage - the IWizardPage that is displayed in the wizard
	 * @param operation - the Runnable() that is executed during the wizard's DoRunEpilogue() method, or null if no operation is specified
	 * @param isStock - true if the page is a stock page provided by Managed Build, false otherwise.
	 * @since 3.0
	 */
	public MBSCustomPageData(String id, IWizardPage wizardPage, IRunnableWithProgress operation, boolean isStock) {

		this.id = id;
		this.wizardPage = wizardPage;
		this.operation = operation;
		this.isStock = isStock;
	}

	/**
	 * @return The unique ID by which this page is referred to.
	 * @since 3.0
	 */
	public String getID() {
		return id;
	}

	/**
	 * @return The IWizardPage corresponding to the actual page to be displayed in the wizard.
	 * @since 3.0
	 */
	public IWizardPage getWizardPage() {
		return wizardPage;
	}

	/**
	 * @return true if this page is a stock page provided by the Managed Build System, false otherwise.
	 * @since 3.0
	 */
	public boolean isStockPage() {

		return isStock;
	}

	/**
	 * @param nature A fully qualified nature ID (org.eclipse.core.resources.IProjectNature).  Currently MBS
	 * 				 only supports creating projects with either one of two natures:
	 * 				 org.eclipse.cdt.core.cnature and org.eclipse.cdt.core.ccnature
	 * @return true if the page should be visible when the project has the given nature, false otherwise.
	 * @since 3.0
	 *
	 * Nature can be either string (old mode) or Set (new mode) or null.
	 * New mode allows to take into account several natures per project.
	 * Accepting null allows to process projects w/o nature
	 * @since 4.0
	 */
	public boolean shouldBeVisibleForNature(Object nature) {
		if (natureSet == null)
			return true;
		if (nature == null)
			return false;

		if (nature instanceof String) // old style
			return hasNature((String) nature);
		else if (nature instanceof Set) {
			Iterator<?> it = ((Set<?>) nature).iterator();
			while (it.hasNext()) {
				String s = it.next().toString();
				if (hasNature(s))
					return true;
			}
		}
		return false; // no one nature fits or bad data
	}

	private boolean hasNature(String nature) {
		return natureSet.contains(nature);
	}

	/**
	 * @return An array of nature IDs corresponding to the natures for which this page should appear.
	 * @since 3.0
	 */
	public String[] getNatures() {
		if (natureSet == null || natureSet.size() == 0)
			return null;

		Object[] objArray = natureSet.toArray();

		String[] strArray = new String[objArray.length];
		for (int k = 0; k < objArray.length; k++) {
			strArray[k] = objArray[k].toString();

		}

		return strArray;
	}

	/**
	 * @param id - The unique ID of the toolchain
	 * @param version - The version of the toolchain, or <code>null</code> if versions are not to be checked.
	 * @return true if the page should be present for the given toolchain and version, false otherwise.
	 * @since 3.0
	 */
	public boolean shouldBeVisibleForToolchain(String id, String version) {
		// if no toolchains specified then always return true
		if (toolchainSet.size() == 0)
			return true;

		Iterator<ToolchainData> iterator = toolchainSet.iterator();
		while (iterator.hasNext()) {
			ToolchainData tcd = iterator.next();
			// look for toolchain with same id.  The id in the tool-chain data should never
			// contain a version suffix.
			if (tcd.getId().equals(id)) {
				// if we don't check versions then we're done
				if (tcd.getVersionsSupported() == null)
					return true;
				// is the toolchain of one of the specified versions?
				for (int k = 0; k < tcd.getVersionsSupported().length; k++) {
					if (tcd.getVersionsSupported()[k].equals(version))
						return true;
				}
			}
		}
		return false;
	}

	/**
	 * @return The set of toolchains supported by this page, or null if this page does not specify any
	 * 		   toolchain dependencies.
	 * @since 3.0
	 */
	public ToolchainData[] getToolchains() {
		if (toolchainSet == null)
			return null;

		ToolchainData[] tcd = new ToolchainData[toolchainSet.size()];

		Iterator<ToolchainData> iterator = toolchainSet.iterator();

		int k = 0;

		while (iterator.hasNext()) {
			tcd[k++] = iterator.next();
		}
		if (tcd.length > 0)
			return tcd;
		else
			return null;
	}

	/**
	 * @return The set of project types supported by this page, or null if there are no such dependencies.
	 * @since 3.0
	 */
	public String[] getProjectTypes() {
		if (projectTypeSet == null || projectTypeSet.size() == 0)
			return null;

		Object[] objArray = projectTypeSet.toArray();

		String[] strArray = new String[objArray.length];
		for (int k = 0; k < objArray.length; k++) {
			strArray[k] = objArray[k].toString();

		}

		return strArray;
	}

	/**
	 * Adds a dependency to this page upon a given nature.  The page will be visible
	 * iff the given nature is selected by the user.
	 *
	 * @param nature The unique ID of the nature.
	 * @since 3.0
	 */
	public void addNature(String nature) {
		if (nature == null)
			return;

		if (natureSet == null)
			natureSet = new TreeSet<>();

		natureSet.add(nature);
	}

	/**
	 * Adds a dependency to this page upon a given toolchain.  The page will be visible
	 * iff one or more of the selected project configurations utilizes the specified toolchain.
	 * If versions are specified, then the version of the toolchain must exactly match one of the specified versions.
	 *
	 * @param toolchainID - The unique ID of the toolchain.
	 * @param versionsSupported - A comma separated list of supported versions, or null if no version checking is to be done.
	 * @since 3.0
	 */
	public void addToolchain(String toolchainID, String[] versionsSupported) {
		if (toolchainID == null)
			return;

		if (toolchainSet == null)
			toolchainSet = new TreeSet<>();

		ToolchainData toolchainData = new ToolchainData();
		toolchainData.setId(toolchainID);
		toolchainData.setVersionsSupported(versionsSupported);

		toolchainSet.add(toolchainData);
	}

	/**
	 * @param projectType The unique ID of the project type to check.
	 * @return true if this page should be visible if the given project type is selected, false otherwise.
	 * @since 3.0
	 *
	 * Type can be either string (old mode) or Set (new mode) or null.
	 * New mode allows to take into account several types per project,
	 * or types absence in some cases
	 * @since 4.0
	 */
	public boolean shouldBeVisibleForProjectType(Object projectType) {
		if (projectTypeSet == null)
			return true;
		if (projectType == null)
			return false;

		if (projectType instanceof String)
			return projectTypeSet.contains(projectType);
		else if (projectType instanceof Set) {
			Iterator<?> it = ((Set<?>) projectType).iterator();
			while (it.hasNext()) {
				String s = it.next().toString();
				if (projectTypeSet.contains(s))
					return true;
			}
		}
		return false; // no one type fits
	}

	/**
	 * Adds a dependency to this page upon a given project type.  The page will be visible
	 * iff the given project type is selected by the user.
	 *
	 * @param projectType - The unique ID of the project type.
	 * @since 3.0
	 */
	public void addProjectType(String projectType) {
		if (projectType == null)
			return;

		if (projectTypeSet == null)
			projectTypeSet = new TreeSet<>();

		projectTypeSet.add(projectType);
	}

	/**
	 * @return the {@link IRunnableWithProgress} operation associated with this page that should be run during
	 * the wizard's doRunEpilogue() method.  This operation should only be executed if in fact the page
	 * is visible.
	 * @since 3.0
	 */
	public IRunnableWithProgress getOperation() {
		return operation;
	}

	private static IRunnableWithProgress convertRunnable(final Runnable runnable) {
		if (runnable == null) {
			return null;
		}
		return new IRunnableWithProgress() {
			@Override
			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
				runnable.run();
			}
		};
	}
}