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

class="kw">import com.hypixel.hytale.assetstore.AssetPack;
class="kw">import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.event.IEventDispatcher;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.logger.sentry.SkipSentryException;
class="kw">import com.hypixel.hytale.protocol.UpdateType;
class="kw">import com.hypixel.hytale.protocol.packets.assets.UpdateTranslations;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.HytaleServerConfig;
class="kw">import com.hypixel.hytale.server.core.asset.AssetModule;
class="kw">import com.hypixel.hytale.server.core.asset.AssetPackRegisterEvent;
class="kw">import com.hypixel.hytale.server.core.asset.AssetPackUnregisterEvent;
class="kw">import com.hypixel.hytale.server.core.asset.LoadAssetEvent;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.AssetMonitor;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.AssetMonitorHandler;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.EventKind;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.bench.Bench;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.bench.CraftingBench;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.FieldcraftCategory;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
class="kw">import com.hypixel.hytale.server.core.modules.i18n.commands.EnableTmpTagsCommand;
class="kw">import com.hypixel.hytale.server.core.modules.i18n.commands.InternationalizationCommands;
class="kw">import com.hypixel.hytale.server.core.modules.i18n.event.MessagesUpdated;
class="kw">import com.hypixel.hytale.server.core.modules.i18n.parser.LangFileParser;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.io.BufferedReader;
class="kw">import java.io.File;
class="kw">import java.io.IOException;
class="kw">import java.io.InputStream;
class="kw">import java.net.URI;
class="kw">import java.net.URL;
class="kw">import java.nio.file.DirectoryStream;
class="kw">import java.nio.file.FileSystem;
class="kw">import java.nio.file.FileSystemNotFoundException;
class="kw">import java.nio.file.FileSystems;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.Paths;
class="kw">import java.util.Collection;
class="kw">import java.util.Collections;
class="kw">import java.util.Enumeration;
class="kw">import java.util.Iterator;
class="kw">import java.util.Map;
class="kw">import java.util.Properties;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.atomic.AtomicLong;
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">public class I18nModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(I18nModule.class).optDepends(AssetModule.class).build();
   class="kw">private class="kw">static class="kw">final String BUNDLED_DEFAULTS_RESOURCE_ROOT = "bundledDefaults/";
   class="kw">public class="kw">static class="kw">final String DEFAULT_LANGUAGE = "en-US";
   class="kw">public class="kw">static class="kw">final Path FALLBACK_LANG_PATH = Paths.get("fallback.lang");
   class="kw">public class="kw">static class="kw">final String FILE_EXTENSION = ".lang";
   class="kw">public class="kw">static class="kw">final String SERVER_ASSETS = "Server";
   class="kw">public class="kw">static class="kw">final String LANGUAGE_ASSETS = "Languages";
   class="kw">public class="kw">static class="kw">final Path DEFAULT_GENERATED_PATH = Path.of("Server", "Languages", "en-US");
   class="kw">private class="kw">static I18nModule instance;
   class="kw">private class="kw">final Map<String, String> fallbacks = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<String, String> bundledDefaults = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<String, Map<String, String>> languages = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<String, I18nModule.CachedMessages> cachedLanguages = new ConcurrentHashMap<>();
   class="kw">private class="kw">final AtomicLong messagesVersion = new AtomicLong();

   class="kw">public class="kw">static I18nModule get() {
      class="kw">return instance;
   }

   class="kw">public I18nModule(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Override
   class="kw">protected void setup() {
      this.loadBundledDefaultsFromClasspath();
      if (AssetModule.get() != null) {
         this.getEventRegistry().register((short)-32, LoadAssetEvent.class, var1 -> {
            for (AssetPack var3 : AssetModule.get().getAssetPacks()) {
               this.loadMessagesFromPack(var3);
            }
         });
         this.getEventRegistry().register((short)-32, AssetPackRegisterEvent.class, var1 -> this.loadMessagesFromPack(var1.getAssetPack()));
         this.getEventRegistry().register(AssetPackUnregisterEvent.class, var0 -> {});
         this.getEventRegistry()
            .register(
               LoadedAssetsEvent.class,
               BlockType.class,
               var1 -> {
                  Map var2 = new Object2ObjectOpenHashMap();
                  var1.getLoadedAssets()
                     .values()
                     .forEach(
                        var1x -> {
                           Bench var2 = var1x.getBench();
                           if (var2 != null) {
                              String var3 = var1x.getId();
                              if (var2 class="kw">instanceof CraftingBench var4) {
                                 for (CraftingBench.BenchCategory var8 : var4.getCategories()) {
                                    var2.put("server.items." + var3 + ".bench.categories." + var8.getId() + ".name", var8.getName());
                                    if (var8.getItemCategories() != null) {
                                       for (CraftingBench.BenchItemCategory var12 : var8.getItemCategories()) {
                                          var2.put(
                                             "server.items." + var3 + ".bench.categories." + var8.getId() + ".itemCategories." + var12.getId() + ".name",
                                             var12.getName()
                                          );
                                       }
                                    }
                                 }
                              }

                              if (var2.getDescriptiveLabel() != null) {
                                 var2.put("server.items." + var3 + ".bench.descriptiveLabel", var2.getDescriptiveLabel());
                              }
                           }
                        }
                     );
                  this.addDefaultMessages(var2, var1.isInitial());
               }
            );
         this.getEventRegistry().register(LoadedAssetsEvent.class, FieldcraftCategory.class, var1 -> {
            Map var2 = new Object2ObjectOpenHashMap();
            var1.getLoadedAssets().values().forEach(var1x -> {
               if (var1x.getName() != null) {
                  var2.put("fieldcraftCategories." + var1x.getId() + ".name", var1x.getName());
               }
            });
            this.addDefaultMessages(var2, var1.isInitial());
         });
      }
   }

   @Override
   class="kw">protected void start() {
      if (AssetModule.get() != null) {
         this.getCommandRegistry().registerCommand(new InternationalizationCommands());
         this.getCommandRegistry().registerCommand(new EnableTmpTagsCommand());
      }
   }

   class="kw">private void loadBundledDefaultsFromClasspath() {
      ClassLoader var1 = I18nModule.class.getClassLoader();

      try {
         Enumeration var2 = var1.getResources("bundledDefaults/");

         while (var2.hasMoreElements()) {
            URL var3 = var2.nextElement();
            this.loadBundledDefaultsFromUrl(this.bundledDefaults, var3);
         }
      } catch (IOException var4) {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var4)).log("Failed to enumerate %s resources", "bundledDefaults/");
      }
   }

   class="kw">private void loadBundledDefaultsFromUrl(@Nonnull Map<String, String> var1, @Nonnull URL var2) {
      try {
         label118: {
            URI var3 = var2.toURI();
            FileSystem var4 = null;

            try {
               Path var5;
               if ("jar".equals(var3.getScheme())) {
                  FileSystem var6;
                  try {
                     var6 = FileSystems.getFileSystem(var3);
                  } catch (FileSystemNotFoundException var19) {
                     var6 = FileSystems.newFileSystem(var3, Collections.emptyMap());
                     var4 = var6;
                  }

                  var5 = var6.getPath("/bundledDefaults/");
               } else {
                  var5 = Paths.get(var3);
               }

               if (Files.isDirectory(var5)) {
                  try (DirectoryStream var23 = Files.newDirectoryStream(var5, var0 -> var0.getFileName().toString().endsWith(".lang"))) {
                     for (Path var8 : var23) {
                        String var9 = var8.getFileName().toString();
                        String var10 = var9.substring(0, var9.length() - ".lang".length());
                        int var11 = var1.size();
                        this.loadMessagesFrom(var1, var10, var8);
                        this.getLogger().at(Level.INFO).log("Loaded %d bundled class="kw">default translations from %s", var1.size() - var11, var8);
                     }
                     break label118;
                  }
               }
            } class="kw">finally {
               if (var4 != null) {
                  var4.close();
               }
            }

            class="kw">return;
         }
      } catch (Exception var22) {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(new SkipSentryException(var22))).log("Failed to load bundled defaults from %s", var2);
      }
   }

   class="kw">private void loadMessagesFromPack(AssetPack var1) {
      Path var2 = var1.getRoot().resolve("Server").resolve("Languages");
      if (Files.isDirectory(var2)) {
         AssetMonitor var3 = AssetModule.get().getAssetMonitor();
         if (var3 != null && !var1.isImmutable()) {
            var3.monitorDirectoryFiles(var2, new I18nModule.I18nAssetMonitorHandler(var2));
         }

         try (DirectoryStream var4 = Files.newDirectoryStream(var2, var0 -> Files.isDirectory(var0))) {
            for (Path var6 : var4) {
               try {
                  String var7 = var6.getFileName().toString();
                  int var8 = this.loadMessages(var7, var6);
                  this.getLogger().at(Level.INFO).log("Loaded %d entries for '%s' from %s", var8, var7, var2);
               } catch (IOException var11) {
                  ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var11)).log("Failed to load messages from: %s", var6);
               }
            }
         } catch (IOException var15) {
            ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var15)).log("Failed to load languages from: %s", var2);
         }
      }

      Path var16 = var2.resolve("fallback.lang");
      if (Files.exists(var16)) {
         Properties var17 = new Properties();

         try {
            try (InputStream var18 = Files.newInputStream(var16)) {
               var17.load(var18);
            }

            for (Entry var20 : var17.entrySet()) {
               this.fallbacks.put((String)var20.getKey(), (String)var20.getValue());
            }

            if (!var17.isEmpty()) {
               this.getLogger().at(Level.INFO).log("Loaded %d entries from %s", var17.size(), var16);
            }
         } catch (IOException var13) {
            ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var13)).log("Failed to load fallback languages from: %s", var16);
         }
      }

      this.messagesVersion.incrementAndGet();
   }

   @Nonnull
   class="kw">public UpdateTranslations[] getUpdatePacketsForChanges(
      String var1, @Nonnull Map<String, Map<String, String>> var2, @Nonnull Map<String, Map<String, String>> var3
   ) {
      Map var4 = this.getMessages(var3, var1);
      Map var5 = this.getMessages(var2, var1);
      int var6 = (var4.isEmpty() ? 0 : 1) + (var5.isEmpty() ? 0 : 1);
      UpdateTranslations[] var7 = new UpdateTranslations[var6];
      int var8 = 0;
      if (!var4.isEmpty()) {
         var7[var8++] = new UpdateTranslations(UpdateType.Remove, var4);
      }

      if (!var5.isEmpty()) {
         var7[var8] = new UpdateTranslations(UpdateType.AddOrUpdate, var5);
      }

      class="kw">return var7;
   }

   class="kw">private void addDefaultMessages(@Nonnull Map<String, String> var1, boolean var2) {
      Map var3 = this.languages.computeIfAbsent("en-US", var0 -> new ConcurrentHashMap<>());

      for (Entry var5 : var1.entrySet()) {
         if (var5.getKey() != null && var5.getValue() != null) {
            var3.put(var5.getKey(), var5.getValue());
         } else {
            this.getLogger().at(Level.WARNING).log("Attempted to add invalid class="kw">default translation message: %s=%s", var5.getKey(), var5.getValue());
         }
      }

      this.messagesVersion.incrementAndGet();
      if (!var2) {
         UpdateTranslations var7 = new UpdateTranslations(UpdateType.AddOrUpdate, var1);
         Universe.get().broadcastPacketNoCache(var7);
         IEventDispatcher var8 = HytaleServer.get().getEventBus().dispatchFor(MessagesUpdated.class);
         if (var8.hasListener()) {
            Object2ObjectOpenHashMap var6 = new Object2ObjectOpenHashMap();
            var6.put("en-US", var1);
            var8.dispatch(new MessagesUpdated(var6, new Object2ObjectOpenHashMap()));
         }
      }
   }

   class="kw">private int loadMessages(String var1, @Nonnull Path var2) class="kw">throws IOException {
      Map var3 = this.languages.computeIfAbsent(var1, var0 -> new ConcurrentHashMap<>());

      try (Stream var4 = Files.find(
            var2, Integer.MAX_VALUE, (var0, var1x) -> var0.toString().endsWith(".lang") && var1x.isRegularFile(), FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY
         )) {
         class="kw">return var4.mapToInt(var3x -> {
            String var4 = this.getPrefix(var2, var3x);
            class="kw">return this.loadMessagesFrom(var3, var4, var3x);
         }).sum();
      }
   }

   class="kw">private int loadMessagesFrom(@Nonnull Map<String, String> var1, String var2, @Nonnull Path var3) {
      Map var4;
      try (BufferedReader var5 = Files.newBufferedReader(var3)) {
         var4 = LangFileParser.parse(var3.toString(), var5);
      } catch (Exception var12) {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(new SkipSentryException(var12)))
            .log("Error parsing language file: %s", var3.toString());
         class="kw">return 0;
      }

      for (Entry var6 : var4.entrySet()) {
         String var7 = var2 + "." + var6.getKey();
         String var8 = var6.getValue();
         String var9 = var1.get(var7);
         if (var9 != null) {
            if (!var9.equals(var8)) {
               this.getLogger().at(Level.WARNING).log("'%s' has multiple definitions: `%s` and `%s`", var7, var9, var8);
            }
         } else {
            var1.put(var7, var8);
         }
      }

      class="kw">return var4.size();
   }

   @Nonnull
   class="kw">private String getPrefix(@Nonnull Path var1, @Nonnull Path var2) {
      String var3 = "";
      Path var4 = var2.getParent();
      if (!var1.equals(var4)) {
         Path var5 = var1.relativize(var4);
         var3 = var3 + var5.toString().replace(File.separatorChar, '.') + ".";
      }

      String var6 = var2.getFileName().toString();
      class="kw">return var3 + var6.substring(0, var6.length() - ".lang".length());
   }

   @Nonnull
   class="kw">public Map<String, String> getMessages(@Nullable String var1) {
      String var2 = var1 == null ? "en-US" : var1;
      I18nModule.CachedMessages var3 = this.cachedLanguages.get(var2);
      class="kw">return var3 != null && var3.version() == this.messagesVersion.get()
         ? var3.messages()
         : this.cachedLanguages
            .compute(
               var2,
               (var1x, var2x) -> {
                  long var3 = this.messagesVersion.get();
                  class="kw">return (I18nModule.CachedMessages)(var2x != null && var2x.version() == var3
                     ? var2x
                     : new I18nModule.CachedMessages(var3, Collections.unmodifiableMap(this.getMessages(this.languages, var1x))));
               }
            )
            .messages();
   }

   class="kw">public Map<String, String> getMessages(@Nonnull Map<String, Map<String, String>> var1, @Nullable String var2) {
      if (var2 == null) {
         class="kw">return this.getMessages(var1, "en-US");
      }

      Map var3 = var1.get(var2);
      if ("en-US".equals(var2)) {
         class="kw">return var3 != null ? var3 : Collections.emptyMap();
      }

      String var4 = this.fallbacks.getOrDefault(var2, "en-US");
      Map var5 = this.getMessages(var1, var4);
      if (var5 == null) {
         class="kw">return var3 != null ? var3 : Collections.emptyMap();
      }

      if (var3 == null) {
         class="kw">return var5;
      }

      Object2ObjectOpenHashMap var6 = new Object2ObjectOpenHashMap(var5);
      var6.putAll(var3);
      class="kw">return var6;
   }

   class="kw">public void sendTranslations(@Nonnull PacketHandler var1, String var2) {
      if (!this.isDisabled()) {
         var1.writeNoCache(new UpdateTranslations(UpdateType.Init, this.getMessages(var2)));
      }
   }

   @Nullable
   class="kw">public String getMessage(String var1, @Nonnull String var2) {
      String var3 = this.getMessages(var1).get(var2);
      if (var3 == null) {
         var3 = this.bundledDefaults.get(var2);
         if (var3 == null) {
            class="kw">return null;
         }
      }

      HytaleServerConfig var4 = HytaleServer.get().getConfig();
      class="kw">return var4 != null && var4.isDisplayTmpTagsInStrings() ? var3 : var3.replace("[TMP] ", "").replace("[TMP]", "");
   }

   class="kw">private record CachedMessages(long version, @Nonnull Map<String, String> messages) {
      class="kw">private CachedMessages {
      }
   }

   class="kw">private class I18nAssetMonitorHandler class="kw">implements AssetMonitorHandler {
      class="kw">private class="kw">final Path languagesPath;

      class="kw">public I18nAssetMonitorHandler(Path nullx) {
         this.languagesPath = nullx;
      }

      @Override
      class="kw">public Object getKey() {
         class="kw">return I18nModule.this;
      }

      class="kw">public boolean test(Path var1, EventKind var2) {
         class="kw">return !Files.isDirectory(var1) && var1.getFileName().toString().endsWith(".lang") && I18nModule.this.isEnabled();
      }

      class="kw">public void accept(Map<Path, EventKind> var1) {
         Map var2 = new Object2ObjectOpenHashMap();
         Map var3 = new Object2ObjectOpenHashMap();
         Iterator var4 = var1.entrySet().iterator();

         while (true) {
            Properties var37;
            while (true) {
               if (!var4.hasNext()) {
                  if (var2.isEmpty() && var3.isEmpty()) {
                     class="kw">return;
                  }

                  for (Entry var24 : var3.entrySet()) {
                     Map var27 = I18nModule.this.languages.computeIfAbsent(var24.getKey(), var0 -> new ConcurrentHashMap<>());
                     var27.putAll(var24.getValue());
                  }

                  I18nModule.this.messagesVersion.incrementAndGet();

                  for (Entry var25 : var2.entrySet()) {
                     Map var28 = I18nModule.this.getMessages(var25.getKey());
                     Map var31 = var3.computeIfAbsent(var25.getKey(), var0 -> new Object2ObjectOpenHashMap());
                     Iterator var33 = var25.getValue().keySet().iterator();

                     while (var33.hasNext()) {
                        String var35 = var33.next();
                        if (var31.containsKey(var35)) {
                           var33.remove();
                        } else {
                           String var38 = var28.get(var35);
                           if (var38 != null) {
                              var33.remove();
                              var31.put(var35, var38);
                           }
                        }
                     }
                  }

                  Collection var23 = Universe.get().getPlayers();
                  Map var26 = new Object2ObjectOpenHashMap();

                  for (PlayerRef var32 : var23) {
                     PacketHandler var34 = var32.getPacketHandler();
                     String var36 = var32.getLanguage();
                     UpdateTranslations[] var39 = var26.get(var36);
                     if (var39 == null) {
                        var39 = I18nModule.this.getUpdatePacketsForChanges(var36, var3, var2);
                        var26.put(var36, var39);
                     }

                     if (var39.length != 0) {
                        var34.write(var39);
                     }
                  }

                  IEventDispatcher var30 = HytaleServer.get().getEventBus().dispatchFor(MessagesUpdated.class);
                  if (var30.hasListener()) {
                     var30.dispatch(new MessagesUpdated(var3, var2));
                  }

                  I18nModule.this.getLogger().at(Level.INFO).log("Handled language changes for: %s", var3.keySet());
                  class="kw">return;
               }

               Entry var5 = (Entry<Path, EventKind>)var4.next();
               Path var6 = var5.getKey();
               EventKind var7 = var5.getValue();
               Path var8 = var6.toAbsolutePath().normalize();
               Path var9 = this.languagesPath.relativize(var8);
               if (I18nModule.FALLBACK_LANG_PATH.equals(var9)) {
                  var37 = new Properties();

                  try (InputStream var40 = Files.newInputStream(var6)) {
                     var37.load(var40);
                     break;
                  } catch (IOException var20) {
                     ((HytaleLogger.Api)I18nModule.this.getLogger().at(Level.SEVERE).withCause(var20)).log("Failed to load fallback languages from: %s", var6);
                  }
               } else {
                  String var10 = var9.getName(0).toString();
                  Path var11 = this.languagesPath.resolve(var10).toAbsolutePath().normalize();
                  String var12 = I18nModule.this.getPrefix(var11, var8);
                  class="kw">switch (var7) {
                     case ENTRY_MODIFY:
                     case ENTRY_DELETE:
                        String var13 = var12 + ".";
                        Map var14 = var2.computeIfAbsent(var10, var0 -> new Object2ObjectOpenHashMap());
                        Map var15 = I18nModule.this.languages.computeIfAbsent(var10, var0 -> new ConcurrentHashMap<>());
                        Iterator var16 = var15.keySet().iterator();

                        while (var16.hasNext()) {
                           String var17 = var16.next();
                           if (var17.startsWith(var13)) {
                              var14.put(var17, "");
                              var16.remove();
                           }
                        }

                        if (var7 == EventKind.ENTRY_DELETE) {
                           break;
                        }
                     case ENTRY_CREATE:
                        Map var41 = var3.computeIfAbsent(var10, var0 -> new Object2ObjectOpenHashMap());
                        I18nModule.this.loadMessagesFrom(var41, var12, var6);
                  }
               }
            }

            I18nModule.this.fallbacks.clear();
            var37.forEach((var1x, var2x) -> I18nModule.this.fallbacks.put(var1x, var2x));
            I18nModule.this.messagesVersion.incrementAndGet();
         }
      }
   }
}