package com.l7tech.external.assertions.gatewaygraphql.server.resolver.query;

import com.l7tech.external.assertions.gatewaygraphql.EntityTypeInfo;
import com.l7tech.external.assertions.gatewaygraphql.server.data.AssertionMetadataDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.CustomAssertionMetadataDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.EncapsulatedAssertionMetadataDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.EntityMetadataDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.VariableMetadataDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.input.EntityFilterInput;
import com.l7tech.external.assertions.gatewaygraphql.server.resolver.helper.PolicyCodeHelper;
import com.l7tech.external.assertions.gatewaygraphql.server.util.AssertionLocalBeanFactory;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.encass.EncapsulatedAssertionConfig;
import com.l7tech.policy.AssertionRegistry;
import com.l7tech.policy.CustomAssertionRegistry;
import com.l7tech.policy.assertion.Assertion;
import com.l7tech.policy.assertion.CustomAssertionHolder;
import com.l7tech.policy.assertion.EncapsulatedAssertion;
import com.l7tech.policy.code.PolicyCodeModuleProvider;
import com.l7tech.policy.variable.BuiltinVariables;
import com.l7tech.policy.variable.VariableMetadata;
import com.l7tech.server.policy.EncapsulatedAssertionConfigManager;
import graphql.schema.DataFetchingEnvironment;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import org.springframework.beans.factory.BeanFactory;

public class GatewayMetadataQueryResolver extends BasicGraphQLQueryResolver {
   private final AssertionRegistry c;
   private final CustomAssertionRegistry d;
   private final EncapsulatedAssertionConfigManager e;
   private final PolicyCodeModuleProvider f;
   private final PolicyCodeHelper g;
   private static final String[] j;

   public GatewayMetadataQueryResolver(ExecutorService var1, BeanFactory var2, AssertionLocalBeanFactory var3) {
      super(EntityTypeInfo.NONE, var1);
      String[] var4 = j;
      this.c = (AssertionRegistry)var2.getBean(var4[3], AssertionRegistry.class);
      this.d = (CustomAssertionRegistry)var2.getBean(var4[0], CustomAssertionRegistry.class);
      this.e = (EncapsulatedAssertionConfigManager)var2.getBean(var4[2], EncapsulatedAssertionConfigManager.class);
      this.f = (PolicyCodeModuleProvider)var2.getBean(var4[1], PolicyCodeModuleProvider.class);
      this.g = var3.getRequired(PolicyCodeHelper.class);
   }

   public CompletableFuture<List<AssertionMetadataDTO>> assertionsMetadata(DataFetchingEnvironment var1) {
      return this.executeAsync(var1, () -> {
         ArrayList var1x = new ArrayList();
         this.c.getAssertions().stream().map(this::a).forEach(var1x::add);
         this.d.findAll().stream().map(this::a).forEach(var1x::add);
         this.a().stream().map(this::a).forEach(var1x::add);
         return var1x;
      });
   }

   public CompletableFuture<List<AssertionMetadataDTO>> assertionsMetadataByType(AssertionMetadataDTO.AssertionType var1, DataFetchingEnvironment var2) {
      return this.executeAsync(var2, () -> {
         ArrayList var2x = new ArrayList();

         try {
            if (AssertionMetadataDTO.AssertionType.CUSTOM.equals(var1)) {
               this.d.findAll().stream().map(this::a).forEach(var2x::add);
               return var2x;
            }
         } catch (Exception var4) {
            throw a(var4);
         }

         try {
            if (AssertionMetadataDTO.AssertionType.ENCAPSULATED.equals(var1)) {
               this.a().stream().map(this::a).forEach(var2x::add);
               return var2x;
            }
         } catch (Exception var3) {
            throw a(var3);
         }

         this.c.getAssertions().stream().filter(var2xx -> this.a(var2xx, var1)).map(this::a).forEach(var2x::add);
         return var2x;
      });
   }

   public CompletableFuture<List<AssertionMetadataDTO>> assertionsMetadataByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.assertionsMetadata(var2), var1, AssertionMetadataDTO.class);
   }

   public CompletableFuture<AssertionMetadataDTO> assertionMetadataByConfigName(String var1, DataFetchingEnvironment var2) {
      return this.executeAsync(var2, () -> {
         if (CustomAssertionHolder.isCustomAssertionExternalName(var1)) {
            CustomAssertionHolder var2x = this.d.findByClassname(CustomAssertionHolder.getLocalExternalName(var1));

            try {
               if (var2x != null) {
                  return this.a(var2x);
               }
            } catch (Exception var5) {
               throw a(var5);
            }
         } else if (EncapsulatedAssertion.isEncapsulatedAssertionExternalName(var1)) {
            EncapsulatedAssertionConfig var6 = this.a(var1);

            try {
               if (var6 != null) {
                  return this.a(var6);
               }
            } catch (Exception var4) {
               throw a(var4);
            }
         } else {
            Assertion var7 = this.c.findByExternalName(var1);

            try {
               if (var7 != null) {
                  return this.a(var7);
               }
            } catch (Exception var3) {
               throw a(var3);
            }
         }

         return null;
      });
   }

   public CompletableFuture<List<VariableMetadataDTO>> builtinPolicyVariables(DataFetchingEnvironment var1) {
      return this.executeAsync(var1, () -> BuiltinVariables.getAllMetadata().values().stream().map(var1x -> this.a((VariableMetadata)var1x)).toList());
   }

   public CompletableFuture<List<VariableMetadataDTO>> builtinPolicyVariablesByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.builtinPolicyVariables(var2), var1, VariableMetadataDTO.class);
   }

   public CompletableFuture<List<EntityMetadataDTO>> entitiesMetadata(DataFetchingEnvironment var1) {
      return this.executeAsync(var1, () -> Arrays.stream(EntityTypeInfo.values()).filter(var0 -> Objects.nonNull(var0.getTypeName())).map(this::a).toList());
   }

   public CompletableFuture<List<EntityMetadataDTO>> entitiesMetadataByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.entitiesMetadata(var2), var1, EntityMetadataDTO.class);
   }

   public EntityMetadataDTO entityMetadataByName(String var1) {
      return Arrays.stream(EntityTypeInfo.values())
         .filter(var1x -> var1.equals(var1x.getTypeName()) || var1.equals(var1x.getAltTypeName()))
         .map(EntityMetadataDTO::new)
         .findFirst()
         .orElse(null);
   }

   public EntityMetadataDTO entityMetadataByPluralName(String var1) {
      return this.a(EntityTypeInfo.fromBundleName(var1));
   }

   private AssertionMetadataDTO a(Assertion var1) {
      return new AssertionMetadataDTO(var1, this.f, this.g);
   }

   private CustomAssertionMetadataDTO a(CustomAssertionHolder var1) {
      return new CustomAssertionMetadataDTO(var1, this.f, this.g);
   }

   private EncapsulatedAssertionMetadataDTO a(EncapsulatedAssertionConfig var1) {
      return new EncapsulatedAssertionMetadataDTO(new EncapsulatedAssertion(var1), this.f, this.g);
   }

   private VariableMetadataDTO a(VariableMetadata var1) {
      return new VariableMetadataDTO(var1);
   }

   private EntityMetadataDTO a(EntityTypeInfo var1) {
      return new EntityMetadataDTO(var1);
   }

   private boolean a(Assertion var1, AssertionMetadataDTO.AssertionType var2) {
      if (AssertionMetadataDTO.AssertionType.NATIVE.equals(var2)) {
         return true;
      }

      AssertionMetadataDTO.AssertionType var3 = AssertionMetadataDTO.isModularAssertion(var1)
         ? AssertionMetadataDTO.AssertionType.MODULAR
         : AssertionMetadataDTO.AssertionType.CORE;
      return var3.equals(var2);
   }

   private Collection<EncapsulatedAssertionConfig> a() {
      try {
         return this.e.findAll();
      } catch (FindException var2) {
         throw var2;
      }
   }

   private EncapsulatedAssertionConfig a(String var1) {
      try {
         EncapsulatedAssertionConfigManager var10000;
         try {
            var10000 = this.e;
            if (EncapsulatedAssertion.isEncapsulatedAssertionExternalName(var1)) {
               return (EncapsulatedAssertionConfig)var10000.findByUniqueName(var1.substring(EncapsulatedAssertion.EXTERNAL_NAME_PREFIX.length()));
            }
         } catch (FindException var3) {
            throw a(var3);
         }

         return (EncapsulatedAssertionConfig)var10000.findByUniqueName(var1);
      } catch (FindException var4) {
         throw var4;
      }
   }

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

   static {
      String[] var5 = new String[4];
      int var3 = 0;
      String var2 = "\u0015\u0019@\u000b:Zh\u0005\u001fV\r!^F\u0018>V\u0018<D]\u0004\u0015\u0018\u0006\u0003_\u00166Nj\u0019\bV2:S\\\u001a\tc\r:A@\u0012\tA";
      int var4 = "\u0015\u0019@\u000b:Zh\u0005\u001fV\r!^F\u0018>V\u0018<D]\u0004\u0015\u0018\u0006\u0003_\u00166Nj\u0019\bV2:S\\\u001a\tc\r:A@\u0012\tA"
         .length();
      char var1 = 23;
      int var7 = -1;

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

         while (true) {
            String var8 = c(var10000, b(var10001));
            switch (var10002) {
               case 0:
                  var5[var3++] = var8;
                  if ((var7 += var1) >= var4) {
                     j = var5;
                     return;
                  }

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

                  var2 = "\u0010\u0001S\u001d&G_\u0019\u000eD\u00192uY\u0006\nB\b?[D6\u0000^\u001a?Sg\u0014\u0001Q\u001b3F\u0011\u0014\u001cC\u0019$@C\u001a\u0001b\u00191]Y\u0001\u001dI";
                  var4 = "\u0010\u0001S\u001d&G_\u0019\u000eD\u00192uY\u0006\nB\b?[D6\u0000^\u001a?Sg\u0014\u0001Q\u001b3F\u0011\u0014\u001cC\u0019$@C\u001a\u0001b\u00191]Y\u0001\u001dI"
                     .length();
                  var1 = '"';
                  var7 = -1;
            }

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

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

      return var10000;
   }

   private static String c(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 -> 78;
            case 1 -> 84;
            case 2 -> 11;
            case 3 -> 71;
            case 4 -> 109;
            case 5 -> 15;
            default -> 17;
         });
      }

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