/*
 * Copyright (c) 2014-2016 Eike Stepper (Berlin, Germany) 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:
 *    Eike Stepper - initial API and implementation
 *    Ericsson AB (Julian Enoch) - Bug 434525 - Allow prompted variables to be pre-populated
 */
package org.eclipse.oomph.setup.ui.wizards;

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.ui.AccessUtil;
import org.eclipse.oomph.preferences.util.PreferencesUtil;
import org.eclipse.oomph.setup.AnnotationConstants;
import org.eclipse.oomph.setup.Installation;
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.VariableChoice;
import org.eclipse.oomph.setup.VariableTask;
import org.eclipse.oomph.setup.Workspace;
import org.eclipse.oomph.setup.internal.core.SetupContext;
import org.eclipse.oomph.setup.internal.core.SetupTaskPerformer;
import org.eclipse.oomph.setup.internal.core.util.Authenticator;
import org.eclipse.oomph.setup.internal.core.util.SetupCoreUtil;
import org.eclipse.oomph.setup.ui.PropertyField;
import org.eclipse.oomph.setup.ui.PropertyField.AuthenticatedField;
import org.eclipse.oomph.setup.ui.PropertyField.ValueListener;
import org.eclipse.oomph.setup.ui.SetupUIPlugin;
import org.eclipse.oomph.setup.ui.wizards.SetupWizard.IndexLoader;
import org.eclipse.oomph.setup.util.StringExpander;
import org.eclipse.oomph.ui.ButtonBar;
import org.eclipse.oomph.ui.ErrorDialog;
import org.eclipse.oomph.ui.UICallback;
import org.eclipse.oomph.ui.UIUtil;
import org.eclipse.oomph.util.CollectionUtil;
import org.eclipse.oomph.util.OS;
import org.eclipse.oomph.util.StringUtil;
import org.eclipse.oomph.util.UserCallback;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;

import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.FocusListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Point;
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.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Eike Stepper
 */
public class VariablePage extends SetupWizardPage implements SetupPrompter
{
  private static final String SETUP_TASK_ANALYSIS_TITLE = "Setup Task Analysis";

  private static final URI INSTALLATION_ID_URI = URI.createURI("#~installation.id");

  private static final URI WORKSPACE_ID_URI = URI.createURI("#~workspace.id");

  private Composite composite;

  private ScrolledComposite scrolledComposite;

  private final FieldHolderManager manager = new FieldHolderManager();

  private final Set<String> unusedVariables = new HashSet<String>();

  private boolean prompted;

  private boolean fullPrompt;

  private boolean updating;

  private Set<SetupTaskPerformer> incompletePerformers = new LinkedHashSet<SetupTaskPerformer>();

  private Set<SetupTaskPerformer> allPromptedPerfomers = new LinkedHashSet<SetupTaskPerformer>();

  private SetupTaskPerformer performer;

  private Control focusControl;

  private SetupContext originalContext;

  private boolean save = true;

  private boolean defaultsSet;

  private UserCallback userCallback;

  private final Validator validator = new Validator();

  private FocusListener focusListener = new FocusAdapter()
  {
    @Override
    public void focusGained(FocusEvent e)
    {
      focusControl = (Control)e.widget;
    }
  };

  private PerformerCreationJob performerCreationJob;

  private long delay;

  public VariablePage()
  {
    super("VariablePage");
    setTitle("Variables");
    setDescription("Enter values for the required variables.");
  }

  @Override
  protected Control createUI(Composite parent)
  {
    Composite mainComposite = new Composite(parent, SWT.NONE);
    mainComposite.setLayout(UIUtil.createGridLayout(1));
    mainComposite.setLayoutData(new GridData(GridData.FILL_BOTH));

    GridLayout outerLayout = (GridLayout)parent.getParent().getLayout();
    outerLayout.marginLeft = outerLayout.marginWidth;
    outerLayout.marginWidth = 0;

    scrolledComposite = new ScrolledComposite(mainComposite, SWT.VERTICAL);
    scrolledComposite.setExpandHorizontal(true);
    scrolledComposite.setExpandVertical(true);
    scrolledComposite.setShowFocusedControl(true);
    scrolledComposite.setLayoutData(new GridData(GridData.FILL_BOTH));

    GridLayout layout = UIUtil.createGridLayout(3);
    layout.horizontalSpacing = 10;
    layout.verticalSpacing = 10;
    layout.marginRight = outerLayout.marginLeft;

    composite = new Composite(scrolledComposite, SWT.NONE);
    composite.setLayout(layout);
    scrolledComposite.setContent(composite);
    composite.setLayoutData(new GridData(GridData.FILL_BOTH));

    ControlAdapter resizeListener = new ControlAdapter()
    {
      @Override
      public void controlResized(ControlEvent event)
      {
        Point size = composite.computeSize(scrolledComposite.getClientArea().width, SWT.DEFAULT);
        scrolledComposite.setMinSize(size);
      }
    };

    scrolledComposite.addControlListener(resizeListener);
    composite.addControlListener(resizeListener);
    composite.notifyListeners(SWT.Resize, new Event());

    return mainComposite;
  }

  @Override
  protected void createCheckButtons(ButtonBar buttonBar)
  {
    final Button fullPromptButton = buttonBar.addCheckButton("Show all variables", "", false, "fullPrompt");
    fullPrompt = fullPromptButton.getSelection();
    fullPromptButton.addSelectionListener(new SelectionAdapter()
    {
      @Override
      public void widgetSelected(SelectionEvent e)
      {
        fullPrompt = fullPromptButton.getSelection();
        validator.schedule(false);
      }
    });

    AccessUtil.setKey(fullPromptButton, "showAll");
  }

  private synchronized boolean updateFields()
  {
    unusedVariables.clear();

    for (FieldHolder fieldHolder : manager)
    {
      fieldHolder.clear();
    }

    Set<SetupTaskPerformer> performers = new LinkedHashSet<SetupTaskPerformer>();
    if (incompletePerformers.isEmpty())
    {
      if (performer != null)
      {
        performers.add(performer);
      }

      performers.addAll(allPromptedPerfomers);
    }
    else
    {
      performers.addAll(incompletePerformers);
      performers.addAll(allPromptedPerfomers);
    }

    Set<String> usedVariables = new HashSet<String>();
    for (FieldHolder fieldHolder : manager)
    {
      String value = fieldHolder.getValue();
      if (!StringUtil.isEmpty(value))
      {
        usedVariables.addAll(SetupTaskPerformer.getVariables(value));
      }
    }

    for (SetupTaskPerformer setupTaskPerformer : performers)
    {
      List<VariableTask> variables = setupTaskPerformer.getUnresolvedVariables();
      for (VariableTask variable : variables)
      {
        VariableTask ruleVariable = setupTaskPerformer.getRuleVariable(variable);
        if (ruleVariable == null)
        {
          if (variable.getAnnotation(AnnotationConstants.ANNOTATION_UNDECLARED_VARIABLE) != null)
          {
            String name = variable.getName();
            if (!usedVariables.contains(name))
            {
              Trigger trigger = getTrigger();
              boolean isUsedInActualTriggeredTask = false;
              for (SetupTask setupTask : setupTaskPerformer.getTriggeredSetupTasks())
              {
                if (setupTask.getTriggers().contains(trigger) && setupTaskPerformer.isVariableUsed(name, setupTask, true))
                {
                  isUsedInActualTriggeredTask = true;
                  break;
                }
              }

              if (!isUsedInActualTriggeredTask)
              {
                unusedVariables.add(name);
                continue;
              }
            }
          }

          manager.getFieldHolder(variable, true, false);
        }
        else
        {
          FieldHolder fieldHolder = manager.getFieldHolder(ruleVariable, true, false);
          fieldHolder.add(variable);
          manager.associate(variable, fieldHolder);
        }
      }
    }

    boolean setDefault = false;
    for (FieldHolder fieldHolder : manager)
    {
      if (StringUtil.isEmpty(fieldHolder.getValue()))
      {
        String initialValue = null;
        String initialDefaultValue = null;
        for (VariableTask variable : fieldHolder.getVariables())
        {
          if (initialValue == null)
          {
            String value = variable.getValue();
            if (!StringUtil.isEmpty(value))
            {
              initialValue = value;

              // Check the choices for ones that specify "match choice" annotations.
              for (VariableChoice choice : variable.getChoices())
              {
                Annotation annotation = choice.getAnnotation(AnnotationConstants.ANNOTATION_MATCH_CHOICE);
                if (annotation != null)
                {
                  String choiceValue = choice.getValue();
                  if (choiceValue != null)
                  {
                    // Expand the choice into a pattern where the variables expand to ".*" and the rest of the value is quoted as literal.
                    StringBuffer result = new StringBuffer("\\Q");
                    Matcher matcher = StringExpander.STRING_EXPANSION_PATTERN.matcher(choiceValue);
                    while (matcher.find())
                    {
                      matcher.appendReplacement(result, "\\\\E.*\\\\Q");
                    }

                    matcher.appendTail(result);

                    try
                    {
                      // If the pattern matches, use the value of the choice as the initial value.
                      Pattern pattern = Pattern.compile(result.toString());
                      if (pattern.matcher(value).matches())
                      {
                        initialValue = choiceValue;
                        setDefault = true;
                        break;
                      }
                    }
                    catch (Throwable throwable)
                    {
                      // Ignore.
                    }
                  }
                }
              }
            }
          }

          if (initialDefaultValue == null)
          {
            String defaultValue = variable.getDefaultValue();
            if (!StringUtil.isEmpty(defaultValue))
            {
              initialDefaultValue = defaultValue;
            }
          }
        }

        if (!StringUtil.isEmpty(initialValue))
        {
          fieldHolder.setValue(initialValue);
        }
        else if (!StringUtil.isEmpty(initialDefaultValue))
        {
          setDefault = true;
          fieldHolder.setValue(initialDefaultValue);
        }
        else
        {
          String defaultValue = fieldHolder.getDefaultValue();
          if (!StringUtil.isEmpty(defaultValue))
          {
            setDefault = true;
            fieldHolder.setValue(defaultValue);
          }
        }
      }
    }

    try
    {
      for (FieldHolder fieldHolder : manager)
      {
        updating = true;
        fieldHolder.update();
      }
    }
    finally
    {
      updating = false;
    }

    for (FieldHolder fieldHolder : manager)
    {
      fieldHolder.recordInitialValue();
    }

    // Determine the URIs of all the variables actually being used.
    Set<URI> uris = new HashSet<URI>();
    if (performer != null)
    {
      for (VariableTask variable : performer.getUnresolvedVariables())
      {
        uris.add(manager.getURI(variable));
        VariableTask ruleVariable = performer.getRuleVariable(variable);
        if (ruleVariable != null)
        {
          uris.add(manager.getURI(ruleVariable));
        }
      }
    }

    manager.cleanup(uris);

    ScrolledComposite parent = (ScrolledComposite)composite.getParent();
    Point origin = parent.getOrigin();
    parent.setRedraw(false);

    List<SetupTaskPerformer> allPerformers = new ArrayList<SetupTaskPerformer>(allPromptedPerfomers);
    if (performer != null)
    {
      allPerformers.add(0, performer);
    }

    // Determine an appropriate field order.
    manager.reorder(allPerformers);

    parent.pack();
    parent.getParent().layout();
    parent.setOrigin(origin);
    parent.setRedraw(true);

    FieldHolder firstField = null;
    FieldHolder firstEmptyField = null;
    for (FieldHolder fieldHolder : manager)
    {
      if (!fieldHolder.isDisposed())
      {
        if (firstField == null)
        {
          firstField = fieldHolder;
        }

        if (firstEmptyField == null && StringUtil.isEmpty(fieldHolder.getValue()))
        {
          firstEmptyField = fieldHolder;
        }
      }
    }

    if (focusControl != null && !focusControl.isDisposed())
    {
      focusControl.setFocus();
      parent.showControl(focusControl);
    }
    else
    {
      FieldHolder field = firstEmptyField;
      if (field == null)
      {
        field = firstField;
      }

      if (field != null)
      {
        field.setFocus();
        parent.showControl(field.getControl());
      }
    }

    for (FieldHolder fieldHolder : manager)
    {
      if (!fieldHolder.isDisposed())
      {
        Control control = fieldHolder.getControl();
        PropertyField field = fieldHolder.field;
        Label label = field.getLabel();
        Control helper = field.getHelper();
        for (VariableTask variable : fieldHolder.getVariables())
        {
          String name = variable.getName();
          if (name.startsWith("@<id>"))
          {
            name = name.substring(name.indexOf("name: ") + 6, name.indexOf(')'));
          }

          AccessUtil.setKey(label, name + ".label");
          AccessUtil.setKey(control, name + ".control");
          AccessUtil.setKey(helper, name + ".helper");

          break;
        }
      }
    }

    if (setDefault)
    {
      defaultsSet = true;
    }

    if (isPageComplete() ? setDefault : firstEmptyField == null || setDefault)
    {
      // If the page isn't complete but there are no empty fields, then the last change introduced a new field.
      // So we should validate again to be sure there really needs to be more information prompted from the user.
      return true;
    }

    return false;
  }

  private void validate()
  {
    try
    {
      performer = null;
      incompletePerformers.clear();
      allPromptedPerfomers.clear();

      setButtonState(IDialogConstants.NEXT_ID, false);

      performerCreationJob = new PerformerCreationJob(SETUP_TASK_ANALYSIS_TITLE)
      {
        @Override
        protected SetupTaskPerformer createPerformer() throws Exception
        {
          return VariablePage.this.createPerformer(VariablePage.this, fullPrompt);
        }

        @Override
        protected Dialog createDialog()
        {
          return createDialog(getShell(), SETUP_TASK_ANALYSIS_TITLE, null,
              "Analyzing the needed setup tasks has taken more than " + (System.currentTimeMillis() - getStart()) / 1000
                  + " seconds.  The Next button will be disabled, though animated, until it completes.  You may continue to modify the values of the variables.",
              MessageDialog.INFORMATION, new String[] { IDialogConstants.OK_LABEL }, 0);
        }

        @Override
        protected void handleDialogResult(int result)
        {
          if (result == 0)
          {
            setDelay(Integer.MAX_VALUE);
          }
          else
          {
            setDelay(2 * getDelay());
          }
        }
      };

      if (delay != 0)
      {
        performerCreationJob.setDelay(delay);
      }

      performerCreationJob.create();
      delay = performerCreationJob.getDelay();

      Throwable throwable = performerCreationJob.getThrowable();
      if (throwable != null)
      {
        if (throwable instanceof OperationCanceledException)
        {
          performerCreationJob = null;
          return;
        }

        throw throwable;
      }

      performer = performerCreationJob.getPerformer();

      UIUtil.asyncExec(getControl(), new Runnable()
      {
        public void run()
        {
          performerCreationJob = null;
          if (updateFields())
          {
            validate();
          }
        }
      });

      if (performer == null)
      {
        setPageComplete(false);
      }
      else
      {
        setPageComplete(true);

        if (!prompted)
        {
          prompted = true;
          gotoNextPage();
        }
      }
    }
    catch (Throwable t)
    {
      performerCreationJob = null;
      SetupUIPlugin.INSTANCE.log(t);
      ErrorDialog.open(t);
    }
  }

  private void clearSpecialFieldHolders()
  {
    clearSpecialFieldHolders(INSTALLATION_ID_URI);
    clearSpecialFieldHolders(WORKSPACE_ID_URI);
  }

  private void clearSpecialFieldHolders(URI uri)
  {
    FieldHolderRecord fieldHolderRecord = manager.getFieldHolderRecord(uri);
    if (fieldHolderRecord != null)
    {
      FieldHolder fieldHolder = fieldHolderRecord.getFieldHolder();
      if (fieldHolder != null && !fieldHolder.isDirty())
      {
        fieldHolder.clearValue();
      }
    }
  }

  @Override
  public void enterPage(boolean forward)
  {
    if (forward)
    {
      if (userCallback == null)
      {
        Shell shell = getShell();
        userCallback = new UICallback(shell, shell.getText());
      }

      clearSpecialFieldHolders();
    }

    performer = getWizard().getPerformer();
    if (performer != null && forward)
    {
      performer.setPrompter(this);
      setPageComplete(true);
      gotoNextPage();
    }
    else
    {
      if (!forward)
      {
        getWizard().setSetupContext(originalContext);
        originalContext = null;
      }

      IndexLoader indexLoader = getWizard().getIndexLoader();
      if (indexLoader != null)
      {
        indexLoader.awaitIndexLoad();
      }

      setPageComplete(false);
      validate();
      if (forward && getPreviousPage() == null)
      {
        UIUtil.asyncExec(getControl(), new Runnable()
        {
          public void run()
          {
            if (isPageComplete() && !defaultsSet)
            {
              gotoNextPage();
            }
          }
        });
      }
    }
  }

  @Override
  public void leavePage(boolean forward)
  {
    if (forward)
    {
      originalContext = getWizard().getSetupContext();

      final List<VariableTask> unresolvedVariables = performer.getUnresolvedVariables();
      for (FieldHolder fieldHolder : manager)
      {
        unresolvedVariables.addAll(fieldHolder.getVariables());
      }

      final ResourceSet resourceSet = SetupCoreUtil.createResourceSet();

      User user = getUser();
      final User copiedUser = EcoreUtil.copy(user);
      URI userResourceURI = user.eResource().getURI();
      Resource userResource = resourceSet.createResource(userResourceURI);
      userResource.getContents().add(copiedUser);

      Installation installation = performer.getInstallation();
      Resource installationResource = installation.eResource();
      URI installationResourceURI = installationResource.getURI();
      installationResource
          .setURI(URI.createFileURI(new File(performer.getProductConfigurationLocation(), "org.eclipse.oomph.setup/installation.setup").toString()));

      Workspace workspace = performer.getWorkspace();
      Resource workspaceResource = null;
      URI workspaceResourceURI = null;
      if (workspace != null)
      {
        workspaceResource = workspace.eResource();
        workspaceResourceURI = workspaceResource.getURI();
        workspaceResource
            .setURI(URI.createFileURI(new File(performer.getWorkspaceLocation(), ".metadata/.plugins/org.eclipse.oomph.setup/workspace.setup").toString()));
      }

      Installation copiedInstallation = EcoreUtil.copy(installation);
      URI copiedInstallationResourceURI = installation.eResource().getURI();
      Resource copiedInstallationResource = resourceSet.createResource(copiedInstallationResourceURI);
      copiedInstallationResource.getContents().add(copiedInstallation);

      Workspace copiedWorkspace = EcoreUtil.copy(workspace);
      if (workspace != null)
      {
        URI copiedWorkspaceResourceURI = workspace.eResource().getURI();
        Resource copiedWorkspaceResource = resourceSet.createResource(copiedWorkspaceResourceURI);
        copiedWorkspaceResource.getContents().add(copiedWorkspace);
      }

      performer.recordVariables(copiedInstallation, copiedWorkspace, copiedUser);

      unresolvedVariables.clear();

      getWizard().setSetupContext(SetupContext.create(copiedInstallation, copiedWorkspace, copiedUser));
      setPerformer(performer);

      if (save)
      {
        BaseUtil.saveEObject(copiedUser);

        performer.savePasswords();
      }

      installationResource.setURI(installationResourceURI);
      if (workspaceResource != null)
      {
        workspaceResource.setURI(workspaceResourceURI);
      }
    }
    else
    {
      originalContext = null;

      setPerformer(null);

      validator.cancel();
    }
  }

  public synchronized String getValue(VariableTask variable)
  {
    FieldHolder fieldHolder = manager.getFieldHolder(variable, false, true);
    if (fieldHolder != null && (updating || fieldHolder.isDirty()))
    {
      String value = fieldHolder.getValue();
      if (!"".equals(value))
      {
        return value;
      }
    }

    if (updating && performer != null)
    {
      Object value = performer.getMap().get(variable.getName());
      if (value != null)
      {
        return value.toString();
      }
    }

    return null;
  }

  public OS getOS()
  {
    return getWizard().getOS();
  }

  public String getVMPath()
  {
    return getWizard().getVMPath();
  }

  public synchronized boolean promptVariables(List<? extends SetupTaskContext> contexts)
  {
    prompted = true;

    @SuppressWarnings("unchecked")
    List<SetupTaskPerformer> performers = (List<SetupTaskPerformer>)contexts;
    allPromptedPerfomers.addAll(performers);

    for (SetupTaskPerformer performer : performers)
    {
      boolean resolvedAll = true;
      List<VariableTask> unresolvedVariables = performer.getUnresolvedVariables();
      for (VariableTask variable : unresolvedVariables)
      {
        FieldHolder fieldHolder = manager.getFieldHolder(variable, false, true);
        if (fieldHolder != null)
        {
          String value = fieldHolder.getValue();
          if (!"".equals(value))
          {
            variable.setValue(value);
          }
          else
          {
            resolvedAll = false;
          }
        }
        else if (unusedVariables.contains(variable.getName()))
        {
          variable.setValue(" ");
        }
        else
        {
          resolvedAll = false;
        }
      }

      if (!resolvedAll)
      {
        incompletePerformers.add(performer);
      }
    }

    boolean isComplete = incompletePerformers.isEmpty();
    return isComplete;
  }

  public UserCallback getUserCallback()
  {
    return userCallback;
  }

  /**
   * @author Ed Merks
   */
  private final class FieldHolder implements ValueListener
  {
    private final Set<VariableTask> variables = new LinkedHashSet<VariableTask>();

    private PropertyField field;

    private String initialValue;

    public FieldHolder(VariableTask variable)
    {
      field = PropertyField.createField(variable);
      field.fill(composite);
      field.addValueListener(this);
      field.getControl().addFocusListener(focusListener);
      variables.add(variable);
    }

    public boolean isDisposed()
    {
      return field == null;
    }

    private Control getControl()
    {
      if (field == null)
      {
        return null;
      }

      Control control = field.getControl();
      Control parent = control.getParent();
      if (parent == composite)
      {
        return control;
      }

      return null;
    }

    public void setFocus()
    {
      if (field == null)
      {
        throw new IllegalStateException("Can't set the value of a disposed field");
      }

      field.setFocus();
    }

    public String getValue()
    {
      return field == null ? initialValue : field.getValue();
    }

    public String getDefaultValue()
    {
      return field == null ? null : field.getDefaultValue();
    }

    public void clearValue()
    {
      initialValue = "";

      if (field != null)
      {
        field.setValue("", false, false);
      }
    }

    public void setValue(String value)
    {
      if (field == null)
      {
        throw new IllegalStateException("Can't set the value of a disposed field");
      }

      initialValue = null;

      field.setValue(value, false);
    }

    public Set<VariableTask> getVariables()
    {
      return Collections.unmodifiableSet(variables);
    }

    public void clear()
    {
      variables.clear();

      if (field instanceof AuthenticatedField)
      {
        AuthenticatedField authenticatedField = (AuthenticatedField)field;
        authenticatedField.clear();
      }
    }

    public void add(VariableTask variable)
    {
      if (variables.add(variable))
      {
        String value = field.getValue();
        if (!"".equals(value))
        {
          variable.setValue(value);
        }
      }
    }

    public void update()
    {
      if (field instanceof AuthenticatedField)
      {
        AuthenticatedField authenticatedField = (AuthenticatedField)field;
        String value = field.getValue();
        Set<Authenticator> allAuthenticators = new LinkedHashSet<Authenticator>();
        for (VariableTask variable : variables)
        {
          if (!StringUtil.isEmpty(value))
          {
            variable.setValue(value);
          }

          Set<? extends Authenticator> authenticators = SetupTaskPerformer.getAuthenticators(variable);
          if (authenticators != null)
          {
            allAuthenticators.addAll(authenticators);
          }
        }

        if (!allAuthenticators.isEmpty())
        {
          for (Iterator<Authenticator> it = allAuthenticators.iterator(); it.hasNext();)
          {
            Authenticator authenticator = it.next();
            if (authenticator.isFiltered())
            {
              it.remove();
            }
          }

          authenticatedField.addAll(allAuthenticators);

          if (allAuthenticators.isEmpty())
          {
            dispose(PreferencesUtil.encrypt(" "));
          }
        }
      }
    }

    public void valueChanged(String oldValue, String newValue) throws Exception
    {
      synchronized (VariablePage.this)
      {
        for (VariableTask variable : variables)
        {
          variable.setValue(newValue);
        }
      }

      validator.schedule(true);
    }

    public void recordInitialValue()
    {
      if (initialValue == null && field != null)
      {
        initialValue = field.getValue();
      }
    }

    public boolean isDirty()
    {
      return field != null && initialValue != null && !initialValue.equals(field.getValue());
    }

    public void dispose(String value)
    {
      if (field != null)
      {
        field.dispose();
        field = null;
      }

      if (StringUtil.isEmpty(initialValue))
      {
        initialValue = value;
      }
    }

    public void dispose()
    {
      if (field != null)
      {
        field.dispose();
        field = null;
      }
    }

    @Override
    public String toString()
    {
      return field == null ? "<disposed>" : field.toString();
    }
  }

  /**
   * @author Ed Merks
   */
  private static class FieldHolderRecord
  {
    private FieldHolder fieldHolder;

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

    public FieldHolderRecord()
    {
    }

    public FieldHolder getFieldHolder()
    {
      return fieldHolder;
    }

    public void setFieldHolder(FieldHolder fieldHolder)
    {
      this.fieldHolder = fieldHolder;
    }

    public Set<URI> getVariableURIs()
    {
      return variableURIs;
    }

    @Override
    public String toString()
    {
      return variableURIs.toString();
    }
  }

  /**
   * @author Ed Merks
   */
  private class FieldHolderManager implements Iterable<FieldHolder>
  {
    private final EList<FieldHolderRecord> fields = new BasicEList<FieldHolderRecord>();

    public Iterator<FieldHolder> iterator()
    {
      final Iterator<FieldHolderRecord> iterator = fields.iterator();
      return new Iterator<FieldHolder>()
      {
        public boolean hasNext()
        {
          return iterator.hasNext();
        }

        public FieldHolder next()
        {
          return iterator.next().getFieldHolder();
        }

        public void remove()
        {
          throw new UnsupportedOperationException();
        }
      };
    }

    public void reorder(List<SetupTaskPerformer> allPerformers)
    {
      List<Control> controls = new ArrayList<Control>();
      Map<FieldHolderRecord, Set<FieldHolderRecord>> ruleUses = new LinkedHashMap<FieldHolderRecord, Set<FieldHolderRecord>>();
      LOOP: for (FieldHolderRecord fieldHolderRecord : fields)
      {
        FieldHolder fieldHolder = fieldHolderRecord.getFieldHolder();
        Control control = fieldHolder.getControl();
        if (control != null)
        {
          controls.add(control);
          for (VariableTask variable : fieldHolder.getVariables())
          {
            for (SetupTaskPerformer performer : allPerformers)
            {
              EAttribute eAttribute = performer.getAttributeRuleVariableData(variable);
              if (eAttribute != null)
              {
                CollectionUtil.addAll(ruleUses, fieldHolderRecord, Collections.<FieldHolderRecord> emptySet());
                continue LOOP;
              }
            }
          }

          // for (VariableTask variable : fieldHolder.getVariables())
          // {
          // for (SetupTaskPerformer performer : allPerformers)
          // {
          // EStructuralFeature.Setting setting = performer.getImpliedVariableData(variable);
          // if (setting != null)
          // {
          // continue LOOP;
          // }
          // }
          // }

          for (VariableTask variable : fieldHolder.getVariables())
          {
            for (SetupTaskPerformer performer : allPerformers)
            {
              VariableTask dependantVariable = performer.getRuleVariableData(variable);
              if (dependantVariable != null)
              {
                VariableTask ruleVariable = performer.getRuleVariable(dependantVariable);
                if (ruleVariable != null)
                {
                  FieldHolderRecord dependantFieldHolderRecord = getFieldHolderRecord(getURI(ruleVariable));
                  if (dependantFieldHolderRecord != null)
                  {
                    CollectionUtil.add(ruleUses, dependantFieldHolderRecord, fieldHolderRecord);
                    continue LOOP;
                  }
                }
              }
            }
          }
        }
      }

      int fieldsSize = fields.size();
      if (fieldsSize > 1)
      {
        int index = 0;
        int maxPosition = fieldsSize - 1;
        for (Map.Entry<FieldHolderRecord, Set<FieldHolderRecord>> entry : ruleUses.entrySet())
        {
          FieldHolderRecord fieldHolderRecord = entry.getKey();
          fields.move(index++, fieldHolderRecord);
          Set<FieldHolderRecord> fieldHolderRecords = entry.getValue();
          for (FieldHolderRecord dependantFieldHolderRecord : fieldHolderRecords)
          {
            fields.move(Math.min(index++, maxPosition), dependantFieldHolderRecord);
          }
        }
      }

      int size = controls.size();
      if (size > 1)
      {
        List<Control> children = Arrays.asList(composite.getChildren());

        int controlOffset = 0;
        for (Control child : children)
        {
          if (controls.contains(child))
          {
            break;
          }

          ++controlOffset;
        }

        Control target = children.get(PropertyField.NUM_COLUMNS - 1);
        int count = 0;
        for (FieldHolder fieldHolder : this)
        {
          Control control = fieldHolder.getControl();
          if (control != null)
          {
            int index = children.indexOf(control) - controlOffset;
            Control newTarget = null;
            for (int j = PropertyField.NUM_COLUMNS - 1; j >= 0; --j)
            {
              Control child = children.get(index + j);
              if (newTarget == null)
              {
                newTarget = child;
                if (index == count)
                {
                  break;
                }
              }

              child.moveBelow(target);
            }

            target = newTarget;
            count += PropertyField.NUM_COLUMNS;
          }
        }
      }
    }

    public void cleanup(Set<URI> uris)
    {
      LOOP: for (FieldHolderRecord fieldHolderRecord : fields)
      {
        for (URI uri : fieldHolderRecord.getVariableURIs())
        {
          if (uris.contains(uri))
          {
            continue LOOP;
          }
        }

        FieldHolder fieldHolder = fieldHolderRecord.getFieldHolder();
        if (fieldHolder.getVariables().isEmpty() && !fieldHolder.isDirty())
        {
          fieldHolder.dispose();
        }
      }
    }

    public URI getURI(VariableTask variable)
    {
      String name = variable.getName();
      if (variable.getAnnotation(AnnotationConstants.ANNOTATION_GLOBAL_VARIABLE) != null)
      {
        return URI.createURI("#" + name);
      }

      Resource resource = variable.eResource();
      URI uri;
      if (resource == null)
      {
        uri = URI.createURI("#");
      }
      else
      {
        EObject eObject = resource.getContents().get(0);
        if (eObject instanceof Installation || eObject instanceof Workspace)
        {
          uri = URI.createURI(resource.getURI().lastSegment()).appendFragment(resource.getURIFragment(variable));
        }
        else
        {
          uri = EcoreUtil.getURI(variable);
        }
      }

      uri = uri.appendFragment(uri.fragment() + "~" + name);
      return uri;
    }

    private FieldHolderRecord getFieldHolderRecord(URI uri)
    {
      for (FieldHolderRecord fieldHolderRecord : fields)
      {
        if (fieldHolderRecord.getVariableURIs().contains(uri))
        {
          return fieldHolderRecord;
        }
      }

      return null;
    }

    public void associate(VariableTask variable, FieldHolder fieldHolder)
    {
      URI uri = getURI(variable);
      for (FieldHolderRecord fieldHolderRecord : fields)
      {
        if (fieldHolderRecord.getFieldHolder() == fieldHolder)
        {
          fieldHolderRecord.getVariableURIs().add(uri);
          break;
        }
      }
    }

    public FieldHolder getFieldHolder(VariableTask variable, boolean demandCreate, boolean includeDisposed)
    {
      URI uri = getURI(variable);
      FieldHolderRecord fieldHolderRecord = getFieldHolderRecord(uri);
      FieldHolder fieldHolder = null;
      if (fieldHolderRecord == null)
      {
        if (!demandCreate)
        {
          return null;
        }

        fieldHolderRecord = new FieldHolderRecord();
        fieldHolderRecord.getVariableURIs().add(uri);
        fields.add(fieldHolderRecord);
      }
      else
      {
        fieldHolder = fieldHolderRecord.getFieldHolder();
        if (fieldHolder.isDisposed())
        {
          if (includeDisposed)
          {
            return fieldHolder;
          }

          if (!demandCreate)
          {
            return null;
          }

          fieldHolder = null;
        }
      }

      if (fieldHolder == null)
      {
        fieldHolder = new FieldHolder(variable);
        fieldHolderRecord.setFieldHolder(fieldHolder);
      }
      else if (!updating)
      {
        fieldHolder.add(variable);
      }

      return fieldHolder;
    }

    @Override
    public String toString()
    {
      return fields.toString();
    }
  }

  /**
   * A class for delayed validation.
   * @author Ed Merks
   */
  private class Validator implements Runnable
  {
    private boolean canceled;

    private boolean dispatched;

    private boolean redispatch;

    private boolean clearSpecialFieldHolders;

    public void run()
    {
      if (!canceled && !getShell().isDisposed())
      {
        dispatched = false;
        if (redispatch || performerCreationJob != null)
        {
          if (performerCreationJob != null)
          {
            performerCreationJob.cancel();
          }

          schedule(clearSpecialFieldHolders);
        }
        else
        {
          if (clearSpecialFieldHolders)
          {
            clearSpecialFieldHolders();
            clearSpecialFieldHolders = false;
          }

          validate();
        }
      }
    }

    public void schedule(boolean clearSpecialFieldHolders)
    {
      canceled = false;

      if (clearSpecialFieldHolders)
      {
        this.clearSpecialFieldHolders = true;
      }

      if (dispatched)
      {
        redispatch = true;
      }
      else
      {
        dispatched = true;
        redispatch = false;

        UIUtil.timerExec(350, this);
      }
    }

    public void cancel()
    {
      canceled = true;
      dispatched = false;
      redispatch = false;
      clearSpecialFieldHolders = false;

      if (performerCreationJob != null)
      {
        performerCreationJob.cancel();
      }
    }
  }
}