package org.apache.fulcrum.json.jackson;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.io.IOException;
  import java.text.DateFormat;
  import java.text.SimpleDateFormat;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  
  import org.apache.avalon.framework.activity.Initializable;
  import org.apache.avalon.framework.configuration.Configurable;
  import org.apache.avalon.framework.configuration.Configuration;
  import org.apache.avalon.framework.configuration.ConfigurationException;
  import org.apache.avalon.framework.logger.AbstractLogEnabled;
  import org.apache.avalon.framework.logger.LogEnabled;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.fulcrum.json.JsonService;
  import org.apache.fulcrum.json.jackson.filters.CustomModuleWrapper;
  import org.apache.fulcrum.json.jackson.jsonpath.DefaultJsonPathWrapper;
  
  import com.fasterxml.jackson.core.JsonGenerator;
  import com.fasterxml.jackson.core.JsonParser;
  import com.fasterxml.jackson.core.JsonParser.Feature;
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.core.SerializableString;
  import com.fasterxml.jackson.core.io.CharacterEscapes;
  import com.fasterxml.jackson.core.type.TypeReference;
  import com.fasterxml.jackson.databind.AnnotationIntrospector;
  import com.fasterxml.jackson.databind.DeserializationFeature;
  import com.fasterxml.jackson.databind.JsonDeserializer;
  import com.fasterxml.jackson.databind.JsonSerializer;
  import com.fasterxml.jackson.databind.MapperFeature;
  import com.fasterxml.jackson.databind.Module;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;
  import com.fasterxml.jackson.databind.ObjectReader;
  import com.fasterxml.jackson.databind.SerializationFeature;
  import com.fasterxml.jackson.databind.SerializerProvider;
  import com.fasterxml.jackson.databind.cfg.ConfigFeature;
  import com.fasterxml.jackson.databind.introspect.AnnotationIntrospectorPair;
  import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
  import com.fasterxml.jackson.databind.module.SimpleModule;
  import com.fasterxml.jackson.databind.ser.FilterProvider;
  import com.fasterxml.jackson.databind.ser.PropertyFilter;
  import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
  import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
  
  /**
   * 
   * 
   * By default multiple serialization of the same object in a single thread is
   * not supported (e.g filter + mixin or default + filter for the same bean /
   * object).
   * 
   * By default a filter is defined by its {@link Class#getName()}.
   * 
   * Note: If using {@link SimpleNameIntrospector}, filter caches are set by class
   * id. Caching is enabled by default, if not (a) by setting
   * {@link #cacheFilters} to <code>false</code>. By setting (b) the Boolean
   * parameter clean
   * {@link #serializeAllExceptFilter(Object, Class, Boolean, String...)} or
   * {@link #serializeOnlyFilter(Object, Class, Boolean, String...)} you could
   * clean the filter. If caching is disabled each filter will be unregistered and
   * the cache cleaned.
   * 
   * @author <a href="mailto:gk@apache.org">Georg Kallidis</a>
   * @version $Id$
   * 
   */
  public class Jackson2MapperService extends AbstractLogEnabled implements JsonService, Initializable, Configurable {
  
      private static final String DEFAULT_TYPING = "defaultTyping";
      private static final String CACHE_FILTERS = "cacheFilters";
      private static final String DATE_FORMAT = "dateFormat";
      private static final String ESCAPE_CHARS = "escapeCharsGlobal";
      private static final String ESCAPE_CHAR_CLASS = "escapeCharsClass";
      private static final String USE_JSON_PATH = "useJsonPath";
      ObjectMapper mapper;
     AnnotationIntrospector primary; // support default
     AnnotationIntrospector secondary;
 
     private static final String ANNOTATIONINSPECTOR = "annotationInspectors";
 
     private Map<String, String> annotationInspectors = null;
     private Map<String, Boolean> features = null;
     private Map<String, String> featureTypes = null;
 
     private String dateFormat;
 
     /**
      * Default dateformat is <code>MM/dd/yyyy</code>, could be overwritten in
      * {@link #setDateFormat(DateFormat)}.
      */
     public static final String DEFAULTDATEFORMAT = "MM/dd/yyyy";
 
     
     private boolean cacheFilters = true; // true -> this is by default true in jackson, if not using
                                             // multiple serialization in one thread
     String[] defaultTypeDefs = null;
     private CacheService cacheService;
     private boolean escapeCharsGlobal = false; // to be backward compatible, but should be true, then escaping to avoid
                                                 // XSS payload by default
     private boolean useJsonPath = false;
     private String escapeCharsClass = null;
 
     @Override
     public String ser(Object src) throws Exception {
         return ser(src, false);
     }
 
     @Override
     public <T> String ser(Object src, Class<T> type) throws Exception {
         return ser(src, type, false);
     }
 
     public String ser(Object src, FilterProvider filter) throws Exception {
         return ser(src, filter, false);
     }
 
     /**
      * 
      * @param src the object to be serailized as JSON
      * @param filter may be null, then sserialize without otherwise set into cache service and as filter provider.
      * @param cleanCache cleans the jackson cache
      * @return the serialzed JSON string
      * @throws Exception exception
      */
     public String ser(Object src, FilterProvider filter, Boolean cleanCache) throws Exception {
         String serResult = null;
         if (src == null) {
             getLogger().info("no serializable object.");
             return serResult;
         }
         if (filter == null) {
             getLogger().debug("ser class::" + src.getClass() + " without filter.");
             return ser(src);
         } else {
             getLogger().debug("add filter for cache filter Class " + src.getClass().getName());
             setCustomIntrospectorWithExternalFilterId(src.getClass(), null); // filter class
             if (isCacheFilters()) {
                 cacheService.getFilters().put(src.getClass().getName(), filter);
             }
         }
         getLogger().debug("ser class::" + src.getClass() + " with filter " + filter);
         mapper.setFilterProvider(filter);
         String res = mapper.writer(filter).writeValueAsString(src);
         if (cleanCache) {
             cacheService.cleanSerializerCache(mapper);
         }
         return res;
     }
 
     @Override
     public <T> T deSer(String json, Class<T> type) throws Exception {
         ObjectReader reader = null;
         if (type != null)
             reader = mapper.readerFor(type);
         else
             reader = mapper.reader();
 
         return reader.readValue(json);
     }
 
     /**
      * basically wrapper for {@link ObjectMapper#convertValue(Object, Class)}.
      * 
      * @param src Object
      * @param type target Object
      * @return
      */
     public <T> T deSer(Object src, Class<T> type) {
         return mapper.convertValue(src, type);
     }
 
     /**
      * Add a named module or a {@link Module}.
      * 
      * @param name   Name of the module, optional. Could be null, if module is a
      *               {@link Module}.
      * 
      * @param target Target class, optional. Could be null, if module is a
      *               {@link Module}.
      * 
      * @param module Either an Jackson Module @link {@link Module} or an custom
      *               wrapper @link CustomModuleWrapper.
      */
     @Override
     public JsonService addAdapter(String name, Class target, Object module)
             throws Exception {
         if (module instanceof CustomModuleWrapper) {
             CustomModuleWrapper./../org/apache/fulcrum/json/jackson/filters/CustomModuleWrapper.html#CustomModuleWrapper">CustomModuleWrapper cmw = (CustomModuleWrapper) module;
             Module cm = new CustomModule(name, target, cmw.getSer(),
                     cmw.getDeSer());
             getLogger().debug("registering custom module " + cm + "  for: " + target);
             mapper.registerModule(cm);
         } else if (module instanceof Module) {
             getLogger().debug(
                     "registering module " + module );
             mapper.registerModule((Module) module);
         } else {
             throw new ClassCastException("expecting module type " + Module.class);
         }
         return this;
     }
     
     public Class<?> showMixinForClass(Class target) {
         Class<?> mixin =  mapper.findMixInClassFor( target );
         getLogger().debug("find mixin for target " + target + " -> mixin: " + mixin);
         return mixin;
     }
     
     public <T> List<T> deSerList(String json, Class<? extends List> targetList, Class<T> elementType) throws Exception {
         return mapper.readValue(json, mapper.getTypeFactory().constructParametricType(targetList, elementType));
     }
 
     public <T, U> Map<T, U> deSerMap(String json, Class<? extends Map> mapClass, Class<T> keyClass, Class<U> valueClass)
             throws Exception {
         return mapper.readValue(json, mapper.getTypeFactory().constructMapType(mapClass, keyClass, valueClass));
     }
 
     public <T> Collection<T> deSerCollectionWithTypeReference(String json, TypeReference<T> collectionType)
             throws Exception {
         return (Collection<T>) mapper.readValue(json, collectionType);
     }
   
     public <T> Collection<T> deSerCollectionWithType(String json, Class<? extends Collection> collectionClass,
             Class<T> type) throws Exception {
         return mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(collectionClass, type));
     }
     
     @Override
     public <T> Collection<T> deSerCollection(String json, Object collectionType, Class<T> elementType)
             throws Exception {
         if (collectionType instanceof TypeReference) {
             return deSerCollectionWithTypeReference(json, (TypeReference<T>) collectionType);
         } else {
             return mapper.readValue(json, mapper.getTypeFactory()
                     .constructCollectionType(((Collection<T>) collectionType).getClass(), elementType));
         }
     }
     
     /**
      * 
      * @param src the collection to be serialized 
      * @param collectionType the {@link TypeReference}.
      * @param cleanCache cleans jackson serializer cache 
      * @return the serialized JSON string
      * @throws JsonProcessingException JSON processing error
      */
     public <T> String serCollectionWithTypeReference(Collection<T> src, TypeReference collectionType,
                                                      Boolean cleanCache) throws JsonProcessingException {
          String res = mapper.writerFor(collectionType).writeValueAsString(src);
          if (cleanCache) {
              cacheService.cleanSerializerCache(mapper);
          }
          return res;
      }
     
      /**
      * @param name   name of the module
      * @param target target class
      * @param mixin  provide mixin as class. Deregistering module could be only done
      *               by setting this parameter to null.
      * 
      * @see #addAdapter(String, Class, Object)
      */
     @Override
     public JsonService addAdapter(String name, Class target, Class mixin) throws Exception {
         getLogger().debug(
                 "registering unversioned simple mixin module named " + name + " of type " + mixin + "  for: " + target);
         mapper.addMixIn(target, mixin);
         return this;
     }
 
     /**
      * set a single mixin. convenience method, calls
      * {@link ObjectMapper#registerModule(Module)}
      * 
      * @param src    he object to be serialized
      * @param name   the name for the mixin
      * @param target the target class for the mixin
      * @param mixin  the mixin class
      * @return serialized result
      * @throws JsonProcessingException if not properly processed
      */
     @SuppressWarnings("rawtypes")
     public String withMixinModule(Object src, String name, Class target, Class mixin) throws JsonProcessingException {
         Module mx = new MixinModule(name, target, mixin);
         getLogger().debug("registering module " + mx + ", mixin: " + mixin);
         return mapper.registerModule(mx).writer().writeValueAsString(src);
     }
 
     /**
      * This is a convenience method with read, but the old mixins will be cleared
      * {@link ObjectMapper#setMixIns(Map)}
      * 
      * @param src    the object to be serialized
      * @param target the target class for the mixin
      * @param mixin  the mixin class
      * @return serialized result
      * @throws JsonProcessingException if fail
      */
     @SuppressWarnings("rawtypes")
     public String withSetMixins(Object src, Class target, Class mixin) throws JsonProcessingException {
         return setMixins(target, mixin).writer().writeValueAsString(src);
     }
 
     /**
      * @param target The target class
      * @param mixin  the mixin class
      * @return an objectmapper
      */
     @SuppressWarnings("rawtypes")
     public ObjectMapper setMixins(Class target, Class mixin) {
         Map<Class<?>, Class<?>> sourceMixins = null;
         if (target != null) {
             sourceMixins = new HashMap<>(1);
             sourceMixins.put(target, mixin);
         }
         getLogger().debug("complete reset mixins for target " + target + ", mixin: " + mixin);
         return mapper.setMixIns(sourceMixins);
     }
 
     @Override
     public String serializeAllExceptFilter(Object src, String... filterAttr) throws Exception {
         return serializeAllExceptFilter(src, src.getClass(), true, filterAttr);
     }
 
     @Override
     public synchronized String serializeAllExceptFilter(Object src, Boolean cache, String... filterAttr)
             throws Exception {
         return serializeAllExceptFilter(src, src.getClass(), cache, filterAttr);
     }
 
     public synchronized <T> String serializeAllExceptFilter(Object src, Class<T>[] filterClasses, String... filterAttr)
             throws Exception {
         return serializeAllExceptFilter(src, filterClasses, true, filterAttr);
     }
 
     @Override
     public synchronized <T> String serializeAllExceptFilter(Object src, Class<T> filterClass, String... filterAttr)
             throws Exception {
         return serializeAllExceptFilter(src, filterClass, true, filterAttr);
     }
 
     @Override
     public <T> String serializeAllExceptFilter(Object src, Class<T> filterClass, Boolean cleanFilter,
             String... filterAttr) throws Exception {
         return serializeAllExceptFilter(src, new Class[] { filterClass }, cleanFilter, filterAttr);
     }
 
     /**
      * 
      * @param src           the object to be serailized, may be a list
      * @param filterClasses the same object class or a detail class, which should be
      *                      filtered
      * @param               <T> class type
      * @param clean         cleaning the cache after serialization
      * @param filterAttr    attributes to be filtered for filtered class
      * @return the serailized string
      * @throws Exception generic exception
      */
     public synchronized <T> String serializeAllExceptFilter(Object src, Class<T>[] filterClasses, Boolean clean,
             String... filterAttr) throws Exception {
         PropertyFilter pf = null;
         if (filterAttr != null)
             pf = SimpleBeanPropertyFilter.serializeAllExcept(filterAttr);
         else if (filterClasses == null) { // no filter
             return ser(src, clean);
             // should be better:
             // return filter(src, new Class<?>[] { src.getClass() }, filterClasses, pf,
             // clean);
         }
         return filter(src, new Class<?>[] { filterClasses[0] }, filterClasses, pf, clean);
     }
 
     @Override
     public String serializeOnlyFilter(Object src, String... filterAttrs) throws Exception {
         return serializeOnlyFilter(src, src.getClass(), true, filterAttrs);
     }
 
     @Override
     public synchronized String serializeOnlyFilter(Object src, Boolean cache, String... filterAttr) throws Exception {
         return serializeOnlyFilter(src, src.getClass(), cache, filterAttr);
     }
 
     @Override
     public synchronized <T> String serializeOnlyFilter(Object src, Class<T> filterClass, String... filterAttr)
             throws Exception {
         return serializeOnlyFilter(src, filterClass, true, filterAttr);
     }
 
     @Override
     public synchronized <T> String serializeOnlyFilter(Object src, Class<T> filterClass, Boolean refresh,
             String... filterAttr) throws Exception {
         return serializeOnlyFilter(src, new Class[] { filterClass }, refresh, filterAttr);
     }
 
     public synchronized <T> String serializeOnlyFilter(Object src, Class<T>[] filterClasses, Boolean refresh,
             String... filterAttr) throws Exception {
         PropertyFilter pf = null;
         if (filterAttr != null && filterAttr.length > 0 && !"".equals(filterAttr[0])) {
             pf = SimpleBeanPropertyFilter.filterOutAllExcept(filterAttr);
             getLogger().debug("setting filteroutAllexcept filter for size of filterAttr: " + filterAttr.length);
         } else {
             getLogger().warn("no filter attributes set!");
             pf = SimpleBeanPropertyFilter.filterOutAllExcept("dummy");
         }
         if (filterClasses == null)
             throw new AssertionError("You have to provide some class to apply the filtering!");
         return filter(src, filterClasses, null, pf, refresh);
     }
 
     @Override
     public String ser(Object src, Boolean cleanCache) throws Exception {
         if (isCacheFilters() && cacheService.getFilters().containsKey(src.getClass().getName())) {
             getLogger().warn("Found registered filter - using instead of default view filter for class:"
                     + src.getClass().getName());
             SimpleFilterProvider filter = (SimpleFilterProvider) cacheService.getFilters()
                     .get(src.getClass().getName());
             return ser(src, filter, cleanCache);// mapper.writerWithView(src.getClass()).writeValueAsString(src);
         }
         String res = mapper.writerWithView(Object.class).writeValueAsString(src);
         if (cleanCache != null && cleanCache) {
             cacheService.cleanSerializerCache(mapper);
         }
         return res;
     }
 
     @Override
     public <T> String ser(Object src, Class<T> type, Boolean cleanCache) throws Exception {
         getLogger().info("serializing object:" + src + " for type " + type);
         if (isCacheFilters() && src != null && cacheService.getFilters().containsKey(src.getClass().getName())) {
             getLogger().warn("Found registered filter - could not use custom view and custom filter for class:"
                     + src.getClass().getName());
             // throw new
             // Exception("Found registered filter - could not use custom view and custom
             // filter for class:"+
             // src.getClass().getName());
             SimpleFilterProvider filter = (SimpleFilterProvider) cacheService.getFilters()
                     .get(src.getClass().getName());
             return ser(src, filter);
         }
 
         String res = (type != null) ? mapper.writerWithView(type).writeValueAsString(src)
                 : mapper.writeValueAsString(src);
         if (cleanCache) {
             cacheService.cleanSerializerCache(mapper);
         }
         return res;
     }
 
     /**
      * 
      * @param src            The source Object to be filtered.
      * @param filterClass    This Class array contains at least one element. If no
      *                       class is provided it is the class type of the source
      *                       object. The filterClass is to become the key of the
      *                       filter object cache.
      * @param excludeClasses The classes to be excluded, optionally used only for
      *                       methods like
      *                       {@link #serializeAllExceptFilter(Object, Class[], String...)}.
      * @param pf             Expecting a property filter from e.g @link
      *                       {@link SimpleBeanPropertyFilter}.
      * @param clean          if <code>true</code> does not reuse the filter object
      *                       (no cashing).
      * @return The serialized Object as String
      * @throws Exception
      */
     private <T> String filter(Object src, Class<?>[] filterClasses, Class<T>[] excludeClasses, PropertyFilter pf,
             Boolean clean) throws Exception {
         FilterProvider filter = null;
         if (filterClasses.length > 0) {
             filter = retrieveFilter(pf, filterClasses[0], excludeClasses);
         }
         getLogger().info("filtering with filter " + filter);
         String serialized = ser(src, filter, clean);
         if (!isCacheFilters() || clean) {
             if (filterClasses.length > 0) {
                 boolean exclude = (excludeClasses != null) ? true : false;
                 cacheService.removeFilter(filterClasses[0], exclude);
             }
         }
         return serialized;
     }
 
     private <T> SimpleFilterProvider retrieveFilter(PropertyFilter pf, Class<?> filterClass,
             Class<T>[] excludeClasses) {
         SimpleFilterProvider filter = null;
         if (pf != null) {
             filter = new SimpleFilterProvider();
             filter.setDefaultFilter(pf);
         }
         if (isCacheFilters()) {
             if (!cacheService.getFilters().containsKey(filterClass.getName())) {
                 getLogger().debug("add filter for cache filter Class " + filterClass.getName());
                 setCustomIntrospectorWithExternalFilterId(filterClass, excludeClasses); // filter class
                 if (pf != null) {
                     cacheService.getFilters().put(filterClass.getName(), filter);
                 }
             } else {
                 filter = (SimpleFilterProvider) cacheService.getFilters().get(filterClass.getName());
                 // setCustomIntrospectorWithExternalFilterId(filterClass); // filter
                 // class
             }
         }
         getLogger().debug("set filter:" + filter);
         return filter;
     }
 
     /**
      * @param filterClass
      *                          <li>Adding filterClass into
      *                          {@link SimpleNameIntrospector#setFilteredClass(Class)}
      *                          enables the filtering process.
      * @param externalFilterIds
      *                          <li>Adding externalFilterIs to
      *                          {@link SimpleNameIntrospector#setExternalFilterExcludeClasses(Class...)}
      *                          excludes these classes.
      */
     private <T> void setCustomIntrospectorWithExternalFilterId(Class<?> filterClass,
             Class<T>[] externalFilterClassIds) {
         if (primary instanceof SimpleNameIntrospector) {
             // first one is required that we get to the PropertyFilter
             ((SimpleNameIntrospector) primary).setFilteredClasses(filterClass);
             if (externalFilterClassIds != null) {
                 ((SimpleNameIntrospector) primary).setIsExludeType(true);
                 for (Class<T> filterClazz : externalFilterClassIds) {
                     getLogger().debug("added class for filters " + filterClazz);
                 }
                 ((SimpleNameIntrospector) primary).setExternalFilterExcludeClasses(externalFilterClassIds);
             }
         }
     }
 
     public Jackson2MapperService registerModule(Module module) {
         mapper.registerModule(module);
         return this;
     }
 
     public <T> void addSimpleModule(SimpleModule module, Class<T> type, JsonSerializer<T> ser) {
         module.addSerializer(type, ser);
     }
 
     public <T> void addSimpleModule(SimpleModule module, Class<T> type, JsonDeserializer<T> deSer) {
         module.addDeserializer(type, deSer);
     }
 
     /**
      * Default Dateformat: {@link #DEFAULTDATEFORMAT}
      */
     @Override
     public void setDateFormat(final DateFormat df) {
         mapper.setDateFormat(df);
     }
 
     /**
      * Avalon component lifecycle method
      */
     @Override
     public void configure(Configuration conf) throws ConfigurationException {
         getLogger().debug("conf.getName()" + conf.getName());
         this.annotationInspectors = new HashMap<>();
 
         final Configuration configuredAnnotationInspectors = conf.getChild(ANNOTATIONINSPECTOR, false);
 
         if (configuredAnnotationInspectors != null) {
             Configuration[] nameVal = configuredAnnotationInspectors.getChildren();
             Arrays.stream( nameVal).forEach(c->
             {
                 String key = c.getName();
                 getLogger().debug("configured key: " + key);
                 if (key.equals("features")) {
                     this.features = new HashMap<>();
                     this.featureTypes = new HashMap<>();
                     Arrays.stream( c.getChildren() ).forEach( lf -> {
                         boolean featureValue = lf.getAttributeAsBoolean("value", false);
                         String featureType = null;
                         String feature = null;
                         try {
                             featureType = lf.getAttribute("type");
                             feature = lf.getValue();
                             getLogger().debug("configuredAnnotationInspectors " + feature + ":" + featureValue);
                             this.features.put(feature, featureValue);
                             this.featureTypes.put(feature, featureType);
                         } catch (ConfigurationException e) {
                             throw new RuntimeException(e);
                         }
                     });
                 } else {
                     String val;
                     try {
                         val = c.getValue();
                         getLogger().debug("configuredAnnotationInspectors " + key + ":" + val);
                         this.annotationInspectors.put(key, val);
                     } catch (ConfigurationException e) {
                         throw new RuntimeException(e);
                     }
 
                 }
             });
         }
         final Configuration configuredDateFormat = conf.getChild(DATE_FORMAT, true);
         this.dateFormat = configuredDateFormat.getValue(DEFAULTDATEFORMAT);
 
         final Configuration configuredKeepFilter = conf.getChild(CACHE_FILTERS, false);
         if (configuredKeepFilter != null) {
             setCacheFilters( configuredKeepFilter.getValueAsBoolean());
         }
         final Configuration configuredEscapeChars = conf.getChild(ESCAPE_CHARS, false);
         if (configuredEscapeChars != null) {
             this.escapeCharsGlobal = configuredEscapeChars.getValueAsBoolean();
         }
         final Configuration configuredEscapeCharClass = conf.getChild(ESCAPE_CHAR_CLASS, false);
         if (configuredEscapeCharClass != null) {
             this.escapeCharsClass = configuredEscapeCharClass.getValue();
         }
 
         final Configuration configuredDefaultType = conf.getChild(DEFAULT_TYPING, false);
         if (configuredDefaultType != null) {
             defaultTypeDefs = new String[] { configuredDefaultType.getAttribute("type"),
                     configuredDefaultType.getAttribute("key") };
         }
         final Configuration configuredjsonPath = conf.getChild(USE_JSON_PATH, false);
         if (configuredjsonPath != null) {
             this.useJsonPath = configuredjsonPath.getValueAsBoolean();
         }
     }
 
     @Override
     public void initialize() throws Exception {
         mapper = new ObjectMapper(null, null, null);// add configurable JsonFactory,.. later?
 
         initAnnotationInspectors();
 
         initFeatures();
 
         initDefaultTyping();
 
         getLogger().info("setting date format to:" + dateFormat);
         getLogger().info("cacheFilters is:" + isCacheFilters());
         if (!isCacheFilters()) {
             mapper.configure(SerializationFeature.FLUSH_AFTER_WRITE_VALUE, true);
         }
 
         mapper.setDateFormat(new SimpleDateFormat(dateFormat));
 
         if (escapeCharsGlobal) {
             mapper.getFactory().setCharacterEscapes(characterEscapes);
         }
         if (escapeCharsClass != null) {
             try {
                 characterEscapes = (CharacterEscapes) Class.forName(escapeCharsClass).getConstructor().newInstance();
             } catch (Exception e) {
                 throw new InstantiationException(
                         "JsonMapperService: Error instantiating " + escapeCharsClass + " for " + ESCAPE_CHAR_CLASS);
             }
         }
 
         getLogger().debug("initialized mapper:" + mapper);
 
         mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
             @Override
             public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
                 jgen.writeString("");
 
             }
         });
         cacheService = new CacheService(primary);
         if (cacheService instanceof LogEnabled) {
             cacheService.enableLogging(getLogger().getChildLogger(cacheService.getClass().getSimpleName()));
             getLogger().info("setting cacheService logger: " + cacheService.getClass().getSimpleName());
         }
 
         if (useJsonPath) {
             // set it before runtime
             DefaultJsonPathWrapper djpw = null;
             try {
                 djpw = new DefaultJsonPathWrapper(this.mapper);
                 getLogger().debug("******** initialized new jsonPath defaults: " + djpw.getJsonPathDefault());
             } catch (Exception e) {
                 throw new AssertionError(
                         "JsonMapperService: Error instantiating " + djpw + " using useJsonPath=" + useJsonPath);
             }
 
         }
     }
 
     private void initDefaultTyping() {
         if (defaultTypeDefs != null && defaultTypeDefs.length == 2) {
             DefaultTyping defaultTyping = DefaultTyping.valueOf(defaultTypeDefs[0]);
             mapper.enableDefaultTypingAsProperty(defaultTyping, defaultTypeDefs[1]);
             getLogger().info("default typing is " + defaultTypeDefs[0] + " with key:" + defaultTypeDefs[1]);
         }
     }
 
     private void initFeatures() throws Exception {
         if (features != null && !features.isEmpty()) {
             features.entrySet().stream().forEach( entry -> {
                 String featureKey = entry.getKey();
                 Boolean featureValue = entry.getValue();    
                 String featureType = featureTypes.get(featureKey);
                 Class<?> configFeature = null;
                 try {
                     getLogger().debug("initializing featureType:  " + featureType);
                     configFeature = loadClass(featureType); 
                 } catch (ClassNotFoundException e) {
                     throw new AssertionError("JsonMapperService: Error instantiating " + featureType + " for " + featureKey, e);
                 }
                 ConfigFeature feature = null;
                 if (!StringUtils.isEmpty(featureKey) && featureValue != null) {
                    try 
                    {
                         if (configFeature.equals(SerializationFeature.class)) {
                             feature = SerializationFeature.valueOf(featureKey);
                             mapper.configure((SerializationFeature) feature, featureValue);
                             assert mapper.getSerializationConfig()
                                     .isEnabled((SerializationFeature) feature) == featureValue;
                             getLogger().info("initialized serconfig mapper feature: " + feature + " with "
                                     + mapper.getSerializationConfig().isEnabled((SerializationFeature) feature));
                         } else if (configFeature.equals(DeserializationFeature.class)) {
                             feature = DeserializationFeature.valueOf(featureKey);
                             mapper.configure((DeserializationFeature) feature, featureValue);
                             assert mapper.getDeserializationConfig()
                                     .isEnabled((DeserializationFeature) feature) == featureValue;
                             getLogger().info("initialized deserconfig mapper feature: " + feature + " with "
                                     + mapper.getDeserializationConfig().isEnabled((DeserializationFeature) feature));
                         } else if (configFeature.equals(MapperFeature.class)) {
                             feature = MapperFeature.valueOf(featureKey);
                             mapper.configure((MapperFeature) feature, featureValue);
                             assert mapper.getDeserializationConfig().isEnabled((MapperFeature) feature) == featureValue;
                             assert mapper.getSerializationConfig().isEnabled((MapperFeature) feature) == featureValue;
                             getLogger().info("initialized serconfig mapper feature: " + feature + " with "
                                     + mapper.getDeserializationConfig().isEnabled((MapperFeature) feature));
                             getLogger().info("initialized deserconfig mapper feature: " + feature + " with "
                                     + mapper.getSerializationConfig().isEnabled((MapperFeature) feature));
                         } else if (configFeature.equals(JsonParser.class)) {
                             Feature parserFeature = JsonParser.Feature.valueOf(featureKey);
                             getLogger().info("initializing parser feature: " + parserFeature + " with " + featureValue);
                             mapper.configure(parserFeature, featureValue);
                         } else if (configFeature.equals(JsonGenerator.class)) {
                             com.fasterxml.jackson.core.JsonGenerator.Feature genFeature = JsonGenerator.Feature
                                     .valueOf(featureKey);
                             getLogger().info("initializing parser feature: " + genFeature + " with " + featureValue);
                             mapper.configure(genFeature, featureValue);
                         }
                    } catch (Exception e) {
                        throw new RuntimeException("JsonMapperService: Error instantiating feature " + featureKey + " with  "
                                + featureValue , e);
                    }
                     
                 }
             });   
         }
     }
 
     private void initAnnotationInspectors() throws Exception {
         for (Entry<String, String> entry : annotationInspectors.entrySet()) {
             String key = entry.getKey();
             String avClass = entry.getValue();
             if (key.equals("primary") && !StringUtils.isEmpty(avClass)) {
                 try {
                     primary = (AnnotationIntrospector) Class.forName(avClass).getConstructor().newInstance();
                 } catch (Exception e) {
                     throw new InstantiationException("JsonMapperService: Error instantiating " + avClass + " for " + key);
                 }
             } else if (key.equals("secondary") && avClass != null) {
                 try {
                     secondary = (AnnotationIntrospector) Class.forName(avClass).getConstructor().newInstance();
                 } catch (Exception e) {
                     throw new InstantiationException("JsonMapperService: Error instantiating " + avClass + " for " + key);
                 }
             }
         }
         if (primary == null) {
             primary = new JacksonAnnotationIntrospector(); // support default
             getLogger().info("using default introspector:" + primary.getClass().getName());
             mapper.setAnnotationIntrospector(primary);
         } else if (primary != null && secondary != null) {
             AnnotationIntrospector pair = new AnnotationIntrospectorPair(primary, secondary);
             mapper.setAnnotationIntrospector(pair);
         } else {
             mapper.setAnnotationIntrospector(primary);
         }
 
         if (primary instanceof LogEnabled) {
             ((LogEnabled) primary).enableLogging(getLogger().getChildLogger(primary.getClass().getSimpleName()));
             getLogger().info("setting primary introspector logger: " + primary.getClass().getSimpleName());
         }
         if (secondary instanceof LogEnabled) {
             ((LogEnabled) secondary).enableLogging(getLogger().getChildLogger(secondary.getClass().getSimpleName()));
             getLogger().info("setting secondary introspector logger: " + secondary.getClass().getSimpleName());
         }
     }
     
     /**
      * Loads the named class using the default class loader.
      *
      * @param className the name of the class to load.
      * @return {@inheritDoc} the loaded class.
      * @throws ClassNotFoundException if the class was not found.
      */
     @SuppressWarnings("unchecked")
     protected <T> Class<T> loadClass(String className) throws ClassNotFoundException {
         ClassLoader loader = this.getClass().getClassLoader();
         try {
             Class<T> clazz;
 
             if (loader != null) {
                 clazz = (Class<T>) loader.loadClass(className);
             } else {
                 clazz = (Class<T>) Class.forName(className);
             }
 
             return clazz;
         } catch (ClassNotFoundException x) {
             /* Give up. */
             throw x;
         }
     }
 
     public ObjectMapper getMapper() {
         return mapper;
     }
 
     public void setMapper(ObjectMapper mapper) {
         this.mapper = mapper;
     }
 
     public boolean isCacheFilters() {
         return cacheFilters;
     }
 
     public void setCacheFilters(boolean cacheFilters) {
         this.cacheFilters = cacheFilters;
         if (!cacheFilters)
             mapper.configure(SerializationFeature.FLUSH_AFTER_WRITE_VALUE, true);
     }
 
     static CharacterEscapes characterEscapes = new CharacterEscapes() {
         private static final long serialVersionUID = 1L;
         private final int[] asciiEscapes;
         { // instance init
             int[] esc = standardAsciiEscapesForJSON();
             // this avoids to get evaluated immediately
             esc['<'] = CharacterEscapes.ESCAPE_STANDARD;
             esc['>'] = CharacterEscapes.ESCAPE_STANDARD;
             esc['&'] = CharacterEscapes.ESCAPE_STANDARD;
             esc['\''] = CharacterEscapes.ESCAPE_STANDARD;
             // esc['/'] = '/'; //CharacterEscapes.ESCAPE_CUSTOM;
             asciiEscapes = esc;
         }
 
         @Override
         public int[] getEscapeCodesForAscii() {
             return asciiEscapes;
         }
 
         @Override
         public SerializableString getEscapeSequence(final int ch) {
 //            if ( ch == '/') { 
 //                return new SerializedString("\\\\/");
 //            } else {
             return null;
 //            }
         }
     };
 }