package com.acumenvelocity.ath.common;
   
   import java.io.IOException;
   import java.time.Instant;
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Date;
   import java.util.List;
   
  import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
  import com.fasterxml.jackson.annotation.PropertyAccessor;
  import com.fasterxml.jackson.core.JsonGenerator;
  import com.fasterxml.jackson.core.JsonParser;
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.core.type.TypeReference;
  import com.fasterxml.jackson.databind.DeserializationContext;
  import com.fasterxml.jackson.databind.DeserializationFeature;
  import com.fasterxml.jackson.databind.JsonNode;
  import com.fasterxml.jackson.databind.MapperFeature;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.PropertyNamingStrategies;
  import com.fasterxml.jackson.databind.SerializationFeature;
  import com.fasterxml.jackson.databind.SerializerProvider;
  import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
  import com.fasterxml.jackson.databind.module.SimpleModule;
  import com.fasterxml.jackson.databind.node.ArrayNode;
  import com.fasterxml.jackson.databind.node.ObjectNode;
  import com.fasterxml.jackson.databind.node.TextNode;
  import com.fasterxml.jackson.databind.ser.std.StdSerializer;
  import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
  
  /**
   * Utility class for JSON/Java object conversion using Jackson library.
   * Provides serialization and deserialization capabilities with custom handlers
   * for Date and MongoDB ObjectId types. Supports both JSON and YAML formats.
   * 
   * <p>
   * This utility handles special serialization formats commonly used with MongoDB
   * where dates and object IDs may be represented as extended JSON objects.
   * </p>
   * 
   * @author Acumen Velocity
   * @version 1.0
   * @since 1.0
   * @see ObjectMapper
   * @see JsonNode
   */
  public class JacksonUtil {
  
    // Custom modules for handling specific type serialization/deserialization
    private static SimpleModule dateModule = new SimpleModule();
    private static SimpleModule objectIdModule = new SimpleModule();
    private static SimpleModule objectIdModule2 = new SimpleModule();
  
    // Static initialization block for configuring custom serializers and deserializers
    static {
      configureDateSerialization();
    }
  
    /**
     * Configures custom serialization and deserialization for Date objects.
     * Handles both ISO string format and MongoDB extended JSON format for dates.
     */
    private static void configureDateSerialization() {
      // Custom serializer for Date objects to ISO string format
      dateModule.addSerializer(new StdSerializer<Date>(Date.class) {
        private static final long serialVersionUID = 1L;
  
        /**
         * Serializes Date object to ISO string format using QUARTZ_DATE_FORMAT.
         * 
         * @param date     the Date object to serialize
         * @param gen      the JsonGenerator to write serialized content
         * @param provider the SerializerProvider for serialization context
         * @throws IOException if serialization fails
         */
        @Override
        public void serialize(Date date, JsonGenerator gen, SerializerProvider provider)
            throws IOException {
          
          String dateSt = Const.QUARTZ_DATE_FORMAT.format(date);
          gen.writeString(dateSt);
        }
      });
  
      // Custom deserializer for Date objects supporting multiple formats
      dateModule.addDeserializer(Date.class, new StdDeserializer<Date>(Date.class) {
        private static final long serialVersionUID = 2L;
  
        /**
         * Deserializes Date from JSON, supporting both ISO string format and
         * MongoDB extended JSON format ({$date: {/$numberLong: "timestamp"}}).
         * 
         * @param jp the JsonParser for reading JSON content
         * @param dc the DeserializationContext for deserialization context
         * @return deserialized Date object, or null if parsing fails
         * @throws IOException             if deserialization fails
         * @throws JsonProcessingException if JSON processing fails
         */
       @Override
       public Date deserialize(JsonParser jp, DeserializationContext dc)
           throws IOException, JsonProcessingException {
         
         JsonNode tree = jp.readValueAsTree();
         JsonNode dateVal = tree.get("$date");
 
         // Handle ISO string format: {"$date": "2023-01-01T00:00:00Z"}
         if (dateVal instanceof TextNode) {
           String dateSt = dateVal == null ? tree.textValue() : dateVal.textValue();
           Instant instant = Instant.parse(dateSt);
           
           return Date.from(instant);
         }
 
         // Handle MongoDB extended format: {"$date": {"$numberLong": "1672531200000"}}
         if (dateVal instanceof ObjectNode) {
           JsonNode numberLong = dateVal.get("$numberLong");
 
           if (numberLong instanceof TextNode) {
             String millisSt = numberLong.textValue();
             long millis = Long.parseLong(millisSt);
             Instant instant = Instant.ofEpochMilli(millis);
             
             return Date.from(instant);
           }
         }
 
         return null; // Return null if format is not recognized
       }
     });
   }
 
   /**
    * Primary ObjectMapper instance with custom configuration for handling
    * MongoDB extended JSON formats and custom type serialization.
    */
   @SuppressWarnings("deprecation")
   private static ObjectMapper mapper = new ObjectMapper()
       .setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
       .enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS) // Sort map entries for consistent
                                                               // output
       .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) // Ignore unknown
                                                                            // properties
       .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, false) // Maintain property order
       .setVisibility(PropertyAccessor.FIELD, Visibility.ANY) // Allow field access without
                                                              // getters/setters
       .registerModule(dateModule) // Register custom date handling
       .registerModule(objectIdModule); // Register custom ObjectId handling
 
   /**
    * Alternative ObjectMapper instance with different ObjectId deserialization strategy.
    * Used when ObjectId values are expected as direct strings rather than extended JSON objects.
    */
   @SuppressWarnings("deprecation")
   private static ObjectMapper mapper2 = new ObjectMapper()
       .setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
       .enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)
       .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
       .configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, false)
       .setVisibility(PropertyAccessor.FIELD, Visibility.ANY)
       .registerModule(dateModule)
       .registerModule(objectIdModule2); // Use alternative ObjectId deserializer
 
   /**
    * Creates a JsonNode from a JSON string.
    * 
    * @param json the JSON string to parse
    * @return JsonNode representing the parsed JSON, or null if parsing fails
    */
   public static JsonNode makeNode(String json) {
     try {
       JsonNode node = mapper.readValue(json, JsonNode.class);
       return node;
       
     } catch (IOException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return null;
     }
   }
 
   /**
    * Converts a Java object to a JsonNode.
    * 
    * @param obj the Java object to convert
    * @return JsonNode representation of the object
    */
   public static JsonNode makeNode(Object obj) {
     JsonNode node = mapper.valueToTree(obj);
     return node;
   }
 
   /**
    * Creates a JSON object node with an array field containing the provided objects.
    * 
    * @param fieldName the name of the array field
    * @param arr       the array of objects to include in the array field
    * @return ObjectNode containing the specified array field
    */
   public static JsonNode makeNode(String fieldName, Object[] arr) {
     ObjectNode objNode = mapper.createObjectNode();
     ArrayNode arrNode = objNode.putArray(fieldName);
 
     // Convert each object to JsonNode and add to array
     Arrays.stream(arr).forEach(e -> {
       JsonNode node = mapper.valueToTree(e);
       arrNode.add(node);
     });
     
     return objNode;
   }
 
   /**
    * Creates an ArrayNode from an array of objects.
    * 
    * @param arr the array of objects to convert
    * @return ArrayNode containing JsonNode representations of the objects
    */
   public static ArrayNode makeArrayNode(Object[] arr) {
     ArrayNode arrNode = mapper.createArrayNode();
 
     Arrays.stream(arr).forEach(e -> {
       JsonNode node = mapper.valueToTree(e);
       arrNode.add(node);
     });
     
     return arrNode;
   }
 
   /**
    * Creates an ArrayNode from a List of objects.
    * 
    * @param list the List of objects to convert
    * @return ArrayNode containing JsonNode representations of the objects, or null if input is null
    */
   public static ArrayNode makeArrayNode(List<?> list) {
     return list == null ? null : makeArrayNode(list.toArray());
   }
 
   /**
    * Creates an array of JsonNode objects from an array of Java objects.
    * 
    * @param arr the array of objects to convert
    * @return array of JsonNode representations of the objects
    */
   public static JsonNode[] makeNodes(Object[] arr) {
     List<JsonNode> list = new ArrayList<>(arr.length);
 
     Arrays.stream(arr).forEach(e -> {
       JsonNode node = mapper.valueToTree(e);
       list.add(node);
     });
 
     return list.toArray(new JsonNode[list.size()]);
   }
 
   /**
    * Creates an array of JsonNode objects from a List of Java objects.
    * 
    * @param list the List of objects to convert
    * @return array of JsonNode representations of the objects, or null if input is null
    */
   public static JsonNode[] makeNodes(List<?> list) {
     return list == null ? null : makeNodes(list.toArray());
   }
 
   /**
    * Creates a JSON object node with an array field containing objects from a List.
    * 
    * @param fieldName the name of the array field
    * @param list      the List of objects to include in the array field
    * @return ObjectNode containing the specified array field, or null if input is null
    */
   public static JsonNode makeNode(String fieldName, List<?> list) {
     return list == null ? null : makeNode(fieldName, list.toArray());
   }
 
   /**
    * Creates a simple JSON object node with a single string field.
    * 
    * @param fieldName  the name of the field
    * @param fieldValue the string value of the field
    * @return JsonNode representing the simple object
    */
   public static JsonNode makeNode(String fieldName, String fieldValue) {
     return makeNode(makeJson(fieldName, fieldValue));
   }
 
   /**
    * Creates a simple JSON string with a single field-value pair.
    * 
    * @param fieldName  the name of the field
    * @param fieldValue the string value of the field
    * @return JSON string representation of the simple object
    */
   public static String makeJson(String fieldName, String fieldValue) {
     return Log.format("{\"{}\": \"{}\"}", fieldName, fieldValue);
   }
 
   /**
    * Creates a JSON string with an array field from an array of objects.
    * 
    * @param fieldName the name of the array field
    * @param arr       the array of objects to include
    * @return JSON string representation of the object with array field
    */
   public static String makeJson(String fieldName, Object[] arr) {
     return makeJson(makeNode(fieldName, arr));
   }
 
   /**
    * Creates a JSON string with an array field from a List of objects.
    * 
    * @param fieldName the name of the array field
    * @param list      the List of objects to include
    * @return JSON string representation of the object with array field, or null if input is null
    */
   public static String makeJson(String fieldName, List<?> list) {
     return list == null ? null : makeJson(fieldName, list.toArray());
   }
 
   /**
    * Converts a JsonNode to a JSON string.
    * 
    * @param node the JsonNode to convert
    * @return JSON string representation, or null if conversion fails
    */
   public static String makeJson(JsonNode node) {
     try {
       return mapper.writeValueAsString(node);
       
     } catch (JsonProcessingException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return null;
     }
   }
 
   /**
    * Converts a YAML string to a pretty-printed JSON string.
    * 
    * @param yaml the YAML string to convert
    * @return pretty-printed JSON string representation, or empty string if conversion fails
    */
   public static String makeJson(String yaml) {
     try {
       ObjectMapper yamlReader = new ObjectMapper(new YAMLFactory());
       Object obj = yamlReader.readValue(yaml, Object.class);
       ObjectMapper jsonWriter = new ObjectMapper();
       return jsonWriter.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
       
     } catch (IOException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return "";
     }
   }
 
   /**
    * Converts an object to a pretty-printed JSON string.
    * 
    * @param obj the object to convert
    * @return pretty-printed JSON string representation, or empty string if conversion fails
    */
   public static String makePrettyJson(Object obj) {
     mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
     
     try {
       return mapper.writeValueAsString(obj);
       
     } catch (JsonProcessingException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return "";
     }
   }
 
   /**
    * Converts an object to JSON string with configurable pretty-printing.
    * 
    * @param obj         the object to convert
    * @param prettyPrint true to enable pretty-printing, false for compact format
    * @return JSON string representation, or empty string if conversion fails
    */
   public static String toJson(Object obj, boolean prettyPrint) {
     if (prettyPrint) {
       mapper.enable(SerializationFeature.INDENT_OUTPUT);
       
     } else {
       mapper.disable(SerializationFeature.INDENT_OUTPUT);
     }
     
     try {
       return mapper.writeValueAsString(obj);
       
     } catch (JsonProcessingException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return "";
     }
   }
 
   /**
    * Deserializes JSON string to an object of the specified class using the primary ObjectMapper.
    * 
    * @param <T>      the type of the object to deserialize
    * @param json     the JSON string to deserialize
    * @param objClass the class of the object to deserialize
    * @return deserialized object, or null if deserialization fails
    */
   public static <T> T fromJson(String json, Class<? extends T> objClass) {
     try {
       return mapper.readValue(json, objClass);
       
     } catch (IOException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return null;
     }
   }
 
   public static <T> T fromJson(String json, TypeReference<T> type) {
     try {
       return mapper.readValue(json, type);
 
     } catch (IOException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return null;
     }
   }
 
   /**
    * Deserializes JSON string to an object of the specified class using the alternative
    * ObjectMapper.
    * This version uses the ObjectId deserializer that expects direct string values.
    * 
    * @param <T>      the type of the object to deserialize
    * @param json     the JSON string to deserialize
    * @param objClass the class of the object to deserialize
    * @return deserialized object, or null if deserialization fails
    */
   public static <T> T fromJson2(String json, Class<? extends T> objClass) {
     try {
       return mapper2.readValue(json, objClass);
       
     } catch (IOException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return null;
     }
   }
 
   public static <T> T fromJsonNode(JsonNode jsonNode, Class<? extends T> objClass) {
     try {
       return mapper.treeToValue(jsonNode, objClass);
 
     } catch (IOException e) {
       Log.error(JacksonUtil.class, e, e.getMessage());
       return null;
     }
   }
 
   public static Object fromJsonNode(JsonNode jsonNode) {
     return fromJsonNode(jsonNode, Object.class);
   }
 }