/*
 * Copyright (c) 2022 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 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
 */
package org.eclipse.emf.cdo.lm.ui.views;

import org.eclipse.emf.cdo.common.branch.CDOBranchManager;
import org.eclipse.emf.cdo.common.branch.CDOBranchPoint;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.id.CDOIDUtil;
import org.eclipse.emf.cdo.etypes.Annotation;
import org.eclipse.emf.cdo.explorer.CDOExplorerUtil;
import org.eclipse.emf.cdo.explorer.checkouts.CDOCheckout;
import org.eclipse.emf.cdo.explorer.repositories.CDORepository;
import org.eclipse.emf.cdo.lm.Baseline;
import org.eclipse.emf.cdo.lm.Dependency;
import org.eclipse.emf.cdo.lm.FixedBaseline;
import org.eclipse.emf.cdo.lm.LMPackage;
import org.eclipse.emf.cdo.lm.assembly.AssemblyModule;
import org.eclipse.emf.cdo.lm.assembly.provider.AssemblyEditPlugin;
import org.eclipse.emf.cdo.lm.client.IAssemblyDescriptor;
import org.eclipse.emf.cdo.lm.client.IAssemblyDescriptor.AvailableUpdatesChangedEvent;
import org.eclipse.emf.cdo.lm.client.IAssemblyDescriptor.UpdateStateChangedEvent;
import org.eclipse.emf.cdo.lm.client.IAssemblyDescriptor.Updates;
import org.eclipse.emf.cdo.lm.client.IAssemblyManager;
import org.eclipse.emf.cdo.lm.client.ISystemDescriptor;
import org.eclipse.emf.cdo.lm.internal.client.AssemblyManager;
import org.eclipse.emf.cdo.lm.internal.client.LMManager;
import org.eclipse.emf.cdo.lm.modules.DependencyDefinition;
import org.eclipse.emf.cdo.lm.modules.ModulesFactory;
import org.eclipse.emf.cdo.lm.modules.provider.ModulesEditPlugin;
import org.eclipse.emf.cdo.lm.ui.actions.CheckoutAction;
import org.eclipse.emf.cdo.lm.ui.bundle.OM;
import org.eclipse.emf.cdo.lm.ui.decorators.AvailableUpdatesDecorator;
import org.eclipse.emf.cdo.session.CDOSession;
import org.eclipse.emf.cdo.ui.compare.CDOCompareEditorUtil;

import org.eclipse.net4j.util.container.IContainer;
import org.eclipse.net4j.util.container.IPluginContainer;
import org.eclipse.net4j.util.event.IEvent;
import org.eclipse.net4j.util.ui.MenuFiller;
import org.eclipse.net4j.util.ui.UIUtil;
import org.eclipse.net4j.util.ui.actions.LongRunningAction;
import org.eclipse.net4j.util.ui.views.ContainerItemProvider;
import org.eclipse.net4j.util.ui.views.ContainerItemProvider.Node;
import org.eclipse.net4j.util.ui.views.ContainerView;
import org.eclipse.net4j.util.ui.views.IElementFilter;

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.equinox.p2.metadata.VersionRange;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerComparator;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IActionBars;
import org.eclipse.ui.IWorkbenchPage;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.Properties;

/**
 * @author Eike Stepper
 */
public class AssembliesView extends ContainerView
{
  public static final String ID = "org.eclipse.emf.cdo.lm.AssembliesView";

  public static final String SHOW_IN_MENU_ID = ID + ".ShowInMenu";

  private final InstallUpdatesAction installUpdatesAction = new InstallUpdatesAction();

  private Font bold;

  public AssembliesView()
  {
  }

  @Override
  protected IAssemblyManager getContainer()
  {
    return IAssemblyManager.INSTANCE;
  }

  @Override
  protected void initViewer()
  {
    bold = UIUtil.getBoldFont(getViewer().getControl());
    super.initViewer();
  }

  @Override
  public void dispose()
  {
    UIUtil.dispose(bold);
    super.dispose();
  }

  @Override
  protected ContainerItemProvider<IContainer<Object>> createContainerItemProvider()
  {
    IElementFilter rootElementFilter = getRootElementFilter();
    return new ContainerViewItemProvider(rootElementFilter)
    {
      @Override
      protected Object[] getContainerChildren(ContainerItemProvider<IContainer<Object>>.AbstractContainerNode containerNode, IContainer<?> container)
      {
        Object[] children = super.getContainerChildren(containerNode, container);
        children = addNewModules(container, children);
        return children;
      }

      @Override
      protected Node createNode(Node parent, Object element)
      {
        EList<DependencyDefinition> dependencies = getDependencies(parent, element);
        if (dependencies != null)
        {
          return new FixedChildrenNode(parent, element, dependencies);
        }

        return super.createNode(parent, element);
      }
    };
  }

  @Override
  protected void fillLocalToolBar(IToolBarManager manager)
  {
    manager.add(installUpdatesAction);
    super.fillLocalToolBar(manager);
  }

  @Override
  @SuppressWarnings("restriction")
  protected void fillContextMenu(IMenuManager manager, ITreeSelection selection)
  {
    if (selection == null || selection.size() != 1)
    {
      return;
    }

    Object selectedElement = selection.getFirstElement();
    if (selectedElement == null)
    {
      return;
    }

    IWorkbenchPage page = getSite().getPage();
    TreeViewer viewer = getViewer();

    MenuManager showInMenu = new MenuManager("Show In", SHOW_IN_MENU_ID);
    boolean[] showInFilled = { false };

    if (selectedElement instanceof AssemblyModule)
    {
      AssemblyModule module = (AssemblyModule)selectedElement;

      IAssemblyDescriptor descriptor = IAssemblyManager.INSTANCE.getDescriptor(module);
      if (descriptor != null)
      {
        List<CDOCheckout> checkouts = new ArrayList<>();

        Baseline moduleBaseline = addCheckoutActions(manager, descriptor, module);
        if (moduleBaseline != null)
        {
          IAssemblyManager.INSTANCE.forEachDescriptor(d -> {
            if (d.getBaseline() == moduleBaseline)
            {
              checkouts.add(d.getCheckout());
            }
          });
        }

        String moduleSystemName = module.getAssembly().getSystemName();
        for (CDOCheckout checkout : CDOExplorerUtil.getCheckoutManager().getCheckouts())
        {
          if (!checkout.isOpen())
          {
            Properties properties = LMManager.loadProperties(checkout);
            if (properties != null)
            {
              String systemName = properties.getProperty(AssemblyManager.PROP_SYSTEM_NAME);
              if (Objects.equals(systemName, moduleSystemName))
              {
                CDOID baselineID = CDOIDUtil.read(properties.getProperty(AssemblyManager.PROP_BASELINE_ID));
                if (Objects.equals(baselineID, moduleBaseline.cdoID()))
                {
                  checkouts.add(checkout);
                }
              }
            }
          }
        }

        if (!checkouts.isEmpty())
        {
          showInMenu.add(new org.eclipse.emf.cdo.explorer.ui.checkouts.actions.ShowInActionProvider.ShowInProjectExplorerAction(page,
              checkouts.toArray(new CDOCheckout[checkouts.size()])));
          showInFilled[0] |= true;
        }
      }
    }
    else if (selectedElement instanceof IAssemblyDescriptor)
    {
      IAssemblyDescriptor descriptor = (IAssemblyDescriptor)selectedElement;
      showInMenu.add(new org.eclipse.emf.cdo.explorer.ui.checkouts.actions.ShowInActionProvider.ShowInProjectExplorerAction(page,
          new CDOCheckout[] { descriptor.getCheckout() }));
      showInMenu.add(new org.eclipse.emf.cdo.explorer.ui.checkouts.actions.ShowInActionProvider.ShowInSystemExplorerAction(
          descriptor.getCheckout().getStateFolder(LMManager.STATE_FOLDER_NAME)));
      showInFilled[0] |= true;
    }

    addMenuGroup(manager, "show-in");
    IPluginContainer.INSTANCE.forEachElement(MenuFiller.Factory.PRODUCT_GROUP, MenuFiller.class,
        filler -> showInFilled[0] |= filler.fillMenu(page, viewer, showInMenu, selectedElement));

    if (showInFilled[0])
    {
      manager.add(showInMenu);
    }

    addMenuGroupAdditions(manager);
    IPluginContainer.INSTANCE.forEachElement(MenuFiller.Factory.PRODUCT_GROUP, MenuFiller.class,
        filler -> showInFilled[0] |= filler.fillMenu(page, viewer, manager, selectedElement));

    addMenuGroup(manager, "errors");
    super.fillContextMenu(manager, selection);
  }

  private Baseline addCheckoutActions(IMenuManager manager, IAssemblyDescriptor descriptor, AssemblyModule module)
  {
    Updates updates = descriptor.getAvailableUpdates();
    if (updates != null)
    {
      String moduleName = module.getName();
      AssemblyModule incomingModule = updates.getModifications().get(moduleName);
      if (incomingModule != null)
      {
        Baseline baseline = addCheckoutAction(manager, descriptor, module);
        addCheckoutAction(manager, descriptor, incomingModule);

        manager.add(new Action("Preview Incoming Changes...", ImageDescriptor.createFromImage(CDOCompareEditorUtil.compareImage()))
        {
          @Override
          public void run()
          {
            ISystemDescriptor systemDescriptor = descriptor.getSystemDescriptor();
            CDORepository moduleRepository = systemDescriptor.getModuleRepository(moduleName);
            CDOSession session = moduleRepository.acquireSession();

            try
            {
              CDOBranchManager branchManager = session.getBranchManager();
              CDOBranchPoint leftPoint = module.getBranchPoint().resolve(branchManager);
              CDOBranchPoint rightPoint = incomingModule.getBranchPoint().resolve(branchManager);
              CDOCompareEditorUtil.openDialog(session, leftPoint, rightPoint);
            }
            finally
            {
              moduleRepository.releaseSession();
            }
          }
        });

        return baseline;
      }

      AssemblyModule newModule = updates.getAdditions().get(moduleName);
      if (newModule != null)
      {
        addCheckoutAction(manager, descriptor, newModule);
        return descriptor.getBaseline(module);
      }
    }

    if (!module.isRoot())
    {
      return addCheckoutAction(manager, descriptor, module);
    }

    return descriptor.getBaseline(module);
  }

  private Baseline addCheckoutAction(IMenuManager manager, IAssemblyDescriptor descriptor, AssemblyModule module)
  {
    Baseline baseline = descriptor.getBaseline(module);
    if (baseline != null)
    {
      manager.add(new CheckoutAction(getSite().getPage(), baseline));
    }

    return baseline;
  }

  @Override
  protected void doubleClicked(Object object)
  {
    super.doubleClicked(object);

    if (object instanceof DependencyDefinition)
    {
      DependencyDefinition definition = (DependencyDefinition)object;

      ContainerItemProvider<IContainer<Object>> itemProvider = getItemProvider();
      AssemblyModule module = (AssemblyModule)itemProvider.getParent(definition);
      IAssemblyDescriptor descriptor = (IAssemblyDescriptor)itemProvider.getParent(module);

      AssemblyModule target = descriptor.getModule(definition.getTargetName());
      if (target != null)
      {
        selectReveal(new StructuredSelection(target));
      }
    }
  }

  @Override
  protected void selectionChanged(IActionBars bars, ITreeSelection selection)
  {
    installUpdatesAction.selectionChanged(selection);
  }

  @Override
  protected void handleElementEvent(IEvent event)
  {
    if (event instanceof UpdateStateChangedEvent)
    {
      UIUtil.asyncExec(() -> installUpdatesAction.selectionChanged(getSelection()));
    }
    else if (event instanceof AvailableUpdatesChangedEvent)
    {
      UIUtil.asyncExec(() -> refreshPressed());
    }
  }

  @Override
  protected ViewerComparator createViewerComparator()
  {
    return new ViewerComparator()
    {
      @Override
      public void sort(Viewer viewer, Object[] elements)
      {
        if (elements != null && elements.length != 0 && elements[0] instanceof AssemblyModule)
        {
          // Don't sort dependencies.
          return;
        }

        super.sort(viewer, elements);
      }
    };
  }

  @Override
  protected String getElementText(Object element)
  {
    String text = getText(element);
    if (text != null)
    {
      return text;
    }

    return super.getElementText(element);
  }

  @Override
  protected Image getElementImage(Object element)
  {
    Image image = getImage(element);
    if (image != null)
    {
      return image;
    }

    return super.getElementImage(element);
  }

  @Override
  protected Font getElementFont(Object element)
  {
    Font font = getFont(element, bold, getItemProvider());
    if (font != null)
    {
      return font;
    }

    return super.getElementFont(element);
  }

  @Override
  protected Color getElementForeground(Object element)
  {
    Color foreground = getForeground(element, getDisplay());
    if (foreground != null)
    {
      return foreground;
    }

    return super.getElementForeground(element);
  }

  private static boolean isModuleAddition(Object element)
  {
    if (element instanceof AssemblyModule)
    {
      AssemblyModule module = (AssemblyModule)element;

      IAssemblyDescriptor descriptor = IAssemblyManager.INSTANCE.getDescriptor(module);
      if (descriptor != null)
      {
        if (descriptor.getModule(module.getName()) == null)
        {
          // This must be a module addition in the available updates of the descriptor.
          return true;
        }
      }
    }

    return false;
  }

  public static Object[] addNewModules(IContainer<?> container, Object[] children)
  {
    if (container instanceof IAssemblyDescriptor)
    {
      IAssemblyDescriptor descriptor = (IAssemblyDescriptor)container;

      Updates updates = descriptor.getAvailableUpdates();
      if (updates != null)
      {
        Collection<AssemblyModule> newModules = updates.getAdditions().values();
        if (!newModules.isEmpty())
        {
          List<AssemblyModule> list = new ArrayList<>();

          for (Object child : children)
          {
            list.add((AssemblyModule)child);
          }

          for (AssemblyModule newModule : newModules)
          {
            list.add(newModule);
          }

          children = list.toArray(new AssemblyModule[list.size()]);
        }
      }
    }

    return children;
  }

  public static EList<DependencyDefinition> getDependencies(Node parent, Object element)
  {
    if (element instanceof AssemblyModule)
    {
      AssemblyModule module = (AssemblyModule)element;

      IAssemblyDescriptor descriptor = IAssemblyManager.INSTANCE.getDescriptor(module);
      Baseline baseline = descriptor.getBaseline(module);
      if (baseline instanceof FixedBaseline)
      {
        EList<Dependency> dependencies = ((FixedBaseline)baseline).getDependencies();
        EList<DependencyDefinition> definitions = new BasicEList<>(dependencies.size());

        for (Dependency dependency : dependencies)
        {
          DependencyDefinition definition = ModulesFactory.eINSTANCE.createDependencyDefinition(dependency.getTarget().getName(), dependency.getVersionRange());
          definitions.add(definition);
        }

        return definitions;
      }

      Annotation annotation = module.getAnnotation(LMPackage.ANNOTATION_SOURCE);
      if (annotation != null)
      {
        EList<EObject> contents = annotation.getContents();
        EList<DependencyDefinition> definitions = new BasicEList<>(contents.size());

        for (EObject content : contents)
        {
          if (content instanceof DependencyDefinition)
          {
            DependencyDefinition definition = (DependencyDefinition)content;
            definitions.add(definition);
          }
        }

        return definitions;
      }
    }

    return null;
  }

  public static String getText(Object element)
  {
    if (element instanceof IAssemblyDescriptor)
    {
      IAssemblyDescriptor descriptor = (IAssemblyDescriptor)element;
      return descriptor.getName() + " [" + descriptor.getAssembly().getSystemName() + "]";
    }

    if (element instanceof AssemblyModule)
    {
      AssemblyModule module = (AssemblyModule)element;
      return module.getName() + " " + AvailableUpdatesDecorator.getSuffix(module);
    }

    if (element instanceof DependencyDefinition)
    {
      DependencyDefinition dependency = (DependencyDefinition)element;
      VersionRange versionRange = dependency.getVersionRange();

      String text = dependency.getTargetName();
      if (versionRange != null)
      {
        text += " " + versionRange;
      }

      return text;
    }

    return null;
  }

  public static Image getImage(Object element)
  {
    if (element instanceof IAssemblyDescriptor)
    {
      return ExtendedImageRegistry.INSTANCE.getImage( //
          AssemblyEditPlugin.INSTANCE.getImage("full/obj16/Assembly"));
    }

    if (element instanceof AssemblyModule)
    {
      return ExtendedImageRegistry.INSTANCE.getImage( //
          AssemblyEditPlugin.INSTANCE.getImage(isModuleAddition(element) ? "full/obj16/AssemblyModuleDisabled" : "full/obj16/AssemblyModule"));
    }

    if (element instanceof DependencyDefinition)
    {
      return ExtendedImageRegistry.INSTANCE.getImage( //
          ModulesEditPlugin.INSTANCE.getImage("full/obj16/DependencyDefinition"));
    }

    return null;
  }

  public static Font getFont(Object element, Font bold, ContainerItemProvider<IContainer<Object>> itemProvider)
  {
    if (element instanceof AssemblyModule)
    {
      AssemblyModule module = (AssemblyModule)element;

      if (module.isRoot())
      {
        return bold;
      }
    }

    if (element instanceof DependencyDefinition)
    {
      DependencyDefinition definition = (DependencyDefinition)element;

      AssemblyModule module = (AssemblyModule)itemProvider.getParent(definition);
      if (module.isRoot())
      {
        return bold;
      }
    }

    return null;
  }

  public static Color getForeground(Object element, Display display)
  {
    if (isModuleAddition(element))
    {
      return display.getSystemColor(SWT.COLOR_DARK_GRAY);
    }

    return null;
  }

  /**
   * @author Eike Stepper
   */
  private static final class InstallUpdatesAction extends LongRunningAction
  {
    private IAssemblyDescriptor descriptor;

    public InstallUpdatesAction()
    {
      super("Install Updates...", OM.getImageDescriptor("icons/Update.gif"));
      setToolTipText("Install the available updates into the checkout");
      setEnabled(false);
    }

    public void selectionChanged(ISelection selection)
    {
      descriptor = UIUtil.adaptElement(selection, IAssemblyDescriptor.class);

      if (descriptor == null)
      {
        EObject assemblyElement = UIUtil.adaptElement(selection, EObject.class);
        descriptor = IAssemblyManager.INSTANCE.getDescriptor(assemblyElement);
      }

      setEnabled(descriptor != null && descriptor.hasUpdatesAvailable());
    }

    @Override
    protected void doRun(IProgressMonitor progressMonitor) throws Exception
    {
      if (isEnabled())
      {
        descriptor.update();
      }
    }
  }
}