package com.l7tech.objectmodel;

import com.l7tech.util.Functions.Unary;
import jakarta.persistence.Column;
import java.lang.reflect.AccessibleObject;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class EntityUtil {
   private static final String a;

   public static int getMaxFieldLength(Class<?> var0, String var1, int var2) {
      Integer var3 = b(var0, var1);
      if (var3 == null) {
         var3 = a(var0, var1);
      }

      return var3 == null ? var2 : var3;
   }

   private static Integer a(Class<?> var0, String var1) {
      try {
         char[] var2 = var1.toCharArray();
         var2[0] = Character.toUpperCase(var2[0]);
         String var3 = new StringBuilder(var1.length() + 3).append(a).append(var2).toString();
         return a(var0.getMethod(var3));
      } catch (NoSuchMethodException var4) {
         return null;
      }
   }

   private static Integer b(Class<?> var0, String var1) {
      try {
         return a(var0.getField(var1));
      } catch (NoSuchFieldException var5) {
         try {
            return a(var0.getDeclaredField(var1));
         } catch (NoSuchFieldException var4) {
            return null;
         }
      }
   }

   private static Integer a(AccessibleObject var0) {
      Column var1 = var0.getAnnotation(Column.class);
      return var1 == null ? null : var1.length();
   }

   public static <ET extends PersistentEntity> Map<Goid, ET> buildEntityMap(Iterable<ET> var0) {
      HashMap var1 = new HashMap();

      for (PersistentEntity var3 : var0) {
         var1.put(var3.getGoid(), var3);
      }

      return var1;
   }

   public static <T extends PersistentEntity> EntityUtil.CreatedUpdatedDeleted<T> findCreatedUpdatedDeleted(Map<Goid, T> var0, Map<Goid, T> var1) {
      HashMap var2 = new HashMap();
      HashMap var3 = new HashMap();

      for (Entry var5 : var1.entrySet()) {
         Goid var6 = (Goid)var5.getKey();
         PersistentEntity var7 = (PersistentEntity)var5.getValue();
         if (!var0.containsKey(var6)) {
            var2.put(var6, var7);
         } else {
            PersistentEntity var8 = (PersistentEntity)var0.get(var6);
            if (var8.getVersion() != var7.getVersion()) {
               var3.put(var6, var7);
            }
         }
      }

      HashSet var9 = new HashSet();

      for (Goid var11 : var0.keySet()) {
         if (!var1.containsKey(var11)) {
            var9.add(var11);
         }
      }

      return new EntityUtil.CreatedUpdatedDeleted<>(var2, var3, var9);
   }

   public static Unary<String, Entity> id() {
      return new c();
   }

   public static Unary<String, NamedEntity> name() {
      return new d();
   }

   static {
      String var10002 = a(104, a("&rV"));
      byte var10001 = -1;
      a = var10002;
   }

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

      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 -> 41;
            case 1 -> 127;
            case 2 -> 74;
            case 3 -> 4;
            case 4 -> 77;
            case 5 -> 33;
            default -> 10;
         });
      }

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

   public static class CreatedUpdatedDeleted<T extends PersistentEntity> {
      public final Map<Goid, T> created;
      public final Map<Goid, T> updated;
      public final Set<Goid> deleted;

      public CreatedUpdatedDeleted(Map<Goid, T> var1, Map<Goid, T> var2, Set<Goid> var3) {
         this.created = var1;
         this.updated = var2;
         this.deleted = var3;
      }
   }
}