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

import com.l7tech.external.assertions.gatewaygraphql.EntityTypeInfo;
import com.l7tech.external.assertions.gatewaygraphql.server.data.EncassConfigDTO;
import com.l7tech.external.assertions.gatewaygraphql.server.data.EntityMappingInstruction;
import com.l7tech.external.assertions.gatewaygraphql.server.error.MissingDataException;
import com.l7tech.external.assertions.gatewaygraphql.server.input.EncassArgInput;
import com.l7tech.external.assertions.gatewaygraphql.server.input.EncassResInput;
import com.l7tech.external.assertions.gatewaygraphql.server.resolver.EntityResolver;
import com.l7tech.external.assertions.gatewaygraphql.server.util.Util;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.ZoneableGuidEntityHeader;
import com.l7tech.objectmodel.encass.EncapsulatedAssertionArgumentDescriptor;
import com.l7tech.objectmodel.encass.EncapsulatedAssertionConfig;
import com.l7tech.objectmodel.encass.EncapsulatedAssertionResultDescriptor;
import com.l7tech.policy.Policy;
import com.l7tech.server.policy.EncapsulatedAssertionConfigManager;
import com.l7tech.server.policy.PolicyManager;
import graphql.schema.DataFetchingEnvironment;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.logging.Logger;
import lombok.Generated;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.transaction.PlatformTransactionManager;

public class EncassConfigMutationResolver
   extends EntityManagerAwareGraphQLMutationResolver<EncapsulatedAssertionConfig, ZoneableGuidEntityHeader, EncapsulatedAssertionConfigManager, EncassConfigDTO, EncassConfigDTO.EncassConfigInput> {
   @Generated
   private static final Logger b;
   private final PolicyManager c;
   private static final String[] d;

   public EncassConfigMutationResolver(PlatformTransactionManager var1, BeanFactory var2) {
      String[] var3 = d;
      super(EntityTypeInfo.ENCASS_CONFIG, var1, (EncapsulatedAssertionConfigManager)var2.getBean(var3[7], EncapsulatedAssertionConfigManager.class));
      this.c = (PolicyManager)var2.getBean(var3[0], PolicyManager.class);
   }

   @Override
   protected Logger getLogger() {
      return b;
   }

   public EncassConfigDTO.EncassConfigsPayload setEncassConfigs(List<EncassConfigDTO.EncassConfigInput> var1, DataFetchingEnvironment var2) {
      EncassConfigDTO.EncassConfigsPayload var3 = new EncassConfigDTO.EncassConfigsPayload();

      try {
         this.transformNoDefEntityMappings(var1, var2);
         if (var1.isEmpty()) {
            return var3;
         }
      } catch (MissingDataException var4) {
         throw a(var4);
      }

      return this.execute(var2, (var3x, var4x) -> {
         var1.forEach(var4xx -> this.doUpsertSilently(var4xx, var3x, var3, var4x));
         return var3;
      });
   }

   public EncassConfigDTO.EncassConfigsPayload deleteEncassConfigs(List<String> var1, DataFetchingEnvironment var2) {
      EncassConfigDTO.EncassConfigsPayload var3 = new EncassConfigDTO.EncassConfigsPayload();

      try {
         if (var1.isEmpty()) {
            return var3;
         }
      } catch (MissingDataException var4) {
         throw a(var4);
      }

      return this.execute(var2, (var3x, var4x) -> {
         var1.forEach(var4xx -> this.doDeleteSilently(var4xx, var3x, var3, var4x));
         return var3;
      });
   }

   protected EncapsulatedAssertionConfig toEntity(EncassConfigDTO.EncassConfigInput var1) {
      return new EncapsulatedAssertionConfig();
   }

   protected EncassConfigDTO toEntityDTO(EncapsulatedAssertionConfig var1) {
      return new EncassConfigDTO(var1);
   }

   protected EncassConfigDTO.EncassConfigInput toEntityInput(EntityMappingInstruction var1) {
      EncassConfigDTO.EncassConfigInput var2 = new EncassConfigDTO.EncassConfigInput();
      var2.setName(var1.getIdentityValue());
      return var2;
   }

   protected void setEntity(EncassConfigDTO.EncassConfigInput var1, EncapsulatedAssertionConfig var2) {
      try {
         var2.setName(var1.getName());
         if (this.isNewEntity(var2)) {
            var2.setGuid(Util.getOrCreateGuid(var1.getGuid()));
         }
      } catch (MissingDataException var5) {
         throw a(var5);
      }

      Policy var3 = EntityResolver.toEntityByNameSilently(this.c, var1.getPolicyName());

      try {
         if (var3 == null) {
            throw new MissingDataException(d[8] + var1.getPolicyName());
         }
      } catch (MissingDataException var4) {
         throw a(var4);
      }

      var2.setPolicy(var3);
      this.b(var1, var2);
      this.a(var1, var2);
   }

   protected void resetEntitySelectively(EncassConfigDTO.EncassConfigInput var1, EncapsulatedAssertionConfig var2) {
      try {
         if (var2.getArgumentDescriptors() != null) {
            var2.getArgumentDescriptors().clear();
         }
      } catch (MissingDataException var3) {
         throw a(var3);
      }

      try {
         if (var2.getResultDescriptors() != null) {
            var2.getResultDescriptors().clear();
         }
      } catch (MissingDataException var4) {
         throw a(var4);
      }

      var2.setProperties(new HashMap());
   }

   protected EncapsulatedAssertionConfig findByInput(EncassConfigDTO.EncassConfigInput var1) throws FindException {
      return this.findByName(var1.getName());
   }

   private void a(EncassConfigDTO.EncassConfigInput var1, EncapsulatedAssertionConfig var2) {
      Map var3 = Optional.ofNullable(var2.getProperties()).orElse(new HashMap());

      try {
         if (var1.getProperties() != null) {
            var1.getProperties().stream().filter(var0 -> {
               try {
                  if (!var0.getName().equals(EncapsulatedAssertionConfig.PROP_POLICY_GUID)) {
                     return true;
                  }
               } catch (MissingDataException var1x) {
                  throw a(var1x);
               }

               return false;
            }).forEach(var1x -> var3.put(var1x.getName(), var1x.getValue()));
         }
      } catch (MissingDataException var6) {
         throw a(var6);
      }

      try {
         var3.putIfAbsent(d[4], d[2]);
         var3.putIfAbsent(d[1], d[3]);
         var3.putIfAbsent(d[5], d[6]);
         if (var2.getPolicy() != null) {
            var3.put(EncapsulatedAssertionConfig.PROP_POLICY_GUID, var2.getPolicy().getGuid());
         }
      } catch (MissingDataException var4) {
         throw a(var4);
      }

      try {
         if (var1.getDescription() != null) {
            var3.put(EncapsulatedAssertionConfig.PROP_DESCRIPTION, var1.getDescription());
         }
      } catch (MissingDataException var5) {
         throw a(var5);
      }

      var2.setProperties(var3);
   }

   private void b(EncassConfigDTO.EncassConfigInput var1, EncapsulatedAssertionConfig var2) {
      if (var1.getEncassArgs() != null) {
         Set var3 = Optional.ofNullable(var2.getArgumentDescriptors()).orElse(new HashSet());
         var1.getEncassArgs().forEach(var3x -> var3.add(this.a(var2, var3x)));
         var2.setArgumentDescriptors(var3);
      }

      if (var1.getEncassResults() != null) {
         Set var4 = Optional.ofNullable(var2.getResultDescriptors()).orElse(new HashSet());
         var1.getEncassResults().forEach(var3x -> var4.add(this.a(var2, var3x)));
         var2.setResultDescriptors(var4);
      }
   }

   private EncapsulatedAssertionArgumentDescriptor a(EncapsulatedAssertionConfig var1, EncassArgInput var2) {
      EncapsulatedAssertionArgumentDescriptor var3 = new EncapsulatedAssertionArgumentDescriptor();

      try {
         var3.setEncapsulatedAssertionConfig(var1);
         var3.setArgumentName(var2.getName());
         var3.setArgumentType(EncassConfigDTO.variableDataType(var2.getType()).getShortName());
         var3.setGuiLabel(var2.getGuiLabel());
         if (var2.getOrdinal() != null) {
            var3.setOrdinal(var2.getOrdinal());
         }
      } catch (MissingDataException var4) {
         throw a(var4);
      }

      var3.setGuiPrompt(var2.isGuiPrompt());
      return var3;
   }

   private EncapsulatedAssertionResultDescriptor a(EncapsulatedAssertionConfig var1, EncassResInput var2) {
      EncapsulatedAssertionResultDescriptor var3 = new EncapsulatedAssertionResultDescriptor();
      var3.setEncapsulatedAssertionConfig(var1);
      var3.setResultName(var2.getName());
      var3.setResultType(EncassConfigDTO.variableDataType(var2.getType()).getShortName());
      return var3;
   }

   static {
      String[] var5 = new String[9];
      int var3 = 0;
      String var2 = "l5\u001c&}\u0002j}4\u0011({\t\f}6\u001c i/U}9\u0019!y\u000bl5\u001c&}\u0002ks=\u0019,\u0005z;\u001c<{\rl;\u001c*j\u000fBZ5\u001c+{\t\u0013l;\u0003<S\u001eSn3\u0013<J\u0014w}(\u0015!j\u0005z;\u001c<{";
      int var4 = "l5\u001c&}\u0002j}4\u0011({\t\f}6\u001c i/U}9\u0019!y\u000bl5\u001c&}\u0002ks=\u0019,\u0005z;\u001c<{\rl;\u001c*j\u000fBZ5\u001c+{\t\u0013l;\u0003<S\u001eSn3\u0013<J\u0014w}(\u0015!j\u0005z;\u001c<{"
         .length();
      char var1 = '\r';
      int var7 = -1;

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

         while (true) {
            String var8 = c(var10000, b(var10001));
            switch (var10002) {
               case 0:
                  var5[var3++] = var8;
                  if ((var7 += var1) >= var4) {
                     d = var5;
                     b = Logger.getLogger(EncassConfigMutationResolver.class.getName());
                     return;
                  }

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

                  var2 = "L\u0001&\u001b[=gE\u000e1\u001fO\u000faZ\n7\u000eB!|j\u0000+\u001cB)_H\u0001$\u001dN<\u0016d\u00066\tB u\t\n+\u0019J=a\t\u001f*\u0016B-k\t";
                  var4 = "L\u0001&\u001b[=gE\u000e1\u001fO\u000faZ\n7\u000eB!|j\u0000+\u001cB)_H\u0001$\u001dN<\u0016d\u00066\tB u\t\n+\u0019J=a\t\u001f*\u0016B-k\t"
                     .length();
                  var1 = '"';
                  var7 = -1;
            }

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

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

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

      return var10000;
   }

   private static String c(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 -> 74;
            case 1 -> 12;
            case 2 -> 38;
            case 3 -> 25;
            case 4 -> 72;
            case 5 -> 45;
            default -> 113;
         });
      }

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