//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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.authoring.ui.forms;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.epf.authoring.ui.AuthoringUIPlugin;
import org.eclipse.epf.authoring.ui.AuthoringUIResources;
import org.eclipse.epf.authoring.ui.AuthoringUIText;
import org.eclipse.epf.library.edit.util.MethodElementPropUtil;
import org.eclipse.epf.library.edit.util.MethodElementUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.ui.LibraryUIText;
import org.eclipse.epf.uma.ContentElement;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Role;
import org.eclipse.epf.uma.Task;
import org.eclipse.epf.uma.WorkProduct;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTableViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Table;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorSite;
import org.eclipse.ui.forms.editor.FormEditor;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.ui.forms.widgets.Section;


/**
 * The description page for the Content Package editor.
 * 
 * @author Shilpa Toraskar
 * @author Kelvin Low
 * @since 1.0
 */
public class ContentPackageDescriptionPage extends DescriptionFormPage implements IRefreshable {

	private static final String FORM_PREFIX = LibraryUIText.TEXT_CONTENT_PACKAGE
			+ ": "; //$NON-NLS-1$

	private CheckboxTableViewer ctrl_dependency;

	private ContentPackage contentPackage;
	protected Button supportingCheckbox;

	/**
	 * Creates a new instance.
	 */
	public ContentPackageDescriptionPage(FormEditor editor) {
		super(editor, AuthoringUIText.DESCRIPTION_PAGE_TITLE,
				AuthoringUIText.DESCRIPTION_PAGE_TITLE);
	}

	/**
	 * @see org.eclipse.ui.forms.editor.FormPage#init(org.eclipse.ui.IEditorSite, org.eclipse.ui.IEditorInput)
	 */
	public void init(IEditorSite site, IEditorInput input) {
		super.init(site, input);
		contentPackage = (ContentPackage) methodElement;
		detailSectionOn = false;
		fullDescOn = false;
		keyConsiderationOn = false;
		variabilitySectionOn = false;
		versionSectionOn = false;
	}

	@Override
	protected void createEditorContent(FormToolkit toolkit) {
		super.createEditorContent(toolkit);
		createDependencySection(toolkit);
		// Set focus on the Name text control.
		Display display = form.getBody().getDisplay();
		if (!(display == null || display.isDisposed())) {
			display.asyncExec(new Runnable() {
				public void run() {
					if(ctrl_name.isDisposed()) return;
					if (isAutoGenName()) {
						ctrl_presentation_name.setFocus();
						ctrl_presentation_name.setSelection(0, ctrl_presentation_name.getText().length());
					} else {
						ctrl_name.setFocus();
						ctrl_name.setSelection(0, ctrl_name.getText().length());
					}
				}
			});
		}
	}

	private void createDependencySection(FormToolkit toolkit) {
		Section dependencySection = createSection(toolkit, sectionComposite, 
				AuthoringUIText.DEPENDENCIES_SECTION_NAME, 
				AuthoringUIText.DEPENDENCIES_SECTION_DESC);
		Composite dependencyComposite = createComposite(toolkit, dependencySection);

		Table ctrl_table = toolkit.createTable(dependencyComposite, SWT.V_SCROLL
				| SWT.CHECK | SWT.READ_ONLY | SWT.COLOR_BLUE);
		{
			GridData gridData = new GridData(GridData.BEGINNING
					| GridData.FILL_HORIZONTAL);
			gridData.heightHint = 100;
			ctrl_table.setLayoutData(gridData);
		}

		ctrl_dependency = new CheckboxTableViewer(ctrl_table);

		ILabelProvider labelProvider = new LabelProvider() {
			public String getText(Object element) {
				if (element instanceof ContentPackage) {
					return TngUtil.getLabelWithPath((ContentPackage)element);
				} else {
					return element.toString();
				}
			}
		};
		ctrl_dependency.setLabelProvider(labelProvider);
		ctrl_dependency.setContentProvider(new IStructuredContentProvider() {
			public void dispose() {
			}
			
			public void inputChanged(Viewer viewer, Object oldInput,
					Object newInput) {
			}
			
			public Object[] getElements(Object inputElement) {
				if (inputElement instanceof ContentPackage) {
					return getDependenciesPackages(contentPackage).toArray();
				} else {
					return Collections.EMPTY_LIST.toArray();
				}
			}
		});
		ctrl_dependency.setSorter(new ViewerSorter());
		ctrl_dependency.setInput(contentPackage);

		ctrl_dependency.setAllChecked(true);
		ctrl_dependency.setAllGrayed(true);

		toolkit.paintBordersFor(dependencyComposite);
	}

	/**
	 * Add listeners
	 * 
	 */
	protected void addListeners() {
		super.addListeners();
		
		form.addListener(SWT.Activate, new Listener() {
			public void handleEvent(Event e) {
				// refreshViewers();
				ctrl_dependency.refresh();
				ctrl_dependency.setAllChecked(true);
				ctrl_dependency.setAllGrayed(true);
			}
		});

		ctrl_dependency.addCheckStateListener(new ICheckStateListener() {
			public void checkStateChanged(CheckStateChangedEvent event) {
				Object obj = event.getSource();
				((CheckboxTableViewer) obj).setAllChecked(true);
			}
		});

	}

	/**
	 * Get dependency packages for the given content package
	 * @return
	 * 		List of dependency packages
	 */
	public Collection<ContentPackage> getDependenciesPackages(ContentPackage contentPackage) {

		List elements = new ArrayList();
		for (Iterator iter = contentPackage.getContentElements().iterator(); iter
				.hasNext();) {
			ContentElement contentElement = (ContentElement) iter.next();
			if (contentElement.getVariabilityBasedOnElement() != null) {
				elements.add((ContentElement) contentElement
						.getVariabilityBasedOnElement());
			}
			elements.addAll(MethodElementUtil
					.getSelectedGuidances(contentElement));

			if (contentElement instanceof Role) {
/*				if (AssociationHelper
						.getModifiedWorkProducts((Role) contentElement) != null) {
					elements.addAll(AssociationHelper
							.getModifiedWorkProducts((Role) contentElement));
				}
				if (AssociationHelper.getPrimaryTasks((Role) contentElement) != null) {
					elements.addAll(AssociationHelper
							.getPrimaryTasks((Role) contentElement));
				}
				if (AssociationHelper.getSecondaryTasks((Role) contentElement) != null) {
					elements.addAll(AssociationHelper
							.getSecondaryTasks((Role) contentElement));
				}*/
			}
			if (contentElement instanceof Task) {
				if (((Task) contentElement).getPerformedBy() != null) {
					elements.addAll(((Task) contentElement).getPerformedBy());
				}
				if (((Task) contentElement).getAdditionallyPerformedBy() != null) {
					elements.addAll(((Task) contentElement)
							.getAdditionallyPerformedBy());
				}
				if (((Task) contentElement).getMandatoryInput() != null) {
					elements
							.addAll(((Task) contentElement).getMandatoryInput());
				}
				if (((Task) contentElement).getOptionalInput() != null) {
					elements.addAll(((Task) contentElement).getOptionalInput());
				}
				if (((Task) contentElement).getOutput() != null) {
					elements.addAll(((Task) contentElement).getOutput());
				}
			}
			if (contentElement instanceof WorkProduct) {
/*				if (AssociationHelper
						.getModifiedBy((WorkProduct) contentElement) != null) {
					elements.addAll(AssociationHelper
							.getModifiedBy((WorkProduct) contentElement));
				}
				if (AssociationHelper
						.getMandatoryInputToTasks((WorkProduct) contentElement) != null) {
					elements
							.addAll(AssociationHelper
									.getMandatoryInputToTasks((WorkProduct) contentElement));
				}
				if (AssociationHelper
						.getOutputtingTasks((WorkProduct) contentElement) != null) {
					elements.addAll(AssociationHelper
							.getOutputtingTasks((WorkProduct) contentElement));
				}
				List list = AssociationHelper.getResponsibleRoles((WorkProduct) contentElement);
				if (list != null) {
					elements.addAll(list);
				}*/
			}

		}

		List<ContentPackage> cpList = new ArrayList<ContentPackage>();
		for (int i = 0; i < elements.size(); i++) {
			Object object = ((ContentElement) elements.get(i)).eContainer();
			if (object instanceof ContentPackage) {
				if (!contentPackage.equals(object)) {
					if (!cpList.contains((ContentPackage)object)) {
						cpList.add((ContentPackage)object);
					}
				}
			}
		}
		return cpList;
	}

	@Override
	protected Object getContentElement() {
		return contentPackage;
	}

	@Override
	public void loadSectionDescription() {
		this.generalSectionDescription = MessageFormat.format(
				AuthoringUIText.GENERAL_INFO_SECTION_DESC,
				new String[] { LibraryUIText.getUITextLower(contentPackage) });
	}
	
	@Override
	protected void refresh(boolean editable) {
		super.refresh(editable);
		if(supportingCheckbox != null) {
			supportingCheckbox.setEnabled(editable);
			EObject parent = contentPackage.eContainer();
			if (parent instanceof MethodPlugin
					&& ((MethodPlugin) parent).isSupporting()) {
				supportingCheckbox.setEnabled(false);
			} else if (parent instanceof ContentPackage
					&& MethodElementPropUtil.getMethodElementPropUtil()
							.isSupporting((ContentPackage) parent)) {
				supportingCheckbox.setEnabled(false);
			}
		}
	}
	
	public void updateSupportingCheckbox() {
		if (supportingCheckbox == null) {
			return;
		}
		MethodElementPropUtil propUtil = MethodElementPropUtil.getMethodElementPropUtil();
		boolean isSupporitng0 = propUtil.ancestorIsSupporting(contentPackage);
		boolean isSuporting = isSupporitng0 || propUtil.isSupporting(contentPackage);
		if (supportingCheckbox.getSelection() != isSuporting) {
			supportingCheckbox.setSelection(isSuporting);
		}
		if (isSupporitng0) {
			supportingCheckbox.setEnabled(false);
		}
	}	
	
	@Override
	protected void createGeneralSectionContent() {
		super.createGeneralSectionContent();
		
		supportingCheckbox = toolkit
			.createButton(
				generalComposite,
				AuthoringUIResources.contentPackageDescriptionPage_supportingPackageLabel, SWT.CHECK);
	}
	
	@Override
	protected void addGeneralSectionListeners() {
		super.addGeneralSectionListeners();
		
		supportingCheckbox.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				IStatus status = TngUtil.checkEdit(contentPackage, getSite().getShell());
				if (status.isOK()) {
					MethodElementPropUtil propUtil = MethodElementPropUtil
							.getMethodElementPropUtil(actionMgr);
					propUtil.setSupporting(contentPackage, supportingCheckbox
							.getSelection());
					propUtil.updatePackageSupportingBits(contentPackage
							.getChildPackages(), supportingCheckbox
							.getSelection());
				} else {
					AuthoringUIPlugin.getDefault().getMsgDialog().displayError(
							AuthoringUIResources.editDialog_title,
							AuthoringUIResources.editDialog_msgCannotEdit,
							status);
					// restore old value
					//
					supportingCheckbox.setSelection(!supportingCheckbox.getSelection());
					return;
				}
			}

			
		});
	}
	
	@Override
	protected void loadGeneralSectionData() {
		super.loadGeneralSectionData();
		boolean isSuporting = MethodElementPropUtil.getMethodElementPropUtil().isSupporting(contentPackage);
		supportingCheckbox
			.setSelection(isSuporting);
	}
	

}