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

import com.l7tech.external.assertions.gatewaygraphql.EntityTypeInfo;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FederatedGroupDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FederatedIdpDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FederatedSearchResultDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.FederatedUserDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.PolicyDependency;
import com.l7tech.external.assertions.gatewaygraphql.server.input.EntityFilterInput;
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.server.identity.fed.FederatedIdentityProvider;
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.Logger;
import java.util.stream.Collectors;
import lombok.Generated;
import org.springframework.beans.factory.BeanFactory;

public class FederatedIdpxQueryResolver extends IdpEntityAwareGraphQLQueryResolver<FederatedIdentityProviderConfig, FederatedIdentityProvider, FederatedIdpDTO> {
   @Generated
   private static final Logger c = Logger.getLogger(FederatedIdpxQueryResolver.class.getName());

   public FederatedIdpxQueryResolver(ExecutorService var1, BeanFactory var2, AssertionLocalBeanFactory var3) {
      super(EntityTypeInfo.FEDERATED_IDPX, var1, var3.getRequired(IdpResolverHelper.class), IdentityProviderType.FEDERATED);
      var3.addResolver(new FederatedIdpxQueryResolver.FederatedIdpPolicyDependencyResolver());
   }

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

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

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

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

   public CompletableFuture<List<FederatedIdpDTO>> federatedIdpsByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.federatedIdps(var2), var1, FederatedIdpDTO.class);
   }

   public CompletableFuture<FederatedSearchResultDTO> searchFederatedIdp(IdpFilterInput var1, DataFetchingEnvironment var2) {
      return this.executeAsync(
         var2,
         () -> {
            List var2x = Collections.emptyList();
            List var3 = Collections.emptyList();
            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());
            }

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

   public CompletableFuture<List<FederatedUserDTO>> federatedUsers(DataFetchingEnvironment var1) {
      return this.executeAsyncMultiple(
         var1,
         () -> {
            ArrayList var1x = new ArrayList();
            this.idpHelper
               .idps(this::isInterestedIdp)
               .forEach(var2 -> this.idpHelper.users(var2).forEach(var3 -> var1x.add(this.a((FederatedUser)var3, (FederatedIdentityProvider)var2))));
            return var1x;
         }
      );
   }

   public CompletableFuture<List<FederatedGroupDTO>> federatedGroups(DataFetchingEnvironment var1) {
      return this.executeAsyncMultiple(
         var1,
         () -> {
            ArrayList var1x = new ArrayList();
            this.idpHelper
               .idps(this::isInterestedIdp)
               .forEach(var2 -> this.idpHelper.groups(var2).forEach(var3 -> var1x.add(this.a((FederatedGroup)var3, (FederatedIdentityProvider)var2))));
            return var1x;
         }
      );
   }

   public CompletableFuture<FederatedUserDTO> federatedUserByName(String var1, String var2, DataFetchingEnvironment var3) {
      return this.executeAsync(var3, () -> {
         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 (Exception var5) {
            throw a(var5);
         }

         return null;
      });
   }

   public CompletableFuture<FederatedGroupDTO> federatedGroupByName(String var1, String var2, DataFetchingEnvironment var3) {
      return this.executeAsync(var3, () -> {
         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 (Exception var5) {
            throw a(var5);
         }

         return null;
      });
   }

   public CompletableFuture<List<FederatedUserDTO>> federatedUsersByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.federatedUsers(var2), var1, FederatedUserDTO.class);
   }

   public CompletableFuture<List<FederatedGroupDTO>> federatedGroupsByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.federatedGroups(var2), var1, FederatedGroupDTO.class);
   }

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

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

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

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

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

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

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