/*
    * Licensed 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 KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.addthis.codec.jackson;
  
  import javax.annotation.Nonnull;
  import javax.annotation.Syntax;
  import javax.validation.ConstraintViolation;
  import javax.validation.ValidationException;
  import javax.validation.Validator;
  
  import java.io.IOException;
  
  import java.util.Set;
  
  import com.addthis.codec.config.ConfigTraversingParser;
  import com.addthis.codec.config.Configs;
  import com.addthis.codec.plugins.PluginMap;
  import com.addthis.codec.plugins.PluginRegistry;
  
  import com.google.common.annotations.Beta;
  import com.google.common.base.Preconditions;
  
  import com.fasterxml.jackson.core.JsonProcessingException;
  import com.fasterxml.jackson.databind.JsonNode;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.typesafe.config.Config;
  import com.typesafe.config.ConfigException;
  import com.typesafe.config.ConfigFactory;
  import com.typesafe.config.ConfigValue;
  
  import io.dropwizard.validation.ConstraintViolations;
  
  /**
   * Wrapper over an object mapper, plugin registry, global config, and a validator. Provides
   * methods for constructing objects that automatically perform validation, and bridge hocon
   * strings to jackson construction. Normally obtained either from {@link Jackson#defaultCodec()}
   * or used indirectly from the static helper methods in {@link Configs}.
   */
  @Beta
  public class CodecJackson {
  
      private final ObjectMapper objectMapper;
      private final PluginRegistry pluginRegistry;
      private final Config globalDefaults;
      private final Validator validator;
  
      public CodecJackson(ObjectMapper objectMapper, PluginRegistry pluginRegistry,
                          Config globalDefaults, Validator validator) {
          this.objectMapper = objectMapper;
          this.pluginRegistry = pluginRegistry;
          this.globalDefaults = globalDefaults;
          this.validator = validator;
      }
  
      public CodecJackson withConfig(Config newGlobalDefaults) {
          if (newGlobalDefaults == this.globalDefaults) {
              return this;
          } else {
              PluginRegistry newPluginRegistry = new PluginRegistry(newGlobalDefaults);
              ObjectMapper newObjectMapper = Jackson.newObjectMapper(newPluginRegistry);
              return new CodecJackson(newObjectMapper, newPluginRegistry, newGlobalDefaults, validator);
          }
      }
  
      public CodecJackson withOverrides(Config overrides) {
          if (overrides == this.globalDefaults) {
              return this;
          } else {
              PluginRegistry newPluginRegistry = pluginRegistry.withOverrides(overrides);
              ObjectMapper newObjectMapper = Jackson.newObjectMapper(newPluginRegistry);
              return new CodecJackson(newObjectMapper, newPluginRegistry, overrides, validator);
          }
      }
  
      public ObjectMapper getObjectMapper() {
          return objectMapper;
      }
  
      public PluginRegistry getPluginRegistry() {
          return pluginRegistry;
      }
  
      public Config getGlobalDefaults() {
          return globalDefaults;
      }
  
      public Validator getValidator() {
          return validator;
     }
 
     // doesn't delegate
 
     /**
      * Construct an object of the requested type based on the default values and types (if the requested
      * is not a concrete class).
      */
     public <T> T newDefault(@Nonnull Class<T> type) throws JsonProcessingException, IOException {
         T value = objectMapper.treeToValue(DefaultCodecJackson.DEFAULT_MAPPER.createObjectNode(), type);
         return validate(value);
     }
 
     public <T> T decodeObject(@Nonnull Class<T> type, ConfigValue configValue)
             throws JsonProcessingException, IOException {
         ConfigTraversingParser configParser = new ConfigTraversingParser(configValue, objectMapper);
         return validate(configParser.readValueAs(type));
     }
 
     public <T> T decodeObject(@Nonnull Class<T> type, JsonNode jsonNode) throws JsonProcessingException {
         return validate(objectMapper.treeToValue(jsonNode, type));
     }
 
     // delegates
 
     /** Construct an object of the requested plugin category based on the default type and values */
     public <T> T newDefault(@Nonnull String category) throws JsonProcessingException, IOException {
         Class<T> type = (Class<T>) pluginRegistry.byCategory().get(category).baseClass();
         return newDefault(type);
     }
 
     /**
      * Tries to parse the string as an isolated typesafe-config object, tries to resolve it, and then calls
      * {@link #decodeObject(String, Config)} with the resultant config and the passed in category. Pretty much just
      * a convenience function for simple use cases that don't want to care about how ConfigFactory works.
      */
     public <T> T decodeObject(@Nonnull String category, @Syntax("HOCON") String configText)
             throws JsonProcessingException, IOException {
         PluginMap pluginMap = Preconditions.checkNotNull(pluginRegistry.asMap().get(category),
                                                          "could not find anything about the category %s", category);
         Config config = ConfigFactory.parseString(configText).resolve();
         return (T) decodeObject(pluginMap.baseClass(), config);
     }
 
     /**
      * Tries to parse the string as an isolated typesafe-config object, tries to resolve it, and then calls
      * {@link #decodeObject(Class, Config)} with the resultant config and the passed in type. Pretty much just
      * a convenience function for simple use cases that don't want to care about how ConfigFactory works.
      */
     public <T> T decodeObject(@Nonnull Class<T> type, @Syntax("HOCON") String configText)
             throws JsonProcessingException, IOException {
         Config config = ConfigFactory.parseString(configText).resolve();
         return decodeObject(type, config);
     }
 
     /**
      * Instantiate an object of the requested category based on the provided config. The config should only contain
      * field and type information for the object to be constructed. Global defaults, plugin configuration, etc, are
      * provided by this CodecConfig instance's globalConfig and pluginRegistry fields.
      */
     public <T> T decodeObject(@Nonnull String category, @Nonnull Config config)
             throws JsonProcessingException, IOException {
         PluginMap pluginMap = Preconditions.checkNotNull(pluginRegistry.asMap().get(category),
                                                          "could not find anything about the category %s", category);
         return (T) decodeObject(pluginMap.baseClass(), config);
     }
 
     /**
      * Instantiate an object of the requested type based on the provided config. The config should only contain
      * field and type information for the object to be constructed. Global defaults, plugin configuration, etc, are
      * provided by this CodecConfig instance's globalConfig and pluginRegistry fields.
      */
     public <T> T decodeObject(@Nonnull Class<T> type, Config config)
             throws JsonProcessingException, IOException {
         return decodeObject(type, config.root());
     }
 
     /**
      * Instantiate an object without a compile time expected type. This expects a config of the
      * form "{plugin-category: {...}}". ie. there should be exactly one top level key and that
      * key should be a valid, loaded, plug-in category.
      */
     public <T> T decodeObject(@Syntax("HOCON") String configText) throws JsonProcessingException, IOException {
         Config config = ConfigFactory.parseString(configText).resolve();
         return decodeObject(config);
     }
 
     /**
      * Instantiate an object without a compile time expected type. This expects a config of the
      * form "{plugin-category: {...}}". ie. there should be exactly one top level key and that
      * key should be a valid, loaded, plug-in category.
      */
     public <T> T decodeObject(Config config) throws JsonProcessingException, IOException {
         if (config.root().size() != 1) {
             throw new ConfigException.Parse(config.root().origin(),
                                             "config root must have exactly one key");
         }
         String category = config.root().keySet().iterator().next();
         PluginMap pluginMap = pluginRegistry.asMap().get(category);
         if (pluginMap == null) {
             throw new ConfigException.BadValue(config.root().get(category).origin(),
                                                category,
                                                "top level key must be a valid category");
         }
         ConfigValue configValue = config.root().get(category);
         return (T) decodeObject(pluginMap.baseClass(), configValue);
     }
 
     public <T> T validate(T value) {
         Set<ConstraintViolation<T>> violations = validator.validate(value);
         if (!violations.isEmpty()) {
             throw new ValidationException(ConstraintViolations.<T>format(violations).toString());
         }
         return value;
     }
 }