class="kw">package com.hypixel.hytale.server.core.schema;

class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.AssetStore;
class="kw">import com.hypixel.hytale.assetstore.codec.AssetCodec;
class="kw">import com.hypixel.hytale.assetstore.codec.AssetCodecMapCodec;
class="kw">import com.hypixel.hytale.codec.EmptyExtraInfo;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.schema.SchemaContext;
class="kw">import com.hypixel.hytale.codec.schema.config.ObjectSchema;
class="kw">import com.hypixel.hytale.codec.schema.config.Schema;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.util.BsonUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Comparator;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.CopyOnWriteArrayList;
class="kw">import java.util.function.Function;
class="kw">import java.util.logging.Level;
class="kw">import java.util.stream.Stream;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonArray;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonInt32;
class="kw">import org.bson.BsonString;

class="kw">public class SchemaGenerator {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final List<SchemaGenerator.ConfigRegistration> configRegistrations = new CopyOnWriteArrayList<>();
   class="kw">private class="kw">static class="kw">final List<SchemaGenerator.AssetSchemaRegistration> assetSchemaRegistrations = new CopyOnWriteArrayList<>();

   class="kw">public SchemaGenerator() {
   }

   class="kw">public class="kw">static void registerConfig(@Nonnull String var0, @Nonnull BuilderCodec<?> var1, @Nullable String var2, @Nullable List<String> var3) {
      configRegistrations.add(new SchemaGenerator.ConfigRegistration(var0, var1, var2, var3));
   }

   class="kw">public class="kw">static void registerAssetSchema(
      @Nonnull String var0, @Nonnull Function<SchemaContext, Schema> var1, @Nullable List<String> var2, @Nullable String var3
   ) {
      assetSchemaRegistrations.add(new SchemaGenerator.AssetSchemaRegistration(var0, var1, var2, var3));
   }

   @Nonnull
   class="kw">public class="kw">static Map<String, Schema> generateAssetSchemas() {
      SchemaGenerator.GenerationResult var0 = collectSchemas(false);
      LinkedHashMap var1 = new LinkedHashMap<>();
      var1.putAll(var0.assetSchemas());
      var1.putAll(var0.customAssetSchemas());
      var1.putAll(var0.sharedSchemas());
      class="kw">return var1;
   }

   class="kw">public class="kw">static void generate(@Nullable Path var0, @Nullable Path var1) {
      try {
         SchemaGenerator.GenerationResult var2 = collectSchemas(var1 != null);
         boolean var3 = var0 != null && var1 != null && var0.toAbsolutePath().normalize().equals(var1.toAbsolutePath().normalize());
         if (var3) {
            Path var4 = var0.resolve("Schema");
            cleanAndCreateSchemaDir(var4);
            LinkedHashMap var5 = new LinkedHashMap<>();
            var5.putAll(var2.assetSchemas());
            var5.putAll(var2.customAssetSchemas());
            var5.putAll(var2.configSchemas());
            var5.putAll(var2.sharedSchemas());
            writeSchemas(var5, var4);
            ArrayList var6 = new ArrayList<>();
            var6.addAll(var2.assetVsCodeEntries());
            var6.addAll(var2.customAssetVsCodeEntries());
            var6.addAll(var2.configVsCodeEntries());
            writeVsCodeSettings(var0, var6);
         } else {
            if (var0 != null) {
               Path var8 = var0.resolve("Schema");
               cleanAndCreateSchemaDir(var8);
               LinkedHashMap var10 = new LinkedHashMap<>();
               var10.putAll(var2.assetSchemas());
               var10.putAll(var2.customAssetSchemas());
               var10.putAll(var2.sharedSchemas());
               writeSchemas(var10, var8);
               ArrayList var12 = new ArrayList<>();
               var12.addAll(var2.assetVsCodeEntries());
               var12.addAll(var2.customAssetVsCodeEntries());
               writeVsCodeSettings(var0, var12);
            }

            if (var1 != null) {
               Path var9 = var1.resolve("Schema");
               cleanAndCreateSchemaDir(var9);
               LinkedHashMap var11 = new LinkedHashMap<>();
               var11.putAll(var2.configSchemas());
               var11.putAll(var2.sharedSchemas());
               writeSchemas(var11, var9);
               writeVsCodeSettings(var1, var2.configVsCodeEntries());
            }
         }
      } catch (Throwable var7) {
         ((HytaleLogger.Api)LOGGER.at(Level.SEVERE).withCause(var7)).log("Schema generation failed");
         throw new RuntimeException("Schema generation failed", var7);
      }
   }

   class="kw">private class="kw">static SchemaGenerator.GenerationResult collectSchemas(boolean var0) {
      SchemaContext var1 = new SchemaContext();
      AssetStore[] var2 = AssetRegistry.getStoreMap().values().toArray(AssetStore[]::new);
      Arrays.sort(var2, Comparator.comparing(var0x -> var0x.getAssetClass().getSimpleName()));

      for (AssetStore var6 : var2) {
         String var7 = var6.getAssetClass().getSimpleName();
         var1.addFileReference(var7 + ".json", var6.getCodec());
      }

      LinkedHashMap var22 = new LinkedHashMap<>();
      ArrayList var23 = new ArrayList<>();

      for (AssetStore var8 : var2) {
         Class var9 = var8.getAssetClass();
         String var10 = var8.getPath();
         String var11 = var9.getSimpleName();
         AssetCodec var12 = var8.getCodec();
         Schema var13 = var12.toSchema(var1);
         if (var12 class="kw">instanceof AssetCodecMapCodec) {
            var13.setTitle(var11);
         }

         var13.setId(var11 + ".json");
         Schema.HytaleMetadata var14 = var13.getHytale();
         var14.setPath(var10);
         var14.setExtension(var8.getExtension());
         Class var15 = var8.getIdProvider();
         if (var15 != null) {
            var14.setIdProvider(var15.getSimpleName());
         }

         List var16 = var8.getPreAddedAssets();
         if (var16 != null && !var16.isEmpty()) {
            String[] var17 = new String[var16.size()];

            for (int var18 = 0; var18 < var16.size(); var18++) {
               Object var19 = var16.get(var18);
               Object var20 = var8.getKeyFunction().apply(var19);
               var17[var18] = var20.toString();
            }

            var14.setInternalKeys(var17);
         }

         var22.put(var11 + ".json", var13);
         var23.add(
            new SchemaGenerator.VsCodeEntry(
               var11 + ".json",
               List.of("/Server/" + var10 + "/*" + var8.getExtension(), "/Server/" + var10 + "/**/*" + var8.getExtension()),
               var8.getExtension()
            )
         );
      }

      LinkedHashMap var25 = new LinkedHashMap<>();
      ArrayList var27 = new ArrayList<>();

      for (SchemaGenerator.AssetSchemaRegistration var31 : assetSchemaRegistrations) {
         Schema var33 = var31.factory().apply(var1);
         var25.put(var31.fileName(), var33);
         if (var31.fileMatchPatterns() != null && !var31.fileMatchPatterns().isEmpty()) {
            String var36 = var31.extension() != null ? var31.extension() : ".json";
            var27.add(new SchemaGenerator.VsCodeEntry(var31.fileName(), var31.fileMatchPatterns().stream().map(var0x -> "/Server/" + var0x).toList(), var36));
         }
      }

      LinkedHashMap var30 = new LinkedHashMap<>();
      ArrayList var32 = new ArrayList<>();
      if (var0) {
         for (SchemaGenerator.ConfigRegistration var37 : configRegistrations) {
            try {
               ObjectSchema var39 = var37.codec().toSchema(var1);
               var39.setTitle(var37.name());
               String var41 = toFileName(var37.name());
               var39.setId(var41);
               Schema.HytaleMetadata var42 = var39.getHytale();
               if (var37.virtualPath() != null) {
                  var42.setVirtualPath(var37.virtualPath());
               }

               var30.put(var41, var39);
               if (var37.fileMatchPatterns() != null && !var37.fileMatchPatterns().isEmpty()) {
                  var32.add(new SchemaGenerator.VsCodeEntry(var41, var37.fileMatchPatterns(), null));
               }
            } catch (Throwable var21) {
               ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var21)).log("Failed to generate config schema for '%s', skipping", var37.name());
            }
         }
      }

      LinkedHashMap var35 = new LinkedHashMap<>();
      Schema var38 = new Schema();
      var38.setDefinitions(var1.getDefinitions());
      var38.setId("common.json");
      var35.put("common.json", var38);
      Schema var40 = new Schema();
      var40.setDefinitions(var1.getOtherDefinitions());
      var40.setId("other.json");
      var35.put("other.json", var40);
      class="kw">return new SchemaGenerator.GenerationResult(var22, var25, var30, var35, var23, var27, var32);
   }

   class="kw">private class="kw">static void cleanAndCreateSchemaDir(@Nonnull Path var0) {
      try {
         Files.createDirectories(var0);

         try (Stream var1 = Files.walk(var0, 1)) {
            var1.filter(var0x -> var0x.toString().endsWith(".json")).forEach(SneakyThrow.sneakyConsumer(Files::delete));
         }
      } catch (Exception var6) {
         throw new RuntimeException("Failed to prepare schema directory: " + var0, var6);
      }
   }

   class="kw">private class="kw">static void writeVsCodeSettings(@Nonnull Path var0, @Nonnull List<SchemaGenerator.VsCodeEntry> var1) {
      try {
         BsonDocument var2 = new BsonDocument();
         BsonArray var3 = new BsonArray();
         BsonDocument var4 = new BsonDocument();
         var2.put("json.schemas", var3);
         var2.put("files.associations", var4);
         var2.put("editor.tabSize", new BsonInt32(2));

         for (SchemaGenerator.VsCodeEntry var6 : var1) {
            addVsCodeSchemaLink(var2, var6.schemaFileName(), var6.fileMatchPatterns(), var6.extension());
         }

         Files.createDirectories(var0.resolve(".vscode"));
         BsonUtil.writeDocument(var0.resolve(".vscode/settings.json"), var2, false).join();
      } catch (Exception var7) {
         throw new RuntimeException("Failed to write .vscode/settings.json", var7);
      }
   }

   @Nonnull
   class="kw">public class="kw">static String toFileName(@Nonnull String var0) {
      class="kw">return var0.replace(':', '.') + ".json";
   }

   class="kw">public class="kw">static void writeSchemas(@Nonnull Map<String, Schema> var0, @Nonnull Path var1) {
      for (Entry var3 : var0.entrySet()) {
         BsonUtil.writeDocument(var1.resolve(var3.getKey()), Schema.CODEC.encode(var3.getValue(), EmptyExtraInfo.EMPTY).asDocument(), false).join();
      }
   }

   class="kw">public class="kw">static void addVsCodeSchemaLink(@Nonnull BsonDocument var0, @Nonnull String var1, @Nonnull List<String> var2, @Nullable String var3) {
      BsonDocument var4 = new BsonDocument();
      var4.put("fileMatch", new BsonArray(var2.stream().map(BsonString::new).toList()));
      var4.put("url", new BsonString("./Schema/" + var1));
      var0.getArray("json.schemas").add(var4);
      if (var3 != null && !var3.equals(".json")) {
         var0.getDocument("files.associations").put("*" + var3, new BsonString("json"));
      }
   }

   class="kw">private record AssetSchemaRegistration(
      @Nonnull String fileName, @Nonnull Function<SchemaContext, Schema> factory, @Nullable List<String> fileMatchPatterns, @Nullable String extension
   ) {
      class="kw">private AssetSchemaRegistration {
      }
   }

   class="kw">private record ConfigRegistration(
      @Nonnull String name, @Nonnull BuilderCodec<?> codec, @Nullable String virtualPath, @Nullable List<String> fileMatchPatterns
   ) {
      class="kw">private ConfigRegistration {
      }
   }

   class="kw">private record GenerationResult(
      LinkedHashMap<String, Schema> assetSchemas,
      LinkedHashMap<String, Schema> customAssetSchemas,
      LinkedHashMap<String, Schema> configSchemas,
      LinkedHashMap<String, Schema> sharedSchemas,
      List<SchemaGenerator.VsCodeEntry> assetVsCodeEntries,
      List<SchemaGenerator.VsCodeEntry> customAssetVsCodeEntries,
      List<SchemaGenerator.VsCodeEntry> configVsCodeEntries
   ) {
      class="kw">private GenerationResult {
      }
   }

   class="kw">private record VsCodeEntry(String schemaFileName, List<String> fileMatchPatterns, @Nullable String extension) {
      class="kw">private VsCodeEntry {
      }
   }
}