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

import com.l7tech.identity.Group;
import com.l7tech.identity.IdentityProvider;
import com.l7tech.identity.User;
import com.l7tech.objectmodel.Entity;
import com.l7tech.objectmodel.EntityType;
import com.l7tech.server.search.objects.DependentEntity;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;

public class DependentEntityCacheProvider {
   private final Map<EntityType, DependentEntityCacheProvider.DependentEntityCache> a = new ConcurrentHashMap<>();
   private final Map<EntityType, DependentEntityCacheProvider.IdpDependentEntityCache> b = new ConcurrentHashMap<>();

   public DependentEntityCacheProvider.DependentEntityCache getCache(EntityType var1) {
      return this.a.computeIfAbsent(var1, var0 -> new DependentEntityCacheProvider.DependentEntityCache());
   }

   public DependentEntityCacheProvider.IdpDependentEntityCache getIdpCache(EntityType var1) {
      return this.b.computeIfAbsent(var1, var0 -> new DependentEntityCacheProvider.IdpDependentEntityCache());
   }

   public static class DependentEntityCache {
      private final Map<String, Entity> a = new ConcurrentHashMap<>();

      public <T extends Entity> T get(DependentEntity var1, Supplier<T> var2) {
         return (T)this.a.computeIfAbsent(var1.getEntityHeader().getStrId(), var1x -> (Entity)var2.get());
      }
   }

   public static class IdpDependentEntityCache {
      private final Map<String, IdentityProvider> a = new ConcurrentHashMap<>();
      private final Map<String, User> b = new ConcurrentHashMap<>();
      private final Map<String, Group> c = new ConcurrentHashMap<>();

      public <T extends IdentityProvider> T get(String var1, Supplier<T> var2) {
         return (T)this.a.computeIfAbsent(var1, var1x -> (IdentityProvider)var2.get());
      }

      public <T extends User> T getUser(String var1, Supplier<T> var2) {
         return (T)this.b.computeIfAbsent(var1, var1x -> (User)var2.get());
      }

      public <T extends Group> T getGroup(String var1, Supplier<T> var2) {
         return (T)this.c.computeIfAbsent(var1, var1x -> (Group)var2.get());
      }
   }
}