/*
 * Copyright (c) 2016 Ed Merks (Berlin, 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:
 *    Ed Merks - initial API and implementation
 */
package org.eclipse.oomph.setup.ui.wizards;

import org.eclipse.oomph.base.util.BaseUtil;
import org.eclipse.oomph.setup.Configuration;
import org.eclipse.oomph.setup.EclipseIniTask;
import org.eclipse.oomph.setup.Index;
import org.eclipse.oomph.setup.Installation;
import org.eclipse.oomph.setup.Product;
import org.eclipse.oomph.setup.ProductCatalog;
import org.eclipse.oomph.setup.ProductVersion;
import org.eclipse.oomph.setup.Project;
import org.eclipse.oomph.setup.ProjectCatalog;
import org.eclipse.oomph.setup.ProjectContainer;
import org.eclipse.oomph.setup.Scope;
import org.eclipse.oomph.setup.SetupFactory;
import org.eclipse.oomph.setup.SetupTask;
import org.eclipse.oomph.setup.SetupTaskContainer;
import org.eclipse.oomph.setup.Stream;
import org.eclipse.oomph.setup.Workspace;
import org.eclipse.oomph.setup.WorkspaceTask;
import org.eclipse.oomph.setup.internal.core.SetupContext;
import org.eclipse.oomph.setup.internal.core.util.CatalogManager;
import org.eclipse.oomph.setup.ui.SetupUIPlugin;
import org.eclipse.oomph.util.StringUtil;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
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.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.MessageDialog;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * @author Ed Merks
 */
public class ConfigurationProcessor
{
  protected final SetupWizard setupWizard;

  protected final Configuration configuration;

  protected final Workspace workspace;

  protected Installation installation;

  private final ScopeStatus status = new ScopeStatus(null, "Problems were encountered processing the configuration");

  public ConfigurationProcessor(SetupWizard setupWizard)
  {
    this.setupWizard = setupWizard;
    configuration = setupWizard.getConfiguration();
    if (configuration == null)
    {
      installation = null;
      workspace = null;
    }
    else
    {
      installation = configuration.getInstallation();
      workspace = configuration.getWorkspace();
    }

    status.add(new ScopeStatus(installation, "Problems were encountered processing the installation"));
    status.add(new ScopeStatus(null, "Problems were encountered processing the workspace"));
  }

  public IStatus getStatus()
  {
    status.computeSeverity();

    int okCount = 0;
    IStatus result = null;
    for (IStatus status : status.getChildren())
    {
      if (status.isOK())
      {
        ++okCount;
      }
      else
      {
        result = status;
      }
    }

    if (okCount == 1)
    {
      return result;
    }

    return status;
  }

  public boolean processInstallation()
  {
    return installation == null ? handleNullInstallation() : handleInstallation();
  }

  protected MultiStatus getStatus(final Scope scope)
  {
    if (scope instanceof Installation)
    {
      return (MultiStatus)status.getChildren()[0];
    }

    MultiStatus containerStatus = (MultiStatus)status.getChildren()[scope instanceof ProductVersion ? 0 : 1];
    for (IStatus status : containerStatus.getChildren())
    {
      ScopeStatus scopeStatus = (ScopeStatus)status;
      if (scopeStatus.getScope() == scope)
      {
        return scopeStatus;
      }
    }

    ScopeStatus scopeStatus = new ScopeStatus(scope);
    containerStatus.add(scopeStatus);
    return scopeStatus;
  }

  public boolean processWorkspace()
  {
    return workspace == null ? handleNullWorkspace() : handleWorkspace();
  }

  protected boolean handleNullInstallation()
  {
    return true;
  }

  protected boolean handleInstallation()
  {
    ProductVersion productVersion = installation.getProductVersion();
    return productVersion == null ? handleNullProductVersion() : handleProductVersion(productVersion);
  }

  protected boolean handleNullProductVersion()
  {
    addStatus(IStatus.ERROR, installation, "No product version is specified");
    return false;
  }

  protected boolean handleProductVersion(ProductVersion productVersion)
  {
    if (productVersion.eIsProxy())
    {
      return handleProxyProductVersion(productVersion);
    }

    Product product = productVersion.getProduct();
    if (product == null)
    {
      return handleNullProduct(productVersion);
    }

    ProductCatalog productCatalog = product.getProductCatalog();
    CatalogManager catalogManager = setupWizard.getCatalogManager();
    if (productCatalog == null)
    {
      boolean added = false;
      CatalogSelector catalogSelector = new CatalogSelector(catalogManager, true);
      for (Scope scope : catalogSelector.getCatalogs())
      {
        if (isUserProductCatalog(scope))
        {
          ProductCatalog userProductCatalog = (ProductCatalog)scope;
          userProductCatalog.getProducts().add(product);
          BaseUtil.saveEObject(userProductCatalog);
          catalogManager.selectCatalog(true, userProductCatalog, true);
          added = true;
          break;
        }
      }

      if (!added)
      {
        return handleNoUserProductCatalog(productVersion);
      }
    }
    else
    {
      Index index = catalogManager.getIndex();
      Index productCatalogIndex = productCatalog.getIndex();
      if (productCatalogIndex == index)
      {
        if (!"self".equals(productCatalog.getName()))
        {
          catalogManager.selectCatalog(true, productCatalog, true);
        }
      }
      else if (!addCatalog(true, productCatalog, productVersion))
      {
        return handleNoRedirectableProductCatalog(productVersion);
      }
    }

    if ("self.empty.product.version".equals(productVersion.getQualifiedName()))
    {
      return applyEmptyProductVersion();
    }

    return applyProductVersion(productVersion);
  }

  protected boolean applyEmptyProductVersion()
  {
    return false;
  }

  protected boolean applyProductVersion(ProductVersion productVersion)
  {
    return false;
  }

  protected void applyInstallation()
  {
    SetupContext setupContext = SetupContext.create(setupWizard.getResourceSet(), null);
    Installation setupInstallation = setupContext.getInstallation();

    applyAttributes(setupInstallation, installation);
    applySetupTasks(setupInstallation, installation);

    setupWizard.addAppliedConfigurationResource(installation.eResource());
  }

  protected void applyAttributes(Scope targetScope, Scope sourceScope)
  {
    String name = sourceScope.getName();
    if (!StringUtil.isEmpty(name))
    {
      targetScope.setName(name);
    }

    String label = sourceScope.getLabel();
    if (!StringUtil.isEmpty(label))
    {
      targetScope.setLabel(label);
    }

    String description = sourceScope.getDescription();
    if (!StringUtil.isEmpty(description))
    {
      targetScope.setDescription(description);
    }

    targetScope.getAnnotations().addAll(sourceScope.getAnnotations());
  }

  protected void applySetupTasks(SetupTaskContainer targetSetupTaskContainer, SetupTaskContainer sourceSetTaskContainer)
  {
    targetSetupTaskContainer.getSetupTasks().addAll(sourceSetTaskContainer.getSetupTasks());
  }

  protected boolean handleNoRedirectableProductCatalog(ProductVersion productVersion)
  {
    return false;
  }

  protected boolean handleNoUserProductCatalog(ProductVersion productVersion)
  {
    addStatus(IStatus.ERROR, productVersion, "Cannot add the product to the user product catalog because the index doesn't contain one");
    return false;
  }

  protected boolean handleProxyProductVersion(ProductVersion productVersion)
  {
    addStatus(IStatus.ERROR, productVersion, "The product version cannot be resolved");
    return false;
  }

  protected boolean handleNullProduct(ProductVersion productVersion)
  {
    addStatus(IStatus.ERROR, productVersion, "The product version is not contained by a product");
    return false;
  }

  protected boolean handleNullWorkspace()
  {
    return true;
  }

  protected boolean handleWorkspace()
  {
    if (setupWizard.isSimple())
    {
      int answer = new MessageDialog(setupWizard.getShell(), "Configuration Handling", null,
          "The configuration contains a workspace that can only be handled by the advanced mode of the installer.", MessageDialog.WARNING,
          installation == null ? //
              new String[] { "Switch to Advanced Mode", "Cancel" } : //
              new String[] { "Switch to Avanced Mode", "Apply only Installation", "Cancel" },
          0).open();
      switch (answer)
      {
        case 0:
        {
          if (configuration != null)
          {
            setupWizard.addAppliedConfigurationResource(configuration.eResource());
          }

          Collection<? extends Resource> configurationResources = setupWizard.getAppliedConfigurationResources();
          handleSwitchToAdvancedMode();
          setupWizard.setConfigurationResources(configurationResources);
          return false;
        }

        case 1:
        {
          if (installation != null)
          {
            return true;
          }

          return false;
        }

        default:
        {
          return false;
        }
      }
    }

    List<Stream> projectStreams = new ArrayList<Stream>();
    for (Stream stream : workspace.getStreams())
    {
      if (stream.eIsProxy())
      {
        addStatus(IStatus.ERROR, stream, "The referenced stream cannot be resolved");
      }
      else
      {
        Project project = stream.getProject();
        if (project == null)
        {
          addStatus(IStatus.ERROR, stream, "The referenced stream is not contained by a project");
        }
        else
        {
          Project rootProject = project;
          ProjectCatalog projectCatalog = null;
          for (ProjectContainer projectContainer = project.getProjectContainer(); projectContainer != null; projectContainer = projectContainer
              .getProjectContainer())
          {
            if (projectContainer instanceof Project)
            {
              rootProject = (Project)projectContainer;
            }
            else if (projectContainer instanceof ProjectCatalog)
            {
              projectCatalog = (ProjectCatalog)projectContainer;
              break;
            }
          }

          if (projectCatalog == null)
          {
            ProjectContainer logicalProjectContainer = rootProject.getLogicalProjectContainer();
            if (logicalProjectContainer == null)
            {
              addStatus(IStatus.ERROR, stream,
                  "The referenced stream's root project is not contained by a project catalog and it doesn't specify a logical project container: "
                      + EcoreUtil.getURI(rootProject));
            }
            else if (logicalProjectContainer.eIsProxy())
            {
              addStatus(IStatus.ERROR, stream,
                  "The referenced stream's root project is not contained by a project catalog and its logical project container cannot be resolved: "
                      + EcoreUtil.getURI(logicalProjectContainer));
            }
            else if (logicalProjectContainer instanceof Project)
            {
              addStatus(IStatus.ERROR, stream,
                  "The referenced stream's root project is not contained by a project catalog and is not contained by its logical project container: "
                      + EcoreUtil.getURI(logicalProjectContainer));
            }
            else
            {
              // Try to add the catalog.
              ProjectCatalog logicalProjectCatalog = (ProjectCatalog)logicalProjectContainer;
              if (handleStream(logicalProjectCatalog, stream))
              {
                // If the project is in that catalog, we're all good.
                if (logicalProjectCatalog.getProjects().contains(rootProject))
                {
                  projectStreams.add(stream);
                }
                // Try to add the root project to the user extension project of the catalog.
                else if (handleUserProject(logicalProjectCatalog, rootProject))
                {
                  projectStreams.add(stream);
                }
                else
                {
                  addStatus(IStatus.ERROR, stream, "Cannot add the stream's root project: " + EcoreUtil.getURI(rootProject));
                  addStatus(IStatus.ERROR, stream,
                      "The target project catalog does not contain an extensible user project: " + EcoreUtil.getURI(logicalProjectCatalog));
                }
              }
              else
              {
                // Errors already handled.
              }
            }
          }
          else
          {
            if (handleStream(projectCatalog, stream))
            {
              projectStreams.add(stream);
            }
            else
            {
              // Errors already handled.
            }
          }
        }
      }
    }

    if (projectStreams.isEmpty() ? applyNoStreams() : applyStreams(projectStreams))
    {
      return applyWorkspace();
    }

    return false;
  }

  protected boolean applyWorkspace()
  {
    SetupContext setupContext = SetupContext.create(installation, Collections.<Stream> emptyList(), null);
    Workspace setupWorkspace = setupContext.getWorkspace();

    applyAttributes(setupWorkspace, workspace);
    applySetupTasks(setupWorkspace, workspace);

    if (setupWorkspace.getStreams().isEmpty() && !setupWorkspace.getSetupTasks().isEmpty())
    {
      WorkspaceTask workspaceTask = SetupFactory.eINSTANCE.createWorkspaceTask();
      workspaceTask.setID("workspace");
      setupWorkspace.getSetupTasks().add(0, workspaceTask);
    }

    setupWizard.addAppliedConfigurationResource(workspace.eResource());

    return true;
  }

  protected boolean applyStreams(List<Stream> streams)
  {
    return true;
  }

  protected boolean applyNoStreams()
  {
    return true;
  }

  protected boolean handleNoRedirectableProjectCatalog(Stream stream)
  {
    return false;
  }

  protected boolean handleUserProject(ProjectCatalog projectCatalog, Project project)
  {
    CatalogManager catalogManager = setupWizard.getCatalogManager();
    for (Project catalogProject : projectCatalog.getProjects())
    {
      if (isUserProject(catalogProject))
      {
        catalogProject.getProjects().add(project);
        BaseUtil.saveEObject(catalogProject);
        catalogManager.selectCatalog(false, projectCatalog, true);
        return true;
      }
    }

    // addStatus(IStatus.ERROR, , message);

    return false;
  }

  protected boolean handleStream(ProjectCatalog projectCatalog, Stream stream)
  {
    CatalogManager catalogManager = setupWizard.getCatalogManager();
    Index projectIndex = projectCatalog.getIndex();
    Index index = catalogManager.getIndex();
    if (projectIndex != index && !addCatalog(false, projectCatalog, stream))
    {
      return handleNoRedirectableProjectCatalog(stream);
    }

    catalogManager.selectCatalog(false, projectCatalog, true);

    return true;
  }

  protected boolean addCatalog(boolean product, Scope catalogScope, Scope originatingScope)
  {
    CatalogManager catalogManager = setupWizard.getCatalogManager();
    Scope catalog = catalogManager.getCatalog(product, "redirectable");
    String label = product ? "product" : "project";
    if (catalog == null)
    {
      addStatus(IStatus.ERROR, originatingScope, "Cannot add the catalog " + EcoreUtil.getURI(catalogScope));

      ResourceSet resourceSet = setupWizard.getResourceSet();
      Resource resource = resourceSet.getResource(URI.createURI("index:/redirectable." + label + "s.setup"), false);
      if (resource == null)
      {
        addStatus(IStatus.ERROR, originatingScope, "There is no redirectable " + label + " catalog is in the index");
      }
      else
      {
        addStatus(IStatus.ERROR, originatingScope,
            "The redirectable " + label + " catalog in the index is already redirected to " + resourceSet.getURIConverter().normalize(resource.getURI()));
      }

      return false;
    }

    Resource catalogResource = catalog.eResource();
    URI sourceURI = catalogResource.getURI();
    URI targetURI = catalogScope.eResource().getURI();
    EcoreUtil.replace(catalog, catalogScope);
    catalogManager.selectCatalog(product, catalogScope, true);
    catalogResource.getResourceSet().getURIConverter().getURIMap().put(targetURI, sourceURI);

    EList<SetupTask> setupTasks = (product ? installation : workspace).getSetupTasks();
    EclipseIniTask redirectionEclipseIniTask = SetupFactory.eINSTANCE.createEclipseIniTask();
    redirectionEclipseIniTask.setVm(true);
    redirectionEclipseIniTask.setOption("-Doomph.redirection." + (product ? "products" : "projects") + "=");
    redirectionEclipseIniTask.setValue(sourceURI + "->" + targetURI);
    setupTasks.add(0, redirectionEclipseIniTask);

    return true;
  }

  protected void addStatus(int severity, Scope scope, String message)
  {
    MultiStatus containerStatus = getStatus(scope);
    containerStatus.add(new Status(severity, SetupUIPlugin.PLUGIN_ID, message));
  }

  protected void handleSwitchToAdvancedMode()
  {
  }

  public static boolean isUserProject(Project project)
  {
    Resource resource = project.eResource();
    return resource != null && SetupContext.isUserScheme(resource.getURI().scheme());
  }

  public static boolean isUserProductCatalog(Scope scope)
  {
    if (scope instanceof ProductCatalog)
    {
      Resource resource = scope.eResource();
      return resource != null && SetupContext.isUserScheme(resource.getURI().scheme());
    }

    return false;
  }

  private static class ScopeStatus extends MultiStatus
  {
    private final Scope scope;

    public ScopeStatus(Scope scope)
    {
      super(SetupUIPlugin.PLUGIN_ID, 0, "Processing " + EcoreUtil.getURI(scope), null);
      this.scope = scope;
    }

    public ScopeStatus(Scope scope, String message)
    {
      super(SetupUIPlugin.PLUGIN_ID, 0, message, null);
      this.scope = scope;
    }

    public Scope getScope()
    {
      return scope;
    }

    public int computeSeverity()
    {
      for (IStatus status : getChildren())
      {
        int newSev = status instanceof ScopeStatus ? ((ScopeStatus)status).computeSeverity() : status.getSeverity();
        if (newSev > getSeverity())
        {
          setSeverity(newSev);
        }
      }

      return getSeverity();
    }
  }
}