package com.l7tech.external.assertions.gatewaygraphql.server.data;

import com.l7tech.external.assertions.gatewaygraphql.server.resolver.query.IdpResolverHelper;
import com.l7tech.external.assertions.gatewaygraphql.server.util.JsonUtil;
import com.l7tech.identity.IdentityProvider;
import com.l7tech.identity.IdentityProviderConfig;
import com.l7tech.identity.IdentityProviderType;
import com.l7tech.objectmodel.Goid;
import com.l7tech.security.cert.TrustedCert;
import org.apache.commons.codec.digest.DigestUtils;

public abstract class IdpDTO<IDPC extends IdentityProviderConfig, IDP extends IdentityProvider> extends IdpEntityDTO<IDP> {
   protected final IDPC idpConfig;
   protected final IdpResolverHelper idpHelper;

   protected IdpDTO(IDPC var1, IDP var2, IdpResolverHelper var3) {
      super((IDP)var2);
      this.idpConfig = (IDPC)var1;
      this.idpHelper = var3;
   }

   public IDPC entity() {
      return this.idpConfig;
   }

   @Override
   public String getGoid() {
      return this.idpConfig.getGoid().toString();
   }

   public String getName() {
      return this.idpConfig.getName();
   }

   protected TrustedCertDTO certDTO(Goid var1) {
      TrustedCert var2 = this.idpHelper.certForGoid(var1);
      return var2 != null ? new TrustedCertDTO(var2) : null;
   }

   @Override
   public String getChecksum() {
      try {
         return DigestUtils.shaHex(JsonUtil.DEFAULT.serialize(this.createWrapperObject()));
      } catch (Throwable var2) {
         throw var2;
      }
   }

   @Override
   public abstract Object createWrapperObject();

   public enum IdpType {
      INTERNAL,
      FEDERATED,
      LDAP,
      SIMPLE_LDAP,
      POLICY_BACKED;

      private final IdentityProviderType intervalValue;
      private static final String[] a;

      IdpType(IdentityProviderType var3) {
         this.intervalValue = var3;
      }

      public IdentityProviderType getIntervalValue() {
         return this.intervalValue;
      }

      public static IdpDTO.IdpType fromInternalValue(IdentityProviderType var0) {
         try {
            if (IdentityProviderType.INTERNAL.toVal() == var0.toVal()) {
               return INTERNAL;
            }
         } catch (IllegalArgumentException var5) {
            throw a(var5);
         }

         try {
            if (IdentityProviderType.FEDERATED.toVal() == var0.toVal()) {
               return FEDERATED;
            }
         } catch (IllegalArgumentException var2) {
            throw a(var2);
         }

         try {
            if (IdentityProviderType.LDAP.toVal() == var0.toVal()) {
               return LDAP;
            }
         } catch (IllegalArgumentException var4) {
            throw a(var4);
         }

         try {
            if (IdentityProviderType.BIND_ONLY_LDAP.toVal() == var0.toVal()) {
               return SIMPLE_LDAP;
            }
         } catch (IllegalArgumentException var1) {
            throw a(var1);
         }

         try {
            if (IdentityProviderType.POLICY_BACKED.toVal() == var0.toVal()) {
               return POLICY_BACKED;
            }
         } catch (IllegalArgumentException var3) {
            throw a(var3);
         }

         throw new IllegalArgumentException(a[1]);
      }

      // $VF: Failed to inline enum fields
      // Please report this to the Vineflower issue tracker, at https://github.com/Vineflower/vineflower/issues with a copy of the class file (if you have the rights to distribute it!)
      static {
         String[] var5 = new String[6];
         int var3 = 0;
         String var2 = "?=\u0014D[.! 0\u0018D\u0019%\u001a/u{\u0002\u001aL\u001d=qy\u001f\u0017\u0018\ryde\u0004\b\u0005\u0010<f\b%:\rQE%? \r<;\u0015]T2!.5\u001a_R/";
         int var4 = "?=\u0014D[.! 0\u0018D\u0019%\u001a/u{\u0002\u001aL\u001d=qy\u001f\u0017\u0018\ryde\u0004\b\u0005\u0010<f\b%:\rQE%? \r<;\u0015]T2!.5\u001a_R/"
            .length();
         char var1 = 11;
         int var7 = -1;

         label24:
         while (true) {
            byte var10000 = 53;
            String var10001 = var2.substring(++var7, var7 + var1);
            byte var10002 = -1;

            while (true) {
               String var9 = a(var10000, a(var10001));
               switch (var10002) {
                  case 0:
                     var5[var3++] = var9;
                     if ((var7 += var1) >= var4) {
                        a = var5;
                        String[] var8 = a;
                        INTERNAL = new IdpDTO.IdpType(IdentityProviderType.INTERNAL);
                        FEDERATED = new IdpDTO.IdpType(IdentityProviderType.FEDERATED);
                        LDAP = new IdpDTO.IdpType(IdentityProviderType.LDAP);
                        SIMPLE_LDAP = new IdpDTO.IdpType(IdentityProviderType.BIND_ONLY_LDAP);
                        POLICY_BACKED = new IdpDTO.IdpType(IdentityProviderType.POLICY_BACKED);
                        return;
                     }

                     var1 = var2.charAt(var7);
                     break;
                  default:
                     var5[var3++] = var9;
                     if ((var7 += var1) < var4) {
                        var1 = var2.charAt(var7);
                        continue label24;
                     }

                     var2 = "g|P\u001c\bggd}\u0004m}U\t";
                     var4 = "g|P\u001c\bggd}\u0004m}U\t".length();
                     var1 = '\t';
                     var7 = -1;
               }

               var10000 = 120;
               var10001 = var2.substring(++var7, var7 + var1);
               var10002 = 0;
            }
         }
      }

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

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

         return var10000;
      }

      private static String a(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 -> 89;
               case 1 -> 65;
               case 2 -> 108;
               case 3 -> 33;
               case 4 -> 34;
               case 5 -> 94;
               default -> 75;
            });
         }

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