package com.l7tech.server.policy.assertion.credential;

import com.l7tech.gateway.common.audit.AssertionMessages;
import com.l7tech.message.Message;
import com.l7tech.policy.assertion.Assertion;
import com.l7tech.policy.assertion.AssertionStatus;
import com.l7tech.policy.assertion.PolicyAssertionException;
import com.l7tech.policy.assertion.credential.CredentialFinderException;
import com.l7tech.policy.assertion.credential.LoginCredentials;
import com.l7tech.server.message.AuthenticationContext;
import com.l7tech.server.message.PolicyEnforcementContext;
import com.l7tech.server.policy.assertion.AbstractServerAssertion;
import com.l7tech.util.ExceptionUtils;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public abstract class ServerCredentialSourceAssertion<A extends Assertion> extends AbstractServerAssertion<A> {
   private static final String f;

   protected ServerCredentialSourceAssertion(A var1) {
      super((A)var1);
      if (!var1.isCredentialSource()) {
         throw new IllegalArgumentException(f + var1);
      }
   }

   @Override
   public AssertionStatus checkRequest(PolicyEnforcementContext var1) throws IOException, PolicyAssertionException {
      HashMap var2 = new HashMap();

      try {
         AuthenticationContext var10 = var1.getDefaultAuthenticationContext();
         LoginCredentials var11 = var10.getLastCredentials();

         label58: {
            try {
               if (var11 == null || var11.getCredentialSourceAssertion().equals(this.assertion.getClass())) {
                  break label58;
               }
            } catch (CredentialFinderException var8) {
               throw a(var8);
            }

            var11 = null;
         }

         if (var11 == null) {
            var11 = this.findCredentials(var1.getRequest(), var2);
         }

         if (var11 == null) {
            var1.setAuthenticationMissing();
            this.challenge(var1, var2);
            this.logAndAudit(AssertionMessages.HTTPCREDS_AUTH_REQUIRED);
            return AssertionStatus.AUTH_REQUIRED;
         } else {
            var10.addCredentials(var11);
            return this.checkCredentials(var11, this.findCredentialAuthParams(var11, var2));
         }
      } catch (CredentialFinderException var9) {
         CredentialFinderException var3 = var9;
         AssertionStatus var4 = var9.getStatus();

         try {
            if (var4 == null) {
               this.logAndAudit(AssertionMessages.EXCEPTION_INFO, null, var3);
               throw new PolicyAssertionException(this.assertion, var3.getMessage(), var3);
            }
         } catch (CredentialFinderException var7) {
            throw a(var7);
         }

         this.challenge(var1, var2);
         String var5 = ExceptionUtils.getMessage(var9);

         try {
            this.logAndAudit(AssertionMessages.EXCEPTION_INFO_WITH_MORE_INFO, new String[]{var5}, null);
            if (var4 == AssertionStatus.AUTH_REQUIRED) {
               var1.setAuthenticationMissing();
               return var4;
            }
         } catch (CredentialFinderException var6) {
            throw a(var6);
         }

         var1.setRequestPolicyViolated();
         return var4;
      }
   }

   protected Map<String, String> findCredentialAuthParams(LoginCredentials var1, Map<String, String> var2) {
      return var2;
   }

   protected abstract LoginCredentials findCredentials(Message var1, Map<String, String> var2) throws IOException, CredentialFinderException;

   protected abstract AssertionStatus checkCredentials(LoginCredentials var1, Map<String, String> var2) throws CredentialFinderException;

   protected abstract void challenge(PolicyEnforcementContext var1, Map<String, String> var2);

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

   static {
      String var10002 = b(121, c("\nNplgN96D`)h\u001a3%M$?i\u001b('D$"));
      byte var10001 = -1;
      f = var10002;
   }

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

      return var10000;
   }

   private static String b(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 -> 61;
            case 1 -> 88;
            case 2 -> 125;
            case 3 -> 53;
            case 4 -> 127;
            case 5 -> 23;
            default -> 35;
         });
      }

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