/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.databind.codegen;
   
   import java.net.URI;
   import java.net.URISyntaxException;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  
  import dev.metaschema.core.util.ObjectUtils;
  import edu.umd.cs.findbugs.annotations.NonNull;
  
  /**
   * A variety of utility methods for normalizing Java class related names.
   */
  public final class ClassUtils {
    private static final Map<String, String> JAVA_NAME_MAPPER = Map.ofEntries(
        Map.entry("Class", "Clazz"));
  
    private ClassUtils() {
      // disable construction
    }
  
    /**
     * Transforms the provided name into a string suitable for use as a Java
     * property name.
     *
     * @param name
     *          the name of an information element definition
     * @return a Java property name
     */
    @SuppressWarnings("null")
    @NonNull
    public static String toPropertyName(@NonNull String name) {
      String property = upperCamelCase(name);
      return JAVA_NAME_MAPPER.getOrDefault(property, property);
    }
  
    /**
     * Transforms the provided name into a string suitable for use as a Java
     * variable name.
     *
     * @param name
     *          the name of an information element definition
     * @return a Java variable name
     */
    @NonNull
    public static String toVariableName(@NonNull String name) {
      return lowerCamelCase(name);
    }
  
    /**
     * Transforms the provided name into a string suitable for use as a Java class
     * name.
     *
     * @param name
     *          the name of an information element definition
     * @return a Java variable name
     */
    @NonNull
    public static String toClassName(@NonNull String name) {
      return upperCamelCase(name);
    }
  
    /**
     * Transforms the provided name into a string suitable for use as a Java package
     * name.
     *
     * @param namespace
     *          a namespace URI to convert to a package name
     * @return a Java package name
     */
    @NonNull
    public static String toPackageName(@NonNull String namespace) {
      return getPackageFromNamespace(namespace);
    }
  
    /**
     * Converts a string to UpperCamelCase.
     * <p>
     * Splits on common separators (hyphen, underscore, period, whitespace) and
     * capitalizes the first letter of each word.
     *
     * @param name
     *          the name to convert
     * @return the name in UpperCamelCase
     */
    @NonNull
    private static String upperCamelCase(@NonNull String name) {
      List<String> words = splitWords(name);
      StringBuilder sb = new StringBuilder();
      for (String word : words) {
        if (!word.isEmpty()) {
         sb.append(Character.toUpperCase(word.charAt(0)));
         if (word.length() > 1) {
           sb.append(word.substring(1).toLowerCase(Locale.ROOT));
         }
       }
     }
     return sb.length() > 0 ? ObjectUtils.notNull(sb.toString()) : name;
   }
 
   /**
    * Converts a string to lowerCamelCase.
    * <p>
    * Splits on common separators (hyphen, underscore, period, whitespace) and
    * capitalizes the first letter of each word except the first.
    *
    * @param name
    *          the name to convert
    * @return the name in lowerCamelCase
    */
   @NonNull
   private static String lowerCamelCase(@NonNull String name) {
     List<String> words = splitWords(name);
     StringBuilder sb = new StringBuilder();
     boolean first = true;
     for (String word : words) {
       if (!word.isEmpty()) {
         if (first) {
           sb.append(word.toLowerCase(Locale.ROOT));
           first = false;
         } else {
           sb.append(Character.toUpperCase(word.charAt(0)));
           if (word.length() > 1) {
             sb.append(word.substring(1).toLowerCase(Locale.ROOT));
           }
         }
       }
     }
     return sb.length() > 0 ? ObjectUtils.notNull(sb.toString()) : name;
   }
 
   /**
    * Splits a name into words based on common separators.
    * <p>
    * Handles hyphens, underscores, periods, and whitespace as word separators.
    * Also splits on camelCase boundaries.
    *
    * @param name
    *          the name to split
    * @return a list of words
    */
   @NonNull
   private static List<String> splitWords(@NonNull String name) {
     List<String> words = new ArrayList<>();
     StringBuilder currentWord = new StringBuilder();
 
     for (int i = 0; i < name.length(); i++) {
       char ch = name.charAt(i);
       if (ch == '-' || ch == '_' || ch == '.' || Character.isWhitespace(ch)) {
         // Separator found, end current word
         if (currentWord.length() > 0) {
           words.add(currentWord.toString());
           currentWord = new StringBuilder();
         }
       } else if (Character.isUpperCase(ch) && currentWord.length() > 0
           && Character.isLowerCase(currentWord.charAt(currentWord.length() - 1))) {
         // CamelCase boundary
         words.add(currentWord.toString());
         currentWord = new StringBuilder();
         currentWord.append(ch);
       } else {
         currentWord.append(ch);
       }
     }
     if (currentWord.length() > 0) {
       words.add(currentWord.toString());
     }
     return words;
   }
 
   /**
    * Converts a namespace URI to a Java package name.
    * <p>
    * Based on the standard URI to package name algorithm:
    * <ol>
    * <li>Extract the host and reverse it (e.g., "csrc.nist.gov" becomes
    * "gov.nist.csrc")</li>
    * <li>Append the path segments, replacing separators with dots</li>
    * <li>Remove or escape invalid package name characters</li>
    * </ol>
    *
    * @param namespace
    *          the namespace URI
    * @return a valid Java package name
    */
   @NonNull
   private static String getPackageFromNamespace(@NonNull String namespace) {
     try {
       URI uri = new URI(namespace);
       StringBuilder sb = new StringBuilder();
 
       // Process the host (reverse the domain name)
       String host = uri.getHost();
       if (host != null && !host.isEmpty()) {
         String[] hostParts = host.split("\\.");
         for (int i = hostParts.length - 1; i >= 0; i--) {
           if (sb.length() > 0) {
             sb.append('.');
           }
           sb.append(normalizePackagePart(ObjectUtils.notNull(hostParts[i])));
         }
       }
 
       // Process the path
       String path = uri.getPath();
       if (path != null && !path.isEmpty()) {
         String[] pathParts = path.split("/");
         for (String part : pathParts) {
           if (!part.isEmpty()) {
             if (sb.length() > 0) {
               sb.append('.');
             }
             sb.append(normalizePackagePart(part));
           }
         }
       }
 
       return sb.length() > 0 ? ObjectUtils.notNull(sb.toString()) : "generated";
     } catch (@SuppressWarnings("unused") URISyntaxException ex) {
       // Fall back to a simple approach if URI parsing fails
       return normalizePackagePart(ObjectUtils.notNull(namespace.replaceAll("[^a-zA-Z0-9]", "_")));
     }
   }
 
   /**
    * Normalizes a string to be a valid Java package name part.
    * <p>
    * Replaces or removes invalid characters and ensures the result is a valid
    * identifier.
    *
    * @param part
    *          the package name part to normalize
    * @return a valid package name part
    */
   @NonNull
   private static String normalizePackagePart(@NonNull String part) {
     if (part.isEmpty()) {
       return "_";
     }
 
     StringBuilder sb = new StringBuilder();
     for (int i = 0; i < part.length(); i++) {
       char ch = part.charAt(i);
       if (i == 0) {
         if (Character.isJavaIdentifierStart(ch)) {
           sb.append(Character.toLowerCase(ch));
         } else if (Character.isDigit(ch)) {
           sb.append('_');
           sb.append(ch);
         } else {
           sb.append('_');
         }
       } else {
         if (Character.isJavaIdentifierPart(ch)) {
           sb.append(Character.toLowerCase(ch));
         } else if (ch == '-' || ch == '.') {
           // Common separators become underscores
           sb.append('_');
         }
         // else skip invalid characters
       }
     }
 
     String result = ObjectUtils.notNull(sb.toString());
     // Handle Java reserved words
     if (isJavaReservedWord(result)) {
       return "_" + result;
     }
     return result.isEmpty() ? "_" : result;
   }
 
   /**
    * Java reserved words and contextual keywords that cannot be used as
    * identifiers.
    * <p>
    * Includes both traditional reserved words and contextual keywords introduced
    * in later Java versions (var, yield, record, sealed, permits) for forward
    * compatibility.
    */
   private static final Set<String> JAVA_RESERVED_WORDS = Set.of(
       "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const",
       "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float",
       "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native",
       "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp",
       "super", "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void",
       "volatile", "while", "true", "false", "null",
       // Contextual keywords (Java 9+)
       "module", "var", "yield", "record", "sealed", "permits");
 
   /**
    * Checks if the given string is a Java reserved word.
    *
    * @param word
    *          the word to check
    * @return {@code true} if the word is a Java reserved word
    */
   private static boolean isJavaReservedWord(@NonNull String word) {
     return JAVA_RESERVED_WORDS.contains(word);
   }
 }