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

import com.l7tech.external.assertions.gatewaygraphql.EntityTypeInfo;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FipDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FipGroupDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FipSearchResult;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FipUserDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.PolicyDependency;
import com.l7tech.external.assertions.gatewaygraphql.server.error.GatewayEntityError;
import com.l7tech.external.assertions.gatewaygraphql.server.input.IdpFilterInput;
import com.l7tech.external.assertions.gatewaygraphql.server.util.AssertionLocalBeanFactory;
import com.l7tech.identity.Group;
import com.l7tech.identity.IdentityProviderType;
import com.l7tech.identity.User;
import com.l7tech.identity.fed.FederatedGroup;
import com.l7tech.identity.fed.FederatedIdentityProviderConfig;
import com.l7tech.identity.fed.FederatedUser;
import com.l7tech.objectmodel.EntityType;
import com.l7tech.objectmodel.FindException;
import com.l7tech.server.identity.fed.FederatedIdentityProvider;
import com.l7tech.util.ExceptionUtils;
import graphql.kickstart.tools.GraphQLResolver;
import graphql.schema.DataFetchingEnvironment;
import java.util.ArrayList;
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.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;
import lombok.Generated;
import org.springframework.beans.factory.BeanFactory;

@Deprecated
public class FederatedIdpQueryResolver extends IdpEntityAwareGraphQLQueryResolver<FederatedIdentityProviderConfig, FederatedIdentityProvider, FipDTO> {
   @Generated
   private static final Logger c = Logger.getLogger(FederatedIdpQueryResolver.class.getName());
   private static final String d;

   public FederatedIdpQueryResolver(ExecutorService var1, BeanFactory var2, AssertionLocalBeanFactory var3) {
      super(EntityTypeInfo.FEDERATED_IDP, var1, var3.getRequired(IdpResolverHelper.class), IdentityProviderType.FEDERATED);
      var3.addResolver(new FederatedIdpQueryResolver.FipPolicyDependencyResolver());
   }

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

   public CompletableFuture<List<FipDTO>> fips(DataFetchingEnvironment var1) {
      return this.executeAsyncMultiple(var1, () -> this.doFindAll(var1));
   }

   public CompletableFuture<FipDTO> fipByGoid(String var1, DataFetchingEnvironment var2) {
      return this.executeAsync(var2, () -> this.doFindByGoid(var2, var1));
   }

   public CompletableFuture<FipDTO> fipByName(String var1, DataFetchingEnvironment var2) {
      return this.executeAsync(var2, () -> this.doFindByName(var2, var1));
   }

   public CompletableFuture<List<FipUserDTO>> fipUsers(DataFetchingEnvironment var1) {
      return this.executeAsync(
         var1,
         () -> {
            ArrayList var1x = new ArrayList();

            try {
               this.idpHelper
                  .idps(this::isInterestedIdp)
                  .forEach(var2 -> this.idpHelper.users(var2).forEach(var3x -> var1x.add(this.a((FederatedUser)var3x, (FederatedIdentityProvider)var2))));
            } catch (Exception var3) {
               this.getLogger()
                  .log(Level.INFO, ExceptionUtils.getDebugException(var3), () -> GatewayEntityError.getReadAllQueryErrorMessage(EntityType.USER, var3));
            }

            return var1x;
         }
      );
   }

   public CompletableFuture<List<FipGroupDTO>> fipGroups(DataFetchingEnvironment var1) {
      return this.executeAsync(
         var1,
         () -> {
            ArrayList var1x = new ArrayList();

            try {
               this.idpHelper
                  .idps(this::isInterestedIdp)
                  .forEach(var2 -> this.idpHelper.groups(var2).forEach(var3x -> var1x.add(this.a((FederatedGroup)var3x, (FederatedIdentityProvider)var2))));
            } catch (Exception var3) {
               this.getLogger()
                  .log(Level.INFO, ExceptionUtils.getDebugException(var3), () -> GatewayEntityError.getReadAllQueryErrorMessage(EntityType.USER, var3));
            }

            return var1x;
         }
      );
   }

   public CompletableFuture<FipUserDTO> fipUserByName(String var1, String var2, DataFetchingEnvironment var3) {
      return this.executeAsync(var3, () -> {
         try {
            FederatedIdentityProvider var3x = this.idpHelper.idpByName(var1, this::isInterestedIdp);
            FederatedUser var4 = this.idpHelper.userByName(var3x, var2);

            try {
               if (var4 != null) {
                  return this.a(var4, var3x);
               }
            } catch (FindException var5) {
               throw a(var5);
            }

            return null;
         } catch (FindException var6) {
            this.getLogger().log(Level.INFO, ExceptionUtils.getDebugException(var6), () -> GatewayEntityError.getReadQueryErrorMessage(EntityType.USER, var6));
            return null;
         }
      });
   }

   public CompletableFuture<FipGroupDTO> fipGroupByName(String var1, String var2, DataFetchingEnvironment var3) {
      return this.executeAsync(var3, () -> {
         try {
            FederatedIdentityProvider var3x = this.idpHelper.idpByName(var1, this::isInterestedIdp);
            FederatedGroup var4 = this.idpHelper.groupByName(var3x, var2);

            try {
               if (var4 != null) {
                  return this.a(var4, var3x);
               }
            } catch (FindException var5) {
               throw a(var5);
            }

            return null;
         } catch (FindException var6) {
            this.getLogger().log(Level.INFO, ExceptionUtils.getDebugException(var6), () -> GatewayEntityError.getReadQueryErrorMessage(EntityType.GROUP, var6));
            return null;
         }
      });
   }

   public CompletableFuture<FipSearchResult> searchFip(IdpFilterInput var1, DataFetchingEnvironment var2) {
      return this.executeAsync(
         var2,
         () -> {
            List var2x = Collections.emptyList();
            List var3 = Collections.emptyList();

            try {
               FederatedIdentityProvider var4 = this.idpHelper.idpByName(var1.getProviderName(), this::isInterestedIdp);
               if (var4 != null) {
                  var2x = this.idpHelper
                     .<User>search(var4.getUserManager(), var1.getGoid(), var1.getNamePattern())
                     .stream()
                     .map(var2xx -> this.a((FederatedUser)var2xx, var4))
                     .collect(Collectors.toList());
                  var3 = this.idpHelper
                     .<Group>search(var4.getGroupManager(), var1.getGoid(), var1.getNamePattern())
                     .stream()
                     .map(var2xx -> this.a((FederatedGroup)var2xx, var4))
                     .collect(Collectors.toList());
               }
            } catch (Exception var5) {
               this.getLogger().log(Level.INFO, ExceptionUtils.getDebugException(var5), () -> d + var5.getMessage());
            }

            return new FipSearchResult(var2x, var3);
         }
      );
   }

   protected FipDTO toEntityDTO(FederatedIdentityProviderConfig var1) {
      return new FipDTO(var1, this.idpHelper);
   }

   private FipUserDTO a(FederatedUser var1, FederatedIdentityProvider var2) {
      return new FipUserDTO(var1, var2, this.idpHelper);
   }

   private FipGroupDTO a(FederatedGroup var1, FederatedIdentityProvider var2) {
      return new FipGroupDTO(var1, var2, this.idpHelper);
   }

   static {
      String var10002 = d(
         83,
         b(
            "4>c,SH\u001d\u001f/~6O\u001c\u001d\u0003)ucV\u0000\u0011\u001d)13S\u0007\u001b\u0014?b*O\u000fX\u0005$tcR\r\u0019\u0003/ycS\r\t\u0004)b7\u0001\u0007\u000e\u0014>1\ne8TQ"
         )
      );
      byte var10001 = -1;
      d = var10002;
   }

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

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

      return var10000;
   }

   private static String d(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 -> 34;
            case 1 -> 31;
            case 2 -> 66;
            case 3 -> 16;
            case 4 -> 114;
            case 5 -> 59;
            default -> 43;
         });
      }

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

   public class FipPolicyDependencyResolver implements GraphQLResolver<PolicyDependency> {
      public CompletableFuture<List<FipDTO>> getFips(PolicyDependency var1, DataFetchingEnvironment var2) {
         return FederatedIdpQueryResolver.this.executeAsyncQuietly(
            var2,
            () -> {
               DependentEntityCacheProvider.DependentEntityCache var3 = FederatedIdpQueryResolver.this.getDependentEntityCache(
                  var2, FederatedIdpQueryResolver.this.entityTypeInfo.getEntityType()
               );
               return FederatedIdpQueryResolver.this.doProcessMultiple(var2, FederatedIdpQueryResolver.this.findMultipleByDependencies(var1.getIdps(), var3));
            },
            Collections::emptyList
         );
      }

      public CompletableFuture<List<FipUserDTO>> getFipUsers(PolicyDependency var1, DataFetchingEnvironment var2) {
         return FederatedIdpQueryResolver.this.executeAsyncQuietly(var2, () -> {
            DependentEntityCacheProvider.DependentEntityCache var3 = FederatedIdpQueryResolver.this.getDependentEntityCache(var2, EntityType.USER);
            Collection var4 = FederatedIdpQueryResolver.this.findMultipleMembersByDependencies(var1.getUsers(), var3, true);
            return var4.stream().map(var1xx -> FederatedIdpQueryResolver.this.a((FederatedUser)var1xx.left, (FederatedIdentityProvider)var1xx.right)).toList();
         }, Collections::emptyList);
      }

      public CompletableFuture<List<FipGroupDTO>> getFipGroups(PolicyDependency var1, DataFetchingEnvironment var2) {
         return FederatedIdpQueryResolver.this.executeAsyncQuietly(var2, () -> {
            DependentEntityCacheProvider.DependentEntityCache var3 = FederatedIdpQueryResolver.this.getDependentEntityCache(var2, EntityType.GROUP);
            Collection var4 = FederatedIdpQueryResolver.this.findMultipleMembersByDependencies(var1.getGroups(), var3, false);
            return var4.stream().map(var1xx -> FederatedIdpQueryResolver.this.a((FederatedGroup)var1xx.left, (FederatedIdentityProvider)var1xx.right)).toList();
         }, Collections::emptyList);
      }
   }
}