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

class="kw">import com.hypixel.hytale.codec.util.RawJsonReader;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.protocol.Color;
class="kw">import com.hypixel.hytale.protocol.ColorAlpha;
class="kw">import com.hypixel.hytale.protocol.ColorLight;
class="kw">import java.awt.image.BufferedImage;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.Path;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Collections;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.Random;
class="kw">import java.util.regex.Pattern;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import javax.imageio.ImageIO;

class="kw">public class ColorParseUtil {
   class="kw">public class="kw">static class="kw">final Pattern HEX_COLOR_PATTERN = Pattern.compile("^\\s*#([0-9a-fA-F]{3}){1,2}\\s*$");
   class="kw">public class="kw">static class="kw">final Pattern HEX_ALPHA_COLOR_PATTERN = Pattern.compile("^\\s*#([0-9a-fA-F]{4}){1,2}\\s*$");
   class="kw">public class="kw">static class="kw">final Pattern RGB_COLOR_PATTERN = Pattern.compile("^\\s*rgb\\((\\s*[0-9]{1,3}\\s*,){2}\\s*[0-9]{1,3}\\s*\\)\\s*$");
   class="kw">public class="kw">static class="kw">final Pattern RGBA_COLOR_PATTERN = Pattern.compile("^\\s*rgba\\((\\s*[0-9]{1,3}\\s*,){3}\\s*[0,1](.[0-9]*)?\\s*\\)\\s*$");
   class="kw">public class="kw">static class="kw">final Pattern RGBA_HEX_COLOR_PATTERN = Pattern.compile("^\\s*rgba\\(\\s*#([0-9a-fA-F]{3}){1,2}\\s*,\\s*[0,1](.[0-9]*)?\\s*\\)\\s*$");

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

   @Nullable
   class="kw">public class="kw">static ColorAlpha readColorAlpha(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      var0.consumeWhiteSpace();

      class="kw">return class="kw">switch (var0.peek()) {
         case 35 -> readHexStringToColorAlpha(var0);
         case 114 -> readRgbaStringToColorAlpha(var0);
         class="kw">default -> null;
      };
   }

   @Nullable
   class="kw">public class="kw">static ColorAlpha parseColorAlpha(@Nonnull String var0) {
      if (HEX_ALPHA_COLOR_PATTERN.matcher(var0).matches()) {
         class="kw">return hexStringToColorAlpha(var0);
      } else if (RGBA_HEX_COLOR_PATTERN.matcher(var0).matches()) {
         class="kw">return rgbaHexStringToColor(var0);
      } else {
         class="kw">return RGBA_COLOR_PATTERN.matcher(var0).matches() ? rgbaDecimalStringToColor(var0) : null;
      }
   }

   @Nullable
   class="kw">public class="kw">static Color readColor(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      var0.consumeWhiteSpace();

      class="kw">return class="kw">switch (var0.peek()) {
         case 35 -> readHexStringToColor(var0);
         case 114 -> readRgbStringToColor(var0);
         class="kw">default -> null;
      };
   }

   @Nullable
   class="kw">public class="kw">static Color parseColor(@Nonnull String var0) {
      if (HEX_COLOR_PATTERN.matcher(var0).matches()) {
         class="kw">return hexStringToColor(var0);
      } else {
         class="kw">return RGB_COLOR_PATTERN.matcher(var0).matches() ? rgbStringToColor(var0) : null;
      }
   }

   @Nonnull
   class="kw">public class="kw">static Color readHexStringToColor(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      int var1 = readHexAlphaStringToRGBAInt(var0);
      class="kw">return new Color((byte)(var1 >> 24 & 0xFF), (byte)(var1 >> 16 & 0xFF), (byte)(var1 >> 8 & 0xFF));
   }

   @Nonnull
   class="kw">public class="kw">static Color hexStringToColor(String var0) {
      int var1 = hexAlphaStringToRGBAInt(var0);
      class="kw">return new Color((byte)(var1 >> 24 & 0xFF), (byte)(var1 >> 16 & 0xFF), (byte)(var1 >> 8 & 0xFF));
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha readHexStringToColorAlpha(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      int var1 = readHexAlphaStringToRGBAInt(var0);
      class="kw">return new ColorAlpha((byte)(var1 & 0xFF), (byte)(var1 >> 24 & 0xFF), (byte)(var1 >> 16 & 0xFF), (byte)(var1 >> 8 & 0xFF));
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha hexStringToColorAlpha(String var0) {
      int var1 = hexAlphaStringToRGBAInt(var0);
      class="kw">return new ColorAlpha((byte)(var1 & 0xFF), (byte)(var1 >> 24 & 0xFF), (byte)(var1 >> 16 & 0xFF), (byte)(var1 >> 8 & 0xFF));
   }

   class="kw">public class="kw">static int readHexAlphaStringToRGBAInt(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      var0.consumeWhiteSpace();
      var0.expect('#');
      var0.mark();

      try {
         int var1 = var0.readIntValue(16);
         int var2 = var0.getMarkDistance();
         class="kw">switch (var2) {
            case 3:
               var1 <<= 4;
               var1 |= 15;
            case 4:
               int var3 = var1 >> 12 & 15;
               int var4 = var1 >> 8 & 15;
               int var5 = var1 >> 4 & 15;
               int var6 = var1 & 15;
               class="kw">return var3 << 28 | var3 << 24 | var4 << 20 | var4 << 16 | var5 << 12 | var5 << 8 | var6 << 4 | var6;
            case 5:
            case 7:
            class="kw">default:
               throw new IllegalArgumentException("Invalid hex color size: " + var2);
            case 6:
               class="kw">return var1 << 8 | 0xFF;
            case 8:
               class="kw">return var1;
         }
      } class="kw">finally {
         var0.unmark();
         var0.consumeWhiteSpace();
      }
   }

   class="kw">public class="kw">static int hexAlphaStringToRGBAInt(String var0) {
      Objects.requireNonNull(var0, "Color must not be null");
      var0 = var0.trim();
      if (!var0.isEmpty() && var0.charAt(0) == '#') {
         var0 = var0.substring(1);
         int var1 = (int)Long.parseLong(var0, 16);
         class="kw">switch (var0.length()) {
            case 3:
               var1 <<= 4;
               var1 |= 15;
            case 4:
               int var2 = var1 >> 12 & 15;
               int var3 = var1 >> 8 & 15;
               int var4 = var1 >> 4 & 15;
               int var5 = var1 & 15;
               class="kw">return var2 << 28 | var2 << 24 | var3 << 20 | var3 << 16 | var4 << 12 | var4 << 8 | var5 << 4 | var5;
            case 5:
            case 7:
            class="kw">default:
               throw new IllegalArgumentException("Invalid hex color format: '" + var0 + "'");
            case 6:
               class="kw">return var1 << 8 | 0xFF;
            case 8:
               class="kw">return var1;
         }
      } else {
         throw new IllegalArgumentException("Hex color must start with '#'");
      }
   }

   class="kw">public class="kw">static int readHexStringToRGBInt(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      class="kw">return readHexAlphaStringToRGBAInt(var0) >>> 8;
   }

   class="kw">public class="kw">static int hexStringToRGBInt(String var0) {
      class="kw">return hexAlphaStringToRGBAInt(var0) >>> 8;
   }

   @Nonnull
   class="kw">public class="kw">static String colorToHexString(@Nullable Color var0) {
      class="kw">return var0 == null ? "#FFFFFF" : toHexString(var0.red, var0.green, var0.blue);
   }

   @Nonnull
   class="kw">public class="kw">static String colorToHexAlphaString(@Nullable ColorAlpha var0) {
      class="kw">return var0 == null ? "#FFFFFFFF" : toHexAlphaString(var0.red, var0.green, var0.blue, var0.alpha);
   }

   @Nonnull
   class="kw">public class="kw">static Color readRgbStringToColor(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      var0.consumeWhiteSpace();
      var0.expect("rgb(", 0);
      var0.consumeWhiteSpace();
      byte var1 = var0.readByteValue();
      var0.consumeWhiteSpace();
      var0.expect(',');
      var0.consumeWhiteSpace();
      byte var2 = var0.readByteValue();
      var0.consumeWhiteSpace();
      var0.expect(',');
      var0.consumeWhiteSpace();
      byte var3 = var0.readByteValue();
      var0.consumeWhiteSpace();
      var0.expect(')');
      var0.consumeWhiteSpace();
      class="kw">return new Color(var1, var2, var3);
   }

   @Nonnull
   class="kw">public class="kw">static Color rgbStringToColor(String var0) {
      Objects.requireNonNull(var0, "Color must not be null");
      var0 = var0.trim();
      if (var0.startsWith("rgb(") && var0.charAt(var0.length() - 1) == ')') {
         var0 = var0.substring(4, var0.length() - 1);
         String[] var1 = var0.split(",", 0);
         int var2 = var1.length;
         if (var2 != 3) {
            throw new IllegalArgumentException("rgb() but contain all 3 channels; r, g and b");
         }

         byte var3 = (byte)Integer.parseInt(var1[0].trim());
         byte var4 = (byte)Integer.parseInt(var1[1].trim());
         byte var5 = (byte)Integer.parseInt(var1[2].trim());
         class="kw">return new Color(var3, var4, var5);
      } else {
         throw new IllegalArgumentException("Color must start with 'rgb(' and end with ')'");
      }
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha readRgbaStringToColorAlpha(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      var0.consumeWhiteSpace();
      var0.expect("rgba(", 0);
      var0.consumeWhiteSpace();
      class="kw">return var0.peek() == 35 ? readRgbaHexStringToColor(var0, false) : readRgbaDecimalStringToColor(var0, false);
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha readRgbaDecimalStringToColor(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      class="kw">return readRgbaDecimalStringToColor(var0, true);
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha readRgbaDecimalStringToColor(@Nonnull RawJsonReader var0, boolean var1) class="kw">throws IOException {
      if (var1) {
         var0.consumeWhiteSpace();
         var0.expect("rgba(", 0);
         var0.consumeWhiteSpace();
      }

      byte var2 = var0.readByteValue();
      var0.consumeWhiteSpace();
      var0.expect(',');
      var0.consumeWhiteSpace();
      byte var3 = var0.readByteValue();
      var0.consumeWhiteSpace();
      var0.expect(',');
      var0.consumeWhiteSpace();
      byte var4 = var0.readByteValue();
      var0.consumeWhiteSpace();
      var0.expect(',');
      var0.consumeWhiteSpace();
      byte var5 = (byte)MathUtil.clamp(var0.readFloatValue() * 255.0F, 0.0F, 255.0F);
      var0.consumeWhiteSpace();
      var0.expect(')');
      var0.consumeWhiteSpace();
      class="kw">return new ColorAlpha(var5, var2, var3, var4);
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha rgbaDecimalStringToColor(String var0) {
      Objects.requireNonNull(var0, "Color must not be null");
      var0 = var0.trim();
      if (var0.startsWith("rgba(") && var0.charAt(var0.length() - 1) == ')') {
         var0 = var0.substring(5, var0.length() - 1);
         String[] var1 = var0.split(",", 0);
         int var2 = var1.length;
         if (var2 != 4) {
            throw new IllegalArgumentException("rgba() but contain all 4 channels; r, g, b and a");
         }

         byte var3 = (byte)MathUtil.clamp(Integer.parseInt(var1[0].trim()), 0, 255);
         byte var4 = (byte)MathUtil.clamp(Integer.parseInt(var1[1].trim()), 0, 255);
         byte var5 = (byte)MathUtil.clamp(Integer.parseInt(var1[2].trim()), 0, 255);
         byte var6 = (byte)MathUtil.clamp(Float.parseFloat(var1[3]) * 255.0F, 0.0F, 255.0F);
         class="kw">return new ColorAlpha(var6, var3, var4, var5);
      } else {
         throw new IllegalArgumentException("Color must start with 'rgba(' and end with ')'");
      }
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha readRgbaHexStringToColor(@Nonnull RawJsonReader var0) class="kw">throws IOException {
      class="kw">return readRgbaHexStringToColor(var0, true);
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha readRgbaHexStringToColor(@Nonnull RawJsonReader var0, boolean var1) class="kw">throws IOException {
      if (var1) {
         var0.consumeWhiteSpace();
         var0.expect("rgba(", 0);
         var0.consumeWhiteSpace();
      }

      long var2 = readHexAlphaStringToRGBAInt(var0);
      var0.consumeWhiteSpace();
      var0.expect(',');
      var0.consumeWhiteSpace();
      byte var4 = (byte)MathUtil.clamp(var0.readFloatValue() * 255.0F, 0.0F, 255.0F);
      var0.consumeWhiteSpace();
      var0.expect(')');
      var0.consumeWhiteSpace();
      class="kw">return new ColorAlpha(var4, (byte)(var2 >> 24 & 255L), (byte)(var2 >> 16 & 255L), (byte)(var2 >> 8 & 255L));
   }

   @Nonnull
   class="kw">public class="kw">static ColorAlpha rgbaHexStringToColor(String var0) {
      Objects.requireNonNull(var0, "Color must not be null");
      var0 = var0.trim();
      if (var0.startsWith("rgba(") && var0.charAt(var0.length() - 1) == ')') {
         var0 = var0.substring(5, var0.length() - 1);
         String[] var1 = var0.split(",", 0);
         int var2 = var1.length;
         if (var2 != 2) {
            throw new IllegalArgumentException("rgba() but contain both #rgb and a");
         }

         long var3 = hexAlphaStringToRGBAInt(var1[0].trim());
         byte var5 = (byte)MathUtil.clamp(Float.parseFloat(var1[1]) * 255.0F, 0.0F, 255.0F);
         class="kw">return new ColorAlpha(var5, (byte)(var3 >> 24 & 255L), (byte)(var3 >> 16 & 255L), (byte)(var3 >> 8 & 255L));
      } else {
         throw new IllegalArgumentException("Color must start with 'rgba(' and end with ')'");
      }
   }

   @Nonnull
   class="kw">public class="kw">static String colorToHex(@Nullable java.awt.Color var0) {
      if (var0 == null) {
         class="kw">return "#FFFFFF";
      }

      int var1 = var0.getRGB();
      int var2 = var1 & 16777215;
      class="kw">return toHexString(var2);
   }

   @Nonnull
   class="kw">public class="kw">static String colorToHexAlpha(@Nullable java.awt.Color var0) {
      if (var0 == null) {
         class="kw">return "#FFFFFFFF";
      }

      int var1 = var0.getRGB();
      int var2 = var1 >> 24 & 0xFF;
      int var3 = var1 & 16777215;
      int var4 = var3 << 8 | var2;
      class="kw">return toHexAlphaString(var4);
   }

   class="kw">public class="kw">static int colorToARGBInt(@Nullable Color var0) {
      class="kw">return var0 == null ? -1 : 0xFF000000 | (var0.red & 0xFF) << 16 | (var0.green & 0xFF) << 8 | var0.blue & 0xFF;
   }

   class="kw">public class="kw">static Color argbIntToColor(int var0) {
      class="kw">return new Color((byte)(var0 >> 16 & 0xFF), (byte)(var0 >> 8 & 0xFF), (byte)(var0 & 0xFF));
   }

   class="kw">public class="kw">static void hexStringToColorLightDirect(@Nonnull ColorLight var0, @Nonnull String var1) {
      if (var1.length() == 4) {
         var0.red = Byte.parseByte(var1.substring(1, 2), 16);
         var0.green = Byte.parseByte(var1.substring(2, 3), 16);
         var0.blue = Byte.parseByte(var1.substring(3, 4), 16);
      } else {
         var0.red = (byte)(Integer.parseInt(var1.substring(1, 3), 16) / 17);
         var0.green = (byte)(Integer.parseInt(var1.substring(3, 5), 16) / 17);
         var0.blue = (byte)(Integer.parseInt(var1.substring(5, 7), 16) / 17);
      }
   }

   @Nonnull
   class="kw">public class="kw">static String colorLightToHexString(@Nonnull ColorLight var0) {
      class="kw">return toHexString((byte)(var0.red * 17), (byte)(var0.green * 17), (byte)(var0.blue * 17));
   }

   @Nonnull
   class="kw">public class="kw">static String toHexString(byte var0, byte var1, byte var2) {
      class="kw">return toHexString((var0 & 255) << 16 | (var1 & 255) << 8 | var2 & 255);
   }

   @Nonnull
   class="kw">public class="kw">static String toHexString(int var0) {
      String var1 = Integer.toHexString(var0);
      class="kw">return "#" + "0".repeat(6 - var1.length()) + var1;
   }

   @Nonnull
   class="kw">public class="kw">static String toHexAlphaString(byte var0, byte var1, byte var2, byte var3) {
      class="kw">return toHexAlphaString((var0 & 255) << 24 | (var1 & 255) << 16 | (var2 & 255) << 8 | var3 & 255);
   }

   @Nonnull
   class="kw">public class="kw">static String toHexAlphaString(int var0) {
      String var1 = Integer.toHexString(var0);
      class="kw">return "#" + "0".repeat(8 - var1.length()) + var1;
   }

   @Nullable
   class="kw">public class="kw">static String computeDominantColor(@Nonnull Path var0) class="kw">throws Exception {
      BufferedImage var1 = ImageIO.read(var0.toFile());
      if (var1 == null) {
         class="kw">return null;
      }

      ArrayList var2 = new ArrayList<>();

      for (int var3 = 0; var3 < var1.getHeight(); var3++) {
         for (int var4 = 0; var4 < var1.getWidth(); var4++) {
            int var5 = var1.getRGB(var4, var3);
            int var6 = var5 >> 24 & 0xFF;
            if (var6 >= 128) {
               var2.add(new int[]{var5 >> 16 & 0xFF, var5 >> 8 & 0xFF, var5 & 0xFF});
            }
         }
      }

      if (var2.isEmpty()) {
         class="kw">return null;
      }

      if (var2.size() < 8) {
         double var21 = 0.0;
         double var25 = 0.0;
         double var29 = 0.0;

         for (int[] var10 : var2) {
            var21 += var10[0];
            var25 += var10[1];
            var29 += var10[2];
         }

         var21 /= var2.size();
         var25 /= var2.size();
         var29 /= var2.size();
         class="kw">return String.format("#%02X%02X%02X", (int)var21, (int)var25, (int)var29);
      } else {
         Random var20 = new Random(42L);
         if (var2.size() > 512) {
            Collections.shuffle(var2, var20);
            var2 = new ArrayList<>(var2.subList(0, 512));
         }

         List var23 = kmeans(var2, 4, var20);
         if (var23.isEmpty()) {
            class="kw">return null;
         }

         int var24 = 0;

         for (ColorParseUtil.KMeansCluster var7 : var23) {
            var24 += var7.count;
         }

         double var28 = 2.0;
         double[] var8 = new double[var23.size()];
         double var9 = 0.0;

         for (int var11 = 0; var11 < var23.size(); var11++) {
            var8[var11] = Math.pow((double)var23.get(var11).count / var24, var28);
            var9 += var8[var11];
         }

         double var32 = 0.0;
         double var13 = 0.0;
         double var15 = 0.0;

         for (int var17 = 0; var17 < var23.size(); var17++) {
            double var18 = var8[var17] / var9;
            var32 += var23.get(var17).centroid[0] * var18;
            var13 += var23.get(var17).centroid[1] * var18;
            var15 += var23.get(var17).centroid[2] * var18;
         }

         int var33 = Math.clamp((int)var32, 0, 255);
         int var34 = Math.clamp((int)var13, 0, 255);
         int var19 = Math.clamp((int)var15, 0, 255);
         class="kw">return String.format("#%02X%02X%02X", var33, var34, var19);
      }
   }

   class="kw">private class="kw">static List<ColorParseUtil.KMeansCluster> kmeans(List<int[]> var0, int var1, Random var2) {
      int var3 = var0.size();
      ArrayList var4 = new ArrayList<>();
      int[] var5 = var0.get(var2.nextInt(var3));
      var4.add(new double[]{var5[0], var5[1], var5[2]});

      for (int var6 = 1; var6 < var1; var6++) {
         double[] var7 = new double[var3];
         double var8 = 0.0;

         for (int var10 = 0; var10 < var3; var10++) {
            double var11 = Double.MAX_VALUE;

            for (double[] var14 : var4) {
               double var15 = distSq(var0.get(var10), var14);
               if (var15 < var11) {
                  var11 = var15;
               }
            }

            var7[var10] = var11;
            var8 += var11;
         }

         if (var8 == 0.0) {
            break;
         }

         double var30 = var2.nextDouble() * var8;
         double var12 = 0.0;

         for (int var40 = 0; var40 < var3; var40++) {
            var12 += var7[var40];
            if (var12 >= var30) {
               int[] var43 = var0.get(var40);
               var4.add(new double[]{var43[0], var43[1], var43[2]});
               break;
            }
         }
      }

      int var26 = var4.size();
      int[] var27 = new int[var3];
      int var28 = 10;

      for (int var9 = 0; var9 < var28; var9++) {
         for (int var31 = 0; var31 < var3; var31++) {
            double var34 = Double.MAX_VALUE;

            for (int var39 = 0; var39 < var26; var39++) {
               double var41 = distSq(var0.get(var31), var4.get(var39));
               if (var41 < var34) {
                  var34 = var41;
                  var27[var31] = var39;
               }
            }
         }

         boolean var32 = true;

         for (int var35 = 0; var35 < var26; var35++) {
            double var37 = 0.0;
            double var42 = 0.0;
            double var16 = 0.0;
            int var18 = 0;

            for (int var19 = 0; var19 < var3; var19++) {
               if (var27[var19] == var35) {
                  var37 += ((int[])var0.get(var19))[0];
                  var42 += ((int[])var0.get(var19))[1];
                  var16 += ((int[])var0.get(var19))[2];
                  var18++;
               }
            }

            if (var18 != 0) {
               double var44 = var37 / var18;
               double var21 = var42 / var18;
               double var23 = var16 / var18;
               double[] var25 = var4.get(var35);
               if (Math.abs(var44 - var25[0]) > 1.0 || Math.abs(var21 - var25[1]) > 1.0 || Math.abs(var23 - var25[2]) > 1.0) {
                  var32 = false;
               }

               var4.set(var35, new double[]{var44, var21, var23});
            }
         }

         if (var32) {
            break;
         }
      }

      ArrayList var29 = new ArrayList<>();

      for (int var33 = 0; var33 < var26; var33++) {
         int var36 = 0;

         for (int var38 = 0; var38 < var3; var38++) {
            if (var27[var38] == var33) {
               var36++;
            }
         }

         var29.add(new ColorParseUtil.KMeansCluster(var4.get(var33), var36));
      }

      class="kw">return var29;
   }

   class="kw">private class="kw">static double distSq(int[] var0, double[] var1) {
      double var2 = var0[0] - var1[0];
      double var4 = var0[1] - var1[1];
      double var6 = var0[2] - var1[2];
      class="kw">return var2 * var2 + var4 * var4 + var6 * var6;
   }

   class="kw">private record KMeansCluster(double[] centroid, int count) {
      class="kw">private KMeansCluster {
      }
   }
}