/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.update.internal.ui.forms;

import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Locale;
import java.util.StringTokenizer;
import java.util.Vector;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.PluginVersionIdentifier;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.help.WorkbenchHelp;
import org.eclipse.update.configuration.IConfiguredSite;
import org.eclipse.update.configuration.IInstallConfiguration;
import org.eclipse.update.configuration.ILocalSite;
import org.eclipse.update.core.IFeature;
import org.eclipse.update.core.IFeatureReference;
import org.eclipse.update.core.IIncludedFeatureReference;
import org.eclipse.update.core.ISite;
import org.eclipse.update.core.SiteManager;
import org.eclipse.update.core.VersionedIdentifier;
import org.eclipse.update.internal.ui.UpdatePerspective;
import org.eclipse.update.internal.ui.UpdateUI;
import org.eclipse.update.internal.ui.UpdateUIImages;
import org.eclipse.update.internal.ui.model.IConfiguredSiteContext;
import org.eclipse.update.internal.ui.model.IFeatureAdapter;
import org.eclipse.update.internal.ui.model.IUpdateModelChangedListener;
import org.eclipse.update.internal.ui.model.MissingFeature;
import org.eclipse.update.internal.ui.model.PendingChange;
import org.eclipse.update.internal.ui.model.UpdateModel;
import org.eclipse.update.internal.ui.pages.UpdateFormPage;
import org.eclipse.update.internal.ui.parts.SWTUtil;
import org.eclipse.update.internal.ui.preferences.UpdateColors;
import org.eclipse.update.internal.ui.views.DetailsView;
import org.eclipse.update.internal.ui.wizards.InstallWizard;
import org.eclipse.update.internal.ui.wizards.InstallWizardDialog;
import org.eclipse.update.ui.forms.internal.ExpandableGroup;
import org.eclipse.update.ui.forms.internal.FormWidgetFactory;
import org.eclipse.update.ui.forms.internal.HTMLTableLayout;
import org.eclipse.update.ui.forms.internal.HyperlinkAdapter;
import org.eclipse.update.ui.forms.internal.HyperlinkHandler;
import org.eclipse.update.ui.forms.internal.IHyperlinkListener;
import org.eclipse.update.ui.forms.internal.SelectableFormLabel;
import org.eclipse.update.ui.forms.internal.TableData;

public class DetailsForm extends PropertyWebForm {
	// NL keys

	private static final String KEY_PROVIDER = "FeaturePage.provider"; //$NON-NLS-1$
	private static final String KEY_VERSION = "FeaturePage.version"; //$NON-NLS-1$
	private static final String KEY_IVERSION = "FeaturePage.installedVersion"; //$NON-NLS-1$
	private static final String KEY_PENDING_VERSION =
		"FeaturePage.pendingVersion"; //$NON-NLS-1$
	private static final String KEY_SIZE = "FeaturePage.size"; //$NON-NLS-1$
	private static final String KEY_ESTIMATE = "FeaturePage.estimate"; //$NON-NLS-1$
	private static final String KEY_OS = "FeaturePage.os"; //$NON-NLS-1$
	private static final String KEY_WS = "FeaturePage.ws"; //$NON-NLS-1$
	private static final String KEY_NL = "FeaturePage.nl"; //$NON-NLS-1$
	private static final String KEY_ARCH = "FeaturePage.arch"; //$NON-NLS-1$
	private static final String KEY_PLATFORMS = "FeaturePage.platforms"; //$NON-NLS-1$
	private static final String KEY_DESC = "FeaturePage.description"; //$NON-NLS-1$
	private static final String KEY_INFO_LINK = "FeaturePage.infoLink"; //$NON-NLS-1$
	private static final String KEY_LICENSE_LINK = "FeaturePage.licenseLink"; //$NON-NLS-1$
	private static final String KEY_COPYRIGHT_LINK =
		"FeaturePage.copyrightLink"; //$NON-NLS-1$
	private static final String KEY_NOT_INSTALLED = "FeaturePage.notInstalled"; //$NON-NLS-1$
	private static final String KEY_SIZE_VALUE = "FeaturePage.sizeValue"; //$NON-NLS-1$
	private static final String KEY_ESTIMATE_VALUE =
		"FeaturePage.estimateValue"; //$NON-NLS-1$
	private static final String KEY_MINUTE_ESTIMATE_VALUE =
		"FeaturePage.minuteEstimateValue"; //$NON-NLS-1$
	private static final String KEY_UNKNOWN_SIZE_VALUE =
		"FeaturePage.unknownSizeValue"; //$NON-NLS-1$
	private static final String KEY_UNKNOWN_ESTIMATE_VALUE =
		"FeaturePage.unknownEstimateValue"; //$NON-NLS-1$
	private static final String KEY_DO_UNCONFIGURE =
		"FeaturePage.doButton.unconfigure"; //$NON-NLS-1$
	private static final String KEY_DO_CONFIGURE =
		"FeaturePage.doButton.configure"; //$NON-NLS-1$
	private static final String KEY_DO_REPAIR = "FeaturePage.doButton.repair"; //$NON-NLS-1$
	private static final String KEY_DO_CHANGE = "FeaturePage.doButton.change"; //$NON-NLS-1$
	private static final String KEY_DO_UPDATE = "FeaturePage.doButton.update"; //$NON-NLS-1$
	private static final String KEY_DO_INSTALL = "FeaturePage.doButton.install"; //$NON-NLS-1$
	private static final String KEY_DO_UNINSTALL =
		"FeaturePage.doButton.uninstall"; //$NON-NLS-1$

	private static final String KEY_BATCH_UNCONFIGURE =
		"FeaturePage.batchButton.unconfigure"; //$NON-NLS-1$
	private static final String KEY_BATCH_CONFIGURE =
		"FeaturePage.batchButton.configure"; //$NON-NLS-1$
	private static final String KEY_BATCH_REPAIR =
		"FeaturePage.batchButton.repair"; //$NON-NLS-1$
	private static final String KEY_BATCH_CHANGE =
		"FeaturePage.batchButton.change"; //$NON-NLS-1$
	private static final String KEY_BATCH_UPDATE =
		"FeaturePage.batchButton.update"; //$NON-NLS-1$
	private static final String KEY_BATCH_INSTALL =
		"FeaturePage.batchButton.install"; //$NON-NLS-1$
	private static final String KEY_BATCH_UNINSTALL =
		"FeaturePage.batchButton.uninstall"; //$NON-NLS-1$
	private static final String KEY_BATCH = "FeaturePage.batch"; //$NON-NLS-1$
	private static final String KEY_SELECTED_UPDATES =
		"FeaturePage.selectedUpdates"; //$NON-NLS-1$

	private static final String KEY_DIALOG_UTITLE = "FeaturePage.dialog.utitle"; //$NON-NLS-1$
	private static final String KEY_DIALOG_TITLE = "FeaturePage.dialog.title"; //$NON-NLS-1$
	private static final String KEY_DIALOG_CTITLE = "FeaturePage.dialog.ctitle"; //$NON-NLS-1$
	private static final String KEY_DIALOG_UCTITLE =
		"FeaturePage.dialog.uctitle"; //$NON-NLS-1$
	private static final String KEY_DIALOG_UMESSAGE =
		"FeaturePage.dialog.umessage"; //$NON-NLS-1$
	private static final String KEY_DIALOG_MESSAGE =
		"FeaturePage.dialog.message"; //$NON-NLS-1$
	private static final String KEY_DIALOG_CMESSAGE =
		"FeaturePage.dialog.cmessage"; //$NON-NLS-1$
	private static final String KEY_DIALOG_UCMESSAGE =
		"FeaturePage.dialog.ucmessage"; //$NON-NLS-1$
	private static final String KEY_MISSING_TITLE = "FeaturePage.missing.title"; //$NON-NLS-1$
	private static final String KEY_MISSING_MESSAGE =
		"FeaturePage.missing.message"; //$NON-NLS-1$
	private static final String KEY_MISSING_SEARCH =
		"FeaturePage.missing.search"; //$NON-NLS-1$
	private static final String KEY_MISSING_ABORT = "FeaturePage.missing.abort"; //$NON-NLS-1$
	private static final String KEY_SEARCH_OBJECT_NAME =
		"FeaturePage.missing.searchObjectName"; //$NON-NLS-1$
	private static final String KEY_OPTIONAL_INSTALL_MESSAGE =
		"FeaturePage.optionalInstall.message"; //$NON-NLS-1$
	private static final String KEY_OPTIONAL_INSTALL_TITLE =
		"FeaturePage.optionalInstall.title"; //$NON-NLS-1$
	//	
	private static final int REPAIR = 1;
	private static final int CHANGE = 2;
	private int reinstallCode = 0;

	private Label imageLabel;
	private Label providerLabel;
	private Label versionLabel;
	private Label installedVersionLabel;
	private Label sizeLabel;
	private Label estimatedTime;
	private Label osLabel;
	private Label wsLabel;
	private Label nlLabel;
	private Label archLabel;
	private Label descriptionText;
	private Label groupUpdatesLabel;
	private URL infoLinkURL;
	private SelectableFormLabel infoLinkLabel;
	private SelectableFormLabel itemsLink;
	private InfoLink licenseLink;
	private InfoLink copyrightLink;
	private ReflowGroup supportedPlatformsGroup;
	private Image providerImage;
	//private Button uninstallButton;
	private Button addButton;
	private Button doButton;
	private IFeature currentFeature;
	private IFeatureAdapter currentAdapter;
	private ModelListener modelListener;
	private Hashtable imageCache = new Hashtable();
	private HyperlinkHandler sectionHandler;
	private boolean alreadyInstalled;
	private IFeature[] installedFeatures;
	private boolean newerVersion;
	private boolean addBlock;
	private boolean inputBlock;
	private static boolean inProgress;

	class ModelListener implements IUpdateModelChangedListener {
		/**
		 * @see IUpdateModelChangedListener#objectAdded(Object, Object)
		 */
		public void objectsAdded(Object parent, Object[] children) {
			if (isCurrentFeature(children)) {
				SWTUtil.getStandardDisplay().asyncExec(new Runnable() {
					public void run() {
						refresh();
					}
				});
			}
		}

		boolean isCurrentFeature(Object[] children) {
			for (int i = 0; i < children.length; i++) {
				Object obj = children[i];
				if (obj instanceof PendingChange) {
					PendingChange job = (PendingChange) obj;
					if (job.getFeature().equals(currentFeature)) {
						return true;
					}
				}
			}
			return false;
		}

		/**
		 * @see IUpdateModelChangedListener#objectRemoved(Object, Object)
		 */
		public void objectsRemoved(Object parent, Object[] children) {
			if (isCurrentFeature(children)) {
				SWTUtil.getStandardDisplay().asyncExec(new Runnable() {
					public void run() {
						//doButton.setEnabled(true);
						refresh();
					}
				});
			}
		}

		/**
		 * @see IUpdateModelChangedListener#objectChanged(Object, String)
		 */
		public void objectChanged(Object object, String property) {
		}
	}

	abstract class LinkListener implements IHyperlinkListener {
		public abstract URL getURL();
		public void linkActivated(Control linkLabel) {
			URL url = getURL();
			if (url != null)
				openURL(url.toString());
		}
		public void linkEntered(Control linkLabel) {
			URL url = getURL();
			if (url != null)
				showStatus(url.toString());
		}
		public void linkExited(Control linkLabel) {
			showStatus(null);
		}

		private void showStatus(String text) {
			IViewSite site = getPage().getView().getViewSite();
			IStatusLineManager sm = site.getActionBars().getStatusLineManager();
			sm.setMessage(text);
		}
	}

	abstract class ReflowGroup extends ExpandableGroup {
		public void expanded() {
			reflow();
			updateSize();
		}
		public void collapsed() {
			reflow();
			updateSize();
		}
		protected SelectableFormLabel createTextLabel(
			Composite parent,
			FormWidgetFactory factory) {
			SelectableFormLabel label = super.createTextLabel(parent, factory);
			label.setFont(JFaceResources.getBannerFont());
			return label;
		}
		protected HyperlinkHandler getHyperlinkHandler(FormWidgetFactory factory) {
			return sectionHandler;
		}
	}

	public DetailsForm(UpdateFormPage page) {
		super(page);
		providerImage = UpdateUIImages.DESC_PROVIDER.createImage();
		modelListener = new ModelListener();
		UpdateModel model = UpdateUI.getDefault().getUpdateModel();
		model.addUpdateModelChangedListener(modelListener);
		sectionHandler = new HyperlinkHandler();
	}

	public void dispose() {
		UpdateModel model = UpdateUI.getDefault().getUpdateModel();
		model.removeUpdateModelChangedListener(modelListener);
		providerImage.dispose();
		for (Enumeration enum = imageCache.elements();
			enum.hasMoreElements();
			) {
			Image image = (Image) enum.nextElement();
			image.dispose();
		}
		imageCache.clear();
		sectionHandler.dispose();
		super.dispose();
	}

	public void initialize(Object modelObject) {
		setHeadingText(""); //$NON-NLS-1$
		super.initialize(modelObject);
	}

	private void configureSectionHandler(
		FormWidgetFactory factory,
		Display display) {
		sectionHandler.setHyperlinkUnderlineMode(
			HyperlinkHandler.UNDERLINE_NEVER);
		sectionHandler.setBackground(factory.getBackgroundColor());
		sectionHandler.setForeground(UpdateColors.getTopicColor(display));
	}

	protected void updateHeadings() {
		Control control = getControl();
		if (control==null) return;
		sectionHandler.setForeground(
			UpdateColors.getTopicColor(control.getDisplay()));
		super.updateHeadings();
	}

	public void createContents(Composite container) {
		HTMLTableLayout layout = new HTMLTableLayout();
		layout.numColumns = 2;
		container.setLayout(layout);
		//layout.rightMargin = 0;
		GridData gd;

		configureSectionHandler(factory, container.getDisplay());

		GridLayout glayout = new GridLayout();
		Composite properties = factory.createComposite(container);
		properties.setLayout(glayout);
		glayout.marginWidth = glayout.marginHeight = 0;
		glayout.verticalSpacing = 0;

		providerLabel =
			createProperty(properties, UpdateUI.getString(KEY_PROVIDER));
		versionLabel =
			createProperty(properties, UpdateUI.getString(KEY_VERSION));
		installedVersionLabel =
			createProperty(properties, UpdateUI.getString(KEY_IVERSION));
		sizeLabel = createProperty(properties, UpdateUI.getString(KEY_SIZE));
		estimatedTime =
			createProperty(properties, UpdateUI.getString(KEY_ESTIMATE));
		supportedPlatformsGroup = new ReflowGroup() {
			public void fillExpansion(
				Composite expansion,
				FormWidgetFactory factory) {
				GridLayout layout = new GridLayout();
				expansion.setLayout(layout);
				layout.marginWidth = 0;
				osLabel = createProperty(expansion, UpdateUI.getString(KEY_OS));
				wsLabel = createProperty(expansion, UpdateUI.getString(KEY_WS));
				nlLabel = createProperty(expansion, UpdateUI.getString(KEY_NL));
				archLabel =
					createProperty(expansion, UpdateUI.getString(KEY_ARCH));
			}
		};
		supportedPlatformsGroup.setText(UpdateUI.getString(KEY_PLATFORMS));
		new Label(properties, SWT.NULL);
		supportedPlatformsGroup.createControl(properties, factory);
		setFocusControl(supportedPlatformsGroup.getControl());

		imageLabel = factory.createLabel(container, null);
		TableData td = new TableData();
		td.align = TableData.CENTER;
		//td.valign = TableData.MIDDLE;
		imageLabel.setLayoutData(td);

		Label label = createHeading(container, UpdateUI.getString(KEY_DESC));
		td = new TableData();
		td.colspan = 2;
		label.setLayoutData(td);
		descriptionText = factory.createLabel(container, null, SWT.WRAP);
		td = new TableData();
		td.colspan = 2;
		td.grabHorizontal = true;
		descriptionText.setLayoutData(td);

		glayout = new GridLayout();
		glayout.numColumns = 4;
		glayout.horizontalSpacing = 20;
		glayout.marginWidth = 10;

		addSeparator(container);

		Composite footer = factory.createComposite(container);
		td = new TableData();
		td.colspan = 2;
		td.align = TableData.FILL;
		footer.setLayoutData(td);
		footer.setLayout(glayout);

		LinkListener listener = new LinkListener() {
			public URL getURL() {
				return infoLinkURL;
			}
		};

		infoLinkLabel = new SelectableFormLabel(footer, SWT.NULL);
		infoLinkLabel.setText(UpdateUI.getString(KEY_INFO_LINK));
		factory.turnIntoHyperlink(infoLinkLabel, listener);
		gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
		infoLinkLabel.setLayoutData(gd);
		licenseLink = new InfoLink((DetailsView) getPage().getView());
		licenseLink.setText(UpdateUI.getString(KEY_LICENSE_LINK));
		licenseLink.createControl(footer, factory);
		gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
		licenseLink.getControl().setLayoutData(gd);
		copyrightLink = new InfoLink((DetailsView) getPage().getView());
		copyrightLink.setText(UpdateUI.getString(KEY_COPYRIGHT_LINK));
		copyrightLink.createControl(footer, factory);
		gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
		copyrightLink.getControl().setLayoutData(gd);

		doButton = factory.createButton(footer, "", SWT.PUSH); //$NON-NLS-1$
		doButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				doButtonSelected();
			}
		});
		gd =
			new GridData(
				GridData.HORIZONTAL_ALIGN_CENTER
					| GridData.VERTICAL_ALIGN_BEGINNING);
		gd.grabExcessHorizontalSpace = true;
		doButton.setLayoutData(gd);

		Composite batch = factory.createComposite(container);
		glayout = new GridLayout();
		glayout.numColumns = 2;
		glayout.marginWidth = 0;
		glayout.marginHeight = 0;
		batch.setLayout(glayout);
		td = new TableData();
		td.colspan = 2;
		td.align = TableData.FILL;
		//td.grabHorizontal = true;
		batch.setLayoutData(td);
		groupUpdatesLabel = createHeading(batch, UpdateUI.getString(KEY_BATCH));
		gd = new GridData();
		gd.horizontalSpan = 2;
		groupUpdatesLabel.setLayoutData(gd);
		addButton =
			factory.createButton(
				batch,
				UpdateUI.getString(KEY_BATCH_INSTALL),
				SWT.CHECK);
		addButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				if (!addBlock)
					doAdd(addButton.getSelection());
			}
		});
		addButton.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_CENTER));
		itemsLink =
			factory.createSelectableLabel(
				batch,
				UpdateUI.getString(KEY_SELECTED_UPDATES));
		factory.turnIntoHyperlink(itemsLink, new HyperlinkAdapter() {
			public void linkActivated(Control link) {
				openUpdateItems();
			}
		});
		itemsLink.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_CENTER));

		//SWTUtil.setButtonDimensionHint(doButton);
		WorkbenchHelp.setHelp(container, "org.eclipse.update.ui.DetailsForm"); //$NON-NLS-1$

	}

	private void addSeparator(Composite container) {
		Composite l = factory.createCompositeSeparator(container);
		l.setBackground(factory.getBorderColor());
		TableData td = new TableData();
		td.colspan = 2;
		td.heightHint = 1;
		td.align = TableData.FILL;
		l.setLayoutData(td);
	}

	private void openUpdateItems() {
		BusyIndicator.showWhile(SWTUtil.getStandardDisplay(), new Runnable() {
			public void run() {
				try {
					IWorkbenchPage page = UpdateUI.getActivePage();
					IViewPart view = page.findView(UpdatePerspective.ID_ITEMS);
					if (view != null)
						page.bringToTop(view);
					else {
						inputBlock = true;
						page.showView(UpdatePerspective.ID_ITEMS);
						inputBlock = false;
					}
				} catch (PartInitException e) {
					UpdateUI.logException(e);
				}
			}
		});
	}

	public void expandTo(final Object obj) {
		if (inputBlock)
			return;
		BusyIndicator.showWhile(getControl().getDisplay(), new Runnable() {
			public void run() {
				if (obj instanceof IFeature) {
					currentAdapter = null;
					currentFeature = (IFeature) obj;
					refresh();
				} else if (obj instanceof IFeatureAdapter) {
					IFeatureAdapter adapter = (IFeatureAdapter) obj;
					try {
						currentAdapter = adapter;
						currentFeature = adapter.getFeature(null);
					} catch (CoreException e) {
						//UpdateUI.logException(e);
						currentFeature =
							new MissingFeature(
								adapter.getSite(),
								adapter.getURL());
					} finally {
						refresh();
					}
				} else {
					currentFeature = null;
					currentAdapter = null;
					refresh();
				}
			}
		});
	}

	private boolean isConfigured(IFeature feature) {
		ISite site = feature.getSite();
		IConfiguredSite csite = site.getCurrentConfiguredSite();
		if (csite == null)
			return false;
		return csite.isConfigured(feature);
	}

	private String getInstalledVersionText(IFeature feature) {
		alreadyInstalled = false;
		VersionedIdentifier vid = feature.getVersionedIdentifier();
		PluginVersionIdentifier version = vid.getVersion();
		newerVersion = installedFeatures.length > 0;

		StringBuffer buf = new StringBuffer();
		for (int i = 0; i < installedFeatures.length; i++) {
			IFeature installedFeature = installedFeatures[i];
			boolean enabled = isConfigured(installedFeature);
			VersionedIdentifier ivid =
				installedFeature.getVersionedIdentifier();
			if (buf.length() > 0)
				buf.append(", "); //$NON-NLS-1$
			PluginVersionIdentifier iversion = ivid.getVersion();
			buf.append(iversion.toString());
			if (!enabled) {
				buf.append(" "); //$NON-NLS-1$
				buf.append(UpdateUI.getString("FeaturePage.disabledVersion")); //$NON-NLS-1$
			}
			if (ivid.equals(vid)) {
				alreadyInstalled = true;
			} else {
				if (iversion.isGreaterOrEqualTo(version))
					newerVersion = false;
			}
		}
		if (buf.length() > 0) {
			String versionText = buf.toString();
			UpdateModel model = UpdateUI.getDefault().getUpdateModel();
			PendingChange change = model.findRelatedPendingChange(feature);
			if (change != null) {
				return UpdateUI.getFormattedMessage(
					KEY_PENDING_VERSION,
					versionText);
			} else
				return versionText;
		} else
			return null;
	}

	private void refresh() {
		IFeature feature = currentFeature;

		if (feature == null)
			return;

		installedFeatures = UpdateUI.getInstalledFeatures(feature);
		if (installedFeatures.length == 0)
			installedFeatures = UpdateUI.getInstalledFeatures(feature, false);

		setHeadingText(feature.getLabel());
		providerLabel.setText(feature.getProvider());
		versionLabel.setText(
			feature.getVersionedIdentifier().getVersion().toString());
		String installedVersion = getInstalledVersionText(feature);
		if (installedVersion == null)
			installedVersion = UpdateUI.getString(KEY_NOT_INSTALLED);
		installedVersionLabel.setText(installedVersion);
		long size = feature.getDownloadSize();
		String sizeText;
		if (size != -1) {
			String stext = Long.toString(size);
			sizeText = UpdateUI.getFormattedMessage(KEY_SIZE_VALUE, stext);
		} else {
			sizeText = UpdateUI.getString(KEY_UNKNOWN_SIZE_VALUE);
		}
		sizeLabel.setText(sizeText);
		estimatedTime.setText(getEstimatedTimeText(feature, size));

		if (feature.getDescription() != null
			&& feature.getDescription().getAnnotation() != null)
			descriptionText.setText(feature.getDescription().getAnnotation());
		else
			descriptionText.setText(""); //$NON-NLS-1$

		Image logoImage = loadProviderImage(feature);
		if (logoImage == null)
			logoImage = providerImage;
		imageLabel.setImage(logoImage);
		infoLinkURL = null;
		if (feature.getDescription() != null)
			infoLinkURL = feature.getDescription().getURL();
		infoLinkLabel.setVisible(infoLinkURL != null);

		setOS(feature.getOS());
		setWS(feature.getWS());
		setNL(feature.getNL());
		setArch(feature.getOSArch());

		licenseLink.setInfo(feature.getLicense());
		copyrightLink.setInfo(feature.getCopyright());
		this.reinstallCode = 0;

		UpdateModel model = UpdateUI.getDefault().getUpdateModel();
		PendingChange relatedJob =
			model.findRelatedPendingChange(currentFeature);
		doButton.setVisible(getDoButtonVisibility(false, relatedJob));
		addButton.setVisible(getDoButtonVisibility(true, relatedJob));
		itemsLink.setVisible(addButton.isVisible());
		groupUpdatesLabel.setVisible(addButton.isVisible());
		if (addButton.isVisible()) {
			if (relatedJob != null) {
				IFeature relatedFeature = relatedJob.getFeature();
				addButton.setEnabled(
					currentFeature.getVersionedIdentifier().equals(
						relatedFeature.getVersionedIdentifier()));
			} else
				addButton.setEnabled(true);
		}
		addBlock = true;
		addButton.setSelection(
			relatedJob != null && relatedJob.isProcessed() == false);
		addBlock = false;
		updateButtonText(newerVersion);
		reflow();
		updateSize();
		((Composite) getControl()).redraw();
	}

	private String getEstimatedTimeText(IFeature feature, long size) {
		long estimate = SiteManager.getEstimatedTransferRate(feature.getURL());
		String estimateFormat = null;
		if (estimate >= 0 && size != -1) {
			long nhours = estimate / 3600000;
			long nminutes = estimate % 3600000;

			if (nhours == 0 && nminutes == 0) {
				estimateFormat = UpdateUI.getString(KEY_MINUTE_ESTIMATE_VALUE);
			} else {
				String hours = Long.toString(nhours);
				String minutes = Long.toString(nminutes);

				estimateFormat =
					UpdateUI.getFormattedMessage(
						KEY_ESTIMATE_VALUE,
						new String[] { hours, minutes });
			}
		} else {
			estimateFormat = UpdateUI.getString(KEY_UNKNOWN_ESTIMATE_VALUE);
		}
		return estimateFormat;
	}

	private boolean getDoButtonVisibility(
		boolean add,
		PendingChange relatedJob) {
		if (currentFeature instanceof MissingFeature) {
			MissingFeature mf = (MissingFeature) currentFeature;
			if (mf.isOptional() && mf.getOriginatingSiteURL() != null)
				return add ? false : true;
			else
				return false;
		}

		if (currentAdapter == null)
			return false;

		boolean localContext = currentAdapter instanceof IConfiguredSiteContext;

		if (currentAdapter.isIncluded()) {
			if (!localContext)
				return false;
			if (!currentAdapter.isOptional())
				return false;
		}

		if (localContext) {
			IConfiguredSiteContext context =
				(IConfiguredSiteContext) currentAdapter;
			if (!context.getInstallConfiguration().isCurrent())
				return false;
			if (context.getConfiguredSite().isEnabled() == false)
				return false;
		}

		if (relatedJob != null) {
			/*if (add)
				return false;
			*/
			if (relatedJob.isProcessed())
				return false;
		}

		if (localContext) {
			IConfiguredSiteContext context =
				(IConfiguredSiteContext) currentAdapter;
			if (!context.getInstallConfiguration().isCurrent())
				return false;
			else
				return true;
		} else {
			// found on a remote site
			// Cannot install feature without a license
			/* Commenting - license is now checked in
			 * ActivityConstraints - bug #33582

			if (!UpdateModel.hasLicense(currentFeature))
				return false;
			*/
		}
		// Random site feature
		if (alreadyInstalled) {
			if (isBrokenFeatureUpdate()) {
				reinstallCode = REPAIR;
				return true;
			}
			if (isOptionalFeatureInstall()) {
				reinstallCode = CHANGE;
				return true;
			}
			return false;
		}
		// Not installed - check if there are other 
		// features with this ID that are installed
		// and that are newer than this one
		if (installedFeatures.length > 0 && !newerVersion)
			return false;
		return true;
	}

	private boolean isBrokenFeatureUpdate() {
		if (installedFeatures.length != 1)
			return false;
		IFeature installedFeature = installedFeatures[0];
		if (installedFeature
			.getVersionedIdentifier()
			.equals(currentFeature.getVersionedIdentifier())) {
			return isBroken(installedFeature);
		}
		return false;
	}

	private boolean isBroken(IFeature feature) {
		try {
			IStatus status =
				SiteManager.getLocalSite().getFeatureStatus(feature);
			if (status != null && status.getSeverity() == IStatus.ERROR)
				return true;
		} catch (CoreException e) {
		}
		return false;
	}

	private boolean isOptionalFeatureInstall() {
		return hasMissingOptionalFeatures(installedFeatures[0]);
	}

	private boolean hasMissingOptionalFeatures(IFeature feature) {
		try {
			IIncludedFeatureReference refs[] =
				feature.getIncludedFeatureReferences();
			for (int i = 0; i < refs.length; i++) {
				IIncludedFeatureReference ref = refs[i];

				try {
					IFeature child = ref.getFeature(null);

					// not missing - try children
					if (hasMissingOptionalFeatures(child))
						return true;
				} catch (CoreException e) {
					// missing - if optional, return true
					if (ref.isOptional())
						return true;
				}
			}
		} catch (CoreException e) {
			// problem with the feature itself
		}
		return false;
	}

	private boolean getUninstallButtonVisibility() {
		/*
		 * We will not allow uninstalls for now.
		if (currentFeature instanceof MissingFeature)
			return false;
		if (currentAdapter == null || currentAdapter.isIncluded())
			return false;
		UpdateModel model = UpdateUI.getDefault().getUpdateModel();
		if (model.isPending(currentFeature))
			return false;
		if (currentAdapter instanceof IConfiguredSiteContext) {
			boolean configured = isConfigured();
			return !configured;
		}
		*/
		return false;
	}

	private boolean isConfigured() {
		if (currentAdapter instanceof IConfiguredSiteContext) {
			IConfiguredSiteContext context =
				(IConfiguredSiteContext) currentAdapter;
			IConfiguredSite csite = context.getConfiguredSite();
			IFeatureReference fref =
				csite.getSite().getFeatureReference(currentFeature);
			IFeatureReference[] cfeatures = csite.getConfiguredFeatures();
			for (int i = 0; i < cfeatures.length; i++) {
				if (cfeatures[i].equals(fref))
					return true;
			}
		}
		return false;
	}

	private void updateButtonText(boolean update) {
		if (reinstallCode == REPAIR) {
			doButton.setText(UpdateUI.getString(KEY_DO_REPAIR));
			addButton.setText(UpdateUI.getString(KEY_BATCH_REPAIR));
			return;
		}
		if (reinstallCode == CHANGE) {
			doButton.setText(UpdateUI.getString(KEY_DO_CHANGE));
			addButton.setText(UpdateUI.getString(KEY_BATCH_CHANGE));
			return;
		}
		if (currentFeature instanceof MissingFeature) {
			MissingFeature mf = (MissingFeature) currentFeature;
			if (mf.isOptional() && mf.getOriginatingSiteURL() != null) {
				doButton.setText(UpdateUI.getString(KEY_DO_INSTALL));
				return;
			}
		}
		if (currentAdapter instanceof IConfiguredSiteContext) {
			boolean configured = isConfigured();
			if (configured) {
				doButton.setText(UpdateUI.getString(KEY_DO_UNCONFIGURE));
				addButton.setText(UpdateUI.getString(KEY_BATCH_UNCONFIGURE));
			} else {
				doButton.setText(UpdateUI.getString(KEY_DO_CONFIGURE));
				addButton.setText(UpdateUI.getString(KEY_BATCH_CONFIGURE));
			}
		} else if (update && !alreadyInstalled) {
			doButton.setText(UpdateUI.getString(KEY_DO_UPDATE));
			addButton.setText(UpdateUI.getString(KEY_BATCH_UPDATE));
		} else {
			doButton.setText(UpdateUI.getString(KEY_DO_INSTALL));
			addButton.setText(UpdateUI.getString(KEY_BATCH_INSTALL));
		}
	}

	private Image loadProviderImage(IFeature feature) {
		Image image = null;
		URL imageURL = feature.getImage();
		if (imageURL == null)
			return null;
		// check table
		image = (Image) imageCache.get(imageURL);
		if (image == null) {
			ImageDescriptor id = ImageDescriptor.createFromURL(imageURL);
			try {
				image = id.createImage();
			} catch (SWTException e) {
				image = null;
			}
			if (image != null)
				imageCache.put(imageURL, image);
		}
		return image;
	}

	private void reflow() {
		versionLabel.getParent().layout(true);
		doButton.getParent().layout(true);
		imageLabel.getParent().layout(true);
		((Composite) getControl()).layout(true);
	}

	private void setOS(String os) {
		if (os == null)
			osLabel.setText(UpdateUI.getString("FeaturePage.all")); //$NON-NLS-1$
		else {
			String[] array = getTokens(os);
			StringBuffer buf = new StringBuffer();
			for (int i = 0; i < array.length; i++) {
				if (i > 0)
					buf.append("\n"); //$NON-NLS-1$
				buf.append(mapOS(array[i]));
			}
			osLabel.setText(buf.toString());
		}
	}

	private String mapOS(String key) {
		return key;
	}

	private String mapWS(String key) {
		return key;
	}

	private String mapArch(String key) {
		return key;
	}

	private String mapNL(String nl) {
		String language, country;

		int loc = nl.indexOf('_');
		if (loc != -1) {
			language = nl.substring(0, loc);
			country = nl.substring(loc + 1);
		} else {
			language = nl;
			country = ""; //$NON-NLS-1$
		}
		Locale locale = new Locale(language, country);
		return locale.getDisplayName();
	}

	private void setWS(String ws) {
		if (ws == null)
			wsLabel.setText(UpdateUI.getString("FeaturePage.all")); //$NON-NLS-1$
		else {
			String[] array = getTokens(ws);
			StringBuffer buf = new StringBuffer();
			for (int i = 0; i < array.length; i++) {
				if (i > 0)
					buf.append("\n"); //$NON-NLS-1$
				buf.append(mapWS(array[i]));
			}
			wsLabel.setText(buf.toString());
		}
	}

	private void setArch(String arch) {
		if (arch == null)
			archLabel.setText(UpdateUI.getString("FeaturePage.all")); //$NON-NLS-1$
		else {
			String[] array = getTokens(arch);
			StringBuffer buf = new StringBuffer();
			for (int i = 0; i < array.length; i++) {
				if (i > 0)
					buf.append("\n"); //$NON-NLS-1$
				buf.append(mapArch(array[i]));
			}
			archLabel.setText(buf.toString());
		}
	}

	private void setNL(String nl) {
		if (nl == null)
			nlLabel.setText(UpdateUI.getString("FeaturePage.all")); //$NON-NLS-1$
		else {
			String[] array = getTokens(nl);
			StringBuffer buf = new StringBuffer();
			for (int i = 0; i < array.length; i++) {
				if (i > 0)
					buf.append("\n"); //$NON-NLS-1$
				buf.append(mapNL(array[i]));
			}
			nlLabel.setText(buf.toString());
		}
	}

	private String[] getTokens(String source) {
		Vector result = new Vector();
		StringTokenizer stok = new StringTokenizer(source, ","); //$NON-NLS-1$
		while (stok.hasMoreTokens()) {
			String tok = stok.nextToken();
			result.add(tok);
		}
		return (String[]) result.toArray(new String[result.size()]);
	}

	private void openURL(final String url) {
		BusyIndicator.showWhile(getControl().getDisplay(), new Runnable() {
			public void run() {
				DetailsView.showURL(url);
			}
		});
	}

	private void doAdd(boolean selection) {
		UpdateModel model = UpdateUI.getDefault().getUpdateModel();
		if (selection) {
			int mode = getCurrentJobType();
			PendingChange job = createPendingChange(mode);
			if (!checkEnabledDuplicates(job)) {
				addButton.setSelection(false);
				return;
			}
			model.addPendingChange(job);
		} else {
			PendingChange job = model.findRelatedPendingChange(currentFeature);
			if (job != null)
				model.removePendingChange(job);
		}
	}

	private void doUninstall() {
		executeJob(PendingChange.UNINSTALL);
	}

	private void executeJob(int mode) {
		if (currentFeature != null) {
			PendingChange job = createPendingChange(mode);
			touchChildren(getControl().getShell(), currentFeature);
			executeJob(getControl().getShell(), job, true);
		}
	}

	private void executeOptionalInstall(MissingFeature mf) {
		VersionedIdentifier vid = mf.getVersionedIdentifier();
		URL siteURL = mf.getOriginatingSiteURL();
		IConfiguredSite targetSite = null;
		if (mf.getParent() != null) {
			ISite psite = mf.getParent().getSite();
			targetSite = psite.getCurrentConfiguredSite();
		}
		IFeature feature =
			fetchFeatureFromServer(getControl().getShell(), siteURL, vid);
		if (feature != null) {
			PendingChange job = new PendingChange(feature, targetSite);
			executeJob(getControl().getShell(), job, true);
		}
	}

	public static IFeature fetchFeatureFromServer(
		Shell shell,
		final URL siteURL,
		final VersionedIdentifier vid) {
		// Locate remote site, find the optional feature
		// and install it

		final IFeature[] result = new IFeature[1];
		final CoreException[] exception = new CoreException[1];
		final boolean aborted[] = new boolean[1];
		aborted[0] = false;
		
		IRunnableWithProgress op = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) throws InvocationTargetException {
				try {
					monitor.beginTask(UpdateUI.getString("DetailsForm.locatingFeature"), 3); //$NON-NLS-1$
					ISite site = SiteManager.getSite(siteURL, new SubProgressMonitor(monitor, 1));
					if (site==null || monitor.isCanceled()) {
						aborted[0] = true;
						return;
					} 
					IFeatureReference[] refs = site.getFeatureReferences();
					result[0] = findFeature(vid, refs, new SubProgressMonitor(monitor, 1));
					if (result[0]!=null) {
						monitor.setTaskName(UpdateUI.getString("DetailsForm.downloadingInfo")); //$NON-NLS-1$
						touchFeatureChildren(result[0], new SubProgressMonitor(monitor, 1));
					}
				} catch (CoreException e) {
					throw new InvocationTargetException(e);
				}
				finally {
					monitor.done();
				}
			}
		};
		
		ProgressMonitorDialog pmd = new ProgressMonitorDialog(shell);
		try {
			pmd.run(true, true, op);
		}
		catch (InterruptedException e) {
			return null;
		}
		catch (InvocationTargetException e) {
			UpdateUI.logException(e);
			return null;
		}
		IStatus status = null;
		if (result[0] != null) {
			return result[0];
		} else if (!aborted[0]) {
			String message =
				UpdateUI.getFormattedMessage(
					KEY_OPTIONAL_INSTALL_MESSAGE,
					siteURL.toString());
			status =
				new Status(
					IStatus.ERROR,
					UpdateUI.PLUGIN_ID,
					IStatus.OK,
					message,
					null);
		}
		if (status != null) {
			// Show error dialog
			ErrorDialog.openError(
				shell,
				UpdateUI.getString(KEY_OPTIONAL_INSTALL_TITLE),
				null,
				status);
		}
		return null;
	}

	private static IFeature findFeature(
		VersionedIdentifier vid,
		IFeatureReference[] refs,
		IProgressMonitor monitor) {
		
		monitor.beginTask("", refs.length*2); //$NON-NLS-1$
			
		for (int i = 0; i < refs.length; i++) {
			IFeatureReference ref = refs[i];
			try {
				VersionedIdentifier refVid = ref.getVersionedIdentifier();
				if (refVid.equals(vid)) {
					return ref.getFeature(null);
				}
				monitor.worked(1);
				// Try children
				IFeature feature = ref.getFeature(null);
				IFeatureReference[] irefs =
					feature.getIncludedFeatureReferences();
				IFeature result = findFeature(vid, irefs, new SubProgressMonitor(monitor, 1));
				if (result != null)
					return result;
			} catch (CoreException e) {
			}
		}
		return null;
	}
	
	private void touchChildren(Shell shell, final IFeature feature) {
		IRunnableWithProgress op = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) {
				monitor.beginTask(UpdateUI.getString("DetailsForm.downloadingIncluded"), 1); //$NON-NLS-1$
				try {
					touchFeatureChildren(feature, new SubProgressMonitor(monitor, 1));
				}
				catch (CoreException e) {
					// ignore
				}
				finally {
					monitor.done();
				}
			}
		};
		try {
			ProgressMonitorDialog pmd = new ProgressMonitorDialog(shell);
			pmd.run(true, false, op);
		}
		catch (InvocationTargetException e) {
		}
		catch (InterruptedException e) {
		}
	}
	
	private static void touchFeatureChildren(IFeature feature, IProgressMonitor monitor) throws CoreException {
		IFeatureReference[] irefs =
			feature.getIncludedFeatureReferences();
		if (irefs.length>0) {
			monitor.beginTask("", irefs.length*2); //$NON-NLS-1$
			for (int i=0; i<irefs.length; i++) {
				IFeatureReference iref = irefs[i];
				IFeature child = iref.getFeature(null);
				monitor.worked(1);
				touchFeatureChildren(child, new SubProgressMonitor(monitor, 1));
			}
		}
		else {
			monitor.beginTask("", 1); //$NON-NLS-1$
			monitor.worked(1);
		}
	}
	
	public static boolean isInProgress() {
		return inProgress;
	}

	public static boolean executeJob(
		Shell shell,
		final PendingChange job,
		final boolean needLicensePage) {
		if (inProgress) {
			return true;
		}
		inProgress = true;
		
		IStatus validationStatus =
			ActivityConstraints.validatePendingChange(job);
		if (validationStatus != null) {
			ErrorDialog.openError(
				UpdateUI.getActiveWorkbenchShell(),
				null,
				null,
				validationStatus);
			return false;
		}
		if (!checkEnabledDuplicates(job))
			return false;

		if (job.getJobType() == PendingChange.UNCONFIGURE
			&& job.getFeature().isPatch()) {
			unconfigurePatch(shell, job.getFeature());
			return false;
		}
		BusyIndicator.showWhile(shell.getDisplay(), new Runnable() {
			public void run() {
				InstallWizard wizard = new InstallWizard(job, needLicensePage);
				WizardDialog dialog =
					new InstallWizardDialog(
						UpdateUI.getActiveWorkbenchShell(),
						wizard);
				dialog.create();
				dialog.getShell().setSize(600, 500);
				dialog.open();
				inProgress = false;
				if (wizard.isSuccessfulInstall())
					UpdateUI.informRestartNeeded();
			}
		});
		return false;
	}

	private static void unconfigurePatch(Shell shell, IFeature feature) {
		IInstallConfiguration config =
			UpdateUI.getBackupConfigurationFor(feature);
		if (config == null) {
			String message =
				UpdateUI.getString("DetailsForm.featureAPatch"); //$NON-NLS-1$
			MessageDialog.openError(shell, UpdateUI.getString("DetailsForm.disableFeature.title"), message); //$NON-NLS-1$
			return;
		}
		try {
			ILocalSite localSite = SiteManager.getLocalSite();
			boolean success = RevertSection.performRevert(config, false, false);
			if (success) {
				localSite.removeFromPreservedConfigurations(config);
				localSite.save();
				UpdateUI.informRestartNeeded();
			}
		} catch (CoreException e) {
			UpdateUI.logException(e);
		}
	}

	private void doButtonSelected() {
		if (currentFeature != null) {
			if (currentFeature instanceof MissingFeature) {
				MissingFeature mf = (MissingFeature) currentFeature;
				if (mf.isOptional() && mf.getOriginatingSiteURL() != null) {
					executeOptionalInstall(mf);
					return;
				}
			}
			int mode;
			if (currentAdapter instanceof IConfiguredSiteContext) {
				boolean configured = isConfigured();
				if (configured)
					mode = PendingChange.UNCONFIGURE;
				else
					mode = PendingChange.CONFIGURE;
			} else {
				mode = PendingChange.INSTALL;
			}
			executeJob(mode);
		}
	}

	private int getCurrentJobType() {
		int mode;
		if (currentAdapter instanceof IConfiguredSiteContext) {
			boolean configured = isConfigured();
			if (configured)
				mode = PendingChange.UNCONFIGURE;
			else
				mode = PendingChange.CONFIGURE;
		} else {
			mode = PendingChange.INSTALL;
		}
		return mode;
	}

	private PendingChange createPendingChange(int type) {
		if (type == PendingChange.INSTALL && installedFeatures.length > 0) {
			return new PendingChange(
				installedFeatures[0],
				currentFeature,
				alreadyInstalled);
		} else {
			return new PendingChange(currentFeature, type);
		}
	}

	private static boolean checkEnabledDuplicates(PendingChange job) {
		if (job.getJobType() != PendingChange.CONFIGURE)
			return true;
		IFeature[] installedEnabledFeatures =
			UpdateUI.getInstalledFeatures(job.getFeature(), true);
		if (installedEnabledFeatures.length == 0)
			return true;

		String title =
			UpdateUI.getString("FeaturePage.duplicatesEnabled.title"); //$NON-NLS-1$
		String message =
			UpdateUI.getString("FeaturePage.duplicatesEnabled.message"); //$NON-NLS-1$
			MessageDialog dialog =
				new MessageDialog(
					UpdateUI.getActiveWorkbenchShell(),
					title,
					null,
		// accept the default window icon
	message,
		MessageDialog.WARNING,
		new String[] {
			IDialogConstants.OK_LABEL,
			IDialogConstants.CANCEL_LABEL },
		0);
		// OK is the default
		return dialog.open() == 0;
	}
}