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

class="kw">import com.google.gson.JsonElement;
class="kw">import com.google.gson.JsonParser;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.common.util.ExceptionUtil;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import java.io.BufferedWriter;
class="kw">import java.io.DataOutputStream;
class="kw">import java.io.IOException;
class="kw">import java.io.StringWriter;
class="kw">import java.nio.ByteBuffer;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.StandardOpenOption;
class="kw">import java.nio.file.attribute.BasicFileAttributes;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonBinaryReader;
class="kw">import org.bson.BsonBinaryWriter;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonString;
class="kw">import org.bson.BsonValue;
class="kw">import org.bson.codecs.BsonDocumentCodec;
class="kw">import org.bson.codecs.DecoderContext;
class="kw">import org.bson.codecs.EncoderContext;
class="kw">import org.bson.io.BasicOutputBuffer;
class="kw">import org.bson.json.JsonMode;
class="kw">import org.bson.json.JsonWriter;
class="kw">import org.bson.json.JsonWriterSettings;

class="kw">public class BsonUtil {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final JsonWriterSettings SETTINGS = JsonWriterSettings.builder()
      .outputMode(JsonMode.STRICT)
      .indent(true)
      .newLineCharacters("\n")
      .int64Converter((var0, var1) -> var1.writeNumber(Long.toString(var0)))
      .build();
   class="kw">private class="kw">static class="kw">final BsonDocumentCodec codec = new BsonDocumentCodec();
   class="kw">private class="kw">static class="kw">final DecoderContext decoderContext = DecoderContext.builder().build();
   class="kw">private class="kw">static class="kw">final EncoderContext encoderContext = EncoderContext.builder().build();
   class="kw">public class="kw">static class="kw">final BsonDocumentCodec BSON_DOCUMENT_CODEC = new BsonDocumentCodec();
   class="kw">private class="kw">static class="kw">final int MAX_PARSE_DEPTH = 256;

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

   class="kw">public class="kw">static byte[] writeToBytes(@Nullable BsonDocument var0) {
      if (var0 == null) {
         class="kw">return ArrayUtil.EMPTY_BYTE_ARRAY;
      }

      BasicOutputBuffer var1 = new BasicOutputBuffer();

      byte[] var2;
      try {
         codec.encode(new BsonBinaryWriter(var1), var0, encoderContext);
         var2 = var1.toByteArray();
      } catch (Throwable var5) {
         try {
            var1.close();
         } catch (Throwable var4) {
            var5.addSuppressed(var4);
         }

         throw var5;
      }

      var1.close();
      class="kw">return var2;
   }

   class="kw">public class="kw">static int encodeInto(@Nullable BsonDocument var0, @Nonnull BasicOutputBuffer var1) {
      var1.truncateToPosition(0);
      if (var0 == null) {
         class="kw">return 0;
      }

      codec.encode(new BsonBinaryWriter(var1), var0, encoderContext);
      class="kw">return var1.getPosition();
   }

   @Nullable
   class="kw">public class="kw">static BsonDocument readFromBytes(@Nullable byte[] var0) {
      class="kw">return var0 != null && var0.length != 0 ? codec.decode(new BsonBinaryReader(ByteBuffer.wrap(var0)), decoderContext) : null;
   }

   @Nullable
   class="kw">public class="kw">static BsonDocument readFromBuffer(@Nullable ByteBuffer var0) {
      class="kw">return var0 != null && var0.hasRemaining() ? codec.decode(new BsonBinaryReader(var0), decoderContext) : null;
   }

   @Nullable
   class="kw">public class="kw">static BsonDocument readFromBinaryStream(@Nonnull ByteBuffer var0) {
      int var1 = Short.toUnsignedInt(var0.getShort());
      if (var1 == 0) {
         class="kw">return null;
      }

      ByteBuffer var2 = var0.slice(var0.position(), var1);
      var0.position(var0.position() + var1);
      class="kw">return readFromBuffer(var2);
   }

   class="kw">public class="kw">static void writeToBinaryStream(@Nonnull DataOutputStream var0, BsonDocument var1) class="kw">throws IOException {
      byte[] var2 = writeToBytes(var1);
      if (var2.length >= 65535) {
         throw new IllegalArgumentException("length is too large");
      }

      var0.writeShort(var2.length);
      var0.write(var2);
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<Void> writeDocument(@Nonnull Path var0, BsonDocument var1) {
      class="kw">return writeDocument(var0, var1, true);
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<Void> writeDocument(@Nonnull Path var0, BsonDocument var1, boolean var2) {
      class="kw">return CompletableFuture.runAsync(SneakyThrow.sneakyRunnable(() -> writeDocumentSync(var0, var1, var2))).whenComplete((var1x, var2x) -> {
         if (var2x != null) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var2x)).log("Failed to write document to '%s'", var0);
         }
      });
   }

   class="kw">private class="kw">static void writeDocumentSync(@Nonnull Path var0, BsonDocument var1, boolean var2) class="kw">throws IOException {
      Path var3 = PathUtil.getParent(var0);
      if (!Files.exists(var3)) {
         Files.createDirectories(var3);
      }

      Path var4 = var0.resolveSibling(var0.getFileName() + ".tmp");

      try (BufferedWriter var5 = Files.newBufferedWriter(var4, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
         BSON_DOCUMENT_CODEC.encode(new JsonWriter(var5, SETTINGS), var1, encoderContext);
      }

      if (var2 && Files.isRegularFile(var0)) {
         FileUtil.atomicMove(var0, var0.resolveSibling(var0.getFileName() + ".bak"));
      }

      FileUtil.atomicMove(var4, var0);
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<BsonDocument> readDocument(@Nonnull Path var0) {
      class="kw">return readDocument(var0, true);
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<BsonDocument> readDocument(@Nonnull Path var0, boolean var1) {
      BasicFileAttributes var2;
      try {
         var2 = Files.readAttributes(var0, BasicFileAttributes.class);
      } catch (IOException var4) {
         if (var1) {
            class="kw">return readDocumentBak(var0);
         }

         class="kw">return CompletableFuture.completedFuture(null);
      }

      if (var2.size() == 0L) {
         LOGGER.at(Level.WARNING).log("Error loading file %s, file was found to be entirely empty", var0);
         class="kw">return var1 ? readDocumentBak(var0) : CompletableFuture.completedFuture(null);
      } else {
         CompletableFuture var3 = CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier(() -> Files.readString(var0))).thenApply(BsonDocument::parse);
         class="kw">return var1 ? var3.exceptionallyCompose(var1x -> readDocumentBak(var0)) : var3;
      }
   }

   @Nullable
   class="kw">public class="kw">static BsonDocument readDocumentNow(@Nonnull Path var0) {
      BasicFileAttributes var1;
      try {
         var1 = Files.readAttributes(var0, BasicFileAttributes.class);
      } catch (IOException var5) {
         ((HytaleLogger.Api)HytaleLogger.getLogger().atWarning()).log("%s", ExceptionUtil.toStringWithStack(var5));
         class="kw">return null;
      }

      if (var1.size() == 0L) {
         class="kw">return null;
      }

      String var2;
      try {
         var2 = Files.readString(var0);
      } catch (IOException var4) {
         class="kw">return null;
      }

      class="kw">return BsonDocument.parse(var2);
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<BsonDocument> readDocumentBak(@Nonnull Path var0) {
      Path var1 = var0.resolveSibling(var0.getFileName() + ".bak");

      BasicFileAttributes var2;
      try {
         var2 = Files.readAttributes(var1, BasicFileAttributes.class);
      } catch (IOException var4) {
         class="kw">return CompletableFuture.completedFuture(null);
      }

      if (var2.size() == 0L) {
         LOGGER.at(Level.WARNING).log("Error loading backup file %s, file was found to be entirely empty", var1);
         class="kw">return CompletableFuture.completedFuture(null);
      } else {
         LOGGER.at(Level.WARNING).log("Loading %s backup file for %s!", var1, var0);
         class="kw">return CompletableFuture.supplyAsync(SneakyThrow.sneakySupplier(() -> Files.readString(var1))).thenApply(BsonDocument::parse);
      }
   }

   @Nonnull
   class="kw">public class="kw">static BsonDocument parseWithMaxDepth(@Nonnull String var0) {
      class="kw">return parseWithMaxDepth(var0, 256);
   }

   @Nonnull
   class="kw">public class="kw">static BsonDocument parseWithMaxDepth(@Nonnull String var0, int var1) {
      class="kw">return codec.decode(new DepthLimitedJsonReader(var0, var1), decoderContext);
   }

   class="kw">public class="kw">static BsonValue translateJsonToBson(@Nonnull JsonElement var0) {
      class="kw">return (BsonValue)(var0.isJsonObject() ? BsonDocument.parse(var0.toString()) : new BsonString(var0.getAsString()));
   }

   class="kw">public class="kw">static JsonElement translateBsonToJson(BsonDocument var0) {
      try (StringWriter var1 = new StringWriter()) {
         codec.encode(new JsonWriter(var1, SETTINGS), var0, encoderContext);
         class="kw">return JsonParser.parseString(var1.toString());
      } catch (IOException var6) {
         throw new RuntimeException(var6);
      }
   }

   class="kw">public class="kw">static String toJson(BsonDocument var0) {
      StringWriter var1 = new StringWriter();
      BSON_DOCUMENT_CODEC.encode(new JsonWriter(var1, SETTINGS), var0, encoderContext);
      class="kw">return var1.toString();
   }

   class="kw">public class="kw">static <T> void writeSync(@Nonnull Path var0, @Nonnull Codec<T> var1, T var2, @Nonnull HytaleLogger var3) class="kw">throws IOException {
      Path var4 = PathUtil.getParent(var0);
      if (!Files.exists(var4)) {
         Files.createDirectories(var4);
      }

      ExtraInfo var5 = ExtraInfo.THREAD_LOCAL.get();
      BsonValue var6 = var1.encode(var2, var5);
      var5.getValidationResults().logOrThrowValidatorExceptions(var3);
      BsonDocument var7 = var6.asDocument();
      Path var8 = var0.resolveSibling(var0.getFileName() + ".tmp");
      Path var9 = var0.resolveSibling(var0.getFileName() + ".bak");

      try (BufferedWriter var10 = Files.newBufferedWriter(var8, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
         BSON_DOCUMENT_CODEC.encode(new JsonWriter(var10, SETTINGS), var7, encoderContext);
      }

      if (Files.isRegularFile(var0)) {
         FileUtil.atomicMove(var0, var9);
      }

      FileUtil.atomicMove(var8, var0);
   }
}