package com.l7tech.gateway.api;

import com.l7tech.gateway.api.impl.MarshallingUtils;
import com.l7tech.gateway.api.impl.ValidationUtils;
import com.l7tech.util.HexUtils;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.cert.CertificateEncodingException;
import java.security.cert.X509Certificate;
import java.util.List;
import javax.security.auth.x500.X500Principal;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.w3c.dom.Document;

public class ManagedObjectFactory {
   private static final String[] a;

   public static ServiceDetail.HttpMapping createHttpMapping() {
      return new ServiceDetail.HttpMapping();
   }

   public static ServiceDetail.SoapMapping createSoapMapping() {
      return new ServiceDetail.SoapMapping();
   }

   public static ServiceDetail createServiceDetail() {
      return new ServiceDetail();
   }

   public static ServiceMO createService() {
      return new ServiceMO();
   }

   public static PolicyDetail createPolicyDetail() {
      return new PolicyDetail();
   }

   public static PolicyMO createPolicy() {
      return new PolicyMO();
   }

   public static CertificateData createCertificateData() {
      return new CertificateData();
   }

   public static CertificateData createCertificateData(String var0) {
      CertificateData var1 = createCertificateData();
      if (var0 != null) {
         var1.setEncoded(HexUtils.decodeBase64(var0, true));
      }

      return var1;
   }

   public static CertificateData createCertificateData(X509Certificate var0) throws ManagedObjectFactory.FactoryException {
      CertificateData var1 = createCertificateData();
      if (var0 != null) {
         X500Principal var10000 = var0.getIssuerX500Principal();
         String[] var5 = a;
         String var2 = var10000.getName(var5[3], ValidationUtils.getOidKeywordMap());
         String var3 = var0.getSubjectX500Principal().getName();

         try {
            var2 = URLEncoder.encode(var2, var5[2]);
            var3 = URLEncoder.encode(var3, var5[1]);
         } catch (UnsupportedEncodingException var7) {
            var5 = a;
            throw new ManagedObjectFactory.FactoryException(var5[4], var7);
         }

         var1.setSerialNumber(var0.getSerialNumber());
         var1.setIssuerName(var2);
         var1.setSubjectName(var3);

         try {
            var1.setEncoded(var0.getEncoded());
         } catch (CertificateEncodingException var6) {
            throw new ManagedObjectFactory.FactoryException(a[0], var6);
         }
      }

      return var1;
   }

   public static TrustedCertificateMO createTrustedCertificate() {
      return new TrustedCertificateMO();
   }

   public static ClusterPropertyMO createClusterProperty() {
      return new ClusterPropertyMO();
   }

   public static FolderMO createFolder() {
      return new FolderMO();
   }

   public static IdentityProviderMO createIdentityProvider() {
      return new IdentityProviderMO();
   }

   public static IdentityProviderMO.LdapIdentityProviderMapping createLdapIdentityProviderMapping() {
      return new IdentityProviderMO.LdapIdentityProviderMapping();
   }

   public static CassandraConnectionMO createCassandraConnectionMO() {
      return new CassandraConnectionMO();
   }

   public static JDBCConnectionMO createJDBCConnection() {
      return new JDBCConnectionMO();
   }

   public static JMSConnection createJMSConnection() {
      return new JMSConnection();
   }

   public static JMSDestinationDetail createJMSDestinationDetails() {
      return new JMSDestinationDetail();
   }

   public static JMSDestinationMO createJMSDestination() {
      return new JMSDestinationMO();
   }

   public static PolicyExportResult createPolicyExportResult() {
      return new PolicyExportResult();
   }

   public static EncapsulatedAssertionExportResult createEncapsulatedAssertionExportResult() {
      return new EncapsulatedAssertionExportResult();
   }

   public static EncapsulatedAssertionImportResult createEncapsulatedAssertionImportResult() {
      return new EncapsulatedAssertionImportResult();
   }

   public static PolicyImportResult createPolicyImportResult() {
      return new PolicyImportResult();
   }

   public static PolicyImportResult.ImportedPolicyReference createImportedPolicyReference() {
      return new PolicyImportResult.ImportedPolicyReference();
   }

   public static PolicyReferenceInstruction createPolicyReferenceInstruction() {
      return new PolicyReferenceInstruction();
   }

   public static PolicyValidationResult createPolicyValidationResult() {
      return new PolicyValidationResult();
   }

   public static PolicyValidationResult.PolicyValidationMessage createPolicyValidationMessage() {
      return new PolicyValidationResult.PolicyValidationMessage();
   }

   public static PolicyValidationResult.AssertionDetail createAssertionDetail() {
      return new PolicyValidationResult.AssertionDetail();
   }

   public static PrivateKeyMO createPrivateKey() {
      return new PrivateKeyMO();
   }

   public static PrivateKeyCreationContext createPrivateKeyCreationContext() {
      return new PrivateKeyCreationContext();
   }

   public static Resource createResource() {
      return new Resource();
   }

   public static ResourceSet createResourceSet() {
      return new ResourceSet();
   }

   public static ResourceDocumentMO createResourceDocument() {
      return new ResourceDocumentMO();
   }

   public static RevocationCheckingPolicyMO createRevocationCheckingPolicy() {
      return new RevocationCheckingPolicyMO();
   }

   public static RevocationCheckingPolicyItemMO createRevocationCheckingPolicyItem() {
      return new RevocationCheckingPolicyItemMO();
   }

   public static ListenPortMO createListenPort() {
      return new ListenPortMO();
   }

   public static ListenPortMO.TlsSettings createTlsSettings() {
      return new ListenPortMO.TlsSettings();
   }

   public static InterfaceTagMO createInterfaceTag() {
      return new InterfaceTagMO();
   }

   public static StoredPasswordMO createStoredPassword() {
      return new StoredPasswordMO();
   }

   public static EncapsulatedAssertionMO createEncapsulatedAssertion() {
      return new EncapsulatedAssertionMO();
   }

   public static GenericEntityMO createGenericEntity() {
      return new GenericEntityMO();
   }

   public static CustomKeyValueStoreMO createCustomKeyValueStore() {
      return new CustomKeyValueStoreMO();
   }

   public static ActiveConnectorMO createActiveConnector() {
      return new ActiveConnectorMO();
   }

   public static SecurityZoneMO createSecurityZone() {
      return new SecurityZoneMO();
   }

   public static SiteMinderConfigurationMO createSiteMinderConfiguration() {
      return new SiteMinderConfigurationMO();
   }

   public static AssertionSecurityZoneMO createAssertionAccess() {
      return new AssertionSecurityZoneMO();
   }

   public static HttpConfigurationMO createHttpConfiguration() {
      return new HttpConfigurationMO();
   }

   public static PolicyAliasMO createPolicyAlias() {
      return new PolicyAliasMO();
   }

   public static ServiceAliasMO createServiceAlias() {
      return new ServiceAliasMO();
   }

   public static EmailListenerMO createEmailListener() {
      return new EmailListenerMO();
   }

   public static RbacRoleMO createRbacRoleMO() {
      return new RbacRoleMO();
   }

   public static RbacRoleAssignmentMO createRbacRoleAssignmentMO() {
      return new RbacRoleAssignmentMO();
   }

   public static RbacRolePermissionMO createRbacRolePermissionMO() {
      return new RbacRolePermissionMO();
   }

   public static RbacRolePredicateMO createRbacRolePredicateMO() {
      return new RbacRolePredicateMO();
   }

   public static UserMO createUserMO() {
      return new UserMO();
   }

   public static GroupMO createGroupMO() {
      return new GroupMO();
   }

   public static PasswordFormatted createPasswordFormatted() {
      return new PasswordFormatted();
   }

   public static FirewallRuleMO createFirewallRuleMO() {
      return new FirewallRuleMO();
   }

   public static SampleMessageMO createSampleMessageMO() {
      return new SampleMessageMO();
   }

   public static LogSinkMO createLogSinkMO() {
      return new LogSinkMO();
   }

   public static LogSinkFilter createLogSinkFilter() {
      return new LogSinkFilter();
   }

   public static ScheduledTaskMO createScheduledTaskMO() {
      return new ScheduledTaskMO();
   }

   public static ServerModuleFileMO createServerModuleFileMO() {
      return new ServerModuleFileMO();
   }

   public static PolicyBackedServiceMO createPolicyBackedServiceMO() {
      return new PolicyBackedServiceMO();
   }

   public static SolutionKitMO createSolutionKitMO() {
      return new SolutionKitMO();
   }

   public static EntityOwnershipDescriptorMO createEntityOwnershipDescriptorMO() {
      return new EntityOwnershipDescriptorMO();
   }

   public static AuditConfigurationMO createAuditConfiguration() {
      return new AuditConfigurationMO();
   }

   public static AuditFtpConfig createAuditFtpConfig() {
      return new AuditFtpConfig();
   }

   public static <MO extends ManagedObject> MO read(String var0, Class<MO> var1) throws IOException {
      StreamSource var2 = new StreamSource(new StringReader(var0));
      return MarshallingUtils.unmarshal(var1, var2);
   }

   public static <MO extends ManagedObject> MO read(Document var0, Class<MO> var1) throws IOException {
      DOMSource var2 = new DOMSource(var0);
      return MarshallingUtils.unmarshal(var1, var2);
   }

   public static <MO extends ManagedObject> MO read(InputStream var0, Class<MO> var1) throws IOException {
      StreamSource var2 = new StreamSource(var0);
      return MarshallingUtils.unmarshal(var1, var2);
   }

   public static Document write(ManagedObject var0) throws IOException {
      DOMResult var1 = new DOMResult();
      MarshallingUtils.marshal(var0, var1, false);
      return (Document)var1.getNode();
   }

   public static void write(ManagedObject var0, OutputStream var1) throws IOException {
      StreamResult var2 = new StreamResult(var1);
      MarshallingUtils.marshal(var0, var2, false);
   }

   public static JAXBContext getJAXBContext() throws JAXBException {
      return MarshallingUtils.getJAXBContext();
   }

   public static DependencyListMO createDependencyListMO() {
      return new DependencyListMO();
   }

   public static DependencyMO createDependencyMO() {
      return new DependencyMO();
   }

   public static Mapping createMapping() {
      return new Mapping();
   }

   public static Mapping createMapping(Mapping var0) {
      return new Mapping(var0);
   }

   public static Mappings createMappings(List<Mapping> var0) {
      return new Mappings(var0);
   }

   public static Link createLink(String var0, String var1) {
      return new Link(var0, var1);
   }

   public static BundleList createBundleList() {
      return new BundleList();
   }

   public static PolicyVersionMO createPolicyVersionMO() {
      return new PolicyVersionMO();
   }

   public static Bundle createBundle() {
      return new Bundle();
   }

   public static ErrorResponse createErrorResponse() {
      return new ErrorResponse();
   }

   static {
      String[] var5 = new String[5];
      int var3 = 0;
      String var2 = "BO=w'2\u0018bI;q;u_bS,w1w\u001b'^*j!{\u0019n^.l02\u001bfI.6\u0005Ri\t5m\u0005Ri\t5m";
      int var4 = "BO=w'2\u0018bI;q;u_bS,w1w\u001b'^*j!{\u0019n^.l02\u001bfI.6\u0005Ri\t5m\u0005Ri\t5m".length();
      char var1 = '\'';
      int var7 = -1;

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

         while (true) {
            String var12 = a(a(var10000));
            switch (var10001) {
               case 0:
                  var5[var3++] = var12;
                  if ((var7 += var1) >= var4) {
                     a = var5;
                     return;
                  }

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

                  var2 = "U{\f*g'L3BO=w'2\u001ai^ |<|\u0018'I'}uq\u001auI&~<q\u001esXoQ\u0006A*Bo`K\u0000P5B~\u001b8;s\u0012b\u0013";
                  var4 = "U{\f*g'L3BO=w'2\u001ai^ |<|\u0018'I'}uq\u001auI&~<q\u001esXoQ\u0006A*Bo`K\u0000P5B~\u001b8;s\u0012b\u0013".length();
                  var1 = 7;
                  var7 = -1;
            }

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

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

      return var10000;
   }

   private static String a(char[] var0) {
      int var10002 = var0.length;
      char[] var10001 = var0;
      int var10000 = var10002;

      for (int var1 = 0; var10000 > var1; var1++) {
         var10001[var1] = (char)(var10001[var1] ^ switch (var1 % 7) {
            case 0 -> 7;
            case 1 -> 61;
            case 2 -> 79;
            case 3 -> 24;
            case 4 -> 85;
            case 5 -> 18;
            default -> 127;
         });
      }

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

   public static class FactoryException extends ManagementException {
      static final long serialVersionUID = -4442291994492652276L;

      public FactoryException(String var1) {
         super(var1);
      }

      public FactoryException(String var1, Throwable var2) {
         super(var1, var2);
      }

      public FactoryException(Throwable var1) {
         super(var1);
      }
   }
}