package com.acumenvelocity.ath.common;
   
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.io.UncheckedIOException;
   import java.lang.reflect.Method;
   import java.net.URI;
  import java.net.URLEncoder;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.nio.file.attribute.PosixFilePermissions;
  import java.text.DateFormat;
  import java.time.Instant;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Date;
  import java.util.List;
  import java.util.Objects;
  import java.util.Optional;
  import java.util.UUID;
  import java.util.zip.ZipEntry;
  import java.util.zip.ZipInputStream;
  import java.util.zip.ZipOutputStream;
  
  import com.fasterxml.jackson.databind.JsonNode;
  
  import net.sf.okapi.common.BOMAwareInputStream;
  import net.sf.okapi.common.StreamUtil;
  import net.sf.okapi.common.Util;
  
  /**
   * Utility class providing commonly used helper methods for
   * null-safe operations, conversions, and lightweight object handling.
   * 
   * @author Acumen Velocity
   * @version 1.0
   * @since 1.0
   */
  public class AthUtil {
  
    /**
     * Returns the given value if non-null, otherwise returns a default value.
     *
     * @param <T>    the type of the values
     * @param val    the candidate value
     * @param defVal the default value if {@code val} is {@code null}
     * @return {@code val} if not {@code null}, otherwise {@code defVal}
     */
    public static <T> T fallback(T val, T defVal) {
      return Optional.ofNullable(val).orElse(defVal);
    }
  
    /**
     * Converts the given object to its string representation,
     * or returns a fallback string if the object is null.
     *
     * @param val the object to stringify
     * @return the string representation or {@code defVal} if {@code val} is null
     */
    public static String safeToStr(Object val, String defVal) {
      return val == null ? defVal : val.toString();
    }
  
    /**
     * Returns the provided string if non-empty, otherwise returns defVal.
     *
     * @param val the candidate string
     * @return the string representation or {@code defVal} if {@code val} is null
     */
    public static String safeToStr(String val, String defVal) {
      return Util.isEmpty(val) ? defVal : val;
    }
  
    /**
     * Attempts to parse an integer from a string.
     * Returns the provided default value if parsing fails.
     *
     * @param val    the string to parse
     * @param defVal the default value to return on failure
     * @return parsed integer or {@code defVal} if parsing fails
     */
    public static Integer safeToInt(String val, int defVal) {
      try {
        return Integer.valueOf(val);
  
      } catch (Exception e) {
        return defVal;
      }
    }
  
    public static UUID safeToUuid(String val, UUID defVal) {
      try {
        return UUID.fromString(val);
  
      } catch (Exception e) {
        return defVal;
     }
   }
 
   public static List<UUID> safeToUuidList(Object val, List<UUID> defVal) {
     if (val == null) {
       return defVal != null ? defVal : Collections.emptyList();
     }
 
     List<UUID> result = new ArrayList<>();
 
     if (val instanceof List) {
       // Handle multi-valued field from Solr (e.g., List<String>)
       for (Object item : (List<?>) val) {
         if (item != null) {
           UUID uuid = safeToUuid(item.toString(), null);
 
           if (uuid != null) {
             result.add(uuid);
           }
         }
       }
     } else if (val instanceof String) {
       // Handle comma-separated string of UUIDs
       String[] uuidStrings = val.toString().split(",");
 
       for (String uuidStr : uuidStrings) {
         uuidStr = uuidStr.trim();
 
         if (!uuidStr.isEmpty()) {
           UUID uuid = safeToUuid(uuidStr, null);
 
           if (uuid != null) {
             result.add(uuid);
           }
         }
       }
     }
 
     return result.isEmpty() && defVal != null ? defVal : result;
   }
 
   public static <E extends Enum<E>> E safeToEnum(String val, Class<E> enumClass, E defVal) {
     if (val == null) {
       return defVal;
     }
 
     try {
       // First try standard valueOf (matches enum constant name)
       return Enum.valueOf(enumClass, val);
 
     } catch (IllegalArgumentException e) {
       // If that fails, try to find a fromValue method (common in generated enums)
       try {
         Method fromValue = enumClass.getMethod("fromValue", String.class);
         return enumClass.cast(fromValue.invoke(null, val));
 
       } catch (Exception ex) {
         return defVal;
       }
     }
   }
 
   /**
    * Adds a non-null element to a list.
    *
    * @param <E>  the element type
    * @param list the list to add to
    * @param elem the element to add (ignored if null)
    * @return true if the element was added, false if {@code elem} was null
    */
   public static <E> boolean safeAddToList(List<E> list, E elem) {
     if (elem == null) {
       return false;
     }
     return list.add(elem);
   }
 
   /**
    * Returns the last {@code numChars} characters of a string.
    *
    * @param st       the string
    * @param numChars the number of trailing characters to return
    * @return substring of last {@code numChars}, or empty string if
    *         {@code st} is null/empty or shorter than {@code numChars}
    */
   public static String lastChars(String st, int numChars) {
     if (Util.isEmpty(st) || st.length() < numChars) {
       return "";
     }
     return st.substring(st.length() - numChars);
   }
 
   /**
    * Creates a shallow copy of the given object using JSON serialization.
    * <p>
    * This relies on {@link JacksonUtil} for serialization and deserialization.
    * Note that it is not a deep clone; nested objects may be shared.
    *
    * @param <T> the object type
    * @param obj the object to clone
    * @param cls the class type
    * @return a shallow copy of {@code obj}
    */
   public static <T> T clone(T obj, Class<T> cls) {
     return JacksonUtil.fromJson(JacksonUtil.toJson(obj, false), cls);
   }
 
   public static <T> List<T> removeNulls(List<T> list) {
     list.removeIf(Objects::isNull);
     return list;
   }
 
   public static String fileAsString(final File file) throws IOException {
     try (final BOMAwareInputStream bis = new BOMAwareInputStream(new FileInputStream(file),
         "UTF-8")) {
       return StreamUtil.streamAsString(bis, bis.detectEncoding());
     }
   }
 
   /**
    * Safely converts a JsonNode to a specified class type.
    * Returns defVal if conversion fails or node is null.
    */
   public static <T> T safeFromJsonNode(JsonNode node, Class<T> clazz, T defVal) {
     if (node == null) {
       return defVal;
     }
     try {
       return JacksonUtil.fromJsonNode(node, clazz);
     } catch (Exception e) {
       return defVal;
     }
   }
 
   /**
    * Safely converts a Date object from an object.
    * Returns defVal if field is null or not a Date.
    */
   public static Date safeToDate(Object val, Date defVal) {
     if (val == null) {
       return defVal;
     }
     try {
       return (Date) val;
     } catch (ClassCastException e) {
       return defVal;
     }
   }
 
   /**
    * Safely parses a Long from a string.
    * Returns defVal if parsing fails or val is null.
    */
   public static Long safeToLong(String val, Long defVal) {
     if (val == null) {
       return defVal;
     }
     try {
       return Long.parseLong(val);
     } catch (NumberFormatException e) {
       return defVal;
     }
   }
 
   /**
    * Safely parses a Float from a string or object.
    * Returns defVal if parsing fails or val is null.
    */
   public static Float safeToFloat(Object val, Float defVal) {
     if (val == null) {
       return defVal;
     }
     try {
       if (val instanceof Float) {
         return (Float) val;
       }
       return Float.parseFloat(val.toString());
     } catch (Exception e) {
       return defVal;
     }
   }
 
   /**
    * Safely parses a Float from a string or object.
    * Returns defVal if parsing fails or val is null.
    */
   public static Double safeToDouble(Object val, Double defVal) {
     if (val == null) {
       return defVal;
     }
 
     try {
       if (val instanceof Double) {
         return (Double) val;
       }
 
       return Double.parseDouble(val.toString());
 
     } catch (Exception e) {
       return defVal;
     }
   }
 
   /**
    * Safely parses an ISO-8601 date string from JsonNode.
    * Returns defVal if parsing fails.
    */
   public static Date safeToDateFromIso(String isoDateStr, Date defVal) {
     if (Util.isEmpty(isoDateStr)) {
       return defVal;
     }
     try {
       return Date.from(Instant.parse(isoDateStr));
     } catch (Exception e) {
       return defVal;
     }
   }
 
   public static String dateToString(DateFormat dateFormat, Date date) {
     return dateFormat.format(date);
   }
 
   public static File createTempFile() {
     return createTempFile(Const.TEMP_PREFIX, null);
   }
 
   public static File createTempFile(String suffix) {
     return createTempFile(Const.TEMP_PREFIX, suffix);
   }
 
   public static File createTempFile(String prefix, String suffix) {
     File file = null;
 
     try {
       file = File.createTempFile(prefix, suffix);
       file.deleteOnExit();
 
       // Set the file permissions to allow only the owner to read and write
       try {
         Files.setPosixFilePermissions(file.toPath(),
             PosixFilePermissions.fromString("rw-------"));
 
       } catch (UnsupportedOperationException e) {
         // Non-POSIX OS like Windows
         file.setReadable(true);
         file.setWritable(true);
       }
 
       return file;
 
     } catch (Exception e) {
       Log.warn(AthUtil.class, "Cannot create a temp file: {}", e.getMessage());
       return null;
     }
   }
 
   /**
    * Converts a string to URI, encoding the path component if needed
    * Handles any URI scheme (gs://, http://, https://, file://, etc.)
    */
   public static URI toURI(String uriString) {
     if (Util.isEmpty(uriString)) {
       return null;
     }
 
     try {
       String trimmed = uriString.trim();
 
       // Try direct creation first
       try {
         return URI.create(trimmed);
 
       } catch (IllegalArgumentException e) {
         // If direct creation fails, try encoding the path
       }
 
       // Parse the URI to encode only the path component
       int schemeEnd = trimmed.indexOf("://");
 
       if (schemeEnd == -1) {
         // No scheme, treat as path only
         return URI.create(encodePath(trimmed));
       }
 
       String scheme = trimmed.substring(0, schemeEnd);
       String rest = trimmed.substring(schemeEnd + 3); // After "://"
 
       // Find where authority ends and path begins
       int pathStart = rest.indexOf('/');
 
       if (pathStart == -1) {
         // No path, just scheme://authority
         return URI.create(trimmed);
       }
 
       String authority = rest.substring(0, pathStart);
       String pathAndQuery = rest.substring(pathStart + 1);
 
       // Split path from query/fragment
       int queryStart = pathAndQuery.indexOf('?');
       int fragmentStart = pathAndQuery.indexOf('#');
 
       String path;
       String suffix = "";
 
       if (queryStart != -1) {
         path = pathAndQuery.substring(0, queryStart);
         suffix = pathAndQuery.substring(queryStart);
 
       } else if (fragmentStart != -1) {
         path = pathAndQuery.substring(0, fragmentStart);
         suffix = pathAndQuery.substring(fragmentStart);
 
       } else {
         path = pathAndQuery;
       }
 
       // Encode the path segments
       String encodedPath = encodePath(path);
 
       return URI.create(scheme + "://" + authority + "/" + encodedPath + suffix);
 
     } catch (Exception e) {
       return null;
     }
   }
 
   /**
    * Encodes each segment of a path
    */
   private static String encodePath(String path) throws Exception {
     if (path.isEmpty()) {
       return path;
     }
 
     String[] segments = path.split("/", -1); // -1 to preserve trailing empty strings
     StringBuilder encoded = new StringBuilder();
 
     for (int i = 0; i < segments.length; i++) {
       if (i > 0)
         encoded.append("/");
 
       if (!segments[i].isEmpty()) {
         encoded.append(URLEncoder.encode(segments[i], "UTF-8")
             .replace("+", "%20")); // Use %20 instead of + for spaces
       }
     }
 
     return encoded.toString();
   }
 
   /**
    * Extracts the last section after the last slash in a path.
    * 
    * @param path the input path string
    * @return the last section after the last slash, or empty string if no slash found
    * @throws NullPointerException if the input path is null
    */
   public static String extractLastSection(String path) {
     Objects.requireNonNull(path, "Path cannot be null");
 
     int lastSlashIndex = path.lastIndexOf('/');
 
     if (lastSlashIndex == -1) {
       return "";
     }
 
     return path.substring(lastSlashIndex + 1);
   }
 
   /**
    * Extracts the last section after the last slash, with a fallback value.
    * 
    * @param path         the input path string
    * @param defaultValue the value to return if no section can be extracted
    * @return the last section after slash, or defaultValue if not found
    */
   public static String extractLastSectionOrDefault(String path, String defaultValue) {
     if (path == null || path.isEmpty()) {
       return defaultValue;
     }
 
     int lastSlashIndex = path.lastIndexOf('/');
     if (lastSlashIndex == -1 || lastSlashIndex == path.length() - 1) {
       return defaultValue;
     }
 
     return path.substring(lastSlashIndex + 1);
   }
 
   public static String nullIfEmpty(JsonNode node) {
     if (node == null || node.isNull() || node.asText("").trim().isEmpty()) {
       return null;
     }
     return node.asText();
   }
 
   public static Integer safeToInt(JsonNode node, Integer defaultValue) {
     if (node == null || node.isNull() || !node.canConvertToInt()) {
       return defaultValue;
     }
     return node.asInt();
   }
 
   public static UUID safeToUuid(JsonNode node, UUID defaultValue) {
     if (node == null || node.isNull()) {
       return defaultValue;
     }
     String text = node.asText(null);
     return safeToUuid(text, defaultValue);
   }
 
   public static void deleteFile(File file) {
     if (file != null && file.exists()) {
       if (!file.delete()) {
         file.deleteOnExit();
       }
     }
   }
 
   public static void deleteDirectory(File dir) {
     File[] files = dir.listFiles();
 
     if (files != null) {
       for (File file : files) {
         if (file.isDirectory()) {
           deleteDirectory(file);
 
         } else {
           file.delete();
         }
       }
     }
 
     dir.delete();
   }
   
   public static void zip(String sourceDirPath, String zipFilePath) throws IOException {
     Path source = Paths.get(sourceDirPath);
 
     try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(zipFilePath))) {
       Files.walk(source).filter(path -> !Files.isDirectory(path)).forEach(path -> {
         ZipEntry entry = new ZipEntry(source.relativize(path).toString().replace("\\", "/"));
 
         try {
           zos.putNextEntry(entry);
           Files.copy(path, zos);
           zos.closeEntry();
 
         } catch (IOException e) {
           throw new UncheckedIOException(e);
         }
       });
     }
   }
 
   public static void unzip(String zipFilePath, String destDir) throws IOException {
     File dir = new File(destDir);
 
     if (!dir.exists()) {
       dir.mkdirs();
     }
 
     try (ZipInputStream zis = new ZipInputStream(new FileInputStream(zipFilePath))) {
       ZipEntry entry;
 
       while ((entry = zis.getNextEntry()) != null) {
         File file = new File(destDir, entry.getName());
 
         if (entry.isDirectory()) {
           file.mkdirs();
 
         } else {
           file.getParentFile().mkdirs();
 
           try (FileOutputStream fos = new FileOutputStream(file)) {
             byte[] buffer = new byte[4096];
             int len;
 
             while ((len = zis.read(buffer)) > 0) {
               fos.write(buffer, 0, len);
             }
           }
         }
 
         zis.closeEntry();
       }
     }
   }
 }