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

import com.l7tech.external.assertions.gatewaygraphql.EntityTypeInfo;
import com.l7tech.external.assertions.gatewaygraphql.server.data.InternalGroupDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.InternalIdpDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.InternalSearchResult;
import com.l7tech.external.assertions.gatewaygraphql.server.data.InternalUserDTO;
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.IdentityProviderConfig;
import com.l7tech.identity.IdentityProviderType;
import com.l7tech.identity.User;
import com.l7tech.identity.internal.InternalGroup;
import com.l7tech.identity.internal.InternalUser;
import com.l7tech.objectmodel.EntityType;
import com.l7tech.server.identity.internal.InternalIdentityProvider;
import com.l7tech.server.search.objects.DependentEntity;
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 java.util.stream.Collectors;
import lombok.Generated;
import org.springframework.beans.factory.BeanFactory;

public class InternalIdpQueryResolver extends IdpEntityAwareGraphQLQueryResolver<IdentityProviderConfig, InternalIdentityProvider, InternalIdpDTO> {
   @Generated
   private static final Logger c = Logger.getLogger(InternalIdpQueryResolver.class.getName());
   private final InternalIdentityProvider d = this.idpHelper.internalIdp();

   public InternalIdpQueryResolver(ExecutorService var1, BeanFactory var2, AssertionLocalBeanFactory var3) {
      super(EntityTypeInfo.INTERNAL_IDP, var1, var3.getRequired(IdpResolverHelper.class), IdentityProviderType.INTERNAL);
      var3.addResolver(new InternalIdpQueryResolver.InternalIdpPolicyDependencyResolver());
   }

   public CompletableFuture<List<InternalIdpDTO>> internalIdps(DataFetchingEnvironment var1) {
      return this.executeAsyncMultiple(var1, () -> {
         try {
            if (this.d != null) {
               return List.of(this.toEntityDTO(this.d.getConfig()));
            }
         } catch (Exception var1x) {
            throw a(var1x);
         }

         return Collections.emptyList();
      });
   }

   public CompletableFuture<List<InternalUserDTO>> internalUsers(DataFetchingEnvironment var1) {
      return this.executeAsyncMultiple(var1, () -> this.idpHelper.users(this.d).stream().map(var1x -> this.a((InternalUser)var1x)).collect(Collectors.toList()));
   }

   public CompletableFuture<List<InternalGroupDTO>> internalGroups(DataFetchingEnvironment var1) {
      return this.executeAsyncMultiple(
         var1, () -> this.idpHelper.groups(this.d).stream().map(var1x -> this.a((InternalGroup)var1x)).collect(Collectors.toList())
      );
   }

   public CompletableFuture<InternalUserDTO> internalUserByLogin(String var1, DataFetchingEnvironment var2) {
      return this.executeAsync(var2, () -> {
         InternalUser var2x = this.idpHelper.userByLogin(this.d, var1);

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

         return null;
      });
   }

   public CompletableFuture<InternalGroupDTO> internalGroupByName(String var1, DataFetchingEnvironment var2) {
      return this.executeAsync(var2, () -> {
         InternalGroup var2x = this.idpHelper.groupByName(this.d, var1);

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

         return null;
      });
   }

   public CompletableFuture<InternalSearchResult> searchInternalIdp(IdpFilterInput var1, DataFetchingEnvironment var2) {
      return this.searchInternal(var1, var2);
   }

   public CompletableFuture<InternalSearchResult> searchInternal(IdpFilterInput var1, DataFetchingEnvironment var2) {
      return this.executeAsync(
         var2,
         () -> {
            List var2x = Collections.emptyList();
            List var3 = Collections.emptyList();
            if (this.d != null) {
               var2x = this.idpHelper
                  .<User>search(this.d.getUserManager(), var1.getGoid(), var1.getNamePattern())
                  .stream()
                  .map(var1xx -> this.a((InternalUser)var1xx))
                  .collect(Collectors.toList());
               var3 = this.idpHelper
                  .<Group>search(this.d.getGroupManager(), var1.getGoid(), var1.getNamePattern())
                  .stream()
                  .map(var1xx -> this.a((InternalGroup)var1xx))
                  .collect(Collectors.toList());
            }

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

   public CompletableFuture<List<InternalIdpDTO>> internalIdpsByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.internalIdps(var2), var1, InternalIdpDTO.class);
   }

   public CompletableFuture<List<InternalUserDTO>> internalUsersByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.internalUsers(var2), var1, InternalUserDTO.class);
   }

   public CompletableFuture<List<InternalGroupDTO>> internalGroupsByFilters(List<EntityFilterInput> var1, DataFetchingEnvironment var2) {
      return this.doProcessMultipleByFilters(var2, this.internalGroups(var2), var1, InternalGroupDTO.class);
   }

   protected InternalIdpDTO toEntityDTO(IdentityProviderConfig var1) {
      return new InternalIdpDTO(var1, this.idpHelper);
   }

   private InternalUserDTO a(InternalUser var1) {
      return new InternalUserDTO(var1, this.d, this.idpHelper);
   }

   private InternalGroupDTO a(InternalGroup var1) {
      return new InternalGroupDTO(var1, this.d, this.idpHelper);
   }

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

   public class InternalIdpPolicyDependencyResolver implements GraphQLResolver<PolicyDependency> {
      public CompletableFuture<List<InternalIdpDTO>> getInternalIdps(PolicyDependency var1, DataFetchingEnvironment var2) {
         return InternalIdpQueryResolver.this.executeAsyncQuietly(
            var2,
            () -> {
               if (InternalIdpQueryResolver.this.d != null) {
                  boolean var2x = var1.getIdps()
                     .stream()
                     .map(var0 -> (DependentEntity)var0.getDependent())
                     .anyMatch(var1xx -> InternalIdpQueryResolver.this.d.getConfig().getGoid().equals(var1xx.getEntityHeader().getGoid()));

                  try {
                     if (var2x) {
                        return List.of(InternalIdpQueryResolver.this.toEntityDTO(InternalIdpQueryResolver.this.d.getConfig()));
                     }
                  } catch (Exception var3) {
                     throw a(var3);
                  }
               }

               return Collections.emptyList();
            },
            Collections::emptyList
         );
      }

      public CompletableFuture<List<InternalUserDTO>> getInternalUsers(PolicyDependency var1, DataFetchingEnvironment var2) {
         return InternalIdpQueryResolver.this.executeAsyncQuietly(var2, () -> {
            DependentEntityCacheProvider.DependentEntityCache var3 = InternalIdpQueryResolver.this.getDependentEntityCache(var2, EntityType.GROUP);
            Collection var4 = InternalIdpQueryResolver.this.findMultipleMembersByDependencies(var1.getUsers(), var3, false);
            return var4.stream().map(var1xx -> InternalIdpQueryResolver.this.a((InternalUser)var1xx.left)).toList();
         }, Collections::emptyList);
      }

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

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