/*
    * 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 static org.fusesource.jansi.AnsiRenderer.Code.BG_RED;
  import static org.fusesource.jansi.AnsiRenderer.Code.BOLD;
  import static org.fusesource.jansi.AnsiRenderer.Code.RED;
  import static org.fusesource.jansi.AnsiRenderer.Code.WHITE;
  import static org.fusesource.jansi.AnsiRenderer.Code.YELLOW;
  
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  
  import org.apache.logging.log4j.status.StatusLogger;
  import org.fusesource.jansi.Ansi;
  import org.fusesource.jansi.AnsiRenderer;
  import org.fusesource.jansi.AnsiRenderer.Code;
  
  /**
   * Renders an input as ANSI escaped output.
   *
   * Uses the JAnsi rendering syntax as the default to render a message into an ANSI escaped string.
   *
   * The default syntax for embedded ANSI codes is:
   *
   * <pre>
   *   &#64;|<em>code</em>(,<em>code</em>)* <em>text</em>|@
   * </pre>
   *
   * For example, to render the message {@code "Hello"} in green, use:
   *
   * <pre>
   *   &#64;|green Hello|@
   * </pre>
   *
   * To render the message {@code "Hello"} in bold and red, use:
   *
   * <pre>
   *   &#64;|bold,red Warning!|@
   * </pre>
   *
   * You can also define custom style names in the configuration with the syntax:
   *
   * <pre>
   * %message{ansi}{StyleName=value(,value)*( StyleName=value(,value)*)*}%n
   * </pre>
   *
   * For example:
   *
   * <pre>
   * %message{ansi}{WarningStyle=red,bold KeyStyle=white ValueStyle=blue}%n
   * </pre>
   *
   * The call site can look like this:
   *
   * <pre>
   * logger.info("@|KeyStyle {}|@ = @|ValueStyle {}|@", entry.getKey(), entry.getValue());
   * </pre>
   *
   * Note: This class originally copied and then heavily modified code from JAnsi's AnsiRenderer (which is licensed as
   * Apache 2.0.)
   *
   * @see AnsiRenderer
   */
  public final class JAnsiTextRenderer implements TextRenderer {
  
      public static final Map<String, Code[]> DefaultExceptionStyleMap;
      static final Map<String, Code[]> DefaultMessageStyleMap;
      private static final Map<String, Map<String, Code[]>> PrefedinedStyleMaps;
  
      private static void put(final Map<String, Code[]> map, final String name, final Code... codes) {
          map.put(name, codes);
      }
  
      static {
          final Map<String, Map<String, Code[]>> tempPreDefs = new HashMap<>();
          // Default style: Spock
          {
              // TODO Should the keys be in an enum?
              final Map<String, Code[]> map = new HashMap<>();
              put(map, "Prefix", WHITE);
              put(map, "Name", BG_RED, WHITE);
              put(map, "NameMessageSeparator", BG_RED, WHITE);
             put(map, "Message", BG_RED, WHITE, BOLD);
             put(map, "At", WHITE);
             put(map, "CauseLabel", WHITE);
             put(map, "Text", WHITE);
             put(map, "More", WHITE);
             put(map, "Suppressed", WHITE);
             // StackTraceElement
             put(map, "StackTraceElement.ClassName", YELLOW);
             put(map, "StackTraceElement.ClassMethodSeparator", YELLOW);
             put(map, "StackTraceElement.MethodName", YELLOW);
             put(map, "StackTraceElement.NativeMethod", YELLOW);
             put(map, "StackTraceElement.FileName", RED);
             put(map, "StackTraceElement.LineNumber", RED);
             put(map, "StackTraceElement.Container", RED);
             put(map, "StackTraceElement.ContainerSeparator", WHITE);
             put(map, "StackTraceElement.UnknownSource", RED);
             // ExtraClassInfo
             put(map, "ExtraClassInfo.Inexact", YELLOW);
             put(map, "ExtraClassInfo.Container", YELLOW);
             put(map, "ExtraClassInfo.ContainerSeparator", YELLOW);
             put(map, "ExtraClassInfo.Location", YELLOW);
             put(map, "ExtraClassInfo.Version", YELLOW);
             // Save
             DefaultExceptionStyleMap = Collections.unmodifiableMap(map);
             tempPreDefs.put("Spock", DefaultExceptionStyleMap);
         }
         // Style: Kirk
         {
             // TODO Should the keys be in an enum?
             final Map<String, Code[]> map = new HashMap<>();
             put(map, "Prefix", WHITE);
             put(map, "Name", BG_RED, YELLOW, BOLD);
             put(map, "NameMessageSeparator", BG_RED, YELLOW);
             put(map, "Message", BG_RED, WHITE, BOLD);
             put(map, "At", WHITE);
             put(map, "CauseLabel", WHITE);
             put(map, "Text", WHITE);
             put(map, "More", WHITE);
             put(map, "Suppressed", WHITE);
             // StackTraceElement
             put(map, "StackTraceElement.ClassName", BG_RED, WHITE);
             put(map, "StackTraceElement.ClassMethodSeparator", BG_RED, YELLOW);
             put(map, "StackTraceElement.MethodName", BG_RED, YELLOW);
             put(map, "StackTraceElement.NativeMethod", BG_RED, YELLOW);
             put(map, "StackTraceElement.FileName", RED);
             put(map, "StackTraceElement.LineNumber", RED);
             put(map, "StackTraceElement.Container", RED);
             put(map, "StackTraceElement.ContainerSeparator", WHITE);
             put(map, "StackTraceElement.UnknownSource", RED);
             // ExtraClassInfo
             put(map, "ExtraClassInfo.Inexact", YELLOW);
             put(map, "ExtraClassInfo.Container", WHITE);
             put(map, "ExtraClassInfo.ContainerSeparator", WHITE);
             put(map, "ExtraClassInfo.Location", YELLOW);
             put(map, "ExtraClassInfo.Version", YELLOW);
             // Save
             tempPreDefs.put("Kirk", Collections.unmodifiableMap(map));
         }
         {
             final Map<String, Code[]> temp = new HashMap<>();
             // TODO
             DefaultMessageStyleMap = Collections.unmodifiableMap(temp);
         }
         PrefedinedStyleMaps = Collections.unmodifiableMap(tempPreDefs);
     }
 
     private final String beginToken;
     private final int beginTokenLen;
     private final String endToken;
     private final int endTokenLen;
     private final Map<String, Code[]> styleMap;
 
     public JAnsiTextRenderer(final String[] formats, final Map<String, Code[]> defaultStyleMap) {
         String tempBeginToken = AnsiRenderer.BEGIN_TOKEN;
         String tempEndToken = AnsiRenderer.END_TOKEN;
         Map<String, Code[]> map;
         if (formats.length > 1) {
             final String allStylesStr = formats[1];
             // Style def split
             final String[] allStyleAssignmentsArr = allStylesStr.split(" ");
             map = new HashMap<>(allStyleAssignmentsArr.length + defaultStyleMap.size());
             map.putAll(defaultStyleMap);
             for (final String styleAssignmentStr : allStyleAssignmentsArr) {
                 final String[] styleAssignmentArr = styleAssignmentStr.split("=");
                 if (styleAssignmentArr.length != 2) {
                     StatusLogger.getLogger().warn("{} parsing style \"{}\", expected format: StyleName=Code(,Code)*",
                             getClass().getSimpleName(), styleAssignmentStr);
                 } else {
                     final String styleName = styleAssignmentArr[0];
                     final String codeListStr = styleAssignmentArr[1];
                     final String[] codeNames = codeListStr.split(",");
                     if (codeNames.length == 0) {
                         StatusLogger.getLogger().warn(
                                 "{} parsing style \"{}\", expected format: StyleName=Code(,Code)*",
                                 getClass().getSimpleName(), styleAssignmentStr);
                     } else {
                         switch (styleName) {
                         case "BeginToken":
                             tempBeginToken = codeNames[0];
                             break;
                         case "EndToken":
                             tempEndToken = codeNames[0];
                             break;
                         case "StyleMapName":
                             final String predefinedMapName = codeNames[0];
                             final Map<String, Code[]> predefinedMap = PrefedinedStyleMaps.get(predefinedMapName);
                             if (predefinedMap != null) {
                                 map.putAll(predefinedMap);
                             } else {
                                 StatusLogger.getLogger().warn("Unknown predefined map name {}, pick one of {}",
                                         predefinedMapName, null);
                             }
                             break;
                         default:
                             final Code[] codes = new Code[codeNames.length];
                             for (int i = 0; i < codes.length; i++) {
                                 codes[i] = toCode(codeNames[i]);
                             }
                             map.put(styleName, codes);
                         }
                     }
                 }
             }
         } else {
             map = defaultStyleMap;
         }
         styleMap = map;
         beginToken = tempBeginToken;
         endToken = tempEndToken;
         beginTokenLen = tempBeginToken.length();
         endTokenLen = tempEndToken.length();
     }
 
     public Map<String, Code[]> getStyleMap() {
         return styleMap;
     }
 
     private void render(final Ansi ansi, final Code code) {
         if (code.isColor()) {
             if (code.isBackground()) {
                 ansi.bg(code.getColor());
             } else {
                 ansi.fg(code.getColor());
             }
         } else if (code.isAttribute()) {
             ansi.a(code.getAttribute());
         }
     }
 
     private void render(final Ansi ansi, final Code... codes) {
         for (final Code code : codes) {
             render(ansi, code);
         }
     }
 
     /**
      * Renders the given text with the given names which can be ANSI code names or Log4j style names.
      *
      * @param text
      *            The text to render
      * @param names
      *            ANSI code names or Log4j style names.
      * @return A rendered string containing ANSI codes.
      */
     private String render(final String text, final String... names) {
         final Ansi ansi = Ansi.ansi();
         for (final String name : names) {
             final Code[] codes = styleMap.get(name);
             if (codes != null) {
                 render(ansi, codes);
             } else {
                 render(ansi, toCode(name));
             }
         }
         return ansi.a(text).reset().toString();
     }
 
     // EXACT COPY OF StringBuilder version of the method but typed as String for input
     @Override
     public void render(final String input, final StringBuilder output, final String styleName)
             throws IllegalArgumentException {
         output.append(render(input, styleName));
     }
 
     @Override
     public void render(final StringBuilder input, final StringBuilder output) throws IllegalArgumentException {
         int i = 0;
         int j, k;
 
         while (true) {
             j = input.indexOf(beginToken, i);
             if (j == -1) {
                 if (i == 0) {
                     output.append(input);
                     return;
                 }
                 output.append(input.substring(i, input.length()));
                 return;
             }
             output.append(input.substring(i, j));
             k = input.indexOf(endToken, j);
 
             if (k == -1) {
                 output.append(input);
                 return;
             }
             j += beginTokenLen;
             final String spec = input.substring(j, k);
 
             final String[] items = spec.split(AnsiRenderer.CODE_TEXT_SEPARATOR, 2);
             if (items.length == 1) {
                 output.append(input);
                 return;
             }
             final String replacement = render(items[1], items[0].split(","));
 
             output.append(replacement);
 
             i = k + endTokenLen;
         }
     }
 
     private Code toCode(final String name) {
         return Code.valueOf(name.toUpperCase(Locale.ENGLISH));
     }
 
     @Override
     public String toString() {
         return "JAnsiMessageRenderer [beginToken=" + beginToken + ", beginTokenLen=" + beginTokenLen + ", endToken="
                 + endToken + ", endTokenLen=" + endTokenLen + ", styleMap=" + styleMap + "]";
     }
 
 }