class="kw">package com.hypixel.hytale.common.plugin;

class="kw">import com.hypixel.hytale.common.semver.SemverRange;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Comparator;
class="kw">import java.util.HashMap;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.function.BiPredicate;
class="kw">import javax.annotation.Nonnull;

class="kw">public class="kw">interface Mod {
   PluginManifest getManifest();

   class="kw">default boolean isCoreMod() {
      class="kw">return false;
   }

   @Nonnull
   class="kw">static <T class="kw">extends Mod> List<T> calculateLoadOrder(@Nonnull Map<PluginIdentifier, T> var0) class="kw">throws ModLoadOrderException {
      class="kw">return calculateLoadOrder(var0, (var0x, var1) -> false);
   }

   @Nonnull
   class="kw">static <T class="kw">extends Mod> List<T> calculateLoadOrder(@Nonnull Map<PluginIdentifier, T> var0, @Nonnull BiPredicate<PluginIdentifier, SemverRange> var1) class="kw">throws ModLoadOrderException {
      class="kw">return calculateLoadOrder(var0, var1, List.of());
   }

   @Nonnull
   class="kw">static <T class="kw">extends Mod> List<T> calculateLoadOrder(
      @Nonnull Map<PluginIdentifier, T> var0, @Nonnull BiPredicate<PluginIdentifier, SemverRange> var1, @Nonnull List<PluginIdentifier> var2
   ) class="kw">throws ModLoadOrderException {
      HashMap var3 = new HashMap<>(var0.size());

      for (Entry var5 : var0.entrySet()) {
         var3.put(var5.getKey(), new Mod.EntryNode<>(var5.getValue()));
      }

      HashSet var18 = new HashSet<>();

      for (Entry var6 : var0.entrySet()) {
         if (var6.getValue().isCoreMod() && "Hytale".equals(var6.getKey().getGroup())) {
            var18.add(var6.getKey());
         }
      }

      HashMap var20 = new HashMap<>();

      for (Entry var7 : var3.entrySet()) {
         PluginManifest var8 = var7.getValue().mod.getManifest();

         for (Entry var10 : var8.getDependencies().entrySet()) {
            PluginIdentifier var11 = var10.getKey();
            if (var3.containsKey(var11)) {
               var7.getValue().edges.add(var11);
            } else if (!var1.test(var11, var10.getValue())) {
               var20.computeIfAbsent(var7.getKey(), var0x -> new HashSet<>()).add(var11);
            }
         }

         for (PluginIdentifier var37 : var8.getOptionalDependencies().keySet()) {
            Mod.EntryNode var45 = var3.get(var37);
            if (var45 != null) {
               var7.getValue().edges.add(var37);
            }
         }

         if (!var18.contains(var7.getKey())) {
            var7.getValue().edges.addAll(var18);
         }
      }

      for (Entry var24 : var0.entrySet()) {
         PluginManifest var26 = var24.getValue().getManifest();

         for (PluginIdentifier var38 : var26.getLoadBefore().keySet()) {
            Mod.EntryNode var46 = var3.get(var38);
            if (var46 != null) {
               var46.edges.add(var24.getKey());
            }
         }
      }

      ArrayList var23 = new ArrayList<>();
      HashSet var25 = new HashSet<>();

      for (PluginIdentifier var33 : var2) {
         if (var3.containsKey(var33) && var25.add(var33)) {
            var23.add(var33);
         }
      }

      for (int var28 = 0; var28 < var23.size() - 1; var28++) {
         PluginIdentifier var34 = var23.get(var28);
         PluginIdentifier var39 = var23.get(var28 + 1);
         Mod.EntryNode var47 = var3.get(var39);
         var47.edges.add(var34);
         var47.manualOrderEdges.add(var34);
      }

      if (!var20.isEmpty()) {
         StringBuilder var30 = new StringBuilder("Missing required dependencies:\n");

         for (Entry var44 : var20.entrySet()) {
            var30.append("  ")
               .append(var44.getKey())
               .append(" requires: [")
               .append(String.join(", ", var44.getValue().stream().map(PluginIdentifier::toString).toList()))
               .append("]\n");
         }

         throw new ModLoadOrderException(ModLoadOrderException.Type.MISSING_DEPENDENCY, var30.toString());
      } else {
         ObjectArrayList var29 = new ObjectArrayList(var3.size());

         while (!var3.isEmpty()) {
            ArrayList var35 = new ArrayList<>();

            for (Entry var48 : var3.entrySet()) {
               if (var48.getValue().edges.isEmpty()) {
                  var35.add(var48.getKey());
               }
            }

            var35.sort(Comparator.comparing(PluginIdentifier::toString));
            if (var35.isEmpty()) {
               boolean var43 = false;

               for (Entry var53 : var3.entrySet()) {
                  HashSet var55 = new HashSet<>(var53.getValue().manualOrderEdges);
                  var55.retainAll(var3.keySet());
                  if (!var55.isEmpty()) {
                     var43 = true;
                     break;
                  }
               }

               StringBuilder var52;
               ModLoadOrderException.Type var54;
               if (var43) {
                  var54 = ModLoadOrderException.Type.MANUAL_ORDER_CONFLICT;
                  var52 = new StringBuilder("Manual load order conflicts with plugin dependencies:\n");

                  for (Entry var14 : var3.entrySet()) {
                     HashSet var15 = new HashSet<>(var14.getValue().edges);
                     var15.removeAll(var14.getValue().manualOrderEdges);
                     HashSet var16 = new HashSet<>(var14.getValue().manualOrderEdges);
                     var16.retainAll(var3.keySet());
                     ArrayList var17 = new ArrayList<>();
                     if (!var15.isEmpty()) {
                        var17.add("[" + String.join(", ", var15.stream().map(PluginIdentifier::toString).toList()) + "] (dependencies)");
                     }

                     if (!var16.isEmpty()) {
                        var17.add("[" + String.join(", ", var16.stream().map(PluginIdentifier::toString).toList()) + "] (manual order)");
                     }

                     if (!var17.isEmpty()) {
                        var52.append("  ").append(var14.getKey()).append(" waiting on: ").append(String.join(" ", var17)).append("\n");
                     }
                  }
               } else {
                  var54 = ModLoadOrderException.Type.CYCLIC_DEPENDENCY;
                  var52 = new StringBuilder("Found cyclic dependency between plugins:\n");

                  for (Entry var58 : var3.entrySet()) {
                     var52.append("  ")
                        .append(var58.getKey())
                        .append(" waiting on: [")
                        .append(String.join(", ", var58.getValue().edges.stream().map(PluginIdentifier::toString).toList()))
                        .append("]\n");
                  }
               }

               throw new ModLoadOrderException(var54, var52.toString());
            }

            for (PluginIdentifier var49 : var35) {
               var29.add(var3.get(var49).mod);
               var3.remove(var49);
            }

            for (PluginIdentifier var50 : var35) {
               for (Mod.EntryNode var13 : var3.values()) {
                  var13.edges.remove(var50);
               }
            }
         }

         class="kw">return var29;
      }
   }

   class="kw">final class EntryNode<T> {
      class="kw">private class="kw">final Set<PluginIdentifier> edges = new HashSet<>();
      class="kw">private class="kw">final Set<PluginIdentifier> manualOrderEdges = new HashSet<>();
      class="kw">private class="kw">final T mod;

      class="kw">private EntryNode(T var1) {
         this.mod = var1;
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "EntryNode{plugin=" + this.mod + ", dependencies=" + this.edges + "}";
      }
   }
}