//------------------------------------------------------------------------------
// Copyright (c) 2005, 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.publishing.ui.wizards;

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

import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.LibraryServiceUtil;
import org.eclipse.epf.library.configuration.ConfigurationHelper;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.ui.views.ProcessTreeContentProvider;
import org.eclipse.epf.library.ui.views.ProcessTreeLabelProvider;
import org.eclipse.epf.library.ui.views.ProcessTreeUIFolder;
import org.eclipse.epf.publishing.ui.PublishingUIPlugin;
import org.eclipse.epf.publishing.ui.PublishingUIResources;
import org.eclipse.epf.publishing.ui.preferences.PublishingUIPreferences;
import org.eclipse.epf.ui.wizards.BaseWizardPage;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.DeliveryProcess;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;

/**
 * A wizard page that prompts the user to publish the entire method
 * configuration or only specific processes in the configuration.
 * 
 * @author Kelvin Low
 * @author Bingxue Xu
 * @author Jinhua Xi
 * @since 1.0
 */
public class SelectContentPage extends BaseWizardPage implements Listener {

	/**
	 * The wizard page name.
	 */
	public static final String PAGE_NAME = SelectContentPage.class.getName();

	protected Button publishConfigRadioButton;

	protected Button publishProcessesRadioButton;

	protected CheckboxTreeViewer processViewer;

	protected Button includeBaseProcessesCheckbox;

	protected MethodConfiguration config;

	protected class ProcessViewerContentProvider extends
			ProcessTreeContentProvider {

		private List<MethodPackage> packages = new ArrayList<MethodPackage>();

		/**
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#inputChanged(Viewer,
		 *      Object, Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			super.inputChanged(viewer, oldInput, newInput);
		}

		/**
		 * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(Object)
		 */
		public Object[] getChildren(Object parentElement) {
			if (parentElement instanceof MethodConfiguration) {
				MethodConfiguration config = (MethodConfiguration) parentElement;
				List<Object> children = new ArrayList<Object>();
				packages = config.getMethodPackageSelection();
				List<MethodPlugin> plugins = config.getMethodPluginSelection();
				for (Iterator<MethodPlugin> it = plugins.iterator(); it
						.hasNext();) {
					MethodPlugin plugin = it.next();
					List<Process> processes = TngUtil.getAllProcesses(plugin);
					if (processes.size() > 0) {
						children.add(plugin);
					}
				}
				return children.toArray();
			} else if (parentElement instanceof ProcessTreeUIFolder) {
				ProcessTreeUIFolder uiFolder = (ProcessTreeUIFolder) parentElement;
				MethodPlugin plugin = (MethodPlugin) uiFolder.getParent();
				if (uiFolder.getName() == CAPABILITY_PATTERNS) {
					List<CapabilityPattern> selectedCapabilityPatterns = new ArrayList<CapabilityPattern>();
					List<CapabilityPattern> capabilityPatterns = LibraryServiceUtil
							.getCapabilityPatterns(plugin);
					for (Iterator<CapabilityPattern> it = capabilityPatterns
							.iterator(); it.hasNext();) {
						CapabilityPattern cp = it.next();
						ProcessPackage pkg = UmaUtil.getProcessPackage(cp);
						if (packages.contains(pkg)) {
							selectedCapabilityPatterns.add(cp);
						}
					}
					return selectedCapabilityPatterns.toArray();
				} else {
					List<DeliveryProcess> selectedDeliveryProcesses = new ArrayList<DeliveryProcess>();
					List<DeliveryProcess> deliveryProcesses = LibraryServiceUtil
							.getDeliveryProcesses(plugin);
					for (Iterator<DeliveryProcess> it = deliveryProcesses
							.iterator(); it.hasNext();) {
						DeliveryProcess dp = it.next();
						ProcessPackage pkg = UmaUtil.getProcessPackage(dp);
						if (packages.contains(pkg)) {
							selectedDeliveryProcesses.add(dp);
						}
					}
					return selectedDeliveryProcesses.toArray();
				}
			} else {
				return super.getChildren(parentElement);
			}
		}
	}

	/**
	 * Creates a new instance.
	 */
	public SelectContentPage() {
		super(PAGE_NAME);
		setTitle(PublishingUIResources.selectContentWizardPage_title);
		setDescription(PublishingUIResources.selectContentWizardPage_text);
		setImageDescriptor(PublishingUIPlugin.getDefault().getImageDescriptor(
				"full/wizban/PublishConfiguration.gif")); //$NON-NLS-1$
	}

	/**
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(Composite)
	 */
	public void createControl(Composite parent) {
		Composite composite = createGridLayoutComposite(parent, 1);

		publishConfigRadioButton = createRadioButton(composite,
				PublishingUIResources.publishConfigRadioButton_text, 1, true);

		publishProcessesRadioButton = createRadioButton(composite,
				PublishingUIResources.publishProcessesRadioButton_text, 1,
				false);

		Composite processComposite = createChildGridLayoutComposite(composite,
				1);

		processViewer = new CheckboxTreeViewer(processComposite);
		GridData gridData = new GridData(GridData.FILL_BOTH
				| GridData.GRAB_HORIZONTAL);
		gridData.heightHint = 300;
		processViewer.getTree().setLayoutData(gridData);
		processViewer.setContentProvider(new ProcessViewerContentProvider());
		processViewer.setLabelProvider(new ProcessTreeLabelProvider());

		includeBaseProcessesCheckbox = createCheckbox(processComposite,
				PublishingUIResources.includeBaseProcessesCheckboxLabel_text);

		initControls();

		addListeners();

		setControl(composite);
	}

	/**
	 * Initializes the wizard page controls with data.
	 */
	protected void initControls() {
		String configId = config != null ? config.getGuid() : ""; //$NON-NLS-1$
		boolean publishConfig = PublishingUIPreferences.getPublishEntireConfig(configId);
		publishConfigRadioButton.setSelection(publishConfig);
		publishProcessesRadioButton.setSelection(!publishConfig);
		processViewer.getControl().setEnabled(!publishConfig);
		
		if (!publishConfig) {
			List<String> processIds = PublishingUIPreferences.getProcesses(configId);
			List<Process> processes = new ArrayList<Process>();
			if (processIds != null) {
				for (String guid : processIds) {
					MethodElement e = LibraryService.getInstance().getCurrentLibraryManager().getMethodElement(guid);
					if (e instanceof Process) {
						processes.add((Process) e);
					}
				}
			}
			processViewer.setCheckedElements(processes.toArray());
		}
		
		boolean includeBaseProcess = PublishingUIPreferences.getIncludeBaseProcesses(configId);
		includeBaseProcessesCheckbox.setSelection(includeBaseProcess);
		
		updateCheckedStates();
	}

	/**
	 * Adds event handlers to the wizard page controls.
	 */
	protected void addListeners() {
		publishConfigRadioButton.addListener(SWT.Selection, this);
		publishProcessesRadioButton.addListener(SWT.Selection, this);
		includeBaseProcessesCheckbox.addListener(SWT.Selection, this);

		processViewer.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				Object checkedElement = event.getElement();
				boolean checked = event.getChecked();

				processViewer.setChecked(checkedElement, checked);
				processViewer.setSubtreeChecked(checkedElement, checked);
				if (includeBaseProcessesCheckbox.getSelection()) {
					selectBaseProcesses();
				}
				updateCheckedStates();

				setPageComplete(isPageComplete());
			}
		});
	}

	/**
	 * Updates the check states of process tree viewer.
	 */
	private void updateCheckedStates() {
		ITreeContentProvider cp = (ITreeContentProvider) processViewer
				.getContentProvider();
		if (config != null) {
			Object[] plugins = cp.getChildren(config);
			for (int i = 0; i < plugins.length; i++) {
				Object[] uiFolders = cp.getChildren(plugins[i]);
				int totalUIFolders = uiFolders.length;
				int checkedUIFolders = 0;
				for (int j = 0; j < uiFolders.length; j++) {
					Object[] processes = cp.getChildren(uiFolders[j]);
					int totalProcesses = processes.length;
					int checkedProcesses = 0;
					for (int k = 0; k < processes.length; k++) {
						if (processViewer.getChecked(processes[k])) {
							checkedProcesses++;
						}
					}
					if (checkedProcesses == 0) {
						processViewer.setGrayChecked(uiFolders[j], false);
					} else if (checkedProcesses == totalProcesses) {
						processViewer.setGrayed(uiFolders[j], false);
						processViewer.setChecked(uiFolders[j], true);
					} else {
						processViewer.setGrayChecked(uiFolders[j], true);
					}
					if (processViewer.getChecked(uiFolders[j])) {
						checkedUIFolders++;
					}
				}
				if (checkedUIFolders == totalUIFolders) {
					processViewer.setGrayed(plugins[i], false);
					processViewer.setChecked(plugins[i], true);
				} else if (checkedUIFolders == 0) {
					processViewer.setGrayChecked(plugins[i], false);
				} else {
					processViewer.setGrayChecked(plugins[i], true);
				}
			}
		}
	}

	/**
	 * Selects the referenced base processes in the process tree viewer.
	 */
	private void selectBaseProcesses() {
		// Get the referenced base processes.
		List<Process> processes = getSelectedProcesses();
		List<Process> baseProcesses = new ArrayList<Process>();
		for (Iterator it = processes.iterator(); it.hasNext();) {
			ConfigurationHelper.getBaseProcesses((Activity) it.next(), config,
					baseProcesses);
		}

		// Update the process tree viewer.
		for (Iterator it = baseProcesses.iterator(); it.hasNext();) {
			Object element = it.next();
			processViewer.setChecked(element, true);
		}
	}

	/**
	 * @see org.eclipse.swt.widgets.Listener#handleEvent(Event)
	 */
	public void handleEvent(Event event) {
		processViewer.getControl().setEnabled(
				publishProcessesRadioButton.getSelection());

		if (event.widget == includeBaseProcessesCheckbox) {
			// If selected, select all referenced base processes.
			selectBaseProcesses();
			updateCheckedStates();
		}

		setPageComplete(isPageComplete());
		getWizard().getContainer().updateButtons();
	}

	/**
	 * @see org.eclipse.epf.ui.wizards.BaseWizardPage#onEnterPage(Object)
	 */
	public void onEnterPage(Object obj) {
		if (obj != null && obj instanceof String) {
			String configName = (String) obj;
			config = LibraryServiceUtil.getMethodConfiguration(LibraryService
					.getInstance().getCurrentMethodLibrary(), configName);
			if (config != null) {
				processViewer.setInput(config);
				processViewer.expandAll();
				initControls();
			}			
		}
	}

	/**
	 * @see org.eclipse.jface.wizard.WizardPage#isPageCompleted()
	 */
	public boolean isPageComplete() {
		if (getErrorMessage() != null) {
			return false;
		}
		if (publishConfigRadioButton.getSelection()) {
			return true;
		}
		return getSelectedProcesses().size() > 0;
	}

	/**
	 * @see org.eclipse.epf.ui.wizards.BaseWizardPage#getNextPageData()
	 */
	public Object getNextPageData() {
		return config;
	}

	/**
	 * Gets the user specified selected processes to be published.
	 * 
	 * @return a list of <code>Process</code>
	 */
	public boolean getPublishConfigSelection() {
		return publishConfigRadioButton.getSelection();
	}

	/**
	 * Gets all the user selected processes to be published.
	 * 
	 * @return a list of <code>Process</code>
	 */
	public List<Process> getSelectedProcesses() {
		List<Process> processes = new ArrayList<Process>();
		Object[] selected = processViewer.getCheckedElements();
		if (selected != null && selected.length > 0) {
			for (int i = 0; i < selected.length; i++) {
				if (selected[i] instanceof Process) {
					processes.add((Process) selected[i]);
				}
			}
		}
		return processes;
	}
	
	public void savePreferences() {
		if (config != null) {
			String configId = config.getGuid();
			boolean publishConfig = publishConfigRadioButton.getSelection();			
			PublishingUIPreferences.setPublishEntireConfig(configId, publishConfig);
			if (publishConfig) {
				List<String> processIds = new ArrayList<String>();
				PublishingUIPreferences.setProcesses(configId, processIds);
			} else {
				List<String> processIds = new ArrayList<String>();
				for (org.eclipse.epf.uma.Process process : getSelectedProcesses()) {
					processIds.add(process.getGuid());
				}
				PublishingUIPreferences.setProcesses(configId, processIds);
			}			
			PublishingUIPreferences.setIncludeBaseProcesses(configId, includeBaseProcessesCheckbox.getSelection());
		}
	}

}