/*
 * Copyright 2003-2016 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 jetbrains.mps.ide.ui.tree;

import jetbrains.mps.extapi.model.TransientSModel;
import jetbrains.mps.util.SModuleNameComparator;
import jetbrains.mps.util.SNodePresentationComparator;
import jetbrains.mps.util.ToStringComparator;
import jetbrains.mps.util.annotation.ToRemove;
import org.jetbrains.mps.openapi.model.SModel;
import org.jetbrains.mps.openapi.model.SNode;
import org.jetbrains.mps.openapi.module.SModule;

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

/**
 * @deprecated extract comparators, use them directly where needed and get rid of this class
 */
@Deprecated
@ToRemove(version = 0)
public class SortUtil {
  public static List<SModel> sortModels(List<SModel> modelDescriptors) {
    List<SModel> sortedModels = new ArrayList<SModel>(modelDescriptors);
    Collections.sort(sortedModels, new SModelComparator());
    return sortedModels;
  }

  public static class SModelComparator implements Comparator<SModel> {
    @Override
    public int compare(SModel o, SModel o1) {
      if (o == o1) return 0;
      int result = SortUtil.compare(o.getName().getLongName(), o1.getName().getLongName());
      if (result != 0) return result;
      String str = o.getName().getStereotype();
      String str1 = o1.getName().getStereotype();
      if ((o instanceof TransientSModel) && (o1 instanceof TransientSModel)) {
        try {
          String[] part = str.split("_");
          String[] part1 = str1.split("_");
          for (int i = 0; i < part.length; i++) {
            result = SortUtil.compare(Integer.valueOf(part[i]), Integer.valueOf(part1[i]));
            if (result != 0) return result;
          }
          return result;
        } catch (NumberFormatException ex) {
          return SortUtil.compare(str, str1);
        }
      } else {
        return SortUtil.compare(str, str1);
      }
    }
  }

  public static List<SModule> sortModules(Collection<SModule> modules) {
    List<SModule> sortedModules = new ArrayList<SModule>(modules);
    Collections.sort(sortedModules, new SModuleNameComparator());

    return sortedModules;
  }

  public static List<SNode> sortNodes(List<SNode> nodes) {
    List<SNode> sortedNodes = new ArrayList<SNode>(nodes);
    Collections.sort(sortedNodes, new ToStringComparator());
    return sortedNodes;
  }

  // in use by mbeddr, TargetChooser_SModelTreeNode
  public static List<SNode> sortNodesByPresentation(List<SNode> nodes) {
    ArrayList<SNode> rv = new ArrayList<SNode>(nodes);
    Collections.sort(rv, new SNodePresentationComparator());
    return rv;
  }

  static <T extends Comparable<T>> int compare(final T name1, final T name2) {
    if (name1 == null) return name2 == null ? 0 : -1;
    if (name2 == null) return 1;
    return name1.compareTo(name2);
  }
}
