/*
 * Copyright (c) 2015-2018 Eike Stepper (Loehne, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 *    Yatta Solutions - [466264] Enhance UX in simple installer
 */
package org.eclipse.oomph.setup.internal.installer;

import org.eclipse.oomph.base.Annotation;
import org.eclipse.oomph.base.util.BaseUtil;
import org.eclipse.oomph.internal.setup.SetupPrompter;
import org.eclipse.oomph.internal.setup.SetupProperties;
import org.eclipse.oomph.internal.ui.FlatButton;
import org.eclipse.oomph.internal.ui.ImageCheckbox;
import org.eclipse.oomph.internal.ui.ImageHoverButton;
import org.eclipse.oomph.jreinfo.JRE;
import org.eclipse.oomph.jreinfo.JREManager;
import org.eclipse.oomph.jreinfo.ui.JREController;
import org.eclipse.oomph.p2.core.AgentManager;
import org.eclipse.oomph.p2.core.P2Util;
import org.eclipse.oomph.p2.internal.core.DownloadArtifactEvent;
import org.eclipse.oomph.setup.AnnotationConstants;
import org.eclipse.oomph.setup.AttributeRule;
import org.eclipse.oomph.setup.Installation;
import org.eclipse.oomph.setup.LicenseInfo;
import org.eclipse.oomph.setup.Product;
import org.eclipse.oomph.setup.ProductCatalog;
import org.eclipse.oomph.setup.ProductVersion;
import org.eclipse.oomph.setup.Scope;
import org.eclipse.oomph.setup.SetupFactory;
import org.eclipse.oomph.setup.SetupPackage;
import org.eclipse.oomph.setup.SetupTask;
import org.eclipse.oomph.setup.SetupTaskContext;
import org.eclipse.oomph.setup.Trigger;
import org.eclipse.oomph.setup.User;
import org.eclipse.oomph.setup.VariableTask;
import org.eclipse.oomph.setup.internal.core.AbstractSetupTaskContext;
import org.eclipse.oomph.setup.internal.core.SetupContext;
import org.eclipse.oomph.setup.internal.core.SetupTaskPerformer;
import org.eclipse.oomph.setup.internal.core.util.SetupCoreUtil;
import org.eclipse.oomph.setup.internal.installer.SimpleInstallLaunchButton.State;
import org.eclipse.oomph.setup.internal.installer.SimpleMessageOverlay.Type;
import org.eclipse.oomph.setup.internal.installer.SimpleProductPage.ProductComposite;
import org.eclipse.oomph.setup.log.ProgressLog;
import org.eclipse.oomph.setup.ui.EnablementComposite;
import org.eclipse.oomph.setup.ui.EnablementDialog;
import org.eclipse.oomph.setup.ui.JREDownloadHandler;
import org.eclipse.oomph.setup.ui.LicensePrePrompter;
import org.eclipse.oomph.setup.ui.SetupUIPlugin;
import org.eclipse.oomph.setup.ui.UnsignedContentDialog;
import org.eclipse.oomph.setup.ui.wizards.ProgressPage;
import org.eclipse.oomph.setup.ui.wizards.SetupWizard.SelectionMemento;
import org.eclipse.oomph.ui.StackComposite;
import org.eclipse.oomph.ui.UIUtil;
import org.eclipse.oomph.util.IOUtil;
import org.eclipse.oomph.util.OS;
import org.eclipse.oomph.util.ObjectUtil;
import org.eclipse.oomph.util.OomphPlugin.Preference;
import org.eclipse.oomph.util.Pair;
import org.eclipse.oomph.util.PropertiesUtil;
import org.eclipse.oomph.util.StringUtil;
import org.eclipse.oomph.util.UserCallback;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.URIConverter;
import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.equinox.p2.core.UIServices;
import org.eclipse.equinox.p2.metadata.ILicense;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.LocationAdapter;
import org.eclipse.swt.browser.LocationEvent;
import org.eclipse.swt.custom.CCombo;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.events.VerifyEvent;
import org.eclipse.swt.events.VerifyListener;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Dialog;
import org.eclipse.swt.widgets.DirectoryDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

import java.io.File;
import java.io.FileFilter;
import java.security.cert.Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EventObject;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author Eike Stepper
 */
public class SimpleVariablePage extends SimpleInstallerPage
{
  public static final int PROGRESS_WATCHDOG_TIMEOUT = PropertiesUtil.getProperty("oomph.progress.watchdog.timeout", 15);

  private static final boolean EXIT_AFTER_LAUNCH = !PropertiesUtil.isProperty("oomph.no.exit.after.launch");

  private static final Preference PREF_STARTMENU_ENTRY = SetupInstallerPlugin.INSTANCE.getConfigurationPreference("startMenuEntry");

  private static final Preference PREF_DESKTOP_SHORTCUT = SetupInstallerPlugin.INSTANCE.getConfigurationPreference("desktopShortcut");

  private static final String PROP_INSTALL_ROOT = "oomph.setup.install.root";

  private static final Preference PREF_INSTALL_ROOT = SetupInstallerPlugin.INSTANCE.getConfigurationPreference("installRoot");

  private static final File FILE_INSTALL_ROOT = new File(SetupInstallerPlugin.INSTANCE.getUserLocation().toFile(), PREF_INSTALL_ROOT.key() + ".txt");

  private static final String TEXT_README = "show readme file";

  private static final String TEXT_SYSTEM_EXPLOROR = "open in system explorer";

  private static final String TEXT_KEEP = "keep installer";

  private static final String MESSAGE_SUCCESS = "Installation completed successfully.";

  private static final String MESSAGE_FAILURE = "Installation failed with an error.";

  protected static final boolean JRE_CHOICE = Boolean.valueOf(PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_JRE_CHOICE, "true"));

  protected static final boolean INSTALL_CHOICE = Boolean.valueOf(PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALL_CHOICE, "true"));

  private final SelectionMemento selectionMemento;

  private final Map<String, ProductVersion> productVersions = new HashMap<String, ProductVersion>();

  private Product product;

  private ProductVersion selectedProductVersion;

  private String readmePath;

  private Browser detailBrowser;

  private ProductComposite detailComposite;

  private CCombo versionCombo;

  private Label versionLabel;

  private Control versionSpacer;

  private ImageCheckbox bitness32Button;

  private ImageCheckbox bitness64Button;

  private Label bitness32Spacer;

  private Label bitness64Spacer;

  private JREController javaController;

  private Label javaLabel;

  private Control javaSpacer;

  private ComboViewer javaViewer;

  private FlatButton javaButton;

  private Control javaTrailingSpacer;

  private Text folderText;

  private Label installFolderLabel;

  private Control installFolderSpacer;

  private FlatButton folderButton;

  private String installRoot;

  private String installFolder;

  private Thread installThread;

  private StackComposite installStack;

  private SimpleInstallLaunchButton installButton;

  private String installError;

  private boolean installed;

  private SetupTaskPerformer performer;

  private SimpleProgress progress;

  private FlatButton cancelButton;

  private FlatButton openInSystemExplorerButton;

  private FlatButton showReadmeButton;

  private FlatButton keepInstallerButton;

  private Composite afterInstallComposite;

  private Composite errorComposite;

  private Composite container;

  private SimpleCheckbox createStartMenuEntryButton;

  private SimpleCheckbox createDesktopShortcutButton;

  private Runnable preInstallAction;

  public SimpleVariablePage(final Composite parent, final SimpleInstallerDialog dialog, SelectionMemento selectionMemento)
  {
    super(parent, dialog, true);
    this.selectionMemento = selectionMemento;
  }

  @Override
  protected void createContent(Composite container)
  {
    this.container = container;

    container.setBackgroundMode(SWT.INHERIT_FORCE);
    container.setBackground(AbstractSimpleDialog.COLOR_WHITE);

    String powerShell = KeepInstallerUtil.getPowerShell();

    // Row 1
    GridData browserLayoutData = GridDataFactory.fillDefaults().indent(0, 13).grab(true, false).create();
    Point defaultSize = SimpleInstallerDialog.getDefaultSize(container);
    browserLayoutData.heightHint = defaultSize.y * (powerShell != null ? 20 : 34) / 100;

    Composite detailArea = new Composite(container, SWT.NONE);
    detailArea.setLayoutData(browserLayoutData);
    detailArea.setLayout(new FillLayout());

    if (UIUtil.isBrowserAvailable())
    {
      detailBrowser = new Browser(detailArea, SWT.NO_SCROLL);
      detailBrowser.addLocationListener(new LocationAdapter()
      {
        @Override
        public void changing(LocationEvent event)
        {
          String url = event.location;
          if (!"about:blank".equals(url))
          {
            OS.INSTANCE.openSystemBrowser(url);
            event.doit = false;
          }
        }
      });
    }
    else
    {
      detailBrowser = null;
      detailComposite = new ProductComposite(detailArea, null, null);
    }

    Composite variablesComposite = new Composite(container, SWT.NONE);
    GridLayout variablesLayout = new GridLayout(5, false);
    variablesLayout.horizontalSpacing = 8;
    variablesLayout.verticalSpacing = 3;
    variablesLayout.marginLeft = 14;
    variablesLayout.marginRight = 30;
    variablesLayout.marginTop = 24;
    variablesLayout.marginBottom = 0;
    variablesLayout.marginHeight = 0;
    variablesComposite.setLayout(variablesLayout);
    variablesComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());

    // Row 3
    versionLabel = createLabel(variablesComposite, "Product Version");

    // Spacer to get a little bit more distance between labels and input fields
    versionSpacer = spacer(variablesComposite);
    versionSpacer.setLayoutData(GridDataFactory.swtDefaults().hint(17, SWT.DEFAULT).create());

    versionCombo = createComboBox(variablesComposite, SWT.READ_ONLY);
    versionCombo.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        String label = versionCombo.getItem(versionCombo.getSelectionIndex());
        productVersionSelected(productVersions.get(label));
        UIUtil.clearTextSelection(versionCombo);
      }
    });

    if (JREManager.BITNESS_CHANGEABLE)
    {
      bitness32Button = new ImageCheckbox(variablesComposite, SetupInstallerPlugin.INSTANCE.getSWTImage("simple/32bit_enabled.png"),
          SetupInstallerPlugin.INSTANCE.getSWTImage("simple/32bit_selected.png"));
      bitness32Button.setDisabledImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/32bit_disabled.png"));
      bitness32Button.setLayoutData(GridDataFactory.swtDefaults().align(SWT.BEGINNING, SWT.BEGINNING).indent(4, 0).hint(SWT.DEFAULT, 30).create());
      bitness32Button.setChecked(false);
      bitness32Button.setVisible(JREManager.BITNESS_CHANGEABLE);
      bitness32Button.setToolTipText("Create a 32 bit installation");
      bitness32Button.addSelectionListener(new SelectionAdapter()
      {
        @Override
        public void widgetSelected(SelectionEvent e)
        {
          bitness32Button.setChecked(true);
          bitness64Button.setChecked(false);
          javaController.setBitness(32);
        }
      });

      bitness64Button = new ImageCheckbox(variablesComposite, SetupInstallerPlugin.INSTANCE.getSWTImage("simple/64bit_enabled.png"),
          SetupInstallerPlugin.INSTANCE.getSWTImage("simple/64bit_selected.png"));
      bitness64Button.setDisabledImage(SetupInstallerPlugin.INSTANCE.getSWTImage("simple/64bit_disabled.png"));
      bitness64Button.setLayoutData(GridDataFactory.swtDefaults().align(SWT.BEGINNING, SWT.BEGINNING).hint(SWT.DEFAULT, 30).create());
      bitness64Button.setChecked(true);
      bitness64Button.setVisible(JREManager.BITNESS_CHANGEABLE);
      bitness64Button.setToolTipText("Create a 64 bit installation");
      bitness64Button.addSelectionListener(new SelectionAdapter()
      {
        @Override
        public void widgetSelected(SelectionEvent e)
        {
          bitness32Button.setChecked(false);
          bitness64Button.setChecked(true);
          javaController.setBitness(64);
        }
      });
    }
    else
    {
      bitness32Spacer = new Label(variablesComposite, SWT.NONE);
      bitness64Spacer = new Label(variablesComposite, SWT.NONE);
    }

    // Row 4
    javaLabel = createLabel(variablesComposite, "Java VM");

    javaSpacer = spacer(variablesComposite);

    final CCombo javaCombo = createComboBox(variablesComposite, SWT.READ_ONLY);

    javaViewer = new ComboViewer(javaCombo);
    javaViewer.setContentProvider(new ArrayContentProvider());
    javaViewer.setLabelProvider(new LabelProvider());
    javaViewer.addPostSelectionChangedListener(new ISelectionChangedListener()
    {
      public void selectionChanged(SelectionChangedEvent event)
      {
        UIUtil.setSelectionToEnd(javaCombo);
      }
    });

    javaButton = new ImageHoverButton(variablesComposite, SWT.PUSH, SetupInstallerPlugin.INSTANCE.getSWTImage("simple/folder.png"),
        SetupInstallerPlugin.INSTANCE.getSWTImage("simple/folder_hover.png"), SetupInstallerPlugin.INSTANCE.getSWTImage("simple/folder_disabled.png"));
    javaButton.setLayoutData(GridDataFactory.swtDefaults().indent(4, 0).create());
    javaButton.setToolTipText("Select a Java VM");
    javaButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        javaController.configureJREs();
      }
    });

    JREDownloadHandler downloadHandler = new JREDownloadHandler()
    {
      @Override
      protected Product getProduct()
      {
        return product;
      }
    };

    javaController = new JREController(javaLabel, javaViewer, downloadHandler)
    {
      @Override
      protected void modelEmpty(boolean empty)
      {
        super.modelEmpty(empty);
        validatePage();
      }

      @Override
      protected void jreChanged(JRE jre)
      {
        super.jreChanged(jre);
        validatePage();
        javaCombo.setToolTipText(jre == null ? null : jre.getJavaHome().toString());
      }

      @Override
      protected void setLabel(String text)
      {
        super.setLabel(text + " ");
      }
    };

    javaTrailingSpacer = spacer(variablesComposite);

    // Row 5
    installFolderLabel = createLabel(variablesComposite, "Installation Folder");
    installFolderSpacer = spacer(variablesComposite);

    folderText = createTextField(variablesComposite);
    folderText.addModifyListener(new ModifyListener()
    {
      /**
       * A class for delayed validation of the install folder.
       * @author Ed Merks
       */
      class Validator extends UIUtil.DelayedRunnable
      {
        public Validator()
        {
          super(folderText, 350);
        }

        @Override
        protected void perform()
        {
          validatePage();
        }

        @Override
        protected void prepareForDispatch()
        {
          // Immediately disable the install button if the install folder is currently invalid.
          if (validateInstallFolder() != null)
          {
            installButton.setEnabled(false);
          }
        }
      }

      private final Validator validator = new Validator();

      public void modifyText(ModifyEvent e)
      {
        final FocusSelectionAdapter focusSelectionAdapter = (FocusSelectionAdapter)folderText.getData(FocusSelectionAdapter.ADAPTER_KEY);
        focusSelectionAdapter.setNextSelectionRange(folderText.getSelection());

        String folder = folderText.getText().trim();
        installFolder = folder;
        folderText.setToolTipText(installFolder);

        validator.schedule();

        String productInstallFolder = getProductInstallFolder().toString();
        installFolderLabel.setToolTipText("Install into the folder '" + productInstallFolder + "'");
        installButton.setToolTipText("Start installing the product into '" + productInstallFolder + "'");
      }
    });

    new FileCompletionSupport(folderText)
    {
      @Override
      protected void setFolderTextAndSelect(String folder)
      {
        SimpleVariablePage.this.setFolderText(folder);
      }
    };

    folderButton = new ImageHoverButton(variablesComposite, SWT.PUSH, SetupInstallerPlugin.INSTANCE.getSWTImage("simple/folder.png"),
        SetupInstallerPlugin.INSTANCE.getSWTImage("simple/folder_hover.png"), SetupInstallerPlugin.INSTANCE.getSWTImage("simple/folder_disabled.png"));
    folderButton.setLayoutData(GridDataFactory.swtDefaults().indent(4, 0).create());
    folderButton.setToolTipText("Select an installation folder");
    folderButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        DirectoryDialog dialog = new DirectoryDialog(getShell());
        dialog.setText(PropertiesUtil.getProductName());
        dialog.setMessage("Select an installation folder:");

        if (!StringUtil.isEmpty(installFolder))
        {
          try
          {
            File existingFolder = IOUtil.getExistingFolder(getEffectiveInstallFolder());
            if (existingFolder != null)
            {
              dialog.setFilterPath(existingFolder.getAbsolutePath());
            }
          }
          catch (Exception ex)
          {
            SetupInstallerPlugin.INSTANCE.log(ex, IStatus.WARNING);
          }
        }

        String dir = dialog.open();
        if (dir != null)
        {
          validatePage();
          setFolderText(dir);

          UIUtil.getDisplay().asyncExec(new Runnable()
          {
            public void run()
            {
              folderText.setFocus();
            }
          });
        }
      }
    });

    // Pin rows
    if (powerShell != null)
    {
      {
        spacer(variablesComposite);
        spacer(variablesComposite);
        spacer(variablesComposite);
        spacer(variablesComposite);
        spacer(variablesComposite);
      }

      {
        spacer(variablesComposite);
        spacer(variablesComposite);
        spacer(variablesComposite);

        createStartMenuEntryButton = createCheckbox(variablesComposite, "create start menu entry");
        createStartMenuEntryButton.setChecked(PREF_STARTMENU_ENTRY.get(true));
        createStartMenuEntryButton.addSelectionListener(new SelectionAdapter()
        {
          @Override
          public void widgetSelected(SelectionEvent e)
          {
            PREF_STARTMENU_ENTRY.set(createStartMenuEntryButton.isChecked());
          }
        });

        spacer(variablesComposite);
      }

      {
        spacer(variablesComposite);
        spacer(variablesComposite);
        spacer(variablesComposite);

        createDesktopShortcutButton = createCheckbox(variablesComposite, "create desktop shortcut");
        createDesktopShortcutButton.setChecked(PREF_DESKTOP_SHORTCUT.get(true));
        createDesktopShortcutButton.addSelectionListener(new SelectionAdapter()
        {
          @Override
          public void widgetSelected(SelectionEvent e)
          {
            PREF_DESKTOP_SHORTCUT.set(createDesktopShortcutButton.isChecked());
          }
        });

        spacer(variablesComposite);
      }
    }

    spacer(variablesComposite);
    spacer(variablesComposite);
    spacer(variablesComposite);

    installButton = new SimpleInstallLaunchButton(variablesComposite);
    Point defaultInstallButtonSize = installButton.computeSize(SWT.DEFAULT, SWT.DEFAULT);
    installButton
        .setLayoutData(GridDataFactory.swtDefaults().align(SWT.FILL, SWT.BEGINNING).hint(SWT.DEFAULT, defaultInstallButtonSize.y + 3).indent(0, 32).create());
    installButton.setCurrentState(SimpleInstallLaunchButton.State.INSTALL);

    spacer(variablesComposite);
    spacer(variablesComposite);
    spacer(variablesComposite);
    spacer(variablesComposite);

    installStack = new StackComposite(variablesComposite, SWT.NONE);
    installStack.setLayoutData(GridDataFactory.fillDefaults().hint(SWT.DEFAULT, 72).create());

    final Composite duringInstallContainer = new Composite(installStack, SWT.NONE);
    duringInstallContainer.setLayout(UIUtil.createGridLayout(1));

    // During installation.
    cancelButton = createButton(duringInstallContainer, "Cancel Installation", "Cancel", SetupInstallerPlugin.INSTANCE.getSWTImage("simple/delete.png"));
    cancelButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        if (progress != null)
        {
          progress.setCanceled(true);
        }
      }
    });

    GridLayout afterInstallLayout = UIUtil.createGridLayout(1);
    afterInstallLayout.verticalSpacing = 3;

    afterInstallComposite = new Composite(installStack, SWT.NONE);
    afterInstallComposite.setLayout(afterInstallLayout);

    showReadmeButton = createButton(afterInstallComposite, TEXT_README, null, null);
    showReadmeButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        if (readmePath != null)
        {
          String relativeProductFolder = performer.getRelativeProductFolder();
          java.net.URI readmeURI = new File(installFolder, relativeProductFolder + "/" + readmePath).toURI();
          dialog.showReadme(readmeURI);
        }
      }
    });
    showReadmeButton.setToolTipText("Show the readme file of the installed product");

    openInSystemExplorerButton = createButton(afterInstallComposite, TEXT_SYSTEM_EXPLOROR, null, null);
    openInSystemExplorerButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        String launchLocation = getProductInstallFolder().toURI().toString();
        OS.INSTANCE.openSystemBrowser(launchLocation);
      }
    });

    keepInstallerButton = createButton(afterInstallComposite, TEXT_KEEP, null, null);
    keepInstallerButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        dialog.showKeepInstaller();
      }
    });
    keepInstallerButton.setToolTipText(KeepInstallerUtil.KEEP_INSTALLER_DESCRIPTION);

    installButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        if (installed)
        {
          launchProduct();
        }
        else
        {
          if (preInstallAction != null)
          {
            preInstallAction.run();
          }

          dialog.clearMessage();
          dialog.setButtonsEnabled(false);

          setEnabled(false);

          installButton.setCurrentState(State.INSTALLING);
          installButton.setProgress(0);

          installStack.setTopControl(duringInstallContainer);
          installStack.setVisible(true);
          layout(true, true);

          forceFocus();

          install();
        }
      }
    });

    GridLayout errorLayout = UIUtil.createGridLayout(1);
    errorLayout.verticalSpacing = 0;

    errorComposite = new Composite(installStack, SWT.NONE);
    errorComposite.setLayout(errorLayout);

    // Exclude browser from focus traversal because otherwise we get
    // a strange traversal behavior
    List<Control> tabList = new ArrayList<Control>(Arrays.asList(container.getTabList()));
    tabList.remove(detailArea);
    container.setTabList(tabList.toArray(new Control[tabList.size()]));

    // Just for debugging
    // installStack.setVisible(true);
    // installStack.setTopControl(errorComposite);
    // installButton.setProgress(0.98f);
    // installButton.setCurrentState(InstallLaunchButton.State.INSTALLING);
    // installButton.setEnabled(false);
  }

  @Override
  protected void backSelected()
  {
    if (promptLaunchProduct("You're about to install another product"))
    {
      super.backSelected();
    }
  }

  public boolean promptLaunchProduct(String currentAction)
  {
    if (installButton != null && installButton.getCurrentState() == State.LAUNCH)
    {
      MessageDialog prompt = new MessageDialog(dialog, "Launch Product", null,
          currentAction + " without having launched the installed product.\n\nDo you want to launch it now?", MessageDialog.QUESTION,
          new String[] { IDialogConstants.YES_LABEL, IDialogConstants.NO_LABEL, IDialogConstants.CANCEL_LABEL }, 0);

      int result = prompt.open();
      if (result == 0)
      {
        // Yes: Do launch; then continue.
        launchProduct(false);
        return true;
      }

      if (result == 1)
      {
        // No: Do not launch; but continue.
        return true;
      }

      // Cancel: Do not launch; and do not continue.
      return false;
    }

    // Nothing to launch; just continue.
    return true;
  }

  private FlatButton createButton(Composite parent, String text, String toolTip, Image icon)
  {
    FlatButton button = new FlatButton(parent, SWT.PUSH);
    button.setBackground(AbstractSimpleDialog.COLOR_LIGHTEST_GRAY);
    button.setFocusForegroundColor(AbstractSimpleDialog.COLOR_LIGHTEST_GRAY);
    button.setText(text);
    button.setCornerWidth(10);
    button.setAlignment(SWT.CENTER);
    button.setFont(SimpleInstallerDialog.getFont(1, "normal"));
    button.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).hint(SWT.DEFAULT, 22).create());
    button.setForeground(AbstractSimpleDialog.COLOR_LABEL_FOREGROUND);

    if (icon != null)
    {
      button.setImage(icon);
    }

    if (toolTip != null)
    {
      button.setToolTipText(toolTip);
    }

    return button;
  }

  protected void productVersionSelected(ProductVersion productVersion)
  {
    if (selectedProductVersion != productVersion)
    {
      selectedProductVersion = productVersion;

      String requiredJavaVersion = productVersion.getRequiredJavaVersion();
      javaController.setJavaVersion(requiredJavaVersion);

      ProductPage.saveProductVersionSelection(installer.getCatalogManager(), selectedProductVersion);

      String toolTipText = ProductPage.getToolTipText(selectedProductVersion);
      versionLabel.setToolTipText(toolTipText);
      versionCombo.setToolTipText(toolTipText);
    }

    setFolderText(getDefaultInstallationFolder());
  }

  @Override
  public boolean setFocus()
  {
    boolean focused = folderText.setFocus();

    // Set the cursor to the end
    UIUtil.setSelectionToEnd(folderText);

    return focused;
  }

  public void setProduct(Product product)
  {
    ProductVersion defaultProductVersion = ProductPage.getDefaultProductVersion(installer.getCatalogManager(), product);
    List<ProductVersion> validProductVersions = ProductPage.getValidProductVersions(product, PRODUCT_VERSION_FILTER);
    for (ProductVersion productVersion : validProductVersions)
    {
      if (defaultProductVersion == null || !validProductVersions.contains(defaultProductVersion))
      {
        defaultProductVersion = productVersion;
      }
    }

    if (defaultProductVersion != null)
    {
      setProductVersion(defaultProductVersion);
    }
  }

  public void setProductVersion(ProductVersion productVersion)
  {
    product = productVersion.getProduct();

    if (detailBrowser != null)
    {
      String html = SimpleInstallerDialog.getPageTemplate();
      html = html.replace("%CONTENT%", SimpleProductPage.renderProduct(product, true));

      detailBrowser.setText(html, true);
    }
    else
    {
      detailComposite.setProduct(product);
    }

    productVersions.clear();
    versionCombo.removeAll();

    int i = 0;
    int selection = -1;
    List<ProductVersion> validProductVersions = ProductPage.getValidProductVersions(product, PRODUCT_VERSION_FILTER);
    for (ProductVersion version : validProductVersions)
    {
      String label = SetupCoreUtil.getLabel(version);
      productVersions.put(label, version);
      versionCombo.add(label);

      if (version == productVersion)
      {
        selection = i;
      }

      ++i;
    }

    // If the product version is filtered out of the valid available versions, add a choice for it anyway.
    if (selection == -1)
    {
      String label = SetupCoreUtil.getLabel(productVersion);
      productVersions.put(label, productVersion);
      versionCombo.add(label);
      selection = i;
    }

    versionCombo.select(selection);
    productVersionSelected(productVersion);
    UIUtil.setSelectionToEnd(versionCombo);

    installButton.setCurrentState(State.INSTALL);
    installStack.setVisible(false);
    installed = false;

    UIUtil.asyncExec(container, new Runnable()
    {
      public void run()
      {
        setEnabled(true);
      }
    });
  }

  private void setVisible(Control control, boolean visible)
  {
    if (control != null)
    {
      control.setVisible(visible);

      Object layoutData = control.getLayoutData();
      if (layoutData == null)
      {
        layoutData = new GridData();
        control.setLayoutData(layoutData);
      }

      if (layoutData instanceof GridData)
      {
        GridData gridData = (GridData)layoutData;
        gridData.exclude = !visible;
      }
    }
  }

  @Override
  public void setEnabled(boolean enabled)
  {
    super.setEnabled(enabled);
    versionCombo.setEnabled(enabled);

    javaViewer.getControl().setEnabled(enabled);
    javaButton.setEnabled(enabled);

    folderText.setEnabled(enabled);
    folderButton.setEnabled(enabled);

    if (createStartMenuEntryButton != null)
    {
      createStartMenuEntryButton.setEnabled(enabled);
    }

    if (createDesktopShortcutButton != null)
    {
      createDesktopShortcutButton.setEnabled(enabled);
    }

    boolean versionVisible = versionCombo.getItemCount() != 1;
    setVisible(versionLabel, versionVisible);
    setVisible(versionSpacer, versionVisible);
    setVisible(versionCombo.getParent(), versionVisible);
    setVisible(bitness32Button, versionVisible);
    setVisible(bitness32Spacer, versionVisible);
    setVisible(bitness64Button, versionVisible);
    setVisible(bitness64Spacer, versionVisible);

    if (JREManager.BITNESS_CHANGEABLE)
    {
      int bitness = javaController.getBitness();
      bitness32Button.setEnabled(enabled);
      bitness32Button.setVisible(versionVisible && (enabled || bitness == 32));
      bitness64Button.setEnabled(enabled);
      bitness64Button.setVisible(versionVisible && (enabled || bitness == 64));
    }

    IStructuredSelection structuredSelection = (IStructuredSelection)javaViewer.getSelection();
    boolean javaVisible = JRE_CHOICE || !(structuredSelection.getFirstElement() instanceof JRE);
    setVisible(javaLabel, javaVisible);
    setVisible(javaSpacer, javaVisible);
    setVisible(javaViewer.getCCombo().getParent(), javaVisible);
    setVisible(javaButton, javaVisible);
    setVisible(javaTrailingSpacer, javaVisible);

    setVisible(folderText, INSTALL_CHOICE);
    setVisible(folderText.getParent(), INSTALL_CHOICE);
    setVisible(installFolderLabel, INSTALL_CHOICE);
    setVisible(installFolderSpacer, INSTALL_CHOICE);
    setVisible(folderButton, INSTALL_CHOICE);

    container.layout(true, true);
  }

  public boolean refreshJREs()
  {
    if (javaController != null)
    {
      javaController.refresh();
      return true;
    }

    return false;
  }

  private File getProductInstallFolder()
  {
    String productFolderName = SetupTaskPerformer.getProductFolderName(selectedProductVersion, OS.INSTANCE);
    String relativeProductFolderName = OS.INSTANCE.getRelativeProductFolder(productFolderName);
    File result = new File(getEffectiveInstallFolder(), relativeProductFolderName);
    return result;
  }

  private String getDefaultInstallationFolder()
  {
    String name = product.getName();
    int lastDot = name.lastIndexOf('.');
    if (lastDot != -1)
    {
      name = name.substring(lastDot + 1);
    }

    name += "-" + selectedProductVersion.getName().replace('.', '-');

    if (installRoot == null)
    {
      installRoot = PropertiesUtil.getProperty(PROP_INSTALL_ROOT);
    }

    if (installRoot == null)
    {
      if (FILE_INSTALL_ROOT.isFile())
      {
        List<String> lines = IOUtil.readLines(FILE_INSTALL_ROOT, "UTF-8");
        if (lines != null && !lines.isEmpty())
        {
          installRoot = lines.get(0);
          if (installRoot.length() == 0)
          {
            installRoot = null;
          }
        }
      }

      if (installRoot == null)
      {
        // Default to ${user.home}/eclipse, unless there is a file at that location, or what looks like an existing Eclipse installation.
        // In that case default just to ${user.home}.
        String defaultValue = PropertiesUtil.getUserHome();
        File defaultInstallRoot = new File(defaultValue, "eclipse");
        if (!defaultInstallRoot.exists())
        {
          defaultValue = defaultInstallRoot.toString();
        }
        else if (defaultInstallRoot.isDirectory())
        {
          boolean isEclipseInstallation = false;
          for (File file : defaultInstallRoot.listFiles())
          {
            if ("eclipse.ini".equals(file.getName()))
            {
              isEclipseInstallation = true;
            }
          }

          if (!isEclipseInstallation)
          {
            defaultValue = defaultInstallRoot.toString();
          }
        }

        installRoot = PREF_INSTALL_ROOT.get(defaultValue);
      }
    }

    for (int i = 1; i < 1000; i++)
    {
      String filename = name;
      if (i != 1)
      {
        filename += i;
      }

      File folder = new File(installRoot, filename);
      if (!folder.exists())
      {
        return folder.getAbsolutePath();
      }
    }

    throw new IllegalStateException("User home is full");
  }

  private void install()
  {
    installThread = new Thread()
    {
      @Override
      public void run()
      {
        installError = null;
        performer = null;
        progress = new SimpleProgress();

        try
        {
          installPerform();
        }
        catch (InterruptedException ex)
        {
          installCancel();
        }
        catch (OperationCanceledException ex)
        {
          installCancel();
        }
        catch (UnloggedException ex)
        {
          installError = ex.getMessage();
        }
        catch (Exception ex)
        {
          if (!progress.isCanceled())
          {
            SetupInstallerPlugin.INSTANCE.log(ex);
            installError = MESSAGE_FAILURE;
          }
        }
        finally
        {
          if (performer != null)
          {
            IOUtil.close(performer.getLogStream());
          }

          if (!progress.isCanceled())
          {
            UIUtil.syncExec(new Runnable()
            {
              public void run()
              {
                try
                {
                  installFinished();
                }
                catch (SWTException ex)
                {
                  //$FALL-THROUGH$
                }
              }
            });
          }
        }
      }
    };

    installThread.setDaemon(true);
    installThread.start();
  }

  @SuppressWarnings("restriction")
  private void installPerform() throws Exception
  {
    if (dialog.getPool() != null)
    {
      P2Util.getAgentManager().setDefaultBundlePool(SetupUIPlugin.INSTANCE.getSymbolicName(), dialog.getPool());
      System.setProperty(AgentManager.PROP_BUNDLE_POOL_LOCATION, dialog.getPool().getLocation().getAbsolutePath());
    }
    else
    {
      System.setProperty(AgentManager.PROP_BUNDLE_POOL_LOCATION, AgentManager.BUNDLE_POOL_LOCATION_NONE);
    }

    JRE jre = javaController.getJRE();
    String vmPath = ProductPage.getVMOption(jre);

    ResourceSet resourceSet = installer.getResourceSet();
    URIConverter uriConverter = resourceSet.getURIConverter();

    SetupContext setupContext = SetupContext.create(resourceSet, selectedProductVersion);
    Installation installation = setupContext.getInstallation();
    final User user = setupContext.getUser();

    if (UIUtil.isBrowserAvailable())
    {
      UIUtil.syncExec(new Runnable()
      {
        public void run()
        {
          EList<LicenseInfo> licenses = LicensePrePrompter.execute(getShell(), user);
          if (licenses != null)
          {
            user.getAcceptedLicenses().addAll(licenses);
            BaseUtil.saveEObject(user);
          }
        }
      });
    }

    UserAdjuster userAdjuster = new UserAdjuster();
    userAdjuster.adjust(user, installFolder);

    try
    {
      IOUtil.writeLines(FILE_INSTALL_ROOT, "UTF-8", Collections.singletonList(installRoot));

      SimplePrompter prompter = new SimplePrompter(OS.INSTANCE.getForBitness(javaController.getBitness()), vmPath);
      performer = SetupTaskPerformer.create(uriConverter, prompter, Trigger.BOOTSTRAP, setupContext, false);

      final List<VariableTask> unresolvedVariables = prompter.getUnresolvedVariables();
      if (!unresolvedVariables.isEmpty())
      {
        StringBuilder builder = new StringBuilder();
        for (VariableTask variable : unresolvedVariables)
        {
          if (builder.length() != 0)
          {
            builder.append(", ");
          }

          builder.append(variable.getName());
        }

        final String variables = builder.toString();
        final boolean multi = unresolvedVariables.size() > 1;

        UIUtil.syncExec(new Runnable()
        {
          public void run()
          {
            String message = "The variable" + (multi ? "s" : "") + " " + variables + " " + (multi ? "are" : "is") + " undefined. You likely declared "
                + (multi ? "them" : "it")
                + " in your 'user.setup' file without appropriate restrictions, so that you can't use the installer's simple mode anymore."
                + "\n\nDo you want to switch to the advanced mode now?";

            if (MessageDialog.openQuestion(getShell(), "Undefined Variables", message))
            {
              unresolvedVariables.clear();
              dialog.switchToAdvancedMode();
            }
          }
        });

        if (unresolvedVariables.isEmpty())
        {
          return;
        }

        throw new UnloggedException("Undefined variable" + (multi ? "s" : "") + ": " + variables);
      }

      EList<SetupTask> triggeredSetupTasks = performer.getTriggeredSetupTasks();
      final Map<EClass, EList<SetupTask>> enablementTasks = EnablementComposite.getEnablementTasks(triggeredSetupTasks);
      if (!enablementTasks.isEmpty())
      {
        UIUtil.syncExec(

            getDisplay(), new Runnable()
            {
              public void run()
              {
                EnablementDialog enablementDialog = new EnablementDialog(getShell(), "the installer", enablementTasks);
                if (enablementDialog.open() == EnablementDialog.OK)
                {
                  selectionMemento.setProductVersion(EcoreUtil.getURI(selectedProductVersion));
                  dialog.restart();
                }

                installCancel();
              }
            });

        throw new OperationCanceledException();
      }

      performer.getUnresolvedVariables().clear();
      performer.put(UIServices.class, Installer.SERVICE_UI);

      if (performer.get(ILicense.class) == null)
      {
        performer.put(ILicense.class, ProgressPage.LICENSE_CONFIRMER);
      }

      if (performer.get(Certificate.class) == null)
      {
        performer.put(Certificate.class, UnsignedContentDialog.createUnsignedContentConfirmer(user, false));
      }

      performer.setOffline(PropertiesUtil.isProperty(SetupProperties.PROP_SETUP_OFFLINE_STARTUP));
      performer.setMirrors(true);
      performer.setProgress(progress);
      performer.log("Executing " + performer.getTrigger().toString().toLowerCase() + " tasks");
      performer.put(org.eclipse.equinox.internal.provisional.p2.core.eventbus.ProvisioningListener.class, new DownloadArtifactLister());
      performer.perform(progress);
      performer.recordVariables(installation, null, user);
      performer.savePasswords();

      File configurationLocation = performer.getProductConfigurationLocation();
      installation.eResource().setURI(URI.createFileURI(new File(configurationLocation, "org.eclipse.oomph.setup/installation.setup").toString()));
      BaseUtil.saveEObject(installation);
    }
    finally
    {
      userAdjuster.undo();
      BaseUtil.saveEObject(user);
    }
  }

  private void installCancel()
  {
    if (progress != null)
    {
      progress.setCanceled(true);
    }

    if (installThread != null)
    {
      installThread.interrupt();
    }

    UIUtil.syncExec(getDisplay(), new Runnable()
    {
      public void run()
      {
        dialog.setButtonsEnabled(true);
        setEnabled(true);

        installButton.setCurrentState(State.INSTALL);
        installStack.setVisible(false);

        dialog.clearMessage();
      }
    });
  }

  private void installFinished()
  {
    readmePath = null;
    boolean success = installError == null;

    if (performer != null)
    {
      Installation installation = performer.getInstallation();
      if (installation != null)
      {
        ProductVersion productVersion = installation.getProductVersion();
        if (productVersion != null)
        {
          OS os = performer.getOS();
          SetupCoreUtil.sendStats(success, productVersion, os);
        }
      }
    }

    if (success)
    {
      installed = true;

      installButton.setCurrentState(State.LAUNCH);
      File launchLocation = performer.getExecutableInfo().getLaunchLocation();
      installButton.setToolTipText("Launch '" + launchLocation + "'");

      keepInstallerButton.setVisible(KeepInstallerUtil.canKeepInstaller());

      Scope scope = selectedProductVersion;
      while (scope != null)
      {
        Annotation annotation = scope.getAnnotation(AnnotationConstants.ANNOTATION_BRANDING_INFO);
        if (annotation != null)
        {
          readmePath = annotation.getDetails().get(AnnotationConstants.KEY_README_PATH);
          if (readmePath != null)
          {
            break;
          }
        }

        scope = scope.getParentScope();
      }

      showReadmeButton.setVisible(readmePath != null);

      openInSystemExplorerButton.setToolTipText("Open the folder '" + getProductInstallFolder() + "' in the system explorer");

      if (createStartMenuEntryButton != null || createDesktopShortcutButton != null)
      {
        File executable = performer.getExecutableInfo().getExecutable();

        // TODO The entire naming of the shortcuts should be revisited and made more flexible with BrandingInfo annotations.

        ProductCatalog productCatalog = product.getProductCatalog();
        String catalogName = "user.products".equals(productCatalog.getName()) ? "" : productCatalog.getLabel();
        int firstDot = catalogName.indexOf('.');
        if (firstDot != -1)
        {
          catalogName = catalogName.substring(0, firstDot);
        }

        String productName = product.getName();
        if (productName.startsWith("epp.package."))
        {
          productName = productName.substring("epp.package.".length());
        }

        productName = productName.replace('.', ' ');

        String qualifiedProductName = productName + " " + selectedProductVersion.getName().replace('.', ' ');

        String shortCutName = StringUtil.capAll(StringUtil.isEmpty(catalogName) ? qualifiedProductName : catalogName + " " + qualifiedProductName);

        if (createStartMenuEntryButton != null && createStartMenuEntryButton.isChecked())
        {
          KeepInstallerUtil.createShortCut("Programs", "Eclipse", executable.getAbsolutePath(), shortCutName);
        }

        if (createDesktopShortcutButton != null && createDesktopShortcutButton.isChecked())
        {
          KeepInstallerUtil.createShortCut("Desktop", null, executable.getAbsolutePath(), shortCutName);
        }
      }

      showSuccessMessage();

      backButton.setEnabled(true);
    }
    else
    {
      setEnabled(true);
      installButton.setCurrentState(State.INSTALL);
      showErrorMessage();
    }

    dialog.setButtonsEnabled(true);
  }

  private void showSuccessMessage()
  {
    dialog.showMessage(MESSAGE_SUCCESS, Type.SUCCESS, true);

    installStack.setTopControl(afterInstallComposite);
    installStack.setVisible(true);
    layout(true, true);
  }

  private void showErrorMessage()
  {
    Runnable action = null;
    String errorMessage = installError;

    if (isInstallLogAvailable())
    {
      action = new SimpleMessageOverlay.RunnableWithLabel()
      {
        public void run()
        {
          openInstallLog();
        }

        public String getLabel()
        {
          return "Show log.";
        }
      };
    }

    dialog.showMessage(errorMessage, Type.ERROR, false, action);

    installStack.setTopControl(errorComposite);
    installStack.setVisible(true);
    layout(true, true);
  }

  private void launchProduct()
  {
    launchProduct(EXIT_AFTER_LAUNCH);
  }

  private void launchProduct(boolean exitAfterLaunch)
  {
    try
    {
      ProgressPage.launchProduct(performer);
    }
    catch (Exception ex)
    {
      SetupInstallerPlugin.INSTANCE.log(ex);
    }

    if (exitAfterLaunch)
    {
      dialog.exitQuiet();
    }
  }

  private void setFolderText(String folder)
  {
    folderText.setText(folder);

    final FocusSelectionAdapter focusSelectionAdapter = (FocusSelectionAdapter)folderText.getData(FocusSelectionAdapter.ADAPTER_KEY);
    int index = folder.length();
    Point selection = new Point(index, index);
    folderText.setSelection(selection);
    focusSelectionAdapter.setNextSelectionRange(selection);
  }

  private void validatePage()
  {
    preInstallAction = null;

    String errorMessage = null;

    Type type = Type.ERROR;
    errorMessage = validateJREs();

    if (errorMessage == null && installFolder != null)
    {
      Pair<Type, String> folderValidationMesage = validateInstallFolder();
      if (folderValidationMesage != null)
      {
        type = folderValidationMesage.getElement1();
        errorMessage = folderValidationMesage.getElement2();
      }

      if (errorMessage == null || type == Type.WARNING)
      {
        OS os = OS.INSTANCE.getForBitness(javaController.getBitness());
        String productFolderName = AbstractSetupTaskContext.getProductFolderName(selectedProductVersion, os);
        String relativeProductFolderName = OS.INSTANCE.getRelativeProductFolder(productFolderName);
        folderValidationMesage = validateChildFolder(IOUtil.getCanonicalFile(getEffectiveInstallFolder()), relativeProductFolderName, true);
        if (folderValidationMesage != null)
        {
          type = folderValidationMesage.getElement1();
          errorMessage = folderValidationMesage.getElement2();
        }
      }
    }

    if (isTop())
    {
      if (errorMessage != null)
      {
        if (type == Type.WARNING)
        {
          preInstallAction = new Runnable()
          {
            public void run()
            {
              preInstallAction = null;
              String folder = IOUtil.getCanonicalFile(getEffectiveInstallFolder()).toString();
              setFolderText(folder);
            }
          };
        }

        dialog.showMessage(errorMessage, type, false, preInstallAction, preInstallAction);
      }
      else
      {
        dialog.clearMessage();
      }
    }

    installButton.setEnabled(errorMessage == null || type == Type.WARNING);
  }

  @Override
  public void aboutToShow()
  {
    super.aboutToShow();
    keepInstallerButton.setVisible(KeepInstallerUtil.canKeepInstaller());

    if (!installed)
    {
      validatePage();
    }
  }

  private String validateJREs()
  {
    Object input = javaViewer.getInput();
    if (input instanceof Collection<?> && ((Collection<?>)input).isEmpty())
    {
      return "Configuration of JRE failed.";
    }

    return null;
  }

  private File getEffectiveInstallFolder()
  {
    File folder = new File(installFolder.trim());
    if (!folder.isAbsolute())
    {
      folder = new File(PropertiesUtil.getUserHome(), "eclipse/" + installFolder.trim());
    }

    return folder;
  }

  private Pair<Type, String> validateInstallFolder()
  {
    File canonicalFolder = IOUtil.getCanonicalFile(getEffectiveInstallFolder());
    File parentFolder = canonicalFolder.getParentFile();
    Pair<Type, String> errorMessage = validateFolder(canonicalFolder.getParentFile(), canonicalFolder.getName());
    if (errorMessage != null)
    {
      return errorMessage;
    }

    if (!canonicalFolder.toString().equals(installFolder.trim()))
    {
      if (StringUtil.isEmpty(installFolder.trim()))
      {
        return Pair.create(Type.WARNING, "The folder is unspecified so '" + canonicalFolder + "' will be used.");
      }

      return Pair.create(Type.WARNING, "The folder is specified as '" + installFolder + "' but '" + canonicalFolder + "' will be used.");
    }

    installRoot = parentFolder == null ? canonicalFolder.getAbsolutePath() : parentFolder.getAbsolutePath();

    return errorMessage;
  }

  private Pair<Type, String> validateFolder(File parentFolder, String childFolder)
  {
    if (parentFolder == null)
    {
      return Pair.create(Type.ERROR, "The product cannot be installed in the root of the file system.");
    }

    if (parentFolder.exists())
    {
      if (parentFolder.isDirectory())
      {
        if (IOUtil.canWriteFolder(parentFolder))
        {
          try
          {
            new File(parentFolder, childFolder).getCanonicalFile();
            Pair<Type, String> result = validateChildFolder(parentFolder, childFolder, false);

            // The folder exists, but that's not a problem we want to report in this case.
            if (result == null || result.getElement1() == Type.WARNING)
            {
              return null;
            }

            return result;
          }
          catch (Exception ex)
          {
            return Pair.create(Type.ERROR, "Folder '" + childFolder + "' cannot be created in the folder '" + parentFolder + "'.");
          }
        }

        Pair<Type, String> result = validateChildFolder(parentFolder, childFolder, false);
        if (result != null)
        {
          // The folder exists, but that's not a problem we want to report in this case.
          if (result.getElement1() == Type.WARNING)
          {
            return null;
          }

          return result;
        }

        return Pair.create(Type.ERROR, "Folder '" + childFolder + "' cannot be created in the read-only folder '" + parentFolder + "'.");
      }

      return Pair.create(Type.ERROR,
          "Folder '" + childFolder + "' cannot be created in the folder '" + parentFolder + "' because '" + parentFolder.getName() + "' exists as a file.");
    }

    return validateFolder(parentFolder.getParentFile(), parentFolder.getName());
  }

  private Pair<Type, String> validateChildFolder(File parentFolder, String childFolder, boolean isProductLocation)
  {
    String prefix = isProductLocation ? "Product folder '" : "Folder '";
    File child = new File(parentFolder, childFolder);
    if (child.exists())
    {
      if (child.isDirectory())
      {
        if (IOUtil.canWriteFolder(child))
        {
          return Pair.create(Type.WARNING, prefix + child + " already exists.");
        }

        return Pair.create(Type.ERROR, prefix + child + "' cannot be used because it is read-only.");
      }

      return Pair.create(Type.ERROR, prefix + child + "' cannot be used because it exists as file.");
    }

    try
    {
      new File(parentFolder, childFolder).getCanonicalFile();
    }
    catch (Exception ex)
    {
      return Pair.create(Type.ERROR, prefix + childFolder + "' cannot be created.");
    }

    return null;
  }

  private File getLogFile()
  {
    return performer.getLogFile();
  }

  private void openInstallLog()
  {
    File installationLogFile = getLogFile();
    dialog.showInstallationLog(installationLogFile);
  }

  private boolean isInstallLogAvailable()
  {
    return performer != null && getLogFile().exists();
  }

  private SimpleCheckbox createCheckbox(Composite parent, String text)
  {
    final SimpleCheckbox checkbox = new SimpleCheckbox(parent);
    checkbox.setLayoutData(GridDataFactory.fillDefaults().grab(true, false).create());
    checkbox.setText(text);
    checkbox.setChecked(true);
    return checkbox;
  }

  /**
   * @author Ed Merks
   */
  @SuppressWarnings("restriction")
  private class DownloadArtifactLister implements org.eclipse.equinox.internal.provisional.p2.core.eventbus.SynchronousProvisioningListener
  {
    public synchronized void notify(EventObject event)
    {
      if (event instanceof DownloadArtifactEvent)
      {
        DownloadArtifactEvent downloadArtifactEvent = (DownloadArtifactEvent)event;
        URI artifactURI = URI.createURI(downloadArtifactEvent.getArtifactURI().toString());
        if (downloadArtifactEvent.isCompleted())
        {
          progress.removeArtifactURI(artifactURI);
        }
        else
        {
          progress.addArtifactURI(artifactURI);
        }
      }
    }
  }

  /**
   * @author Eike Stepper
   */
  private static final class UnloggedException extends RuntimeException
  {
    private static final long serialVersionUID = 1L;

    public UnloggedException(String message)
    {
      super(message);
    }
  }

  /**
   * @author Eike Stepper
   */
  private static class UserAdjuster
  {
    private static final URI INSTALLATION_LOCATION_ATTRIBUTE_URI = SetupTaskPerformer.getAttributeURI(SetupPackage.Literals.INSTALLATION_TASK__LOCATION);

    private EList<AttributeRule> attributeRules;

    private String oldValue;

    private void adjust(User user, String installFolder)
    {
      attributeRules = user.getAttributeRules();
      for (AttributeRule attributeRule : attributeRules)
      {
        if (INSTALLATION_LOCATION_ATTRIBUTE_URI.equals(attributeRule.getAttributeURI()))
        {
          oldValue = attributeRule.getValue();
          attributeRule.setValue(installFolder);
          return;
        }
      }

      AttributeRule attributeRule = SetupFactory.eINSTANCE.createAttributeRule();
      attributeRule.setAttributeURI(INSTALLATION_LOCATION_ATTRIBUTE_URI);
      attributeRule.setValue(installFolder);
      attributeRules.add(attributeRule);
    }

    public void undo()
    {
      for (Iterator<AttributeRule> it = attributeRules.iterator(); it.hasNext();)
      {
        AttributeRule attributeRule = it.next();
        if (INSTALLATION_LOCATION_ATTRIBUTE_URI.equals(attributeRule.getAttributeURI()))
        {
          if (oldValue == null)
          {
            it.remove();
          }
          else
          {
            attributeRule.setValue(oldValue);
          }

          return;
        }
      }
    }
  }

  /**
   * @author Eike Stepper
   */
  private final class SimplePrompter extends HashMap<String, String> implements SetupPrompter
  {
    private static final long serialVersionUID = 1L;

    private final List<VariableTask> unresolvedVariables = new ArrayList<VariableTask>();

    private final OS os;

    private final String vmPath;

    public OS getOS()
    {
      return os;
    }

    public SimplePrompter(OS os, String vmPath)
    {
      this.os = os;
      this.vmPath = vmPath;
    }

    public String getVMPath()
    {
      return vmPath;
    }

    public List<VariableTask> getUnresolvedVariables()
    {
      return unresolvedVariables;
    }

    public boolean promptVariables(List<? extends SetupTaskContext> performers)
    {
      for (SetupTaskContext performer : performers)
      {
        List<VariableTask> unresolvedVariables = ((SetupTaskPerformer)performer).getUnresolvedVariables();
        for (VariableTask variable : unresolvedVariables)
        {
          String value = getValue(variable);
          if (value == null)
          {
            this.unresolvedVariables.add(variable);
          }
        }
      }

      return unresolvedVariables.isEmpty();
    }

    public String getValue(VariableTask variable)
    {
      String name = variable.getName();
      return get(name);
    }

    public UserCallback getUserCallback()
    {
      return null;
    }
  }

  /**
   * @author Eike Stepper
   */
  private final class SimpleProgress implements ProgressLog, IProgressMonitor, Runnable
  {
    private volatile String name;

    private volatile double totalWork;

    private volatile double work;

    private volatile double lastWork;

    private volatile long reportWarningTimeout;

    private volatile boolean canceled;

    private volatile boolean done;

    private String lastName;

    private final Set<URI> artifactURIs = new HashSet<URI>();

    private Set<URI> lastArtifactURIs;

    public synchronized void addArtifactURI(URI uri)
    {
      artifactURIs.add(uri);
    }

    public synchronized void removeArtifactURI(URI uri)
    {
      artifactURIs.remove(uri);
    }

    public void setTerminating()
    {
    }

    public void log(String line)
    {
      log(line, true, Severity.OK);
    }

    public void log(String line, Severity severity)
    {
      log(line, true, severity);
    }

    public void log(String line, boolean filter)
    {
      log(line, filter, Severity.OK);
    }

    public synchronized void log(String line, boolean filter, Severity severity)
    {
      name = line;
    }

    public void log(IStatus status)
    {
      String string = SetupInstallerPlugin.toString(status);
      log(string, false);
    }

    public void log(Throwable t)
    {
      String string = SetupInstallerPlugin.toString(t);
      log(string, false);
    }

    public synchronized void task(SetupTask setupTask)
    {
      if (setupTask != null)
      {
        name = "Performing setup task " + setupTask.eClass().getName();
      }
      else
      {
        name = null;
      }
    }

    public synchronized boolean isCanceled()
    {
      return canceled;
    }

    public synchronized void setCanceled(boolean canceled)
    {
      this.canceled = canceled;
    }

    public synchronized void beginTask(String name, int totalWork)
    {
      performer.log(name);
      if (this.totalWork == 0)
      {
        this.totalWork = totalWork;
        schedule();
      }
    }

    public synchronized void done()
    {
      work = totalWork;
      done = true;
    }

    public synchronized void setTaskName(String name)
    {
      performer.log(name);
    }

    public synchronized void subTask(String name)
    {
      performer.log(name);
    }

    public synchronized void internalWorked(double work)
    {
      this.work += work;
    }

    public void worked(int work)
    {
      internalWorked(work);
    }

    public void run()
    {
      String name;
      double totalWork;
      double work;
      boolean canceled;
      boolean done;
      Set<URI> artifactURIs;

      synchronized (this)
      {
        name = this.name;
        totalWork = this.totalWork;
        work = this.work;
        canceled = this.canceled;
        done = this.done;
        artifactURIs = new HashSet<URI>(this.artifactURIs);
      }

      if (!canceled && !done)
      {
        String safeName = StringUtil.safe(name);

        if (PROGRESS_WATCHDOG_TIMEOUT != 0)
        {
          long now = System.currentTimeMillis();
          boolean slowArtifactDownload = !artifactURIs.isEmpty() && artifactURIs.equals(lastArtifactURIs);
          if ((lastWork == work || slowArtifactDownload) && !isModalShellInForeground())
          {
            if (now >= reportWarningTimeout)
            {
              if (slowArtifactDownload)
              {
                StringBuilder message = new StringBuilder();
                Set<URI> hosts = new HashSet<URI>();
                for (URI artifactURI : artifactURIs)
                {
                  URI hostURI = URI.createHierarchicalURI(artifactURI.scheme(), artifactURI.authority(), null, null, null);
                  if (hosts.add(hostURI))
                  {
                    if (message.length() != 0)
                    {
                      message.append(", ");
                    }

                    message.append(hostURI);
                  }
                }

                if (hosts.size() > 1)
                {
                  message.insert(0, "the following hosts: ");
                }

                message.insert(0, "Artifact download is progressing very slowly from ");
                dialog.showMessage(message.toString().replace(' ', '\u00a0'), Type.WARNING, false);
              }
              else
              {
                dialog.showMessage(("The installation process is taking longer than usual: " + safeName).replace(' ', '\u00a0'), Type.WARNING, false);
              }

              installButton.setProgressAnimationSpeed(0.4f);
              resetWatchdogTimer(now);
            }
          }
          else
          {
            installButton.startProgressAnimation();
            installButton.setProgressAnimationSpeed(1);
            dialog.clearMessage();
            resetWatchdogTimer(now);
          }

          lastWork = work;
          lastArtifactURIs = artifactURIs;
        }

        double progress = work / totalWork;

        try
        {
          installButton.setProgress((float)progress);

          if (!ObjectUtil.equals(name, lastName))
          {
            lastName = name;
            installButton.setToolTipText(safeName);
          }
        }
        catch (SWTException ex)
        {
          return;
        }

        reschedule();
      }
    }

    private boolean isModalShellInForeground()
    {
      Shell mainShell = getShell();
      Shell[] shells = getDisplay().getShells();

      for (Shell shell : shells)
      {
        if (shell != mainShell)
        {
          int style = shell.getStyle();
          if ((style & SWT.APPLICATION_MODAL) != 0 || (style & SWT.PRIMARY_MODAL) != 0 || (style & SWT.SYSTEM_MODAL) != 0)
          {
            return true;
          }
        }
      }

      return false;
    }

    private void resetWatchdogTimer(long now)
    {
      reportWarningTimeout = now + PROGRESS_WATCHDOG_TIMEOUT * 1000;
    }

    private void reschedule()
    {
      UIUtil.timerExec(100, getDisplay(), this);
    }

    private void schedule()
    {
      resetWatchdogTimer(System.currentTimeMillis());
      UIUtil.asyncExec(getDisplay(), this);
    }
  }

  /**
   * @author Ed Merks
   */
  private static class FileCompletionSupport extends KeyAdapter implements VerifyListener
  {
    private final Text folderText;

    private Shell shell;

    public FileCompletionSupport(Text text)
    {
      folderText = text;
      if (OS.INSTANCE.isMac())
      {
        folderText.addKeyListener(this);
      }
      else
      {
        folderText.addVerifyListener(this);
      }
    }

    protected void setFolderTextAndSelect(String folder)
    {
      folderText.setText(folder);
      int length = folder.length();
      folderText.setSelection(new Point(length, length));
    }

    @Override
    public void keyReleased(KeyEvent e)
    {
      if (e.keyCode == ' ' && e.stateMask == SWT.CTRL)
      {
        e.doit = false;
        open();
      }
    }

    public void verifyText(VerifyEvent e)
    {
      if (e.keyCode == ' ' && e.stateMask == SWT.CTRL)
      {
        e.doit = false;
        open();
      }
    }

    private void open()
    {
      if (shell == null)
      {
        new Dialog(folderText.getShell())
        {
          private org.eclipse.swt.widgets.List list;

          private ModifyListener modifyListener = new ModifyListener()
          {
            public void modifyText(ModifyEvent e)
            {
              updater.schedule();
            }
          };

          private FocusListener focusListener = new FocusAdapter()
          {
            @Override
            public void focusLost(FocusEvent e)
            {
              checkFocus();
            }
          };

          private MouseListener mouseListener = new MouseAdapter()
          {
            @Override
            public void mouseDown(MouseEvent e)
            {
              checkFocus();
            }
          };

          private ControlListener controlListener = new ControlListener()
          {
            public void controlResized(ControlEvent e)
            {
              shell.dispose();
            }

            public void controlMoved(ControlEvent e)
            {
              shell.dispose();
            }
          };

          private KeyListener keyListener = new KeyAdapter()
          {
            @Override
            public void keyReleased(KeyEvent e)
            {
              if (e.keyCode == SWT.ARROW_UP)
              {
                int itemCount = list.getItemCount();
                if (itemCount > 0)
                {
                  shell.setFocus();
                  list.select(itemCount - 1);
                  list.showSelection();
                }
              }
              else if (e.keyCode == SWT.ARROW_DOWN)
              {
                int itemCount = list.getItemCount();
                if (itemCount > 0)
                {
                  shell.setFocus();
                  int selectionIndex = list.getSelectionIndex();
                  list.select(selectionIndex + 1);
                }
              }
              else if (e.keyCode == '\r')
              {
                int selectionIndex = list.getSelectionIndex();
                if (selectionIndex != -1)
                {
                  String folder = list.getItem(selectionIndex);
                  File file = new File(folder);
                  if (!folder.endsWith(File.separator) && file.isDirectory() && !IOUtil.canWriteFolder(file))
                  {
                    folder += File.separator;
                  }

                  setFolderTextAndSelect(folder);
                }
              }
            }
          };

          /**
           * A class for delayed update of the list.
           * @author Ed Merks
           */
          class Updater extends UIUtil.DelayedRunnable
          {
            public Updater(Shell shell)
            {
              super(shell, 350);
            }

            @Override
            protected void perform()
            {
              update();
            }
          }

          private Updater updater;

          private void checkFocus()
          {
            UIUtil.asyncExec(list, new Runnable()
            {
              public void run()
              {
                if (shell.getDisplay().getActiveShell() != shell)
                {
                  shell.dispose();
                }
              }
            });
          }

          public void open()
          {
            Shell parent = getParent();
            shell = new Shell(parent, SWT.MODELESS | SWT.NO_TRIM);
            Control wrapper = folderText.getParent();
            Rectangle folderTextBounds = wrapper.getBounds();
            Point position = wrapper.getParent().toDisplay(folderTextBounds.x, folderTextBounds.y + folderTextBounds.height);
            shell.setBounds(position.x, position.y, folderTextBounds.width, 100);
            shell.setLayout(new FillLayout());

            updater = new Updater(shell);

            list = new org.eclipse.swt.widgets.List(shell, SWT.BORDER | SWT.SINGLE | SWT.V_SCROLL);

            list.addMouseListener(new MouseAdapter()
            {
              @Override
              public void mouseUp(MouseEvent e)
              {
                int selectionIndex = list.getSelectionIndex();
                if (selectionIndex != -1)
                {
                  apply(list.getItem(selectionIndex));
                }
              }
            });

            list.addKeyListener(new KeyAdapter()
            {
              @Override
              public void keyReleased(KeyEvent e)
              {
                if (e.keyCode == '\r')
                {
                  int selectionIndex = list.getSelectionIndex();
                  if (selectionIndex != -1)
                  {
                    apply(list.getItem(selectionIndex));
                  }
                }
              }
            });

            shell.addShellListener(new ShellAdapter()
            {
              @Override
              public void shellDeactivated(ShellEvent e)
              {
                shell.dispose();
              }
            });

            shell.addDisposeListener(new DisposeListener()
            {
              public void widgetDisposed(DisposeEvent e)
              {
                folderText.removeModifyListener(modifyListener);
                folderText.removeFocusListener(focusListener);
                folderText.removeMouseListener(mouseListener);
                folderText.removeKeyListener(keyListener);
                if (!folderText.getShell().isDisposed())
                {
                  folderText.getShell().removeControlListener(controlListener);
                }

                shell = null;
              }
            });

            folderText.addModifyListener(modifyListener);
            folderText.addFocusListener(focusListener);
            folderText.addMouseListener(mouseListener);
            folderText.addKeyListener(keyListener);
            folderText.getShell().addControlListener(controlListener);

            update();

            shell.setVisible(true);
          }

          private void update()
          {
            if (!list.isDisposed())
            {
              list.removeAll();
              Point selection = folderText.getSelection();
              String folderLiteral = StringUtil.trimLeft(folderText.getText().substring(0, selection.x));
              File folder = IOUtil.getCanonicalFile(new File(folderLiteral));
              final String name = folder.getName().toLowerCase();
              if (folderLiteral.length() == 0)
              {
                File[] roots = File.listRoots();
                if (roots != null)
                {
                  for (File root : roots)
                  {
                    list.add(root.getPath());
                  }
                }
              }
              else
              {
                boolean isExplicitFolder = folderLiteral.endsWith("/") || folderLiteral.endsWith("\\");
                final String nameFilter = isExplicitFolder ? "" : name;

                File searchFolder = isExplicitFolder ? folder : folder.getParentFile();
                if (searchFolder != null)
                {
                  File[] folders = searchFolder.listFiles(new FileFilter()
                  {
                    public boolean accept(File file)
                    {
                      return file.isDirectory() && file.getName().toLowerCase().startsWith(nameFilter);
                    }
                  });

                  if (folders != null)
                  {
                    for (File root : folders)
                    {
                      list.add(root.getPath());
                    }
                  }
                }
                else
                {
                  File[] roots = File.listRoots();
                  if (roots != null)
                  {
                    String lowerCaseFolderLiteral = folderLiteral.toLowerCase();
                    for (File root : roots)
                    {
                      String path = root.getPath();
                      if (path.length() == 1)
                      {
                        File[] folders = root.listFiles(new FileFilter()
                        {
                          public boolean accept(File file)
                          {
                            return file.isDirectory() && file.getName().toLowerCase().startsWith(nameFilter);
                          }
                        });

                        if (folders != null)
                        {
                          for (File child : folders)
                          {
                            list.add(child.getPath());
                          }
                        }
                      }
                      else
                      {
                        if (path.toLowerCase().startsWith(lowerCaseFolderLiteral))
                        {
                          list.add(root.getPath());
                        }
                      }
                    }
                  }
                }
              }
            }

            if (list.getItemCount() != 0)
            {
              list.select(0);
            }

            int width = list.computeSize(SWT.DEFAULT, SWT.DEFAULT).x;

            Rectangle clientArea = shell.getClientArea();
            Rectangle newClientArea = shell.computeTrim(clientArea.x, clientArea.y, width, clientArea.height);
            Rectangle bounds = shell.getBounds();
            if (bounds.width < newClientArea.width)
            {
              bounds.width = newClientArea.width;
              shell.setBounds(bounds);
            }
          }

          private void apply(String folder)
          {
            File file = new File(folder);
            if (!folder.endsWith(File.separator) && file.isDirectory() && !IOUtil.canWriteFolder(file))
            {
              folder += File.separator;
            }

            setFolderTextAndSelect(folder);
            shell.dispose();
          }
        }.open();
      }
    }
  }
}