/*******************************************************************************
 * Copyright (c) 2000, 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.update.internal.ui.wizards;

import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IMessageProvider;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.custom.SashForm;
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.swt.widgets.TreeItem;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.dialogs.PropertyDialogAction;
import org.eclipse.ui.forms.HyperlinkSettings;
import org.eclipse.ui.forms.events.HyperlinkAdapter;
import org.eclipse.ui.forms.events.HyperlinkEvent;
import org.eclipse.ui.forms.widgets.ScrolledFormText;
import org.eclipse.update.core.ICategory;
import org.eclipse.update.core.IFeature;
import org.eclipse.update.core.IFeatureReference;
import org.eclipse.update.core.IImport;
import org.eclipse.update.core.IIncludedFeatureReference;
import org.eclipse.update.core.IPluginEntry;
import org.eclipse.update.core.ISiteFeatureReference;
import org.eclipse.update.core.IURLEntry;
import org.eclipse.update.core.Utilities;
import org.eclipse.update.core.VersionedIdentifier;
import org.eclipse.update.internal.core.ExtendedSite;
import org.eclipse.update.internal.core.UpdateCore;
import org.eclipse.update.internal.core.UpdateManagerUtils;
import org.eclipse.update.internal.operations.FeatureStatus;
import org.eclipse.update.internal.operations.OperationValidator;
import org.eclipse.update.internal.operations.UpdateUtils;
import org.eclipse.update.internal.operations.OperationValidator.InternalImport;
import org.eclipse.update.internal.operations.OperationValidator.RequiredFeaturesResult;
import org.eclipse.update.internal.ui.UpdateUI;
import org.eclipse.update.internal.ui.UpdateUIImages;
import org.eclipse.update.internal.ui.UpdateUIMessages;
import org.eclipse.update.internal.ui.model.FeatureReferenceAdapter;
import org.eclipse.update.internal.ui.model.SimpleFeatureAdapter;
import org.eclipse.update.internal.ui.model.SiteBookmark;
import org.eclipse.update.internal.ui.model.SiteCategory;
import org.eclipse.update.internal.ui.parts.DefaultContentProvider;
import org.eclipse.update.internal.ui.parts.SWTUtil;
import org.eclipse.update.internal.ui.parts.SharedLabelProvider;
import org.eclipse.update.operations.IInstallFeatureOperation;
import org.eclipse.update.operations.IUpdateModelChangedListener;
import org.eclipse.update.operations.OperationsManager;
import org.eclipse.update.search.IUpdateSearchSite;
import org.eclipse.update.search.UpdateSearchRequest;

public class ReviewPage	extends BannerPage {

	private Label label;
	private ArrayList jobs;
	private Label counterLabel;
	private IStatus validationStatus;
	private Collection problematicFeatures = new HashSet();
	// feature that was recently selected or null
	private IFeature newlySelectedFeature;
	// 
	private FeatureStatus lastDisplayedStatus;
	private PropertyDialogAction propertiesAction;
	private ScrolledFormText descLabel;
	private Button statusButton;
	private Button moreInfoButton;
	private Button propertiesButton;
	private Button selectRequiredFeaturesButton;
	private Button filterCheck;
	private Button filterOlderVersionCheck;
	private ContainmentFilter filter = new ContainmentFilter();
	private LatestVersionFilter olderVersionFilter = new LatestVersionFilter();
	private UpdateSearchRequest searchRequest;
	//private int LABEL_ORDER = 1;
	//private int VERSION_ORDER = 1;
	//private int PROVIDER_ORDER = 1;
    private ContainerCheckedTreeViewer treeViewer;
    private boolean initialized;
    private boolean isUpdateSearch;
  
    
    class TreeContentProvider extends DefaultContentProvider implements
            ITreeContentProvider {

        public Object[] getElements(Object parent) {
            return getSites();
        }

        public Object[] getChildren(final Object parent) {
            if (parent instanceof SiteBookmark) {
                SiteBookmark bookmark = (SiteBookmark) parent;
                bookmark.getSite(null); // triggers catalog creation
                Object[] children = bookmark.getCatalog(true,null);
                ArrayList nonEmptyCategories = new ArrayList(children.length);
                for (int i=0; i<children.length; i++)
                    if (hasChildren(children[i]))
                        nonEmptyCategories.add(children[i]);
                return nonEmptyCategories.toArray();
            } else if (parent instanceof SiteCategory) {
                SiteCategory category = (SiteCategory)parent;
                //return category.getChildren();
                Object[] children = category.getChildren();
                ArrayList list = new ArrayList(children.length);
                for (int i=0; i<children.length; i++) {
                    if (children[i] instanceof FeatureReferenceAdapter) {
                        try {
                            IInstallFeatureOperation job = findJob((FeatureReferenceAdapter)children[i]);
                            if (job != null)
                                list.add(job);
                        } catch (CoreException e) {
                            UpdateCore.log(e.getStatus());
                        }
                    }
                }
                return list.toArray();
            }
            return new Object[0];
        }

        public Object getParent(Object element) {
            if (element instanceof SiteCategory)
                return ((SiteCategory) element).getBookmark();
            if (element instanceof IInstallFeatureOperation) {
                IFeature f = ((IInstallFeatureOperation)element).getFeature();
                ISiteFeatureReference fr = f.getSite().getFeatureReference(f);
                ICategory[] categories = fr.getCategories();
//                if (categories != null && categories.length > 0)
//                    return categories[0];
                SiteBookmark[] sites = (SiteBookmark[])((ITreeContentProvider)treeViewer.getContentProvider()).getElements(null);
                for (int i=0; i<sites.length; i++) {
                	try {
                		if (sites[i].getSite(false, null).getURL() != f.getSite().getSiteContentProvider().getURL()) {
                		    // if the site has mirrors check if this is from the mirror that user selected
                			if (sites[i].getSite(false, null) instanceof ExtendedSite) {
                				ExtendedSite site = (ExtendedSite)sites[i].getSite(false, null);
                				IURLEntry siteMirror = site.getSelectedMirror();
                				if (siteMirror != null && siteMirror.getURL().toExternalForm().equals(f.getSite().getSiteContentProvider().getURL().toExternalForm())) { 
                					// this is the site so proceed with the loop
                				} else {
                					continue;
                				}
                			} else {
                				continue;
                			}
                		}
                	} catch (CoreException ce) {
                		return null;
                	}
                    Object[] children = sites[i].getCatalog(true, null);
                    for (int j = 0; j<children.length; j++) {
                        if (!(children[j] instanceof SiteCategory))
                            continue;
                        for (int c=0; c < categories.length; c++)
                            if (categories[c].getName().equals(((SiteCategory)children[j]).getName()))
                                return children[j];
                    }
                }
            }

            return null;
        }

        public boolean hasChildren(Object element) {
            return (element instanceof SiteBookmark || (
                    element instanceof SiteCategory && getChildren(element).length > 0));
        }

        private SiteBookmark[] getSites() {
            if (searchRequest == null)
                return new SiteBookmark[0];
            else if (searchRequest.getScope().getSearchSites() == null ||
                searchRequest.getScope().getSearchSites().length == 0) {
                // this is an update search, so see if there are any jobs first,
                // and get their sites
                if (jobs != null) {
                    ArrayList sitesList = new ArrayList(jobs.size());
                    for (int i = 0; i < jobs.size(); i++) {
                        IInstallFeatureOperation op = (IInstallFeatureOperation) jobs
                                .get(i);
                        // we need a label for the site, so try to get it from the old
                        // feature update url
                        String label = null;
                        IFeature[] existingFeatures = UpdateUtils
                                .getInstalledFeatures(op.getFeature(), true);
                        if (existingFeatures != null
                                && existingFeatures.length > 0) {
                            IURLEntry entry = op.getFeature()
                                    .getUpdateSiteEntry();
                            label = entry.getAnnotation();
                        }
                        if (label == null)
                            label = op.getFeature().getSite().getURL().toExternalForm();
                                    
                        SiteBookmark bookmark = new SiteBookmark(label,
                                op.getFeature().getSite().getURL(), false);
                        if (sitesList.contains(bookmark))
                            continue;
                        else
                            sitesList.add(bookmark);
                        
                    }
                    if (!sitesList.isEmpty())
                        return (SiteBookmark[]) sitesList
                                .toArray(new SiteBookmark[sitesList.size()]);
                }
                return new SiteBookmark[0];
            } else {
                // search for features
                IUpdateSearchSite[] sites = searchRequest.getScope().getSearchSites();
                SiteBookmark[] siteBookmarks = new SiteBookmark[sites.length];
                for (int i = 0; i < sites.length; i++)
                    siteBookmarks[i] = new SiteBookmark(sites[i].getLabel(),
                            sites[i].getURL(), false);
                return siteBookmarks;
            }
        }
    }

    class TreeLabelProvider extends SharedLabelProvider {

        public Image getImage(Object obj) {
            if (obj instanceof SiteBookmark)
                return UpdateUI.getDefault().getLabelProvider().get(
                        UpdateUIImages.DESC_SITE_OBJ);
            if (obj instanceof SiteCategory)
                return UpdateUI.getDefault().getLabelProvider().get(
                        UpdateUIImages.DESC_CATEGORY_OBJ);
            if (obj instanceof IInstallFeatureOperation) {
                IFeature feature = ((IInstallFeatureOperation) obj).getFeature();
                boolean patch = feature.isPatch();
                
                //boolean problematic=problematicFeatures.contains(feature) && treeViewer.getChecked(obj);
                boolean featureIsProblematic = isFeatureProblematic(feature);
                boolean problematic = treeViewer.getChecked(obj) && featureIsProblematic;
                
                if (!problematic && featureIsProblematic) {
                	Object parent = ((TreeContentProvider)treeViewer.getContentProvider()).getParent(obj);
                	if(parent == null)
                		return super.getImage(obj);
                	problematic = treeViewer.getChecked(parent) && !treeViewer.getGrayed(parent);
                }
                
                if (patch) {
                    return get(UpdateUIImages.DESC_EFIX_OBJ, problematic? F_ERROR : 0);
                } else {
                    return get(UpdateUIImages.DESC_FEATURE_OBJ, problematic? F_ERROR : 0);
                }
            }
            return super.getImage(obj);

        }

        public String getText(Object obj) {
            if (obj instanceof SiteBookmark) 
                return ((SiteBookmark) obj).getLabel();
            /*
            if (obj instanceof SiteCategory)
                return obj.toString();
                */
            if (obj instanceof IInstallFeatureOperation) {
                IInstallFeatureOperation job = (IInstallFeatureOperation) obj;
                IFeature feature = job.getFeature();
                return feature.getLabel() + " " + feature //$NON-NLS-1$
                            .getVersionedIdentifier()
                            .getVersion()
                            .toString();
            }
            return super.getText(obj);
        }
    }

    class ModelListener implements IUpdateModelChangedListener {
        public void objectChanged(Object object, String property) {
            treeViewer.refresh();
            checkItems();
        }

        public void objectsAdded(Object parent, Object[] children) {
            treeViewer.refresh();
            checkItems();
        }

        public void objectsRemoved(Object parent, Object[] children) {
            treeViewer.refresh();
            checkItems();
        }
        
        private void checkItems() {
            TreeItem[] items = treeViewer.getTree().getItems();
            for (int i = 0; i < items.length; i++) {
                SiteBookmark bookmark = (SiteBookmark) items[i].getData();
                treeViewer.setChecked(bookmark, bookmark.isSelected());
                String[] ignoredCats = bookmark.getIgnoredCategories();
                treeViewer.setGrayed(bookmark, ignoredCats.length > 0
                        && bookmark.isSelected());
            }
        }
    }

	class ContainmentFilter extends ViewerFilter {
		
		private IInstallFeatureOperation[] selectedJobs;
		
		public boolean select(Viewer viewer, Object parent, Object element) {
            if (element instanceof IInstallFeatureOperation) {
                return !isContained((IInstallFeatureOperation) element) || isSelected( selectedJobs, (IInstallFeatureOperation)element);
            } else if ( (element instanceof SiteCategory) || (element instanceof SiteBookmark)){
            	Object[] children = ((ITreeContentProvider)((ContainerCheckedTreeViewer)viewer).getContentProvider()).getChildren(element);
            	for ( int i = 0; i < children.length; i++) {
            		if (select(viewer, element, children[i])) {
            			return true;
            		}
            	}
            	return false;
            }
        
            return true;
		}
		
		private boolean isContained(IInstallFeatureOperation job) {
			VersionedIdentifier vid = job.getFeature().getVersionedIdentifier();

			for (int i = 0; i < jobs.size(); i++) {
				IInstallFeatureOperation candidate = (IInstallFeatureOperation) jobs.get(i);
				if (candidate.equals(job))
					continue;
				IFeature feature = candidate.getFeature();
				if (includes(feature, vid,null))
					return true;
			}
			return false;
		}
		private boolean includes(IFeature feature, VersionedIdentifier vid, ArrayList cycleCandidates) {
			try {
				if (cycleCandidates == null)
					cycleCandidates = new ArrayList();
				if (cycleCandidates.contains(feature))
					throw Utilities.newCoreException(NLS.bind(UpdateUIMessages.InstallWizard_ReviewPage_cycle, feature.getVersionedIdentifier().toString()), null);
				else
					cycleCandidates.add(feature);
				IFeatureReference[] irefs =
					feature.getIncludedFeatureReferences();
				for (int i = 0; i < irefs.length; i++) {
					IFeatureReference iref = irefs[i];
					IFeature ifeature = UpdateUtils.getIncludedFeature(feature, iref);
					VersionedIdentifier ivid =
						ifeature.getVersionedIdentifier();
					if (ivid.equals(vid))
						return true;
					if (includes(ifeature, vid, cycleCandidates))
						return true;
				}
				return false;
			} catch (CoreException e) {
				return false;
			} finally {
				// after this feature has been DFS-ed, it is no longer a cycle candidate
				cycleCandidates.remove(feature);
			}
		}


		public IInstallFeatureOperation[] getSelectedJobs() {
			return selectedJobs;
		}
		

		public void setSelectedJobs(IInstallFeatureOperation[] selectedJobs) {
			this.selectedJobs = selectedJobs;
		}

	
	}

	class LatestVersionFilter extends ViewerFilter {
		
		private IInstallFeatureOperation[] selectedJobs;
		
		public boolean select(Viewer viewer, Object parent, Object element) {
						
            if (element instanceof IInstallFeatureOperation) {
                return isLatestVersion((IInstallFeatureOperation) element) || isSelected( selectedJobs, (IInstallFeatureOperation)element);
            } else if ( (element instanceof SiteCategory) || (element instanceof SiteBookmark)){
            	Object[] children = ((ITreeContentProvider)((ContainerCheckedTreeViewer)viewer).getContentProvider()).getChildren(element);
            	for ( int i = 0; i < children.length; i++) {
            		if (select(viewer, element, children[i])) {
            			return true;
            		}
            	}
                return false;
            }
            
            return true;
		}
		
		private boolean isLatestVersion(IInstallFeatureOperation job) {
			IFeature feature = job.getFeature();
			for (int i = 0; i < jobs.size(); i++) {
				IInstallFeatureOperation candidateJob = (IInstallFeatureOperation) jobs.get(i);
				if (candidateJob.equals(job))
					continue;
				IFeature candidate = candidateJob.getFeature();
				if (feature.getSite() != job.getFeature().getSite())
					continue;
				if (!feature.getVersionedIdentifier().getIdentifier().equals(candidate.getVersionedIdentifier().getIdentifier()))
					continue;
				if (!feature.getVersionedIdentifier().getVersion().isGreaterOrEqualTo(candidate.getVersionedIdentifier().getVersion()))
					return false;
			}
			return true;
		}
		
		public IInstallFeatureOperation[] getSelectedJobs() {
			return selectedJobs;
		}
		
		public void setSelectedJobs(IInstallFeatureOperation[] selectedJobs) {
			this.selectedJobs = selectedJobs;
		}
		
		
	}
	
	class FeaturePropertyDialogAction extends PropertyDialogAction {
		private IStructuredSelection selection;

		public FeaturePropertyDialogAction(
			Shell shell,
			ISelectionProvider provider) {
			super(shell, provider);
		}

		public IStructuredSelection getStructuredSelection() {
			return selection;
		}

		public void selectionChanged(IStructuredSelection selection) {
			this.selection = selection;
		}

	}
	/**
	 * Constructor for ReviewPage2
	 */
	public ReviewPage(boolean isUpdateSearch, UpdateSearchRequest searchRequest, ArrayList jobs) {
		super("Review"); //$NON-NLS-1$
        this.isUpdateSearch = isUpdateSearch;
        this.jobs = jobs;
        if (this.jobs==null) this.jobs = new ArrayList();
        this.searchRequest = searchRequest;
        
		setTitle(UpdateUIMessages.InstallWizard_ReviewPage_title); 
		setDescription(UpdateUIMessages.InstallWizard_ReviewPage_desc); 
		UpdateUI.getDefault().getLabelProvider().connect(this);
		setBannerVisible(false);
	}

	public void dispose() {
		UpdateUI.getDefault().getLabelProvider().disconnect(this);
		super.dispose();
	}

	public void setVisible(boolean visible) {
		super.setVisible(visible);
		
		// when searching for updates, only nested patches can be shown.
		// when searching for features, features and patches can be shown
		String filterText = filterCheck.getText();
		String filterFeatures = UpdateUIMessages.InstallWizard_ReviewPage_filterFeatures; 
		String filterPatches = UpdateUIMessages.InstallWizard_ReviewPage_filterPatches; 

		if (isUpdateSearch && filterText.equals(filterFeatures))
			filterCheck.setText(filterPatches);
		else if ( !isUpdateSearch && filterText.equals(filterPatches))
			filterCheck.setText(filterFeatures);
		
		if (visible && !initialized) {
            initialized = true;
//			jobs.clear();

//			setDescription(UpdateUI.getString("InstallWizard.ReviewPage.searching")); //$NON-NLS-1$;
//			label.setText(UpdateUI.getString("")); //$NON-NLS-1$

			getShell().getDisplay().asyncExec(new Runnable() {
				public void run() {
//					searchRunner.runSearch();
					performPostSearchProcessing();
				}
			});
		}
	}

	private void performPostSearchProcessing() {
		BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
			public void run() {
				if (treeViewer != null) {
//                    treeViewer.refresh();
//                    treeViewer.getTree().layout(true);
					if (isUpdateSearch) {
						selectTrueUpdates();
					}
				}
				pageChanged();
				
				int totalCount = jobs != null ? jobs.size(): 0;
				if(totalCount >0) {
					setDescription(UpdateUIMessages.InstallWizard_ReviewPage_desc); 
					label.setText(UpdateUIMessages.InstallWizard_ReviewPage_label); 
				} else {
					if (isUpdateSearch)
						setDescription(UpdateUIMessages.InstallWizard_ReviewPage_zeroUpdates); 
					else
						setDescription(UpdateUIMessages.InstallWizard_ReviewPage_zeroFeatures); 
					label.setText(""); //$NON-NLS-1$
				}
			}
		});
	}
	
	private void selectTrueUpdates() {
		ArrayList trueUpdates = new ArrayList();
		for (int i=0; i<jobs.size(); i++) {
			IInstallFeatureOperation job = (IInstallFeatureOperation)jobs.get(i);
			if (!UpdateUtils.isPatch(job.getFeature()))
				trueUpdates.add(job);
		}
		treeViewer.setCheckedElements(trueUpdates.toArray()); 
		validateSelection(new NullProgressMonitor());
	}	

	/**
	 * @see DialogPage#createControl(Composite)
	 */
	public Control createContents(Composite parent) {
		Composite client = new Composite(parent, SWT.NULL);
		GridLayout layout = new GridLayout();
		layout.numColumns = 2;
		layout.marginWidth = layout.marginHeight = 0;
		client.setLayout(layout);
		label = new Label(client, SWT.NULL);
		label.setText(UpdateUIMessages.InstallWizard_ReviewPage_label); 
		GridData gd = new GridData();
		gd.horizontalSpan = 2;
		label.setLayoutData(gd);

        createTreeViewer(client);

		Composite comp = new Composite(client, SWT.NONE);
		layout = new GridLayout();
		layout.marginWidth = layout.marginHeight = 0;
		comp.setLayout(layout);
		comp.setLayoutData(new GridData(GridData.FILL_VERTICAL));
				
		Composite buttonContainer = new Composite(comp, SWT.NULL);
		gd = new GridData(GridData.FILL_VERTICAL);
		buttonContainer.setLayoutData(gd);
		layout = new GridLayout();
		layout.marginWidth = 0;
		layout.marginHeight = 0; //30?
		buttonContainer.setLayout(layout);
		buttonContainer.setLayoutData(new GridData(GridData.FILL_BOTH));

		Button button = new Button(buttonContainer, SWT.PUSH);
		button.setText(UpdateUIMessages.InstallWizard_ReviewPage_deselectAll); 
		gd =
			new GridData(
				GridData.HORIZONTAL_ALIGN_FILL
					| GridData.VERTICAL_ALIGN_BEGINNING);
		button.setLayoutData(gd);
		SWTUtil.setButtonDimensionHint(button);
		button.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleDeselectAll();
			}
		});

		moreInfoButton = new Button(buttonContainer, SWT.PUSH);
		moreInfoButton.setText(UpdateUIMessages.InstallWizard_ReviewPage_moreInfo); 
		gd =
			new GridData(
				GridData.HORIZONTAL_ALIGN_FILL
					| GridData.VERTICAL_ALIGN_BEGINNING);
		moreInfoButton.setLayoutData(gd);
		SWTUtil.setButtonDimensionHint(moreInfoButton);
		moreInfoButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleMoreInfo();
			}
		});
		moreInfoButton.setEnabled(false);
		
		
		propertiesButton = new Button(buttonContainer, SWT.PUSH);
		propertiesButton.setText(UpdateUIMessages.InstallWizard_ReviewPage_properties); 
		gd =
			new GridData(
				GridData.HORIZONTAL_ALIGN_FILL
					| GridData.VERTICAL_ALIGN_BEGINNING);
		propertiesButton.setLayoutData(gd);
		SWTUtil.setButtonDimensionHint(propertiesButton);
		propertiesButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				handleProperties();
			}
		});
		propertiesButton.setEnabled(false);

		selectRequiredFeaturesButton = new Button(buttonContainer, SWT.PUSH);
		selectRequiredFeaturesButton.setText(UpdateUIMessages.InstallWizard_ReviewPage_selectRequired);
		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL
				| GridData.VERTICAL_ALIGN_BEGINNING);
		selectRequiredFeaturesButton.setLayoutData(gd);
		SWTUtil.setButtonDimensionHint(selectRequiredFeaturesButton);
		selectRequiredFeaturesButton
				.addSelectionListener(new SelectionAdapter() {
					public void widgetSelected(SelectionEvent e) {
						BusyIndicator.showWhile(e.display, new Runnable() {
							public void run() {
								Object[] elements = treeViewer.getExpandedElements();
								treeViewer.expandAll();
								treeViewer.setExpandedElements(elements);
								selectRequiredFeatures();
								updateItemCount();
							}
						});
					}
				});

		statusButton = new Button(buttonContainer, SWT.PUSH);
		statusButton.setText(UpdateUIMessages.InstallWizard_ReviewPage_showStatus); 
		gd =
			new GridData(
				GridData.HORIZONTAL_ALIGN_FILL
					| GridData.VERTICAL_ALIGN_BEGINNING);
		statusButton.setLayoutData(gd);
		SWTUtil.setButtonDimensionHint(statusButton);
		statusButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				showStatus();
			}
		});

		//new Label(client, SWT.NULL);

		counterLabel = new Label(client, SWT.NULL);
		gd = new GridData();
		gd.horizontalSpan = 2;
		counterLabel.setLayoutData(gd);

		filterOlderVersionCheck = new Button(client, SWT.CHECK);
		filterOlderVersionCheck.setText(UpdateUIMessages.InstallWizard_ReviewPage_filterOlderFeatures); 
		filterOlderVersionCheck.setSelection(true);
		treeViewer.addFilter(olderVersionFilter);
		filterOlderVersionCheck.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {

				IInstallFeatureOperation[] jobs = getSelectedJobs();
				
				if (filterOlderVersionCheck.getSelection())
					treeViewer.addFilter(olderVersionFilter);
				else 
					treeViewer.removeFilter(olderVersionFilter);
				
				olderVersionFilter.setSelectedJobs(jobs);				
				pageChanged(jobs);
			}
		});
		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
		gd.horizontalSpan = 2;
		filterOlderVersionCheck.setLayoutData(gd);
		
		filterCheck = new Button(client, SWT.CHECK);
		filterCheck.setText(UpdateUIMessages.InstallWizard_ReviewPage_filterFeatures); 
		filterCheck.setSelection(false);
		//tableViewer.addFilter(filter);
		filterCheck.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				
				IInstallFeatureOperation[] jobs = getSelectedJobs();
				
				if (filterCheck.getSelection()) {
					// make sure model is local
					if (downloadIncludedFeatures()) {
						treeViewer.addFilter(filter);
					} else {
						filterCheck.setSelection(false);
					}
				} else {
					treeViewer.removeFilter(filter);
				}
				
				filter.setSelectedJobs(jobs);
				
				pageChanged(jobs);
			}
		});
		gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
		gd.horizontalSpan = 2;
		filterCheck.setLayoutData(gd);
		
		pageChanged();

		PlatformUI.getWorkbench().getHelpSystem().setHelp(client, "org.eclipse.update.ui.MultiReviewPage2"); //$NON-NLS-1$

		Dialog.applyDialogFont(parent);

		return client;
	}

    private void createTreeViewer(final Composite parent) {
        SashForm sform = new SashForm(parent, SWT.VERTICAL);
        GridData gd = new GridData(GridData.FILL_BOTH);
        gd.widthHint = 250;
        gd.heightHint =100;
        sform.setLayoutData(gd);
        
        treeViewer = new ContainerCheckedTreeViewer(sform, SWT.H_SCROLL | SWT.V_SCROLL
                | SWT.BORDER);
        treeViewer.getTree().setLayoutData(new GridData(GridData.FILL_BOTH));
        treeViewer.setContentProvider(new TreeContentProvider());
        treeViewer.setLabelProvider(new TreeLabelProvider());
        treeViewer.setInput(UpdateUI.getDefault().getUpdateModel());

        treeViewer
            .addSelectionChangedListener(new ISelectionChangedListener() {
            public void selectionChanged(SelectionChangedEvent e) {
                handleSelectionChanged((IStructuredSelection) e.getSelection());
            }
        });
        
        treeViewer.addCheckStateListener(new ICheckStateListener() {
            public void checkStateChanged(CheckStateChangedEvent event) {
    			/*
				 * validateSelection(); Object site =
				 * getSite(event.getElement()); ArrayList descendants = new
				 * ArrayList(); collectDescendants(site, descendants); Object[]
				 * nodes = new Object[descendants.size()]; for (int i = 0; i <
				 * nodes.length; i++) nodes[i] = descendants.get(i);
				 * treeViewer.update(nodes, null); updateItemCount();
				 */
				try {
					getContainer().run(true, true,
							getCheckStateOperation(event, parent.getDisplay()));
					getContainer().updateButtons();
					updateStatusButton();
				} catch (InvocationTargetException e) {
					UpdateUI.logException(e);
				} catch (InterruptedException e) {
					UpdateUI.logException(e);
				}
            }
        });
        
      descLabel = new ScrolledFormText(sform, true);
      descLabel.setText(""); //$NON-NLS-1$
      descLabel.setBackground(parent.getBackground());
      HyperlinkSettings settings = new HyperlinkSettings(parent.getDisplay());
      descLabel.getFormText().setHyperlinkSettings(settings);
      descLabel.getFormText().addHyperlinkListener(new HyperlinkAdapter() {
    	  public void linkActivated(HyperlinkEvent e) {
    		  Object href = e.getHref();
    		  if (href==null)
    			  return;
    		  try {
    			  URL url = new URL(href.toString());
    			  PlatformUI.getWorkbench().getBrowserSupport().getExternalBrowser().openURL(url);
    		  }
    		  catch (PartInitException ex) {
    			  UpdateUI.logException(ex);
    		  }
    		  catch (MalformedURLException ex) {
    			  UpdateUI.logException(ex);
    		  }
    	  }
      });
      
      gd = new GridData(SWT.FILL, SWT.FILL, true, true);
      gd.horizontalSpan = 1;
      descLabel.setLayoutData(gd);
      
      sform.setWeights(new int[] {10, 2});
    }
    
	private IRunnableWithProgress getCheckStateOperation(
			final CheckStateChangedEvent event, final Display display) {
		return new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) {
				monitor.beginTask(UpdateUIMessages.ReviewPage_validating,
						IProgressMonitor.UNKNOWN);
				validateSelection(monitor);
				if (monitor.isCanceled()) {
					undoStateChange(event);
					monitor.done();
					return;
				}
				Object site = getSite(event.getElement());
				ArrayList descendants = new ArrayList();
				collectDescendants(site, descendants, monitor);
				final Object[] nodes = new Object[descendants.size()];
				if (monitor.isCanceled()) {
					undoStateChange(event);
					monitor.done();
					return;
				}
				for (int i = 0; i < nodes.length; i++)
					nodes[i] = descendants.get(i);
				display.syncExec(new Runnable() {
					public void run() {
						treeViewer.update(nodes, null);
						updateItemCount();
					}
				});
				monitor.done();
			}
		};
	}
	
	private void undoStateChange(final CheckStateChangedEvent e) {
		treeViewer.getControl().getDisplay().syncExec(new Runnable() {
			public void run() {
				treeViewer.setChecked(e.getElement(), !e.getChecked());
			}
		});
	}
    
    private void handleSelectionChanged(IStructuredSelection ssel) {
        
        Object item = ssel.getFirstElement();
        String description = null;
        if (item instanceof SiteBookmark) {
            description = ((SiteBookmark)item).getDescription();
        } else if (item instanceof SiteCategory) {
            IURLEntry descEntry = ((SiteCategory)item).getCategory().getDescription();
            if (descEntry != null)
                description = descEntry.getAnnotation();
        } else if (item instanceof IInstallFeatureOperation) {
            jobSelected(ssel);
            return;
        }

        if (description == null)
            description = ""; //$NON-NLS-1$
        //descLabel.setText(UpdateManagerUtils.getWritableXMLString(description), false, true);
        updateDescription(description);
        propertiesButton.setEnabled(false);
        moreInfoButton.setEnabled(false);
    }

/*	
	private void fillContextMenu(IMenuManager manager) {
		if (treeViewer.getSelection().isEmpty()) return;
		Action action = new Action(UpdateUIMessages.InstallWizard_ReviewPage_prop) { 
			public void run() {
				handleProperties();
			}
		};
		manager.add(action);
	}
*/

	private void jobSelected(IStructuredSelection selection) {
		IInstallFeatureOperation job = (IInstallFeatureOperation) selection.getFirstElement();
		IFeature feature = job != null ? job.getFeature() : null;
		IURLEntry descEntry = feature != null ? feature.getDescription() : null;
		String desc = null;
		if (descEntry != null)
			desc = descEntry.getAnnotation();
		if (desc == null)
			desc = ""; //$NON-NLS-1$
		//descLabel.setText(UpdateManagerUtils.getWritableXMLString(desc));
		updateDescription(desc);
		propertiesButton.setEnabled(feature != null);
		moreInfoButton.setEnabled(job != null && getMoreInfoURL(job) != null);
	}
	
	private void updateDescription(String text) {
		descLabel.getFormText().setText(UpdateManagerUtils.getWritableXMLString(text), false, true);
		descLabel.reflow(true);
	}
	
	private void pageChanged() {
		pageChanged(this.getSelectedJobs());
	}
	
	private void pageChanged( IInstallFeatureOperation[] jobsSelected) {
	
		if (jobsSelected.length == 0) {
			lastDisplayedStatus = null;
			setErrorMessage(null);
			setPageComplete(false);
			setValidationStatus(null);
			problematicFeatures.clear();
		}
		treeViewer.setCheckedElements(jobsSelected);
		//validateSelection();
        treeViewer.refresh();
        treeViewer.setCheckedElements(jobsSelected);
        updateItemCount();
	}
	
	private void setValidationStatus(IStatus newValidationStatus) {
		this.validationStatus = newValidationStatus;
		updateStatusButton();
	}
	
	private void updateStatusButton() {
		statusButton.getDisplay().syncExec(new Runnable() {
			public void run() {
				boolean newState = validationStatus != null && validationStatus.getSeverity() != IStatus.OK;
				statusButton.setEnabled(newState);
			}
		});
	}
	
	private void updateItemCount() {
		updateItemCount(-1, -1);
	}
	
	private int getSelectedJobsUniqueCount() {
		Object[] checkedElements = getSelectedJobs();
		Set set = new HashSet();
		for (int i=0; i<checkedElements.length; i++) {
			IInstallFeatureOperation job = (IInstallFeatureOperation)checkedElements[i];
			IFeature feature = job.getFeature();
			if (set.contains(feature))
				continue;
			set.add(feature);
		}
		return set.size();
	}

	private void updateItemCount(int checkedCount, int totalCount) {
		if (checkedCount == -1) {
			checkedCount = getSelectedJobsUniqueCount();
		}
		if (totalCount == -1) {
			totalCount = jobs.size();
		}
		String total = "" + totalCount; //$NON-NLS-1$
		String selected = "" + checkedCount; //$NON-NLS-1$
		counterLabel.setText(
			NLS.bind(UpdateUIMessages.InstallWizard_ReviewPage_counter, (new String[] { selected, total })));	
        counterLabel.getParent().layout();
	}

//	private void handleSelectAll(boolean select) {
//		treeViewer.setAllChecked(select);
////		 make sure model is local (download using progress monitor from container)
//		downloadIncludedFeatures(); 
//			
//		treeViewer.getControl().getDisplay().asyncExec(new Runnable() {
//			public void run() {
//				pageChanged();
//			}
//		});
//	}

//  private void handleSelectAll(boolean select) {
//  treeViewer.setAllChecked(select);
////     make sure model is local (download using progress monitor from container)
//  downloadIncludedFeatures(); 
//      
//  treeViewer.getControl().getDisplay().asyncExec(new Runnable() {
//      public void run() {
//          pageChanged();
//      }
//  });
//}

   private void handleDeselectAll() {
        //treeViewer.setCheckedElements(new Object[0]);
         IInstallFeatureOperation[] selectedJobs = getSelectedJobs();
         for( int i = 0; i < selectedJobs.length; i++)
        	 treeViewer.setChecked( selectedJobs[i], false);
        // make sure model is local (download using progress monitor from
        // container)
//        downloadIncludedFeatures();

        treeViewer.getControl().getDisplay().asyncExec(new Runnable() {
            public void run() {
                pageChanged();
            }
        });
}
    
	private void handleProperties() {
		final IStructuredSelection selection =
			(IStructuredSelection) treeViewer.getSelection();

		final IInstallFeatureOperation job =
			(IInstallFeatureOperation) selection.getFirstElement();
		if (propertiesAction == null) {
			propertiesAction =
				new FeaturePropertyDialogAction(getShell(), treeViewer);
		}

		BusyIndicator
			.showWhile(treeViewer.getControl().getDisplay(), new Runnable() {
			public void run() {
				SimpleFeatureAdapter adapter =
					new SimpleFeatureAdapter(job.getFeature());
				propertiesAction.selectionChanged(
					new StructuredSelection(adapter));
				propertiesAction.run();
			}
		});
	}

	private String getMoreInfoURL(IInstallFeatureOperation job) {
		IURLEntry desc = job.getFeature().getDescription();
		if (desc != null) {
			URL url = desc.getURL();
			return (url == null) ? null : url.toString();
		}
		return null;
	}

	private void handleMoreInfo() {
		IStructuredSelection selection =
			(IStructuredSelection) treeViewer.getSelection();
		final IInstallFeatureOperation selectedJob =
			(IInstallFeatureOperation) selection.getFirstElement();
		BusyIndicator
			.showWhile(treeViewer.getControl().getDisplay(), new Runnable() {
			public void run() {
				String urlName = getMoreInfoURL(selectedJob);
				UpdateUI.showURL(urlName);
			}
		});
	}

	private IStatus selectRequiredFeatures() {
		
		IInstallFeatureOperation[] jobs = getSelectedJobs();
		RequiredFeaturesResult requiredFeaturesResult = ((OperationValidator)OperationsManager
				.getValidator()).getRequiredFeatures(jobs);
		setValidationStatus(requiredFeaturesResult.getStatus());
		Set requiredFeatures = requiredFeaturesResult.getRequiredFeatures();
		problematicFeatures.clear();
		
		Iterator requiredFeaturesIterator = requiredFeatures.iterator();
		ArrayList toBeInstalled = new ArrayList();
		
		while (requiredFeaturesIterator.hasNext()) {
			IImport requiredFeature = ((InternalImport)requiredFeaturesIterator.next()).getImport();

			IInstallFeatureOperation currentFeatureSelected = null;
			TreeItem[] items = treeViewer.getTree().getItems();
			for (int i = 0; i < items.length; i++) {
				TreeItem[] siteRootContent = items[i].getItems();
				for (int j = 0; j < siteRootContent.length; j++) {
					if (siteRootContent[j].getData() instanceof SiteCategory) {
						
						if ( !treeViewer.getChecked(siteRootContent[j].getData())) {
							// this category has not been checked at all so we have to create its features
							treeViewer.createChildren(siteRootContent[j]);
						}
						TreeItem[] features = siteRootContent[j].getItems();
						if ((features.length > 0) && (features[0].getData() == null)) {
							// this category has been checked but not visited yet so restore the features in it
							treeViewer.createChildren(siteRootContent[j]);
							treeViewer.updateChildrenItems(siteRootContent[j]);
							features = siteRootContent[j].getItems();
						}
						
						for (int k = 0; k < features.length; k++) {
							currentFeatureSelected = decideOnFeatureSelection(
									requiredFeature,
									(IInstallFeatureOperation) features[k]
											.getData(), currentFeatureSelected);
						}
					} else if (siteRootContent[j].getData() instanceof IInstallFeatureOperation) {
						currentFeatureSelected = decideOnFeatureSelection(
								requiredFeature,
								(IInstallFeatureOperation) siteRootContent[j]
										.getData(), currentFeatureSelected);
					}
				}
			}

			if (currentFeatureSelected != null)
				toBeInstalled.add(currentFeatureSelected);
		}

		if (!toBeInstalled.isEmpty()) {
			Iterator toBeInstalledIterator = toBeInstalled.iterator();
			while (toBeInstalledIterator.hasNext()) {
				IInstallFeatureOperation current = (IInstallFeatureOperation)toBeInstalledIterator.next();
				treeViewer.setChecked(current, true);			
			}
			return selectRequiredFeatures();
		} else {
			problematicFeatures.clear();
			if (validationStatus != null) {
				IStatus[] status = validationStatus.getChildren();
				for (int i = 0; i < status.length; i++) {
					IStatus singleStatus = status[i];
					if (isSpecificStatus(singleStatus)) {
						IFeature f = ((FeatureStatus) singleStatus)
								.getFeature();
						problematicFeatures.add(f);
					}
				}
			}

			setPageComplete(validationStatus == null
					|| validationStatus.getSeverity() == IStatus.WARNING);

			lastDisplayedStatus = null;
			updateWizardMessage();
			
			treeViewer.update(getSelectedJobs(), null);
			return validationStatus;
		}
	}

	public IInstallFeatureOperation[] getSelectedJobs() {      
        Object[] selected = treeViewer.getCheckedElements();
        ArrayList selectedJobs = new ArrayList(selected.length);
        for (int i=0; i<selected.length; i++)
            if (selected[i] instanceof IInstallFeatureOperation)
                selectedJobs.add(selected[i]);
        return (IInstallFeatureOperation[])selectedJobs.toArray(new IInstallFeatureOperation[selectedJobs.size()]);
	}
	
	public void validateSelection(IProgressMonitor monitor) {
		IInstallFeatureOperation[] jobs;

		final IInstallFeatureOperation[][] bag = new IInstallFeatureOperation[1][];
		treeViewer.getControl().getDisplay().syncExec(new Runnable() {
			public void run() {
				bag[0] = getSelectedJobs();
			}
		});
		if (monitor.isCanceled()) return;
		jobs = bag[0];
		setValidationStatus(OperationsManager.getValidator()
				.validatePendingChanges(jobs));
		problematicFeatures.clear();
		if (monitor.isCanceled()) return;
		if (validationStatus != null) {
			IStatus[] status = validationStatus.getChildren();
			for (int i = 0; i < status.length; i++) {
				IStatus singleStatus = status[i];
				if (isSpecificStatus(singleStatus)) {
					IFeature f = ((FeatureStatus) singleStatus).getFeature();
					problematicFeatures.add(f);
				}
			}
		}
		if (monitor.isCanceled())
				return;
		treeViewer.getControl().getDisplay().syncExec(new Runnable() {
			public void run() {
				setPageComplete(validationStatus == null
						|| validationStatus.getSeverity() == IStatus.WARNING);
/*
				statusButton.setEnabled(validationStatus != null
						&& validationStatus.getSeverity() != IStatus.OK);
						*/

				updateWizardMessage();
			}
		});
	}

	private void showStatus() {
		if (validationStatus != null) {
			new StatusDialog().open();
		}

	}
	/**
	 * Check whether status is relevant to show for
	 * a specific feature or is a other problem
	 * @param status
	 * @return true if status is FeatureStatus with
	 * specified feature and certain error codes
	 */
	private boolean isSpecificStatus(IStatus status){
		if(!(status instanceof FeatureStatus)){
			return false;
		}
		if(status.getSeverity()!=IStatus.ERROR){
			return false;
		}
		FeatureStatus featureStatus = (FeatureStatus) status;
		if(featureStatus.getFeature()==null){
			return false;
		}
		return 0!= (featureStatus.getCode()
				& FeatureStatus.CODE_CYCLE
				+ FeatureStatus.CODE_ENVIRONMENT
				+ FeatureStatus.CODE_EXCLUSIVE
				+ FeatureStatus.CODE_OPTIONAL_CHILD
				+ FeatureStatus.CODE_PREREQ_FEATURE
				+ FeatureStatus.CODE_PREREQ_PLUGIN);
	}
	/**
	 * Update status in the wizard status area
	 */
	private void updateWizardMessage() {
		
		if (validationStatus == null) {
			lastDisplayedStatus=null;
			setErrorMessage(null);
		} else if (validationStatus.getSeverity() == IStatus.WARNING) {
			lastDisplayedStatus=null;
			setErrorMessage(null);
			setMessage(validationStatus.getMessage(), IMessageProvider.WARNING);
		} else {
			// 1.  Feature selected, creating a problem for it, show status for it
			if(newlySelectedFeature !=null){
				IStatus[] status = validationStatus.getChildren();
				for(int s =0; s< status.length; s++){
					if(isSpecificStatus(status[s])){
						FeatureStatus featureStatus = (FeatureStatus)status[s];
						if(newlySelectedFeature.equals(featureStatus.getFeature())){
							lastDisplayedStatus=featureStatus;
							setErrorMessage(featureStatus.getMessage());
							return;
						}
					}
				}
			}
			
			// 2.  show old status if possible (it is still valid)
			if(lastDisplayedStatus !=null){
				IStatus[] status = validationStatus.getChildren();
				for(int i=0; i<status.length; i++){
					if(lastDisplayedStatus.equals(status[i])){
						//lastDisplayedStatus=lastDisplayedStatus;
						//setErrorMessage(status[i].getMessage());
						return;
					}
				}
				lastDisplayedStatus = null;
			}
			
			// 3.  pick the first problem that is specific to some feature
			IStatus[] status = validationStatus.getChildren();
			for(int s =0; s< status.length; s++){
				if(isSpecificStatus(status[s])){
					lastDisplayedStatus = (FeatureStatus)status[s];
					setErrorMessage(status[s].getMessage());
					return;
				}
			}
				
			// 4.  display the first problem (no problems specify a feature)
			if(status.length>0){
				IStatus singleStatus=status[0];
				setErrorMessage(singleStatus.getMessage());
			}else{
			// 5. not multi or empty multi status
				setErrorMessage(UpdateUIMessages.InstallWizard_ReviewPage_invalid_long); 
			}
		}
	}

	class StatusDialog extends ErrorDialog {
//		Button detailsButton;
		public StatusDialog() {
			super(getContainer().getShell(), UpdateUIMessages.InstallWizard_ReviewPage_invalid_short, null, 
					validationStatus, IStatus.OK | IStatus.INFO
							| IStatus.WARNING | IStatus.ERROR);
		}
//		protected Button createButton(
//				Composite parent,
//				int id,
//				String label,
//				boolean defaultButton) {
//			Button b = super.createButton(parent, id, label, defaultButton);
//			if(IDialogConstants.DETAILS_ID == id){
//				detailsButton = b;
//			}
//			return b;
//		}
		public void create() {
			super.create();
			buttonPressed(IDialogConstants.DETAILS_ID);
//			if(detailsButton!=null){
//				detailsButton.dispose();
//			}
		}
	}

	/**
	 * @return true, if completed, false if canceled by the user
	 */
	private boolean downloadIncludedFeatures() {
		try {
			Downloader downloader = new Downloader(jobs);
			getContainer().run(true, true, downloader);
			return !downloader.isCanceled();
		} catch (InvocationTargetException ite) {
		} catch (InterruptedException ie) {
		}
		return true;
	}
	/**
	 * Runnable to resolve included feature references.
	 */
	class Downloader implements IRunnableWithProgress {
		boolean canceled = false;
		/**
		 * List of IInstallFeatureOperation
		 */
		ArrayList operations;
		public Downloader(ArrayList installOperations) {
			operations = installOperations;
		}
		public boolean isCanceled() {
			return canceled;
		}
		public void run(IProgressMonitor monitor)
				throws InvocationTargetException, InterruptedException {
			for (int i = 0; i < operations.size(); i++) {
				IInstallFeatureOperation candidate = (IInstallFeatureOperation) operations
						.get(i);
				IFeature feature = candidate.getFeature();
				try {
					IFeatureReference[] irefs = feature
							.getRawIncludedFeatureReferences();
					for (int f = 0; f < irefs.length; f++) {
						if (monitor.isCanceled()) {
							canceled = true;
							return;
						}
						IFeatureReference iref = irefs[f];
						iref.getFeature(monitor);
					}
				} catch (CoreException e) {
				}
			}
			if (monitor.isCanceled()) {
				canceled = true;
			}
		}
	}
    
    private IInstallFeatureOperation findJob(FeatureReferenceAdapter feature)
            throws CoreException {
        if (jobs == null)
            return null;
        for (int i = 0; i < jobs.size(); i++)
            if (((IInstallFeatureOperation) jobs.get(i)).getFeature()
                    .getVersionedIdentifier().equals(feature.getFeatureReference()
                    .getVersionedIdentifier()))
                return (IInstallFeatureOperation) jobs.get(i);

        return null;
    }
    
    private Object getSite(Object object) {
        ITreeContentProvider provider = (ITreeContentProvider)treeViewer.getContentProvider();
        while (object != null && !(object instanceof SiteBookmark)) {
            object = provider.getParent(object);
        }
        return object;
    }
    
	private void collectDescendants(Object root, ArrayList list,
			IProgressMonitor monitor) {
		ITreeContentProvider provider = (ITreeContentProvider) treeViewer
				.getContentProvider();
		Object[] children = provider.getChildren(root);
		if (children != null && children.length > 0)
			for (int i = 0; i < children.length; i++) {
				if (monitor.isCanceled())
					return;
				list.add(children[i]);
				collectDescendants(children[i], list, monitor);
			}
	}

	
	public boolean isFeatureGood(IImport requiredFeature, IFeature feature) {
		return isFeatureGood(requiredFeature, feature, new ArrayList());
	}
	
	public boolean isFeatureGood(IImport prereq, IFeature feature, List visitedFeatures) {

		if (prereq.getKind() == IImport.KIND_FEATURE) { 
			if ((!prereq.getVersionedIdentifier().getIdentifier().equals(
					feature.getVersionedIdentifier().getIdentifier()))) {
				IIncludedFeatureReference[] iifr = null;
				try {
					iifr = feature.getIncludedFeatureReferences();
				} catch (CoreException e) {
					UpdateUI.logException(e);
					//	if we can not get included features then they can not satisfy requirement, so just ignore them
					return false;
				}
				if (iifr == null) {
					return false;
				}
				
				for(int i = 0; i < iifr.length; i++) {
					IFeature current;
					try {
						current = UpdateUtils.getIncludedFeature(feature, iifr[i]);
					} catch (CoreException e) {
						// if we can not get feature then it can not satisfy requirement, so just ignore it
						UpdateUI.logException(e);
						continue;
					}
					if (!visitedFeatures.contains(current)) {
						visitedFeatures.add(current);
						if (isFeatureGood(prereq, current, visitedFeatures)) {
							return true;
						}
					}
				}
				
				return false;
			}

			int rule = (prereq.getRule() != IImport.RULE_NONE) ? prereq.getRule() : IImport.RULE_COMPATIBLE;

			switch (rule) {
			case IImport.RULE_PERFECT: return feature.getVersionedIdentifier().getVersion().isPerfect(
								prereq.getVersionedIdentifier()
								.getVersion());
			case IImport.RULE_EQUIVALENT:
						return feature.getVersionedIdentifier().getVersion()
						.isEquivalentTo(
								prereq.getVersionedIdentifier()
								.getVersion());
			case IImport.RULE_COMPATIBLE:
				return feature.getVersionedIdentifier().getVersion()
						.isCompatibleWith(
								prereq.getVersionedIdentifier()
								.getVersion());
			case IImport.RULE_GREATER_OR_EQUAL:
						return feature.getVersionedIdentifier().getVersion()
						.isGreaterOrEqualTo(
								prereq.getVersionedIdentifier()
								.getVersion());
			}

			return false;
		} else {
			if ((prereq.getKind() == IImport.KIND_PLUGIN)) { 
				return checkIfFeatureHasPlugin( prereq, feature);
			}
			return false;
		}
	}
	
	private boolean checkIfFeatureHasPlugin(IImport requiredFeature, IFeature feature)  {
		
		IPluginEntry[] plugins = feature.getPluginEntries();
		try {			
			List includedPlugins = getPluginEntriesFromIncludedFeatures(feature, new ArrayList(), new ArrayList());
			includedPlugins.addAll(Arrays.asList(plugins));
			plugins = (IPluginEntry[])includedPlugins.toArray( new IPluginEntry[includedPlugins.size()]);
		} catch( CoreException ce) {
			UpdateUI.logException(ce);
			// ignore this plugins can not sutisfy requirement anyways
		}
		if (plugins == null) {
			return false;
		}
		
		for(int i = 0; i < plugins.length; i++) {
			if (isMatch(plugins[i].getVersionedIdentifier(), requiredFeature.getVersionedIdentifier(), requiredFeature.getIdRule())) {
				return true;
			}
		}
		
		return false;
	}

	private List getPluginEntriesFromIncludedFeatures(IFeature feature, List plugins, List visitedFeatures) throws CoreException {
		IIncludedFeatureReference[] iifr = feature.getIncludedFeatureReferences();
		for(int i = 0; i < iifr.length; i++) {
			IFeature current = UpdateUtils.getIncludedFeature( feature, iifr[i]);
			if (!visitedFeatures.contains(current)) {
				IPluginEntry[] pluginEntries = current.getPluginEntries();
				plugins.addAll(Arrays.asList(pluginEntries));
				visitedFeatures.add(current);
				getPluginEntriesFromIncludedFeatures(current, plugins, visitedFeatures);
			}
		}
		
		return plugins;
	}

	// vid1 = feature
	// vid2 = requiredFeature
	private boolean isMatch( VersionedIdentifier vid1, VersionedIdentifier vid2, int rule) {
		
		if (!vid1.getIdentifier().equals(vid2.getIdentifier())) {
			return false;
		}
		if ( vid2.getVersion().getMajorComponent() == 0 && vid2.getVersion().getMinorComponent() == 0 && vid2.getVersion().getServiceComponent() == 0 ) {
			//version is ignored
			return true;
		}
		switch (rule) {
		case IImport.RULE_PERFECT:
			return vid1.getVersion().isPerfect(vid2.getVersion());
		case IImport.RULE_EQUIVALENT:
			return vid1.getVersion().isEquivalentTo(vid2.getVersion());
		case IImport.RULE_COMPATIBLE:
			return vid1.getVersion().isCompatibleWith(vid2.getVersion());
		case IImport.RULE_GREATER_OR_EQUAL:
			return vid1.getVersion().isGreaterOrEqualTo(vid2.getVersion());
		}
		return false;
	}

	public boolean isFeatureBetter(IInstallFeatureOperation feature,
			IInstallFeatureOperation currentFeatureSelected) {

		if (currentFeatureSelected == null)
			return true;
		// If the feature is the same, pick the newer one
		if (currentFeatureSelected.getFeature().getVersionedIdentifier().getIdentifier().equals(
				feature.getFeature().getVersionedIdentifier().getIdentifier())) {
			return !currentFeatureSelected.getFeature().getVersionedIdentifier()
			.getVersion().isGreaterOrEqualTo(
					feature.getFeature().getVersionedIdentifier()
							.getVersion());			
		}
		else {
			// Different features.
			// Pick a feature with smaller number of plug-ins
			NullProgressMonitor monitor = new NullProgressMonitor();
			int currentNumber = getTotalNumberOfPluginEntries(currentFeatureSelected.getFeature(), monitor);
			int newNumber = getTotalNumberOfPluginEntries(feature.getFeature(), monitor);
			return newNumber<currentNumber;
		}
	}
	
	private int getTotalNumberOfPluginEntries(IFeature feature, IProgressMonitor monitor) {
		int count = 0;
		try {
			count = feature.getPluginEntryCount();
			IIncludedFeatureReference [] irefs = feature.getIncludedFeatureReferences();
			for (int i=0; i<irefs.length; i++) {
				IFeature child = irefs[i].getFeature(monitor);
				count += getTotalNumberOfPluginEntries(child, monitor);
			}
		}
		catch (CoreException e) {
		}
		return count;
	}

	public IInstallFeatureOperation decideOnFeatureSelection(
			IImport requiredFeature, IInstallFeatureOperation feature,
			IInstallFeatureOperation currentFeatureSelected) {

		if (isFeatureGood(requiredFeature, feature.getFeature()) && isFeatureBetter(feature, currentFeatureSelected)) {
				return feature;
		} else {
			return currentFeatureSelected;
		}
	}
	
	private boolean isFeatureProblematic(IFeature feature) {
		
		if ( problematicFeatures.contains(feature) )
			return true;
		
		IImport[] iimports = feature.getImports();
		
		for(int i = 0; i < iimports.length; i++) {
			Iterator problematicFeatures = this.problematicFeatures.iterator();
			while(problematicFeatures.hasNext()) {
				if (iimports[i].getVersionedIdentifier().equals( ((IFeature)problematicFeatures.next()).getVersionedIdentifier()) ) {
					return true;
				}
			}
		}
		try {
			Iterator includedFeatures = OperationValidator.computeFeatureSubtree(feature, null, null, false, new ArrayList(), null ).iterator();
			while (includedFeatures.hasNext()) {
				Iterator problematicFeatures = this.problematicFeatures.iterator();		
				VersionedIdentifier currentIncludedFeaturesVI = ((IFeature)includedFeatures.next()).getVersionedIdentifier();
				while (problematicFeatures.hasNext()) {
					Object currentProblematicFeatures = problematicFeatures.next();
					if (currentProblematicFeatures instanceof IFeature) {
						VersionedIdentifier currentProblematicFeaturesVI = ((IFeature)currentProblematicFeatures).getVersionedIdentifier();						
						if (currentProblematicFeaturesVI.equals( currentIncludedFeaturesVI) ) {
							return true;
						}
					}
				}
			}
		} catch (CoreException ce) {
		}
 		return false;
	}
	
	private boolean isSelected( IInstallFeatureOperation[] selectedJobs, IInstallFeatureOperation iInstallFeatureOperation) {
		
		if (selectedJobs == null)
			return false;
		
		for( int i = 0; i < selectedJobs.length; i++) {
			
			if (iInstallFeatureOperation.getFeature().getVersionedIdentifier().equals(selectedJobs[i].getFeature().getVersionedIdentifier()) &&
				iInstallFeatureOperation.getFeature().getSite().getURL().equals(selectedJobs[i].getFeature().getSite().getURL())) {
				return true;
			}
		}
		
		return false;
	}
}