package com.l7tech.common.log;

import com.l7tech.util.CollectionUtils;
import com.l7tech.util.Functions;
import com.l7tech.util.Functions.Binary;
import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicReference;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class HybridDiagnosticContextMatcher {
   private static final AtomicReference<HybridDiagnosticContextMatcher.MatcherRules> a;
   private static final Binary<Boolean, String, String> b;
   private static final String[] c;

   public static boolean matches(@NotNull HybridDiagnosticContextMatcher.MatcherRules var0) {
      try {
         if (var0 == null) {
            a(0);
         }
      } catch (IllegalArgumentException var6) {
         throw a(var6);
      }

      boolean var1 = true;

      for (Entry var3 : var0.template.entrySet()) {
         Collection var4 = HybridDiagnosticContext.a((String)var3.getKey());

         label48: {
            try {
               if (!var0.isPrefixMatch((String)var3.getKey())) {
                  if (CollectionUtils.containsAny(var4, (Collection)var3.getValue())) {
                     continue;
                  }
                  break label48;
               }
            } catch (IllegalArgumentException var5) {
               throw a(var5);
            }

            if (CollectionUtils.matchesAny(var4, (Collection)var3.getValue(), b)) {
               continue;
            }

            var1 = false;
            break;
         }

         var1 = false;
         break;
      }

      return var1;
   }

   public static boolean matches() {
      return matches(getDefaultRules());
   }

   @NotNull
   public static HybridDiagnosticContextMatcher.MatcherRules getDefaultRules() {
      try {
         HybridDiagnosticContextMatcher.MatcherRules var10000 = a.get();
         if (var10000 == null) {
            a(1);
         }

         return var10000;
      } catch (IllegalArgumentException var0) {
         throw a(var0);
      }
   }

   @NotNull
   public static HybridDiagnosticContextMatcher.MatcherRules setDefaultRules(@Nullable HybridDiagnosticContextMatcher.MatcherRules var0) {
      AtomicReference var10000;
      HybridDiagnosticContextMatcher.MatcherRules var10001;
      label24: {
         try {
            var10000 = a;
            if (var0 == null) {
               var10001 = new HybridDiagnosticContextMatcher.MatcherRules();
               break label24;
            }
         } catch (IllegalArgumentException var2) {
            throw a(var2);
         }

         var10001 = var0;
      }

      try {
         HybridDiagnosticContextMatcher.MatcherRules var3 = var10000.getAndSet(var10001);
         if (var3 == null) {
            a(2);
         }

         return var3;
      } catch (IllegalArgumentException var1) {
         throw a(var1);
      }
   }

   static {
      String[] var5 = new String[8];
      int var3 = 0;
      String var2 = "\u0005\u0006j\u000b*)c0Tk\u00115lM\n\u001by02 ad\u0004l\f&!h0\u0011\u007f^`i~cTb\u0018gi~jQ~^*9~0Tc\u00113lo!Tc\u000b+ \u00056\u0001a\u001b44'\u001b`Q+{y!\u0017eQ$#`)\u001bcQ+#jk<t\u001c5%i\u0000\u001dl\u0019)#~0\u001dn=(\"y!\fy3&8n,\u0011\u007f*\u0004:b\n\t9a(T`\u001b3$b T(\rii~d\u0019x\r3lc+\u0000-\f\"8x6\u001a-\u00102 a\u0007)\u0015y\u001d/)~4'\u001b`Q+{y!\u0017eQ$#`)\u001bcQ+#jk<t\u001c5%i\u0000\u001dl\u0019)#~0\u001dn=(\"y!\fy3&8n,\u0011\u007f";
      int var4 = "\u0005\u0006j\u000b*)c0Tk\u00115lM\n\u001by02 ad\u0004l\f&!h0\u0011\u007f^`i~cTb\u0018gi~jQ~^*9~0Tc\u00113lo!Tc\u000b+ \u00056\u0001a\u001b44'\u001b`Q+{y!\u0017eQ$#`)\u001bcQ+#jk<t\u001c5%i\u0000\u001dl\u0019)#~0\u001dn=(\"y!\fy3&8n,\u0011\u007f*\u0004:b\n\t9a(T`\u001b3$b T(\rii~d\u0019x\r3lc+\u0000-\f\"8x6\u001a-\u00102 a\u0007)\u0015y\u001d/)~4'\u001b`Q+{y!\u0017eQ$#`)\u001bcQ+#jk<t\u001c5%i\u0000\u001dl\u0019)#~0\u001dn=(\"y!\fy3&8n,\u0011\u007f"
         .length();
      char var1 = '>';
      int var7 = -1;

      label24:
      while (true) {
         byte var10000 = 123;
         String var10001 = var2.substring(++var7, var7 + var1);
         byte var10002 = -1;

         while (true) {
            String var8 = a(var10000, a(var10001));
            switch (var10002) {
               case 0:
                  var5[var3++] = var8;
                  if ((var7 += var1) >= var4) {
                     c = var5;
                     a = new AtomicReference<>(new HybridDiagnosticContextMatcher.MatcherRules());
                     b = new c();
                     return;
                  }

                  var1 = var2.charAt(var7);
                  break;
               default:
                  var5[var3++] = var8;
                  if ((var7 += var1) < var4) {
                     var1 = var2.charAt(var7);
                     continue label24;
                  }

                  var2 = "sU=~fn(u\\=hvd,s\u000fgU=~fn(u\\=hvd,s";
                  var4 = "sU=~fn(u\\=hvd,s\u000fgU=~fn(u\\=hvd,s".length();
                  var1 = 15;
                  var7 = -1;
            }

            var10000 = 63;
            var10001 = var2.substring(++var7, var7 + var1);
            var10002 = 0;
         }
      }
   }

   private static IllegalArgumentException a(IllegalArgumentException var0) {
      return var0;
   }

   private static char[] a(String var0) {
      char[] var10000 = var0.toCharArray();
      if (var10000.length < 2) {
         var10000[0] = (char)(var10000[0] ^ 118);
      }

      return var10000;
   }

   private static String a(int var0, char[] var1) {
      int var10003 = var1.length;
      int var10002 = var0;
      char[] var10001 = var1;
      int var10000 = var10003;

      for (int var2 = 0; var10000 > var2; var2++) {
         var10001[var2] = (char)(var10001[var2] ^ var10002 ^ switch (var2 % 7) {
            case 0 -> 63;
            case 1 -> 15;
            case 2 -> 118;
            case 3 -> 5;
            case 4 -> 60;
            case 5 -> 55;
            default -> 118;
         });
      }

      return new String(var10001).intern();
   }

   public static final class MatcherRules implements Serializable {
      private static final long serialVersionUID = 1L;
      private final Map<String, List<String>> template;
      private final Set<String> prefixTemplates;

      public MatcherRules() {
         this.template = Collections.emptyMap();
         this.prefixTemplates = Collections.emptySet();
      }

      public MatcherRules(Map<String, List<String>> var1, Collection<String> var2) {
         this.template = Collections.unmodifiableMap(Functions.map(var1, null, Functions.identity(), new d(this)));
         this.prefixTemplates = var2 == null ? Collections.emptySet() : Collections.unmodifiableSet(new HashSet<>(var2));
      }

      private boolean isPrefixMatch(String var1) {
         return this.prefixTemplates != null && this.prefixTemplates.contains(var1);
      }
   }
}