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

import com.l7tech.external.assertions.gatewaygraphql.EntityTypeInfo;
import com.l7tech.external.assertions.gatewaygraphql.server.data.PolicyDependency;
import com.l7tech.external.assertions.gatewaygraphql.server.data.ServerModuleFileDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.input.EntityFilterInput;
import com.l7tech.external.assertions.gatewaygraphql.server.util.AssertionLocalBeanFactory;
import com.l7tech.gateway.common.module.ServerModuleFile;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.Goid;
import com.l7tech.server.module.ServerModuleFileManager;
import graphql.kickstart.tools.GraphQLResolver;
import graphql.schema.DataFetchingEnvironment;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.logging.Logger;
import lombok.Generated;
import org.springframework.beans.factory.BeanFactory;

public class ServerModuleFileQueryResolver extends EntityAwareGraphQLQueryResolver<ServerModuleFile, ServerModuleFileDTO> {
   @Generated
   private static final Logger c = Logger.getLogger(ServerModuleFileQueryResolver.class.getName());
   private final ServerModuleFileManager d;
   private static final String e;

   public ServerModuleFileQueryResolver(ExecutorService var1, BeanFactory var2, AssertionLocalBeanFactory var3) {
      super(EntityTypeInfo.SERVER_MODULE_FILE, var1);
      this.d = (ServerModuleFileManager)var2.getBean(e, ServerModuleFileManager.class);
      var3.addResolver(new ServerModuleFileQueryResolver.ServerModuleFilePolicyDependencyResolver());
   }

   @Override
   protected Logger getLogger() {
      return c;
   }

   public CompletableFuture<List<ServerModuleFileDTO>> serverModuleFiles(DataFetchingEnvironment var1) {
      return this.<ServerModuleFileDTO>executeAsyncMultiple(var1, () -> this.doFindAll(var1))
         .thenApply(var2 -> var2.stream().peek(var2x -> this.a(var2x, var1)).toList());
   }

   public CompletableFuture<ServerModuleFileDTO> serverModuleFileByGoid(String var1, DataFetchingEnvironment var2) {
      return this.<ServerModuleFileDTO>executeAsync(var2, () -> this.doFindByGoid(var2, var1)).thenApply(var2x -> this.a(var2x, var2));
   }

   public CompletableFuture<ServerModuleFileDTO> serverModuleFileByName(String var1, DataFetchingEnvironment var2) {
      return this.<ServerModuleFileDTO>executeAsync(var2, () -> this.doFindByName(var2, var1)).thenApply(var2x -> this.a(var2x, var2));
   }

   public CompletableFuture<List<ServerModuleFileDTO>> serverModuleFilesByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.serverModuleFiles(var2), var1, ServerModuleFileDTO.class);
   }

   protected ServerModuleFileDTO toEntityDTO(ServerModuleFile var1) {
      return new ServerModuleFileDTO(var1, this.d);
   }

   protected ServerModuleFile findByName(String var1) throws FindException {
      return (ServerModuleFile)this.d.findByUniqueName(var1);
   }

   protected ServerModuleFile findByGoid(Goid var1) throws FindException {
      return (ServerModuleFile)this.d.findByPrimaryKey(var1);
   }

   @Override
   protected Collection<ServerModuleFile> findAll() throws FindException {
      return this.d.findAll();
   }

   private ServerModuleFileDTO a(ServerModuleFileDTO var1, DataFetchingEnvironment var2) {
      if (var1 != null) {
         var1.setFilePartSupplier(this.getFilePartSupplier(var2));
      }

      return var1;
   }

   static {
      String var10002 = c(85, a("G%\u0000B%i9[$\u0007X%]\u001dX%?U.z\u0013Q2"));
      byte var10001 = -1;
      e = var10002;
   }

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

      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 -> 97;
            case 1 -> 21;
            case 2 -> 39;
            case 3 -> 97;
            case 4 -> 21;
            case 5 -> 78;
            default -> 33;
         });
      }

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

   public class ServerModuleFilePolicyDependencyResolver implements GraphQLResolver<PolicyDependency> {
      public CompletableFuture<List<ServerModuleFileDTO>> getServerModuleFiles(PolicyDependency var1, DataFetchingEnvironment var2) {
         return ServerModuleFileQueryResolver.this.executeAsyncQuietly(
            var2,
            () -> {
               DependentEntityCacheProvider.DependentEntityCache var3 = ServerModuleFileQueryResolver.this.getDependentEntityCache(
                  var2, ServerModuleFileQueryResolver.this.entityTypeInfo.getEntityType()
               );
               return ServerModuleFileQueryResolver.this.doProcessMultiple(
                     var2, ServerModuleFileQueryResolver.this.findMultipleByDependencies(var1.getServerModuleFiles(), var3)
                  )
                  .stream()
                  .peek(var2xx -> ServerModuleFileQueryResolver.this.a(var2xx, var2))
                  .toList();
            },
            Collections::emptyList
         );
      }
   }
}