/*
 * 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.yaml;

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

import java.io.*;
import java.util.*;
import java.util.function.*;

import org.apache.juneau.commons.bean.*;
import org.apache.juneau.commons.lang.*;
import org.apache.juneau.marshall.*;
import org.apache.juneau.marshall.serializer.*;
import org.apache.juneau.marshall.stream.*;

/**
 * Session object that lives for the duration of a single use of {@link YamlSerializer}.
 *
 * <h5 class='section'>Notes:</h5><ul>
 *    <li class='warn'>This class is not thread safe and is typically discarded after one use.
 * </ul>
 *
 * <h5 class='section'>See Also:</h5><ul>
 *    <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/YamlSupport">YAML</a>
 * </ul>
 */
@SuppressWarnings({
   "java:S110", // Inheritance depth acceptable for this class hierarchy
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "java:S3776", // Cognitive complexity acceptable for YAML serializer session methods
   "rawtypes", // writeMap()/writeCollection() take raw Map/Collection and writeAnything() casts to raw BeanMap/Map/Collection after ClassMeta type checks
   "resource", // Resource management handled externally
   "unchecked" // Raw-to-generic casts in writeAnything()/writeMap()/writeCollection() are guarded by the ClassMeta isMap()/isCollection() checks
})
public class YamlSerializerSession extends WriterSerializerSession implements RecordWritable, ArrayRecordWritable {

   /**
    * Builder class.
    */
   public static class Builder extends WriterSerializerSession.Builder<Builder> {

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

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

   }

   /**
    * Creates a new builder for this object.
    *
    * @param ctx The context creating this session.
    *    <br>Cannot be <jk>null</jk>.
    * @return A new builder.
    */
   public static Builder create(YamlSerializer ctx) {
      return new Builder(reqnn("ctx", ctx));
   }

   /**
    * Constructor.
    *
    * @param builder The builder for this object.
    */
   protected YamlSerializerSession(Builder builder) {
      super(builder);
   }

   @Override /* Overridden from SerializerSession */
   protected void doWrite(SerializerPipe out, Object o) throws IOException, SerializeException {
      writeAnything(getYamlWriter(out), o, getExpectedRootType(o), "root", null, true);
   }

   /**
    * Opens a whole-value push generator targeting YAML output, bound to this live session.
    * {@link RecordWriter#write(Object) write(Object)} delegates to
    * {@link SerializerSession#write(Object, Object)}.
    *
    * @param output The output.
    * @return A new {@link RecordWriter}.
    * @throws IOException If a problem occurred opening the underlying output.
    */
   @Override /* RecordWritable */
   public RecordWriter writeRecords(Object output) throws IOException {
      return RecordAdapter.writer(this, output);
   }

   /**
    * Buffered array-element {@link RecordWriter} for YAML, bound to this live session.  Buffers
    * each {@code write(...)} and emits the whole list on {@code close()}.
    *
    * @param output The output.
    * @return A new {@link RecordWriter}.
    * @throws IOException If a problem occurred opening the underlying output.
    */
   @Override /* ArrayRecordWritable */
   public RecordWriter writeArrayRecords(Object output) throws IOException {
      return RecordAdapter.arrayWriter(this, output);
   }

   /**
    * The YAML record writer is buffered/{@link RecordAdapter}-backed, not O(1) streaming.
    *
    * @return Always <jk>false</jk>.
    */
   @Override /* RecordWritable */
   public boolean isRecordStreaming() { return false; }

   /**
    * The YAML array-record writer is buffered/{@link RecordAdapter}-backed, not O(1) streaming.
    *
    * @return Always <jk>false</jk>.
    */
   @Override /* ArrayRecordWritable */
   public boolean isArrayRecordStreaming() { return false; }

   /**
    * Converts the specified output target object to a {@link YamlWriter}.
    *
    * @param out The output target object.
    *    <br>Must not be <jk>null</jk>.
    * @return The output target object wrapped in a {@link YamlWriter}.
    */
   protected final YamlWriter getYamlWriter(SerializerPipe out) {
      var output = out.getRawOutput();
      if (output instanceof YamlWriter output2)
         return output2;
      var w = new YamlWriter(out.getWriter(), isUseWhitespace(), getMaxIndent(), isTrimStrings(), getUriResolver());
      out.setWriter(w);
      return w;
   }

   /**
    * Workhorse method.
    * Determines the type of object, and then calls the appropriate type-specific serialization method.
    *
    * @param out The output writer.
    * @param o The object to serialize.
    * @param eType The expected type.
    * @param attrName The attribute name.
    * @param pMeta The bean property currently being parsed.
    * @param asField If <jk>true</jk>, this value appears inline after a key or at root level.
    *    If <jk>false</jk>, this value needs its own indentation as a standalone block.
    * @return The same writer passed in.
    * @throws SerializeException General serialization error occurred.
    */
   protected YamlWriter writeAnything(YamlWriter out, Object o, ClassMeta<?> eType, String attrName, BeanPropertyMeta pMeta, boolean asField) throws SerializeException {

      if (o == null) {
         out.append("null");
         return out;
      }

      if (eType == null)
         eType = object();

      ClassMeta<?> aType;
      ClassMeta<?> sType;

      aType = push2(attrName, o, eType);
      boolean isRecursion = aType == null;

      if (aType == null) {
         o = null;
         aType = object();
      }

      if (isOptional(aType)) {
         o = getOptionalValue(o);
         eType = getOptionalType(eType);
         aType = getClassMetaForObject(o, object());
      }

      sType = aType;
      String typeName = getBeanTypeName(this, eType, aType, pMeta);

      var swap = aType.getSwap(this);
      if (nn(swap)) {
         o = swap(swap, o);
         sType = swap.getSwapClassMeta(this);

         if (sType.isObject())
            sType = getClassMetaForObject(o);
      }

      if (o == null || (sType.isChar() && ((Character)o).charValue() == 0)) {
         out.append("null");
      } else if (sType.isBean()) {
         writeBeanMap(out, toBeanMap(o), typeName);
      } else if (sType.isMap()) {
         if (sType.isBeanMap())
            writeBeanMap(out, (BeanMap)o, typeName);
         else
            writeMap(out, (Map)o, eType);
      } else if (sType.isCollection()) {
         writeCollection(out, (Collection)o, eType, asField);
      } else if (sType.isArray()) {
         writeCollection(out, toList(sType.inner(), o), eType, asField);
      } else if (sType.isNumber() || sType.isBoolean()) {
         out.append(o);
      } else if (sType.isUri() || (nn(pMeta) && pMeta.isUri())) {
         out.uriValue(o);
      } else if (sType.isReader()) {
         pipe((Reader)o, out, SerializerSession::handleThrown);
      } else if (sType.isInputStream()) {
         pipe((InputStream)o, out, SerializerSession::handleThrown);
      } else {
         out.textValue(toString(o));
      }

      if (! isRecursion)
         pop();
      return out;
   }

   /**
    * Determines whether a ClassMeta represents a complex type that requires block-style YAML formatting.
    */
   private boolean isComplexValue(ClassMeta<?> cm) {
      if (cm == null)
         return false;
      if (cm.isMapOrBean() || cm.isCollectionOrArrayOrOptional())
         return true;
      var swap = cm.getSwap(this);
      if (swap != null) {
         var swapType = swap.getSwapClassMeta(this);
         return swapType.isMapOrBean() || swapType.isCollectionOrArrayOrOptional();
      }
      return false;
   }

   private SerializerWriter<?> writeBeanMap(YamlWriter out, BeanMap<?> m, String typeName) throws SerializeException {
      int i = indent - 1;

      var addAtt = Flag.create();
      Predicate<Object> checkNull = x -> isKeepNullProperties() || nn(x);

      if (nn(typeName)) {
         BeanPropertyMeta pm = m.getMeta().getTypeProperty();
         out.key(pm.getName()).textValue(typeName);
         addAtt.set();
      }

      m.forEachValue(checkNull, (pMeta, key, value, thrown) -> {
         var cMeta = (ClassMeta<?>) pMeta.getBeanInfo();
         if (nn(thrown))
            onBeanGetterException(pMeta, thrown);

         if (canIgnoreValue(pMeta, key, value))
            return;

         addAtt.ifSet(() -> out.yamlIndent(i)).set();

         ClassMeta<?> actualType = value == null ? cMeta : getClassMetaForObject(value, cMeta);
         if (value != null && isComplexValue(actualType)) {
            out.keyName(key).w(": ");
            if (actualType.isCollectionOrArrayOrOptional()) {
               writeAnything(out, value, cMeta, key, pMeta, false);
            } else {
               out.yamlIndent(i + 1);
               writeAnything(out, value, cMeta, key, pMeta, true);
            }
         } else {
            out.key(key);
            writeAnything(out, value, cMeta, key, pMeta, true);
         }
      });

      if (addAtt.isUnset())
         out.w("{}");

      return out;
   }

   private SerializerWriter<?> writeMap(YamlWriter out, Map m, ClassMeta<?> type) throws SerializeException {
      int i = indent - 1;

      var keyType = type.getKeyType();
      var valueType = type.getValueType();

      if (m.isEmpty()) {
         out.w("{}");
         return out;
      }

      var addAtt = Flag.create();
      forEachEntry(m, x -> {
         addAtt.ifSet(() -> out.yamlIndent(i)).set();
         Object value = x.getValue();
         Object key = generalize(x.getKey(), keyType);

         ClassMeta<?> actualType = value == null ? valueType : getClassMetaForObject(value, valueType);
         if (value != null && isComplexValue(actualType)) {
            out.keyName(toString(key)).w(": ");
            if (actualType.isCollectionOrArrayOrOptional()) {
               writeAnything(out, value, valueType, (key == null ? null : toString(key)), null, false);
            } else {
               out.yamlIndent(i + 1);
               writeAnything(out, value, valueType, (key == null ? null : toString(key)), null, true);
            }
         } else {
            out.key(toString(key));
            writeAnything(out, value, valueType, (key == null ? null : toString(key)), null, true);
         }
      });

      return out;
   }

   private SerializerWriter<?> writeCollection(YamlWriter out, Collection c, ClassMeta<?> type, boolean asField) throws SerializeException {
      int i = indent - 1;

      if (c.isEmpty()) {
         out.w("[]");
         return out;
      }

      var elementType = type.getElementType();

      var addEntry = Flag.create();
      forEachEntry(c, x -> {
         if (asField && addEntry.isUnset()) {
            out.w("- ");
         } else {
            out.listEntry(i);
         }
         addEntry.set();
         writeAnything(out, x, elementType, "<iterator>", null, true);
      });

      return out;
   }

}