/*
 * Copyright 2000-2012 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.openapi.roots.ui.configuration.dependencyAnalysis;

import com.intellij.ProjectTopics;
import com.intellij.icons.AllIcons;
import com.intellij.ide.DataManager;
import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.actionSystem.ex.ComboBoxAction;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.options.ConfigurationException;
import com.intellij.openapi.project.DumbAwareAction;
import com.intellij.openapi.roots.ModuleRootAdapter;
import com.intellij.openapi.roots.ModuleRootEvent;
import com.intellij.openapi.roots.ModuleSourceOrderEntry;
import com.intellij.openapi.roots.OrderEntry;
import com.intellij.openapi.roots.ui.CellAppearanceEx;
import com.intellij.openapi.roots.ui.OrderEntryAppearanceService;
import com.intellij.openapi.roots.ui.configuration.ProjectStructureConfigurable;
import com.intellij.openapi.ui.MasterDetailsComponent;
import com.intellij.openapi.ui.NamedConfigurable;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.ui.*;
import com.intellij.ui.components.JBScrollPane;
import com.intellij.ui.treeStructure.Tree;
import com.intellij.util.PathUtil;
import com.intellij.util.messages.MessageBusConnection;
import com.intellij.util.ui.UIUtil;
import com.intellij.util.ui.tree.TreeUtil;
import org.jetbrains.annotations.Nls;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;
import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * The classpath details component
 */
public class AnalyzeDependenciesComponent extends MasterDetailsComponent {
  /**
   * Data key for order path element
   */
  public static DataKey<ModuleDependenciesAnalyzer.OrderPathElement> ORDER_PATH_ELEMENT_KEY = DataKey.create("ORDER_PATH_ELEMENT");
  /**
   * The module being analyzed
   */
  private final Module myModule;
  /**
   * The settings for UI mode
   */
  private final AnalyzeDependenciesSettings mySettings;
  /**
   * The cached analyzed classpaths for this module
   */
  private final HashMap<Pair<ClasspathType, Boolean>, ModuleDependenciesAnalyzer> myClasspaths =
    new HashMap<Pair<ClasspathType, Boolean>, ModuleDependenciesAnalyzer>();

  /**
   * The message bus connection to use
   */
  private MessageBusConnection myMessageBusConnection;

  /**
   * The constructor
   *
   * @param module the module to analyze
   */
  public AnalyzeDependenciesComponent(Module module) {
    myModule = module;
    mySettings = AnalyzeDependenciesSettings.getInstance(myModule.getProject());
    initTree();
    init();
    getSplitter().setProportion(0.3f);
    myMessageBusConnection = myModule.getProject().getMessageBus().connect();
    myMessageBusConnection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
      @Override
      public void rootsChanged(ModuleRootEvent event) {
        myClasspaths.clear();
        updateTree();
      }
    });
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void disposeUIResources() {
    if (myMessageBusConnection != null) {
      myMessageBusConnection.disconnect();
    }
  }

  /**
   * Initialize components
   */
  private void init() {
    myTree.setCellRenderer(new ColoredTreeCellRenderer() {
      @Override
      public void customizeCellRenderer(JTree tree,
                                        Object value,
                                        boolean selected,
                                        boolean expanded,
                                        boolean leaf,
                                        int row,
                                        boolean hasFocus) {
        //if(getBackground() == null) {
        //  setBackground(UIUtil.getTreeTextBackground());
        //}
        if (value instanceof MyNode && !(value instanceof MyRootNode)) {
          final MyNode node = (MyNode)value;
          PathNode<?> n = (PathNode<?>)node.getUserObject();
          CellAppearanceEx a = n.getAppearance(selected, node.isDisplayInBold());
          a.customize(this);
        }
      }
    });
    myTree.setShowsRootHandles(false);
    myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
    reloadTree();
  }

  /**
   * {@inheritDoc}
   */
  @Override
  protected ArrayList<AnAction> createActions(boolean fromPopup) {
    if (!fromPopup) {
      ArrayList<AnAction> rc = new ArrayList<AnAction>();
      rc.add(new ClasspathTypeAction());
      rc.add(new SdkFilterAction());
      rc.add(new UrlModeAction());
      return rc;
    }
    else {
      return super.createActions(fromPopup);
    }
  }

  /**
   * {@inheritDoc}
   */
  @Override
  protected void processRemovedItems() {
    // no remove action so far
  }

  /**
   * {@inheritDoc}
   */
  @Override
  protected boolean wasObjectStored(Object editableObject) {
    // no modifications so far
    return false;
  }

  /**
   * {@inheritDoc}
   */
  @Nls
  @Override
  public String getDisplayName() {
    return "Classpath Details";
  }

  /**
   * Reload tree
   */
  public void reloadTree() {
    myRoot.removeAllChildren();
    ModuleDependenciesAnalyzer a = getAnalyzer();
    if (mySettings.isUrlMode()) {
      for (ModuleDependenciesAnalyzer.UrlExplanation urlExplanation : a.getUrls()) {
        myRoot.add(new MyNode(new UrlNode(urlExplanation)));
      }
    }
    else {
      for (ModuleDependenciesAnalyzer.OrderEntryExplanation explanation : a.getOrderEntries()) {
        myRoot.add(new MyNode(new OrderEntryNode(explanation)));
      }
    }
    ((DefaultTreeModel)myTree.getModel()).reload(myRoot);
  }

  /**
   * @return the analyzer for the current settings
   */
  public ModuleDependenciesAnalyzer getAnalyzer() {
    final Pair<ClasspathType, Boolean> key = Pair.create(getClasspathType(), mySettings.isSdkIncluded());
    ModuleDependenciesAnalyzer a = myClasspaths.get(key);
    if (a == null) {
      a = new ModuleDependenciesAnalyzer(myModule, !mySettings.isTest(), !mySettings.isRuntime(), mySettings.isSdkIncluded());
      myClasspaths.put(key, a);
    }
    return a;
  }

  /**
   * @return the current classpath type from settings
   */
  private ClasspathType getClasspathType() {
    return mySettings.isRuntime() ?
           (mySettings.isTest() ? ClasspathType.TEST_RUNTIME : ClasspathType.PRODUCTION_RUNTIME) :
           (mySettings.isTest() ? ClasspathType.TEST_COMPILE : ClasspathType.PRODUCTION_COMPILE);
  }


  /**
   * Schedule updating the tree
   */
  void updateTree() {
    // TODO make loading in the background if there will be significant delays on big projects
    reloadTree();
  }

  /**
   * The action that allows navigating to the path element
   */
  static class NavigateAction extends DumbAwareAction {

    /**
     * The constructor
     */
    NavigateAction() {
      super("Navigate to ...", "Navigate to place where path element is defined", null);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void actionPerformed(AnActionEvent e) {
      final Module module = e.getData(LangDataKeys.MODULE);
      if (module == null) {
        return;
      }
      final ModuleDependenciesAnalyzer.OrderPathElement element = e.getData(ORDER_PATH_ELEMENT_KEY);
      if (element != null && element instanceof ModuleDependenciesAnalyzer.OrderEntryPathElement) {
        final ModuleDependenciesAnalyzer.OrderEntryPathElement o = (ModuleDependenciesAnalyzer.OrderEntryPathElement)element;
        final OrderEntry entry = o.entry();
        final Module m = entry.getOwnerModule();
        ProjectStructureConfigurable.getInstance(module.getProject()).selectOrderEntry(m, entry);
      }
    }
  }

  /**
   * Base class for nodes
   *
   * @param <T> the actual explanation type
   */
  abstract class PathNode<T extends ModuleDependenciesAnalyzer.Explanation> extends NamedConfigurable<T> implements DataProvider {
    /**
     * The cut off length, after which URLs are not shown (only suffix)
     */
    public static final int CUTOFF_LENGTH = 80;

    /**
     * The explanation
     */
    protected final T myExplanation;
    /**
     * The tree with explanation
     */
    private Tree myExplanationTree;

    /**
     * The constructor
     *
     * @param explanation the wrapped explanation
     */
    public PathNode(T explanation) {
      myExplanation = explanation;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public T getEditableObject() {
      return myExplanation;
    }

    /**
     * @return a created tree component (to be used as
     */
    private JComponent createTreeComponent() {
      myExplanationTree = new Tree(new DefaultTreeModel(buildTree()));
      myExplanationTree.setRootVisible(false);
      myExplanationTree.setCellRenderer(new ExplanationTreeRenderer());
      DataManager.registerDataProvider(myExplanationTree, this);
      TreeUtil.expandAll(myExplanationTree);
      final NavigateAction navigateAction = new NavigateAction();
      navigateAction.registerCustomShortcutSet(new CustomShortcutSet(CommonShortcuts.DOUBLE_CLICK_1.getShortcuts()[0]), myExplanationTree);
      DefaultActionGroup group = new DefaultActionGroup();
      group.addAction(navigateAction);
      PopupHandler.installUnknownPopupHandler(myExplanationTree, group, ActionManager.getInstance());
      return new JBScrollPane(myExplanationTree);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public Object getData(@NonNls String dataId) {
      if (CommonDataKeys.PROJECT.is(dataId)) {
        return myModule.getProject();
      }
      if (LangDataKeys.MODULE.is(dataId)) {
        return myModule;
      }
      TreePath selectionPath = myExplanationTree.getSelectionPath();
      DefaultMutableTreeNode node = selectionPath == null ? null : (DefaultMutableTreeNode)selectionPath.getLastPathComponent();
      Object o = node == null ? null : node.getUserObject();
      if (o instanceof ModuleDependenciesAnalyzer.OrderPathElement) {
        if (ORDER_PATH_ELEMENT_KEY.is(dataId)) {
          return o;
        }
      }
      return null;
    }

    /**
     * Build tree for the dependencies
     *
     * @return a tree model
     */
    private DefaultMutableTreeNode buildTree() {
      DefaultMutableTreeNode root = new DefaultMutableTreeNode("ROOT");
      for (ModuleDependenciesAnalyzer.OrderPath orderPath : myExplanation.paths()) {
        addDependencyPath(root, orderPath, 0);
      }
      return root;
    }

    /**
     * Add the dependency path
     *
     * @param parent    the parent to which path is added
     * @param orderPath the order entry path
     * @param i         the position in the path
     */
    private void addDependencyPath(DefaultMutableTreeNode parent,
                                   ModuleDependenciesAnalyzer.OrderPath orderPath,
                                   int i) {
      if (i >= orderPath.entries().size()) {
        return;
      }
      ModuleDependenciesAnalyzer.OrderPathElement e = orderPath.entries().get(i);
      int sz = parent.getChildCount();
      DefaultMutableTreeNode n;
      if (sz == 0) {
        n = null;
      }
      else {
        n = (DefaultMutableTreeNode)parent.getChildAt(sz - 1);
        if (!n.getUserObject().equals(e)) {
          n = null;
        }
      }
      if (n == null) {
        n = new DefaultMutableTreeNode(e);
        parent.add(n);
      }
      addDependencyPath(n, orderPath, i + 1);
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public void setDisplayName(String name) {
      // do nothing
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public JComponent createOptionsPanel() {
      final JComponent tree = createTreeComponent();
      JPanel panel = new JPanel(new BorderLayout());
      JLabel paths = new JLabel("Available Through Paths:");
      paths.setDisplayedMnemonic('P');
      paths.setLabelFor(tree);
      panel.add(paths, BorderLayout.NORTH);
      panel.add(tree, BorderLayout.CENTER);
      return panel;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void disposeUIResources() {
      //Do nothing
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getHelpTopic() {
      return null;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isModified() {
      return false;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void apply() throws ConfigurationException {
      // Do nothing
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void reset() {
      //Do nothing
    }

    /**
     * Get appearance for rendering in master list
     *
     * @param selected true if selected
     * @param bold     true if bold
     * @return the result appearance
     */
    public abstract CellAppearanceEx getAppearance(boolean selected, boolean bold);

    /**
     * @retrun the string cut so it would fit the banner (the prefix is dropped)
     */
    protected String suffixForBanner(String p) {
      if (p.length() > CUTOFF_LENGTH) {
        p = "..." + p.substring(p.length() - CUTOFF_LENGTH);
      }
      return p;
    }

    /**
     * @retrun the string cut so it would fit the banner (the suffix is dropped)
     */
    protected String prefixForBanner(String p) {
      if (p.length() > CUTOFF_LENGTH) {
        p = p.substring(0, CUTOFF_LENGTH) + "...";
      }
      return p;
    }
  }

  /**
   * Cell renderer for explanation tree
   */
  static class ExplanationTreeRenderer extends ColoredTreeCellRenderer {

    @Override
    public void customizeCellRenderer(JTree tree,
                                      Object value,
                                      boolean selected,
                                      boolean expanded,
                                      boolean leaf,
                                      int row,
                                      boolean hasFocus) {
      DefaultMutableTreeNode n = (DefaultMutableTreeNode)value;
      final Object userObject = n.getUserObject();
      if (!(userObject instanceof ModuleDependenciesAnalyzer.OrderPathElement)) {
        return;
      }
      ModuleDependenciesAnalyzer.OrderPathElement e = (ModuleDependenciesAnalyzer.OrderPathElement)userObject;
      final CellAppearanceEx appearance = e.getAppearance(selected);
      appearance.customize(this);
    }
  }

  /**
   * The entry node in URL node
   */
  class UrlNode extends PathNode<ModuleDependenciesAnalyzer.UrlExplanation> {

    /**
     * The constructor
     *
     * @param url the wrapped explanation
     */
    public UrlNode(ModuleDependenciesAnalyzer.UrlExplanation url) {
      super(url);
      setNameFieldShown(false);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public CellAppearanceEx getAppearance(boolean selected, final boolean isBold) {
      return new CellAppearanceEx() {
        @Override
        public void customize(@NotNull SimpleColoredComponent component) {
          component.setIcon(getIcon());
          final Font font = UIUtil.getTreeFont();
          if (isBold) {
            component.setFont(font.deriveFont(Font.BOLD));
          }
          else {
            component.setFont(font.deriveFont(Font.PLAIN));
          }
          final String p = PathUtil.toPresentableUrl(getEditableObject().url());
          component.append(PathUtil.getFileName(p),
                           isBold ? SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES : SimpleTextAttributes.REGULAR_ATTRIBUTES);
          component.append(" (" + PathUtil.getParentPath(p) + ")", SimpleTextAttributes.GRAYED_ATTRIBUTES);
        }

        @Override
        public void customize(@NotNull final HtmlListCellRenderer renderer) {
          throw new UnsupportedOperationException("Rendering in combo box not supported yet.");
        }

        @NotNull
        @Override
        public String getText() {
          return getDisplayName();
        }
      };
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getBannerSlogan() {
      final VirtualFile f = myExplanation.getLocalFile();
      String p = f == null ? myExplanation.url() : f.getPath();
      p = suffixForBanner(p);
      return p;
    }

    /**
     * {@inheritDoc}
     */
    private Icon getIcon() {
      return myExplanation.getIcon();
    }

    /**
     * {@inheritDoc}
     */
    @Nls
    @Override
    public String getDisplayName() {
      return myExplanation.url();
    }
  }

  /**
   * The wrapper for order entries
   */
  class OrderEntryNode extends PathNode<ModuleDependenciesAnalyzer.OrderEntryExplanation> {

    /**
     * The constructor
     *
     * @param orderEntryExplanation the explanation to wrap
     */
    public OrderEntryNode(ModuleDependenciesAnalyzer.OrderEntryExplanation orderEntryExplanation) {
      super(orderEntryExplanation);
      setNameFieldShown(false);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public CellAppearanceEx getAppearance(boolean selected, final boolean isBold) {
      if (myExplanation.entry() instanceof ModuleSourceOrderEntry) {
        ModuleSourceOrderEntry e = (ModuleSourceOrderEntry)myExplanation.entry();
        if (e.getOwnerModule() == myModule) {
          return new CellAppearanceEx() {
            @Override
            public void customize(@NotNull SimpleColoredComponent component) {
              component.setIcon(ModuleType.get(myModule).getIcon());
              component.append("<This Module>", SimpleTextAttributes.SYNTHETIC_ATTRIBUTES);
            }

            @Override
            public void customize(@NotNull final HtmlListCellRenderer renderer) {
              throw new UnsupportedOperationException("Rendering in combo box not supported yet.");
            }

            @NotNull
            @Override
            public String getText() {
              return "<This Module>";
            }
          };
        }
        else {
          return OrderEntryAppearanceService.getInstance().forModule(e.getOwnerModule());
        }
      }
      return OrderEntryAppearanceService.getInstance().forOrderEntry(myModule.getProject(), myExplanation.entry(), selected);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String getBannerSlogan() {
      if (myExplanation.entry() instanceof ModuleSourceOrderEntry) {
        ModuleSourceOrderEntry e = (ModuleSourceOrderEntry)myExplanation.entry();
        return prefixForBanner("Module " + e.getOwnerModule().getName());
      }
      else {
        final String p = myExplanation.entry().getPresentableName() + " in module " + myExplanation.entry().getOwnerModule().getName();
        return suffixForBanner(p);
      }
    }

    /**
     * {@inheritDoc}
     */
    @Nls
    @Override
    public String getDisplayName() {
      return myExplanation.entry().getPresentableName();
    }
  }

  /**
   * The action that allows including and excluding SDK entries from analysis
   */
  private class SdkFilterAction extends ToggleAction {

    /**
     * The constructor
     */
    public SdkFilterAction() {
      super("Include SDK", "If selected, the SDK classes are included", AllIcons.General.Jdk);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isSelected(AnActionEvent e) {
      return mySettings.isSdkIncluded();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setSelected(AnActionEvent e, boolean state) {
      mySettings.setIncludeSdk(state);
      updateTree();
    }
  }

  /**
   * The action that allows switching class path between URL and order entry modes
   */
  private class UrlModeAction extends ToggleAction {
    /**
     * The constructor
     */
    public UrlModeAction() {
      super("Use URL mode", "If selected, the URLs are displayed, otherwise order entries", AllIcons.Nodes.PpFile);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public boolean isSelected(AnActionEvent e) {
      return mySettings.isUrlMode();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setSelected(AnActionEvent e, boolean state) {
      mySettings.setUrlMode(state);
      updateTree();
    }
  }

  /**
   * Classpath type action for the analyze classpath
   */
  private class ClasspathTypeAction extends ComboBoxAction {
    /**
     * The filter action group
     */
    DefaultActionGroup myItems;

    /**
     * {@inheritDoc}
     */
    @NotNull
    @Override
    protected DefaultActionGroup createPopupActionGroup(JComponent button) {
      if (myItems == null) {
        myItems = new DefaultActionGroup(null, true);
        for (final ClasspathType classpathType : ClasspathType.values()) {
          myItems.addAction(new DumbAwareAction(classpathType.getDescription()) {
            @Override
            public void actionPerformed(AnActionEvent e) {
              mySettings.setRuntime(classpathType.isRuntime());
              mySettings.setTest(classpathType.isTest());
              updateTree();
            }
          });
        }
      }
      return myItems;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void update(AnActionEvent e) {
      final Presentation presentation = e.getPresentation();
      updateText(presentation);
    }

    /**
     * Update the text for the combobox
     *
     * @param presentation the presentaiton to update
     */
    private void updateText(Presentation presentation) {
      final ClasspathType classpathType = getClasspathType();
      String t = classpathType.getDescription();
      presentation.setText(t);
    }
  }

  /**
   * The enumeration type that represents classpath entry filter
   */
  private static enum ClasspathType {
    /**
     * The production compile mode
     */
    PRODUCTION_COMPILE(false, false, "Production Compile"),
    /**
     * The production runtime mode
     */
    PRODUCTION_RUNTIME(false, true, "Production Runtime"),
    /**
     * The test runtime mode
     */
    TEST_RUNTIME(true, true, "Test Runtime"),
    /**
     * The test compile mode
     */
    TEST_COMPILE(true, false, "Test Compile");

    /**
     * true, if test mode
     */
    final private boolean myIsTest;
    /**
     * true, if runtime mode
     */
    final private boolean myIsRuntime;
    /**
     * The description text
     */
    final private String myDescription;

    /**
     * The constructor
     *
     * @param isTest      true if the test mode
     * @param isRuntime   true if the runtime ode
     * @param description the description text
     */
    ClasspathType(boolean isTest, boolean isRuntime, String description) {
      myIsTest = isTest;
      myIsRuntime = isRuntime;
      myDescription = description;
    }

    /**
     * @return true if the test mode
     */
    public boolean isTest() {
      return myIsTest;
    }

    /**
     * @return true if the runtime mode
     */
    public boolean isRuntime() {
      return myIsRuntime;
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public String toString() {
      return myDescription;
    }

    /**
     * @return the description for the entry
     */
    public String getDescription() {
      return myDescription;
    }
  }
}