TextFilterClient

package net.minecraft.server.network;

import com.google.common.collect.ImmutableList;
import com.google.gson.JsonObject;
import com.google.gson.internal.Streams;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import com.mojang.authlib.GameProfile;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
import java.util.function.Supplier;
import net.minecraft.SharedConstants;
import net.minecraft.Util;
import net.minecraft.server.network.TextFilter;
import net.minecraft.util.GsonHelper;
import net.minecraft.util.thread.ProcessorMailbox;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class TextFilterClient implements AutoCloseable {
   private static final Logger LOGGER = LogManager.getLogger();
   private static final AtomicInteger WORKER_COUNT = new AtomicInteger(1);
   private static final ThreadFactory THREAD_FACTORY = (debug0) -> {
      Thread debug1 = new Thread(debug0);
      debug1.setName("Chat-Filter-Worker-" + WORKER_COUNT.getAndIncrement());
      return debug1;
   };
   private final URL chatEndpoint;
   private final URL joinEndpoint;
   private final URL leaveEndpoint;
   private final String authKey;
   private final int ruleId;
   private final String serverId;
   private final TextFilterClient.IgnoreStrategy chatIgnoreStrategy;
   private final ExecutorService workerPool;

   private void processJoinOrLeave(GameProfile debug1, URL debug2, Executor debug3) {
      JsonObject debug4 = new JsonObject();
      debug4.addProperty("server", this.serverId);
      debug4.addProperty("room", "Chat");
      debug4.addProperty("user_id", debug1.getId().toString());
      debug4.addProperty("user_display_name", debug1.getName());
      debug3.execute(() -> {
         try {
            this.processRequest(debug4, debug2);
         } catch (Exception var5) {
            LOGGER.warn((String)"Failed to send join/leave packet to {} for player {}", (Object)debug2, debug1, var5);
         }

      });
   }

   private CompletableFuture requestMessageProcessing(GameProfile debug1, String debug2, TextFilterClient.IgnoreStrategy debug3, Executor debug4) {
      if(debug2.isEmpty()) {
         return CompletableFuture.completedFuture(Optional.of(""));
      } else {
         JsonObject debug5 = new JsonObject();
         debug5.addProperty("rule", (Number)Integer.valueOf(this.ruleId));
         debug5.addProperty("server", this.serverId);
         debug5.addProperty("room", "Chat");
         debug5.addProperty("player", debug1.getId().toString());
         debug5.addProperty("player_display_name", debug1.getName());
         debug5.addProperty("text", debug2);
         return CompletableFuture.supplyAsync(() -> {
            try {
               JsonObject debug4 = this.processRequestResponse(debug5, this.chatEndpoint);
               boolean debug5x = GsonHelper.getAsBoolean(debug4, "response", false);
               if(debug5x) {
                  return Optional.of(debug2);
               } else {
                  String debug6 = GsonHelper.getAsString(debug4, "hashed", (String)null);
                  if(debug6 == null) {
                     return Optional.empty();
                  } else {
                     int debug7 = GsonHelper.getAsJsonArray(debug4, "hashes").size();
                     return debug3.shouldIgnore(debug6, debug7)?Optional.empty():Optional.of(debug6);
                  }
               }
            } catch (Exception var8) {
               LOGGER.warn((String)"Failed to validate message \'{}\'", (Object)debug2, (Object)var8);
               return Optional.empty();
            }
         }, debug4);
      }
   }

   public void close() {
      this.workerPool.shutdownNow();
   }

   private void drainStream(InputStream debug1) throws IOException {
      byte[] debug2 = new byte[1024];

      while(debug1.read(debug2) != -1) {
         ;
      }

   }

   private JsonObject processRequestResponse(JsonObject debug1, URL debug2) throws IOException {
      HttpURLConnection debug3 = this.makeRequest(debug1, debug2);
      InputStream debug4 = debug3.getInputStream();
      Throwable var5 = null;

      JsonObject var6;
      try {
         if(debug3.getResponseCode() == 204) {
            var6 = new JsonObject();
            return var6;
         }

         try {
            var6 = Streams.parse(new JsonReader(new InputStreamReader(debug4))).getAsJsonObject();
         } finally {
            this.drainStream(debug4);
         }
      } catch (Throwable var23) {
         var5 = var23;
         throw var23;
      } finally {
         if(debug4 != null) {
            if(var5 != null) {
               try {
                  debug4.close();
               } catch (Throwable var21) {
                  var5.addSuppressed(var21);
               }
            } else {
               debug4.close();
            }
         }

      }

      return var6;
   }

   private void processRequest(JsonObject debug1, URL debug2) throws IOException {
      HttpURLConnection debug3 = this.makeRequest(debug1, debug2);
      InputStream debug4 = debug3.getInputStream();
      Throwable var5 = null;

      try {
         this.drainStream(debug4);
      } catch (Throwable var14) {
         var5 = var14;
         throw var14;
      } finally {
         if(debug4 != null) {
            if(var5 != null) {
               try {
                  debug4.close();
               } catch (Throwable var13) {
                  var5.addSuppressed(var13);
               }
            } else {
               debug4.close();
            }
         }

      }

   }

   private HttpURLConnection makeRequest(JsonObject debug1, URL debug2) throws IOException {
      HttpURLConnection debug3 = (HttpURLConnection)debug2.openConnection();
      debug3.setConnectTimeout(15000);
      debug3.setReadTimeout(2000);
      debug3.setUseCaches(false);
      debug3.setDoOutput(true);
      debug3.setDoInput(true);
      debug3.setRequestMethod("POST");
      debug3.setRequestProperty("Content-Type", "application/json; charset=utf-8");
      debug3.setRequestProperty("Accept", "application/json");
      debug3.setRequestProperty("Authorization", "Basic " + this.authKey);
      debug3.setRequestProperty("User-Agent", "Minecraft server" + SharedConstants.getCurrentVersion().getName());
      OutputStreamWriter debug4 = new OutputStreamWriter(debug3.getOutputStream(), StandardCharsets.UTF_8);
      Throwable var5 = null;

      try {
         JsonWriter debug6 = new JsonWriter(debug4);
         Throwable var7 = null;

         try {
            Streams.write(debug1, debug6);
         } catch (Throwable var30) {
            var7 = var30;
            throw var30;
         } finally {
            if(debug6 != null) {
               if(var7 != null) {
                  try {
                     debug6.close();
                  } catch (Throwable var29) {
                     var7.addSuppressed(var29);
                  }
               } else {
                  debug6.close();
               }
            }

         }
      } catch (Throwable var32) {
         var5 = var32;
         throw var32;
      } finally {
         if(debug4 != null) {
            if(var5 != null) {
               try {
                  debug4.close();
               } catch (Throwable var28) {
                  var5.addSuppressed(var28);
               }
            } else {
               debug4.close();
            }
         }

      }

      int debug41 = debug3.getResponseCode();
      if(debug41 >= 200 && debug41 < 300) {
         return debug3;
      } else {
         throw new TextFilterClient.RequestFailedException(debug41 + " " + debug3.getResponseMessage());
      }
   }

   public TextFilter createContext(GameProfile debug1) {
      return new TextFilterClient.PlayerContext(debug1);
   }

   @FunctionalInterface
   public interface IgnoreStrategy {
      TextFilterClient.IgnoreStrategy NEVER_IGNORE = (debug0, debug1) -> {
         return false;
      };
      TextFilterClient.IgnoreStrategy IGNORE_FULLY_FILTERED = (debug0, debug1) -> {
         return debug0.length() == debug1;
      };

      boolean shouldIgnore(String var1, int var2);
   }

   class PlayerContext implements TextFilter {
      private final GameProfile profile;
      private final Executor streamExecutor;

      private PlayerContext(GameProfile debug2) {
         this.profile = debug2;
         ProcessorMailbox debug3 = ProcessorMailbox.create(TextFilterClient.this.workerPool, "chat stream for " + debug2.getName());
         this.streamExecutor = debug3::tell;
      }

      public void join() {
         TextFilterClient.this.processJoinOrLeave(this.profile, TextFilterClient.this.joinEndpoint, this.streamExecutor);
      }

      public void leave() {
         TextFilterClient.this.processJoinOrLeave(this.profile, TextFilterClient.this.leaveEndpoint, this.streamExecutor);
      }

      public CompletableFuture processMessageBundle(List debug1) {
         List debug2 = (List)debug1.stream().map((debug1) -> {
            return TextFilterClient.this.requestMessageProcessing(this.profile, debug1, TextFilterClient.this.chatIgnoreStrategy, this.streamExecutor);
         }).collect(ImmutableList.toImmutableList());
         return Util.sequence(debug2).thenApply((debug0) -> {
            return Optional.of(debug0.stream().map((debug0) -> {
               return (String)debug0.orElse("");
            }).collect(ImmutableList.toImmutableList()));
         }).exceptionally((debug0) -> {
            return Optional.empty();
         });
      }

      public CompletableFuture processStreamMessage(String debug1) {
         return TextFilterClient.this.requestMessageProcessing(this.profile, debug1, TextFilterClient.this.chatIgnoreStrategy, this.streamExecutor);
      }

      // $FF: synthetic method
      PlayerContext(GameProfile debug2, Object debug3) {
         this(debug2);
      }
   }

   public static class RequestFailedException extends RuntimeException {
      private RequestFailedException(String debug1) {
         super(debug1);
      }

      // $FF: synthetic method
      RequestFailedException(String debug1, Object debug2) {
         this(debug1);
      }
   }
}