package com.l7tech.policy;

import com.l7tech.policy.assertion.Assertion;
import com.l7tech.policy.assertion.AssertionMetadata;
import com.l7tech.policy.assertion.DefaultAssertionMetadata;
import com.l7tech.policy.wsp.AssertionMapping;
import com.l7tech.policy.wsp.TypeMapping;
import com.l7tech.policy.wsp.TypeMappingFinder;
import com.l7tech.policy.wsp.TypeMappingUtils;
import com.l7tech.policy.wsp.WspConstants;
import com.l7tech.util.ClassUtils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Logger;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;

public class AssertionRegistry implements AssertionFinder, TypeMappingFinder, ApplicationContextAware, InitializingBean, DisposableBean {
   protected static final Logger logger;
   private static final AtomicBoolean a;
   public static final String POLICY_GUID_RESOLVER_MAPPING_PROPERTY;
   public static final String ENCASS_GUID_RESOLVER_MAPPING_PROPERTY;
   private static final Map<String, Object> b;
   private final Map<String, Assertion> c = new ConcurrentHashMap<>();
   private final Map<String, Assertion> d = new ConcurrentHashMap<>();
   private ApplicationContext e;
   private boolean f = false;
   private static final String[] g;

   public AssertionRegistry() {
      installEnhancedMetadataDefaults();
   }

   protected void addAssertionMappingProperty(String var1, Object var2) {
      b.put(var1, var2);
   }

   public final void setApplicationContext(ApplicationContext var1) throws BeansException {
      this.e = var1;

      for (Assertion var5 : AllAssertions.SERIALIZABLE_EVERYTHING) {
         this.registerAssertion((Class<? extends Assertion>)var5.getClass());
      }

      this.onApplicationContextSet();
   }

   protected void onApplicationContextSet() {
   }

   public ApplicationContext getApplicationContext() {
      return this.e;
   }

   public synchronized Assertion registerAssertion(Class<? extends Assertion> var1) {
      try {
         Assertion var2 = (Assertion)var1.getDeclaredConstructor().newInstance();
         Assertion var3 = this.c.put(var1.getName(), var2);
         Object var4 = var2.meta().get(g[4]);

         try {
            if (var4 instanceof String) {
               this.d.put((String)var4, var2);
            }
         } catch (InstantiationException var5) {
            throw a(var5);
         }

         try {
            if (var3 != null) {
               this.publishEvent(new AssertionUnregistrationEvent(this, var3));
            }
         } catch (InstantiationException var6) {
            throw a(var6);
         }

         this.publishEvent(new AssertionRegistrationEvent(this, var2));
         return var2;
      } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException var7) {
         throw new RuntimeException(var7);
      }
   }

   protected void publishEvent(ApplicationEvent var1) {
      ApplicationContext var2 = this.getApplicationContext();

      try {
         if (var2 != null) {
            var2.publishEvent(var1);
         }
      } catch (RuntimeException var3) {
         throw a(var3);
      }
   }

   protected synchronized boolean unregisterAssertion(Assertion var1) {
      Class var2 = var1.getClass();
      String var3 = var2.getName();
      Iterator var4 = this.d.values().iterator();

      while (var4.hasNext()) {
         Assertion var5 = (Assertion)var4.next();

         try {
            if (var5.getClass().getName().equals(var3)) {
               var4.remove();
            }
         } catch (RuntimeException var8) {
            throw a(var8);
         }
      }

      boolean var9 = false;
      Iterator var6 = this.c.values().iterator();

      while (var6.hasNext()) {
         Assertion var7 = (Assertion)var6.next();
         if (var7.getClass().getName().equals(var3)) {
            var9 = true;
            var6.remove();
         }
      }

      Assertion.clearCachedMetadata(var3);
      return var9;
   }

   protected Set<String> getAssertionClassnames() {
      HashSet var1 = new HashSet();

      for (Assertion var3 : this.c.values()) {
         var1.add(var3.getClass().getName());
      }

      return var1;
   }

   public boolean isAssertionRegistered(String var1) {
      return this.getAssertionClassnames().contains(var1);
   }

   @Override
   public Set<Assertion> getAssertions() {
      return new HashSet<>(this.c.values());
   }

   public Assertion findByExternalName(String var1) {
      return this.d.get(var1);
   }

   public Assertion findByClassName(String var1) {
      return this.c.get(var1);
   }

   @Override
   public TypeMapping getTypeMapping(String var1) {
      Assertion var2 = this.findByExternalName(var1);

      try {
         if (var2 != null) {
            return var2.meta().get(g[7]);
         }
      } catch (RuntimeException var8) {
         throw a(var8);
      }

      for (Assertion var4 : this.getAssertions()) {
         Map var5 = var4.meta().get(g[9]);
         if (var5 != null) {
            TypeMapping var6 = (TypeMapping)var5.get(var1);

            try {
               if (var6 != null) {
                  return var6;
               }
            } catch (RuntimeException var7) {
               throw a(var7);
            }
         }
      }

      return null;
   }

   @Override
   public TypeMapping getTypeMapping(Type var1, String var2) {
      Class var3 = TypeMappingUtils.getClassForType(var1);
      if (Assertion.class.isAssignableFrom(var3)) {
         try {
            Assertion var4 = (Assertion)var3.newInstance();
            return var4.meta().get(g[2]);
         } catch (InstantiationException | IllegalAccessException var5) {
            throw new RuntimeException(var5);
         }
      } else {
         return null;
      }
   }

   public static void installEnhancedMetadataDefaults() {
      try {
         if (a.get()) {
            return;
         }
      } catch (RuntimeException var1) {
         throw a(var1);
      }

      String[] var0 = g;
      DefaultAssertionMetadata.putDefaultGetter(var0[3], new b());
      DefaultAssertionMetadata.putDefaultGetter(var0[12], new c());
      DefaultAssertionMetadata.putDefaultGetter(var0[8], new d());
      DefaultAssertionMetadata.putDefaultGetter(var0[1], new f());
      DefaultAssertionMetadata.putDefaultGetter(var0[7], new g());
      DefaultAssertionMetadata.putDefaultGetter(var0[5], new h());
      DefaultAssertionMetadata.putDefaultGetter(var0[10], new i());
      a.set(true);
   }

   private static Object a(Object var0) {
      try {
         if (var0 instanceof AssertionMapping) {
            ((AssertionMapping)var0).setProperties(b);
         }

         return var0;
      } catch (RuntimeException var1) {
         throw a(var1);
      }
   }

   public static boolean isCoreAssertion(Class var0) {
      for (Assertion var4 : AllAssertions.SERIALIZABLE_EVERYTHING) {
         try {
            if (var4.getClass() == var0) {
               return true;
            }
         } catch (RuntimeException var6) {
            throw a(var6);
         }
      }

      for (Assertion var10 : AllAssertions.GATEWAY_EVERYTHING) {
         try {
            if (var10.getClass() == var0) {
               return true;
            }
         } catch (RuntimeException var5) {
            throw a(var5);
         }
      }

      return false;
   }

   private static String a(AssertionMetadata var0, String var1, String var2) {
      Class var3 = var0.getAssertionClass();
      String var4 = var3.getName();
      String var5 = ClassUtils.getClassName(var4);
      String var6 = DefaultAssertionMetadata.basepack(var0);
      String var7 = ClassUtils.stripPrefix(var4, var6 + ".");

      try {
         if (!isCoreAssertion(var3)) {
            return var6 + "." + var2.toLowerCase() + "." + var2 + var5;
         }
      } catch (RuntimeException var13) {
         throw a(var13);
      }

      String[] var12 = g;
      var7 = ClassUtils.stripPrefix(var7, var12[13]);
      var7 = ClassUtils.stripPrefix(var7, var12[6]);
      var7 = ClassUtils.stripSuffix(var7, var5);
      var7 = ClassUtils.stripSuffix(var7, ".");
      if (var7.length() > 0) {
         var7 = var7 + ".";
      }

      String var8 = var5;
      String var9 = var2;
      String var10 = var7;
      String var11 = var1;
      return var6 + "." + var11 + g[0] + var10 + var9 + var8;
   }

   public void afterPropertiesSet() throws Exception {
      WspConstants.setTypeMappingFinder(this);
   }

   protected boolean isShuttingDown() {
      return this.f;
   }

   public synchronized void destroy() throws Exception {
      this.f = true;
   }

   static {
      String[] var5 = new String[15];
      int var3 = 0;
      String var2 = "`O,D7\u000e\u0001`^0[;\u001f\f'P-\u0006\u0015>P/A=\u00146![&f?\u0000\u001d\b^ \\1\u001f\u0001\u00169L3|'\u001d\u001d\u0003^3X7\u0003\u001f\u0007Q0\\?\u0003\u001b+\u0018=Z1^;\u001f9=L&Z*\u0004\u0017 |/I-\u001e\u0016/R&\u000f9L3m&\u0019\u001d<Q\"D\u0010\f\u0015+\f;L&L\u001c\u0014;\"V&F*\n/L0M,\u0019\u0011!Qm\u00169L3|'\u001d\u001d\u0003^3X7\u0003\u001f\u0007Q0\\?\u0003\u001b+\u0010/L0M,\u0019\u0011!Q\u0005I=\u0019\u0017<F\u00189L3k1\u0000\b/K*J7\u0001\u0011:F\u000eI.\u001d\u0011 X0\u000e(Z\"\\+\u001f\u001d\u001dZ7f?\u0000\u001d\u0012+Q I-\u001e?;V'z;\u001e\u0017\"I&Z\u0018-S*M0\u00199=L&Z*\u0004\u0017 |/I-\u001e\u0016/R&";
      int var4 = "`O,D7\u000e\u0001`^0[;\u001f\f'P-\u0006\u0015>P/A=\u00146![&f?\u0000\u001d\b^ \\1\u001f\u0001\u00169L3|'\u001d\u001d\u0003^3X7\u0003\u001f\u0007Q0\\?\u0003\u001b+\u0018=Z1^;\u001f9=L&Z*\u0004\u0017 |/I-\u001e\u0016/R&\u000f9L3m&\u0019\u001d<Q\"D\u0010\f\u0015+\f;L&L\u001c\u0014;\"V&F*\n/L0M,\u0019\u0011!Qm\u00169L3|'\u001d\u001d\u0003^3X7\u0003\u001f\u0007Q0\\?\u0003\u001b+\u0010/L0M,\u0019\u0011!Q\u0005I=\u0019\u0017<F\u00189L3k1\u0000\b/K*J7\u0001\u0011:F\u000eI.\u001d\u0011 X0\u000e(Z\"\\+\u001f\u001d\u001dZ7f?\u0000\u001d\u0012+Q I-\u001e?;V'z;\u001e\u0017\"I&Z\u0018-S*M0\u00199=L&Z*\u0004\u0017 |/I-\u001e\u0016/R&"
         .length();
      char var1 = 18;
      int var7 = -1;

      label24:
      while (true) {
         byte var10000 = 15;
         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) {
                     g = var5;
                     String[] var9 = g;
                     POLICY_GUID_RESOLVER_MAPPING_PROPERTY = g[14];
                     ENCASS_GUID_RESOLVER_MAPPING_PROPERTY = var9[11];
                     logger = Logger.getLogger(AssertionRegistry.class.getName());
                     a = new AtomicBoolean(false);
                     installEnhancedMetadataDefaults();
                     b = new HashMap<>();
                     return;
                  }

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

                  var2 = "m\u0003|\u0012nG\u0005\u0012m\u0003|\u0012nGlh\u0005t)hMDq\u001au\t";
                  var4 = "m\u0003|\u0012nG\u0005\u0012m\u0003|\u0012nGlh\u0005t)hMDq\u001au\t".length();
                  var1 = 7;
                  var7 = -1;
            }

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

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

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

      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 -> 65;
            case 1 -> 48;
            case 2 -> 76;
            case 3 -> 39;
            case 4 -> 81;
            case 5 -> 98;
            default -> 119;
         });
      }

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