/*
    * The contents of this file are subject to the terms of the Common Development and
    * Distribution License (the License). You may not use this file except in compliance with the
    * License.
    *
    * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
    * specific language governing permission and limitations under the License.
    *
    * When distributing Covered Software, include this CDDL Header Notice in each file and include
   * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
   * Header, with the fields enclosed by brackets [] replaced by your own identifying
   * information: "Portions copyright [year] [name of copyright owner]".
   *
   * Copyright 2015-2016 ForgeRock AS.
   */
  package org.forgerock.audit.json;
  
  import static org.forgerock.json.JsonValue.field;
  import static org.forgerock.json.JsonValue.json;
  import static org.forgerock.json.JsonValue.object;
  
  import com.fasterxml.jackson.annotation.JsonPropertyDescription;
  import com.fasterxml.jackson.databind.AnnotationIntrospector;
  import com.fasterxml.jackson.databind.ObjectMapper;
  import com.fasterxml.jackson.databind.introspect.Annotated;
  import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
  import com.fasterxml.jackson.module.jsonSchema.jakarta.JsonSchema;
  import com.fasterxml.jackson.module.jsonSchema.jakarta.factories.SchemaFactoryWrapper;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.LinkedHashMap;
  import java.util.Map;
  import org.forgerock.audit.AuditException;
  import org.forgerock.audit.AuditServiceBuilder;
  import org.forgerock.audit.AuditServiceConfiguration;
  import org.forgerock.audit.events.handlers.AuditEventHandler;
  import org.forgerock.audit.events.handlers.EventHandlerConfiguration;
  import org.forgerock.audit.util.JsonValueUtils;
  import org.forgerock.json.JsonValue;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Utility class to facilitate creation and configuration of audit service and audit event handlers
   * through JSON.
   */
  public final class AuditJsonConfig {
      private static final Logger LOGGER = LoggerFactory.getLogger(AuditJsonConfig.class);
  
      /** Field containing the name of an event handler. */
      private static final String NAME_FIELD = "name";
      /** Field containing the implementation class of an event handler. */
      private static final String CLASS_FIELD = "class";
      /** Field containing the configuration of an event handler. */
      private static final String CONFIG_FIELD = "config";
      /** Field containing events topics to process for an event handler. */
      private static final String EVENTS_FIELD = "events";
  
      /** The mapper from JSON structure to Java object. */
      private static final ObjectMapper MAPPER = new ObjectMapper();
  
      private static final AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR = new JacksonAnnotationIntrospector();
      private static final AnnotationIntrospector HELP_APPENDER_ANNOTATION_INTROSPECTOR =
              new HelpAppenderAnnotationIntrospector();
  
      private AuditJsonConfig() {
          // prevent instantiation of the class
      }
  
      /**
       * Returns a JSON value from the provided input stream.
       *
       * @param input
       *          Input stream containing an arbitrary JSON structure.
       * @return the JSON value corresponding to the JSON structure
       * @throws AuditException
       *          If an error occurs.
       */
      public static JsonValue getJson(InputStream input) throws AuditException {
          if (input == null) {
              throw new AuditException("Input stream is null");
          }
          try {
              Object val = MAPPER.readValue(input, LinkedHashMap.class);
              return new JsonValue(val);
          } catch (IOException e) {
              throw new AuditException(String.format("Unable to retrieve json value from json input stream"), e);
          }
      }
  
      /**
       * Returns the audit service configuration from the provided input stream.
       *
       * @param input
       *          Input stream containing JSON configuration of the audit service.
       * @return the configuration object
       * @throws AuditException
       *          If any error occurs.
       */
     public static AuditServiceConfiguration parseAuditServiceConfiguration(InputStream input) throws AuditException {
         try {
             return MAPPER.readValue(input, AuditServiceConfiguration.class);
         } catch (IOException e) {
             throw new AuditException(String.format("Unable to retrieve class %s from json input stream",
                     AuditServiceConfiguration.class), e);
         }
     }
 
     /**
      * Returns the audit service configuration from the provided JSON string.
      *
      * @param json
      *          JSON string representing the configuration of the audit service.
      * @return the configuration object
      * @throws AuditException
      *          If any error occurs.
      */
     public static AuditServiceConfiguration parseAuditServiceConfiguration(String json) throws AuditException {
         if (json == null) {
             return new AuditServiceConfiguration();
         }
         try {
             return MAPPER.readValue(json, AuditServiceConfiguration.class);
         } catch (IOException e) {
             throw new AuditException(String.format("Unable to retrieve class %s from json: %s",
                     AuditServiceConfiguration.class, json), e);
         }
     }
 
     /**
      * Returns the audit service configuration from the provided JSON value.
      *
      * @param json
      *          JSON value representing the configuration of the audit service.
      * @return the configuration object
      * @throws AuditException
      *          If any error occurs.
      */
     public static AuditServiceConfiguration parseAuditServiceConfiguration(JsonValue json) throws AuditException {
         return parseAuditServiceConfiguration(JsonValueUtils.extractValueAsString(json, "/"));
     }
 
     /**
      * Configures and registers the audit event handler corresponding to the provided JSON configuration
      * to the provided audit service.
      *
      * @param jsonConfig
      *          The configuration of the audit event handler as JSON.
      * @param auditServiceBuilder
      *          The builder for the service the event handler will be registered to.
      * @throws AuditException
      *             If any error occurs during configuration or registration of the handler.
      */
     public static void registerHandlerToService(JsonValue jsonConfig, AuditServiceBuilder auditServiceBuilder)
             throws AuditException {
         registerHandlerToService(jsonConfig, auditServiceBuilder, auditServiceBuilder.getClass().getClassLoader());
     }
 
     /**
      * Configures and registers the audit event handler corresponding to the provided JSON configuration
      * to the provided audit service, using a specific class loader.
      *
      * @param jsonConfig
      *          The configuration of the audit event handler as JSON.
      * @param auditServiceBuilder
      *          The builder for the service the event handler will be registered to.
      * @param classLoader
      *          The class loader to use to load the handler and its configuration class.
      * @throws AuditException
      *             If any error occurs during configuration or registration of the handler.
      */
     public static void registerHandlerToService(JsonValue jsonConfig,
             AuditServiceBuilder auditServiceBuilder, ClassLoader classLoader) throws AuditException {
         String name = getHandlerName(jsonConfig);
         Class<? extends AuditEventHandler> handlerClass = getAuditEventHandlerClass(name, jsonConfig, classLoader);
         Class<? extends EventHandlerConfiguration> configClass =
                 getAuditEventHandlerConfigurationClass(name, handlerClass, classLoader);
         EventHandlerConfiguration configuration = parseAuditEventHandlerConfiguration(configClass, jsonConfig);
         auditServiceBuilder.withAuditEventHandler(handlerClass, configuration);
     }
 
     /**
      * Returns the name of the event handler corresponding to provided JSON configuration.
      * <p>
      * The JSON configuration is expected to contains a "name" field identifying the
      * event handler, e.g.
      * <pre>
      *  "name" : "passthrough"
      * </pre>
      *
      * @param jsonConfig
      *          The JSON configuration of the event handler.
      * @return the name of the event handler
      * @throws AuditException
      *          If an error occurs.
      */
     private static String getHandlerName(JsonValue jsonConfig) throws AuditException {
         String name = jsonConfig.get(CONFIG_FIELD).get(NAME_FIELD).asString();
         if (name == null) {
             throw new AuditException(String.format("No name is defined for the provided audit handler. "
                     + "You must define a 'name' property in the configuration."));
         }
         return name;
     }
 
     /**
      * Creates an audit event handler factory from the provided JSON configuration.
      * <p>
      * The JSON configuration is expected to contains a "class" property which provides
      * the class name for the handler factory to instantiate.
      *
      * @param jsonConfig
      *          The configuration of the audit event handler as JSON.
      * @param classLoader
      *          The class loader to use to load the handler and its configuration class.
      * @return the fully configured audit event handler
      * @throws AuditException
      *             If any error occurs during configuration or registration of the handler.
      */
     @SuppressWarnings("unchecked") // Class.forName calls
     private static Class<? extends AuditEventHandler> getAuditEventHandlerClass(
             String handlerName, JsonValue jsonConfig, ClassLoader classLoader) throws AuditException {
         // TODO: class name should not be provided in customer configuration
         // but through a commons module/service context
         String className = jsonConfig.get(CLASS_FIELD).asString();
         if (className == null) {
             String errorMessage = String.format("No class is defined for the audit handler %s. "
                     + "You must define a 'class' property in the configuration.", handlerName);
             throw new AuditException(errorMessage);
         }
         try {
             return (Class<? extends AuditEventHandler>) Class.forName(className, true, classLoader);
         } catch (ClassNotFoundException e) {
             String errorMessage = String.format("Invalid class is defined for the audit handler %s.", handlerName);
             throw new AuditException(errorMessage, e);
         }
     }
 
     @SuppressWarnings("unchecked") // Class.forName calls
     private static Class<? extends EventHandlerConfiguration> getAuditEventHandlerConfigurationClass(
             String handlerName, Class<? extends AuditEventHandler> handlerClass, ClassLoader classLoader)
             throws AuditException {
         String className = handlerClass.getName() + "Configuration";
         try {
             return (Class<? extends EventHandlerConfiguration>) Class.forName(className, true, classLoader);
         } catch (ClassNotFoundException e) {
             String errorMessage = String.format("Unable to locate configuration class %s for the audit handler %s.",
                     className, handlerName);
             throw new AuditException(errorMessage, e);
         }
     }
 
     /**
      * Returns the audit event handler configuration from the provided JSON string.
      *
      * @param <C>
      *          The type of the configuration bean for the event handler.
      * @param jsonConfig
      *          The configuration of the audit event handler as JSON.
      * @param clazz The class for type {@code <C>}.
      * @return the fully configured audit event handler
      * @throws AuditException
      *             If any error occurs while instantiating the configuration from JSON.
      */
     public static <C extends EventHandlerConfiguration> C parseAuditEventHandlerConfiguration(
             Class<C> clazz, JsonValue jsonConfig) throws AuditException {
         C configuration = null;
         JsonValue conf = jsonConfig.get(CONFIG_FIELD);
         if (conf != null) {
             configuration = MAPPER.convertValue(conf.getObject(), clazz);
         }
         return configuration;
     }
 
     /**
      * Gets the configuration schema for an audit event handler as json schema. The supplied json config must contain
      * a field called class with the value of the audit event handler implementation class.
      * @param className The class name to get the configuration for.
      * @param classLoader The {@link ClassLoader} to use to load the event handler and event handler config class.
      * @return The config schema as json schema.
      * @throws AuditException If any error occurs parsing the config class for schema.
      */
     public static JsonValue getAuditEventHandlerConfigurationSchema(final String className,
             final ClassLoader classLoader) throws AuditException {
         final Class<? extends EventHandlerConfiguration> eventHandlerConfiguration =
                 getAuditEventHandlerConfigurationClass(
                         className,
                         getAuditEventHandlerClass(
                                 className,
                                 json(object(field("class", className))),
                                 classLoader),
                         classLoader);
         try {
             MAPPER.setAnnotationIntrospector(HELP_APPENDER_ANNOTATION_INTROSPECTOR);
             SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
             MAPPER.acceptJsonFormatVisitor(MAPPER.constructType(eventHandlerConfiguration), visitor);
             JsonSchema jsonSchema = visitor.finalSchema();
             final JsonValue schema = json(MAPPER.readValue(MAPPER.writeValueAsString(jsonSchema), Map.class));
             MAPPER.setAnnotationIntrospector(DEFAULT_ANNOTATION_INTROSPECTOR);
             return schema;
         } catch (IOException e) {
             final String error = String.format("Unable to parse configuration class schema for configuration class %s",
                     eventHandlerConfiguration.getName());
             LOGGER.error(error, e);
             throw new AuditException(error, e);
         }
     }
 
     /**
      * Extends the default {@link JacksonAnnotationIntrospector} and overrides the {@link JsonPropertyDescription}
      * annotation inorder to append ".help" to the description.
      */
     private static class HelpAppenderAnnotationIntrospector extends JacksonAnnotationIntrospector {
         @Override
         public String findPropertyDescription(Annotated ann) {
             JsonPropertyDescription desc = _findAnnotation(ann, JsonPropertyDescription.class);
             return (desc == null) ? null : desc.value().concat(".help");
         }
     }
 
 }