/*
 * 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.juneau.marshall.markdown;

import static org.apache.juneau.commons.utils.Shorts.*;

import java.io.*;
import java.lang.reflect.*;
import java.time.*;
import java.time.temporal.*;
import java.util.*;

import org.apache.juneau.commons.bean.*;
import org.apache.juneau.marshall.*;
import org.apache.juneau.marshall.json.*;
import org.apache.juneau.marshall.json5.*;
import org.apache.juneau.marshall.serializer.*;
import org.apache.juneau.marshall.stream.*;
import org.apache.juneau.marshall.swap.spi.*;

/**
 * Session object for {@link MarkdownSerializer}.
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='warn'>This class is not thread safe and is typically discarded after one use.
 * </ul>
 *
 */
@SuppressWarnings({
   "java:S110", // Inheritance depth acceptable for serializer session hierarchy
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "java:S3740", // Raw ClassMeta/ObjectSwap types used throughout serializer session; parameterization requires extensive generic changes
   "java:S3776", // Cognitive complexity acceptable for doWrite
   "java:S6541", // Brain method acceptable for doWrite / writeAnything
   "rawtypes", // Raw ClassMeta locals (cm, itemCm, swappedCm) in writeAnything(), writeCollection() and friends are passed to the ObjectSwap API, which is typed on the raw class
   "resource" // MarkdownWriter/Writer lifecycle managed by SerializerPipe
})
public class MarkdownSerializerSession extends WriterSerializerSession implements RecordWritable {

   final String nullValue;
   final boolean showHeaders;

   /**
    * Builder class.
    */
   @SuppressWarnings({
      "java:S119" // 'SELF' (CRTP self-type) is intentional and clearer than a single-letter name.
   })
   public abstract static class Builder<SELF extends Builder<SELF>> extends WriterSerializerSession.Builder<SELF> {

      String nullValue;
      boolean showHeaders;

      /**
       * Constructor.
       *
       * @param ctx The context creating this session.
       *    <br>Cannot be <jk>null</jk>.
       */
      protected Builder(MarkdownSerializer ctx) {
         super(reqnn("ctx", ctx));
         nullValue = ctx.getNullValue();
         showHeaders = ctx.isShowHeaders();
      }

      @Override
      public MarkdownSerializerSession build() {
         return new MarkdownSerializerSession(this);
      }

   }

   /**
    * Concrete default builder leaf for the non-subclassed {@code create()} path (CRTP terminal).
    */
   public static final class DefaultBuilder extends Builder<DefaultBuilder> {

      DefaultBuilder(MarkdownSerializer ctx) {
         super(ctx);
      }
   }

   /**
    * Creates a new builder for this object.
    *
    * @param ctx The context creating this session.
    *    <br>Cannot be <jk>null</jk>.
    * @return A new builder.
    */
   @SuppressWarnings({
      "java:S1452" // Builder<?> wildcard return intentional; callers use it to construct session instances polymorphically
   })
   public static Builder<?> create(MarkdownSerializer ctx) {
      return new DefaultBuilder(reqnn("ctx", ctx));
   }

   /**
    * Constructor.
    *
    * @param builder The builder for this object.
    */
   protected MarkdownSerializerSession(Builder<?> builder) {
      super(builder);
      nullValue = or(builder.nullValue, "*null*");
      showHeaders = builder.showHeaders;
   }

   @Override /* RecordWritable */
   public RecordWriter writeRecords(Object output) throws IOException {
      return RecordAdapter.writer(this, output);
   }

   @Override /* RecordWritable */
   public boolean isRecordStreaming() {
      return false;
   }

   @Override /* Overridden from SerializerSession */
   protected void doWrite(SerializerPipe pipe, Object o) throws IOException, SerializeException {
      try (var w = getMarkdownWriter(pipe)) {
         writeAnything(w, o, getExpectedRootType(o), null);
      }
   }

   /**
    * Main serialization dispatch method.
    *
    * @param w The writer to write to.
    * @param o The object to serialize.
    * @param eType The expected type of the object.
    * @param pMeta The bean property meta (may be null).
    * @throws IOException Thrown by underlying stream.
    * @throws SerializeException If serialization fails.
    */
   protected void writeAnything(MarkdownWriter w, Object o, ClassMeta<?> eType, BeanPropertyMeta pMeta) throws IOException, SerializeException {
      if (o == null) {
         w.text(nullValue);
         return;
      }

      ClassMeta cm = push2("root", o, eType);
      if (cm == null) {
         // Recursion detected
         pop();
         w.text(nullValue);
         return;
      }

      ObjectSwap swap = cm.getSwap(this);
      if (swap != null) {
         o = swap(swap, o);
         cm = swap.getSwapClassMeta(this);
      }

      if (cm.isOptional()) {
         var opt = (Optional<?>) o;
         if (opt.isEmpty()) {
            pop();
            w.text(nullValue);
         } else {
            writeAnything(w, opt.get(), eType, pMeta);
            pop();
         }
         return;
      }

      if (cm.isBean()) {
         writeBeanMap(w, toBeanMap(o), eType, cm);
      } else if (cm.isMap()) {
         writeMap(w, (Map<?,?>) o, cm);
      } else if (cm.isCollectionOrArray()) {
         var l = cm.isArray() ? toObjectList(o) : (Collection<?>) o;
         writeCollection(w, l, eType, cm);
      } else if (cm.isStreamable()) {
         writeCollection(w, toListFromStreamable(o, cm), eType, cm);
      } else if (cm.isDate()) {
         w.text(writeDate((Date)o, cm));
      } else if (cm.isCalendar()) {
         w.text(writeCalendar(o, cm));
      } else if (cm.isTemporal()) {
         w.text(writeTemporal((TemporalAccessor)o, cm));
      } else if (cm.isDuration()) {
         w.text(writeDuration((Duration)o));
      } else if (cm.isPeriod()) {
         w.text(writePeriod((Period)o));
      } else {
         var s = toString(o);
         // Only use JSON5 wrapping for actual string/enum types where auto-detection could misinterpret
         // the value; non-bean objects (e.g. those with a valueOf(String) factory) use plain text so
         // that the parser can use convertToType() on the raw string.
         if ((cm.isCharSequence() || cm.isEnum()) && isAmbiguousString(s, nullValue))
            w.text("`'" + escapeJson5String(s) + "'`");
         else
            w.text(MarkdownWriter.escapeText(s));
      }
      
      pop();
   }

   /**
    * Serializes a bean as a 2-column key/value Markdown table.
    *
    * @param w The writer.
    * @param bm The bean map.
    * @param eType The expected type (for type name calculation).
    * @param aType The actual type (for type name calculation).
    * @throws IOException Thrown by underlying stream.
    * @throws SerializeException If serialization fails.
    */
   protected void writeBeanMap(MarkdownWriter w, BeanMap<?> bm, ClassMeta<?> eType, ClassMeta<?> aType) throws IOException, SerializeException {
      if (showHeaders) {
         w.tableHeader("Property", "Value");
         w.tableSeparator(2);
      }
      
      // Add _type row if needed for polymorphic type identification
      // This handles both addBeanTypes (eType != aType) and addRootType (root object with dict name)
      String typeName = getBeanTypeName(this, eType, aType, null);
      if (typeName != null) {
         w.tableRow("_type", typeName);
      }
      
      for (var entry : bm.entrySet()) {
         if (entry instanceof BeanMapEntry entry2 && !entry2.getMeta().canRead())
            continue;
         w.tableRow(MarkdownWriter.escapeCell(entry.getKey()), writeInlineValue(entry.getValue()));
      }
   }

   /**
    * Serializes a Map as a 2-column key/value Markdown table.
    *
    * @param w The writer.
    * @param m The map.
    * @param cm The class meta.
    * @throws IOException Thrown by underlying stream.
    * @throws SerializeException If serialization fails.
    */
   protected void writeMap(MarkdownWriter w, Map<?,?> m, ClassMeta<?> cm) throws IOException, SerializeException {
      if (showHeaders) {
         w.tableHeader("Key", "Value");
         w.tableSeparator(2);
      }
      for (var entry : m.entrySet()) {
         String rawKey = entry.getKey() == null ? null : toString(entry.getKey());
         String keyStr;
         if (rawKey == null)
            keyStr = nullValue;
         else if (isAmbiguousString(rawKey, nullValue))
            keyStr = "`'" + escapeJson5String(rawKey) + "'`";
         else
            keyStr = MarkdownWriter.escapeCell(rawKey);
         w.tableRow(keyStr, writeInlineValue(entry.getValue()));
      }
   }

   /**
    * Serializes a collection as either a multi-column table (uniform beans/maps) or a bulleted list.
    *
    * @param w The writer.
    * @param c The collection.
    * @param eType The expected type.
    * @param cm The class meta.
    * @throws IOException Thrown by underlying stream.
    * @throws SerializeException If serialization fails.
    */
   protected void writeCollection(MarkdownWriter w, Collection<?> c, ClassMeta<?> eType, ClassMeta<?> cm) throws IOException, SerializeException {
      if (c.isEmpty())
         return;

      var headers = getTableHeaders(c);
      if (headers != null) {
         // Uniform collection of beans or maps → multi-column table
         
         // Determine if we need a _type column
         boolean needsTypeColumn = isAddBeanTypes();
         var elementType = eType != null && eType.isCollectionOrArray() ? eType.getElementType() : cm.getElementType();

         // Add _type column to headers if needed
         String[] finalHeaders = headers;
         if (needsTypeColumn) {
            finalHeaders = new String[headers.length + 1];
            finalHeaders[0] = "_type";
            System.arraycopy(headers, 0, finalHeaders, 1, headers.length);
         }

         if (showHeaders && finalHeaders.length > 0) {
            w.tableHeader(finalHeaders);
            w.tableSeparator(finalHeaders.length);
         }

         for (var item : c) {
            if (item == null) {
               var row = new String[finalHeaders.length];
               Arrays.fill(row, nullValue);
               w.tableRow(row);
               continue;
            }
            ClassMeta itemCm = getClassMetaForObject(item);
            ObjectSwap itemSwap = itemCm.getSwap(this);
            var swapped = itemSwap != null ? swap(itemSwap, item) : item;
            ClassMeta swappedCm = itemSwap != null ? itemSwap.getSwapClassMeta(this) : itemCm;

            var row = new String[finalHeaders.length];
            int colOffset = needsTypeColumn ? 1 : 0;

            // Add type name if needed
            // For root-level collections with addRootType, treat each element as root
            if (needsTypeColumn) {
               String typeName;
               if (isRoot() && isAddRootType()) {
                  // Root-level collection: add type name if the bean has a dictionary name
                  typeName = swappedCm.getBeanDictionaryName();
               } else {
                  // Nested collection: use standard logic
                  typeName = getBeanTypeName(this, elementType, swappedCm, null);
               }
               row[0] = or(typeName, "");
            }

            if (swappedCm.isBean()) {
               var bm = toBeanMap(swapped);
               for (var i = 0; i < headers.length; i++) {
                  var val = bm.get(headers[i]);
                  row[i + colOffset] = writeInlineValue(val);
               }
            } else if (swappedCm.isMap()) {
               var map = (Map<?,?>) swapped;
               for (var i = 0; i < headers.length; i++) {
                  var val = map.get(headers[i]);
                  row[i + colOffset] = writeInlineValue(val);
               }
            }
            w.tableRow(row);
         }
      } else {
         // Mixed or simple values → bulleted list
         for (var item : c)
            w.bulletItem(0, writeInlineValue(item));
      }
   }

   /**
    * Returns true if the string could be misinterpreted during parsing when the target type is Object,
    * or if the string contains characters that would be lost or corrupted in Markdown table cells.
    *
    * <p>Strings that are empty, equal to nullValue, look like booleans or numbers, or contain control
    * characters (< 32 or = 127) are considered ambiguous and should be wrapped in JSON5 backtick syntax.
    */
   private static boolean isAmbiguousString(String s, String nullValue) {
      if (s.isEmpty()) return true;
      if (s.equals(nullValue)) return true;
      if (eqa(s, "true", "false")) return true;
      for (int i = 0; i < s.length(); i++) {
         char c = s.charAt(i);
         if (c < 32 || c == 127) return true;
      }
      try { Integer.parseInt(s); return true; } catch (@SuppressWarnings("unused") NumberFormatException ignored) { /* Not a number; fall through */ }
      try { Long.parseLong(s); return true; } catch (@SuppressWarnings("unused") NumberFormatException ignored) { /* Not a number; fall through */ }
      try { Double.parseDouble(s); return true; } catch (@SuppressWarnings("unused") NumberFormatException ignored) { /* Not a number; fall through */ }
      return false;
   }

   /**
    * Escapes a string for use within a JSON5 single-quoted string literal.
    */
   private static String escapeJson5String(String s) {
      if (s == null) return "";
      var sb = new StringBuilder(s.length() + 4);
      for (var i = 0; i < s.length(); i++) {
         var c = s.charAt(i);
         switch (c) {
            case '\'' -> sb.append("\\'");
            case '\\' -> sb.append("\\\\");
            case '\n' -> sb.append("\\n");
            case '\r' -> sb.append("\\r");
            case '\t' -> sb.append("\\t");
            default -> sb.append(c);
         }
      }
      return sb.toString();
   }

   /**
    * Converts an array (including primitive arrays) to a List of boxed objects.
    */
   private static List<Object> toObjectList(Object array) {
      int len = Array.getLength(array);
      var list = new ArrayList<>(len);
      for (int i = 0; i < len; i++)
         list.add(Array.get(array, i));
      return list;
   }

   /**
    * Returns a Json5Serializer that shares this session's bean context (swaps, implClasses, dictionary).
    * Creates a new serializer each time to ensure settings are current.
    */
   private JsonSerializer getJson5Serializer() {
      var b = Json5Serializer.create().marshallingContext((MarshallingContext) getContext());
      if (isAddBeanTypes())
         b = b.addBeanTypes();
      if (isAddRootType())
         b = b.addRootType();
      if (isTrimStrings())
         b = b.trimStrings();
      return b.build();
   }

   /**
    * Serializes a value for placement in a Markdown table cell.
    *
    * <p>
    * Simple values (strings, numbers, booleans, enums, dates) are escaped and returned inline.
    * Complex values (beans, maps, collections) are serialized as JSON5 in backticks.
    *
    * @param o The value to serialize.
    * @return The cell string value.
    * @throws SerializeException If serialization fails.
    */
   protected String writeInlineValue(Object o) throws SerializeException {
      if (o == null)
         return nullValue;

      ClassMeta cm = getClassMetaForObject(o);
      ObjectSwap swap = cm.getSwap(this);
      if (swap != null) {
         o = swap(swap, o);
         cm = swap.getSwapClassMeta(this);
      }

      if (cm.isCharSequence() || cm.isEnum()) {
         var s = toString(o);
         if (isAmbiguousString(s, nullValue))
            return "`'" + escapeJson5String(s) + "'`";
         return MarkdownWriter.escapeCell(s);
      }

      if (cm.isNumber() || cm.isBoolean())
         return o.toString();

      if (cm.isDate())
         return MarkdownWriter.escapeCell(writeDate((Date)o, cm));

      if (cm.isCalendar())
         return MarkdownWriter.escapeCell(writeCalendar(o, cm));

      if (cm.isTemporal())
         return MarkdownWriter.escapeCell(writeTemporal((TemporalAccessor)o, cm));

      if (cm.isDuration())
         return MarkdownWriter.escapeCell(writeDuration((Duration)o));

      if (cm.isPeriod())
         return MarkdownWriter.escapeCell(writePeriod((Period)o));

      // Complex value: serialize as JSON5 in backticks — use context-aware serializer for swaps
      try {
         var json5 = getJson5Serializer().write(o);
         return "`" + json5 + "`";
      } catch (@SuppressWarnings("unused") SerializeException e) {
         return MarkdownWriter.escapeCell(o.toString());
      }
   }

   /**
    * Determines if a collection can be rendered as a multi-column table.
    *
    * <p>
    * Returns the column header names if the collection is a uniform set of beans or maps,
    * or {@code null} if it should be rendered as a bulleted list.
    *
    * @param c The collection to inspect.
    *    <br>Must not be <jk>null</jk>.
    * @return The column header names, or {@code null} for list rendering.
    * @throws SerializeException If inspection fails.
    */
   @SuppressWarnings({
      "java:S1168" // null signals list rendering; empty array would incorrectly trigger table mode
   })
   protected String[] getTableHeaders(Collection<?> c) throws SerializeException {
      if (c.isEmpty())
         return null;

      // Find first non-null element
      Object first = null;
      for (var item : c) {
         if (item != null) {
            first = item;
            break;
         }
      }
      if (first == null)
         return null;

      ClassMeta cm = getClassMetaForObject(first);
      ObjectSwap swap = cm.getSwap(this);
      if (swap != null) {
         try {
            first = swap(swap, first);
            cm = swap.getSwapClassMeta(this);
         } catch (@SuppressWarnings("unused") SerializeException e) {
            return null;
         }
      }

      if (!cm.isMapOrBean())
         return null;

      if (cm.isBean()) {
         var bm = toBeanMap(first);
         // Skip write-only properties: they are never serialized, so they get no column.
         return bm.keySet().stream().filter(k -> bm.getProperty(k).getMeta().canRead()).toArray(String[]::new);
      }

      // Non-bean map: collect keys from first entry
      if (first instanceof Map<?,?> map2) {
         return map2.keySet().stream().map(Object::toString).toArray(String[]::new);
      }

      return null;
   }

   /**
    * Gets or creates a {@link MarkdownWriter} from the given pipe.
    *
    * @param out The serializer pipe.
    *    <br>Must not be <jk>null</jk>.
    * @return The writer.
    */
   protected MarkdownWriter getMarkdownWriter(SerializerPipe out) {
      var output = out.getRawOutput();
      if (output instanceof MarkdownWriter output2)
         return output2;
      var w = new MarkdownWriter(out.getWriter(), isUseWhitespace(), getMaxIndent(), isTrimStrings(), getUriResolver());
      out.setWriter(w);
      return w;
   }
}