/*
    * 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 KIND, either express or implied.
   * See the license for the specific language governing permissions and
   * limitations under the license.
   */
  package org.apache.logging.log4j.core.pattern;
  
  import java.util.Locale;
  
  import org.apache.logging.log4j.core.LogEvent;
  import org.apache.logging.log4j.core.config.Configuration;
  import org.apache.logging.log4j.core.config.plugins.Plugin;
  import org.apache.logging.log4j.core.util.ArrayUtils;
  import org.apache.logging.log4j.core.util.Constants;
  import org.apache.logging.log4j.core.util.Loader;
  import org.apache.logging.log4j.message.Message;
  import org.apache.logging.log4j.message.MultiformatMessage;
  import org.apache.logging.log4j.status.StatusLogger;
  import org.apache.logging.log4j.util.MultiFormatStringBuilderFormattable;
  import org.apache.logging.log4j.util.PerformanceSensitive;
  import org.apache.logging.log4j.util.StringBuilderFormattable;
  
  /**
   * Returns the event's rendered message in a StringBuilder.
   */
  @Plugin(name = "MessagePatternConverter", category = PatternConverter.CATEGORY)
  @ConverterKeys({ "m", "msg", "message" })
  @PerformanceSensitive("allocation")
  public final class MessagePatternConverter extends LogEventPatternConverter {
  
      private static final String NOLOOKUPS = "nolookups";
  
      private final String[] formats;
      private final Configuration config;
      private final TextRenderer textRenderer;
      private final boolean noLookups;
  
      /**
       * Private constructor.
       *
       * @param options
       *            options, may be null.
       */
      private MessagePatternConverter(final Configuration config, final String[] options) {
          super("Message", "message");
          this.formats = options;
          this.config = config;
          final int noLookupsIdx = loadNoLookups(options);
          this.noLookups = Constants.FORMAT_MESSAGES_PATTERN_DISABLE_LOOKUPS || noLookupsIdx >= 0;
          this.textRenderer = loadMessageRenderer(noLookupsIdx >= 0 ? ArrayUtils.remove(options, noLookupsIdx) : options);
      }
  
      private int loadNoLookups(final String[] options) {
          if (options != null) {
              for (int i = 0; i < options.length; i++) {
                  final String option = options[i];
                  if (NOLOOKUPS.equalsIgnoreCase(option)) {
                      return i;
                  }
              }
          }
          return -1;
      }
  
      private TextRenderer loadMessageRenderer(final String[] options) {
          if (options != null) {
              for (final String option : options) {
                  switch (option.toUpperCase(Locale.ROOT)) {
                  case "ANSI":
                      if (Loader.isJansiAvailable()) {
                          return new JAnsiTextRenderer(options, JAnsiTextRenderer.DefaultMessageStyleMap);
                      }
                      StatusLogger.getLogger()
                              .warn("You requested ANSI message rendering but JANSI is not on the classpath.");
                      return null;
                  case "HTML":
                      return new HtmlTextRenderer(options);
                  }
              }
          }
          return null;
      }
  
      /**
       * Obtains an instance of pattern converter.
       *
       * @param config
       *            The Configuration.
      * @param options
      *            options, may be null.
      * @return instance of pattern converter.
      */
     public static MessagePatternConverter newInstance(final Configuration config, final String[] options) {
         return new MessagePatternConverter(config, options);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void format(final LogEvent event, final StringBuilder toAppendTo) {
         final Message msg = event.getMessage();
         if (msg instanceof StringBuilderFormattable) {
 
             final boolean doRender = textRenderer != null;
             final StringBuilder workingBuilder = doRender ? new StringBuilder(80) : toAppendTo;
 
             final int offset = workingBuilder.length();
             if (msg instanceof MultiFormatStringBuilderFormattable) {
                 ((MultiFormatStringBuilderFormattable) msg).formatTo(formats, workingBuilder);
             } else {
                 ((StringBuilderFormattable) msg).formatTo(workingBuilder);
             }
 
             // TODO can we optimize this?
             if (config != null && !noLookups) {
                 for (int i = offset; i < workingBuilder.length() - 1; i++) {
                     if (workingBuilder.charAt(i) == '$' && workingBuilder.charAt(i + 1) == '{') {
                         final String value = workingBuilder.substring(offset, workingBuilder.length());
                         workingBuilder.setLength(offset);
                         workingBuilder.append(config.getStrSubstitutor().replace(event, value));
                     }
                 }
             }
             if (doRender) {
                 textRenderer.render(workingBuilder, toAppendTo);
             }
             return;
         }
         if (msg != null) {
             String result;
             if (msg instanceof MultiformatMessage) {
                 result = ((MultiformatMessage) msg).getFormattedMessage(formats);
             } else {
                 result = msg.getFormattedMessage();
             }
             if (result != null) {
                 toAppendTo.append(config != null && result.contains("${")
                         ? config.getStrSubstitutor().replace(event, result) : result);
             } else {
                 toAppendTo.append("null");
             }
         }
     }
 }