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

import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.IoUtils.*;
import static org.apache.juneau.commons.utils.ObjectUtils.*;
import static org.apache.juneau.commons.utils.Shorts.*;
import static org.apache.juneau.marshall.xml.XmlFormat.*;
import static org.apache.juneau.marshall.xml.XmlSerializerSession.ContentResult.*;
import static org.apache.juneau.marshall.xml.XmlSerializerSession.JsonType.*;

import java.io.*;
import java.lang.reflect.*;
import java.time.*;
import java.time.temporal.*;
import java.util.*;
import java.util.AbstractMap.*;
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 XmlSerializer}.
 *
 * <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/XmlSupport">XML</a>

 * </ul>
 */
@SuppressWarnings({
   "java:S110", // Deep inheritance inherent to the serializer/parser session hierarchy
   "java:S1192", // Duplicated literals (argument/property names) read more clearly inline than as constants
   "java:S1452", // create() and getXmlWriter() return wildcard Builder<?>/XmlWriter<?> because the concrete self-type is not known statically
   "java:S3776", // Cognitive complexity acceptable for this specific logic
   "java:S6541", // Single-threaded session contexts do not require synchronization
   "null", // Null handling verified by context or framework
   "rawtypes", // Raw Map/Collection necessary for serializer dispatch over heterogeneous types
   "resource", // Writer/Closeable resources managed by try-with-resources; analyzer FP in lambdas
   "unchecked" // Type erasure requires unchecked casts in serializer dispatch
})
public class XmlSerializerSession extends WriterSerializerSession implements RecordWritable {

   /**
    * 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> {

      private boolean addNamespaceUrisToRoot;
      private boolean autoDetectNamespaces;
      private String defaultNamespace;
      private boolean enableNamespaces;
      private String textNodeDelimiter;
      private final XmlSerializer ctx;

      /**
       * Constructor
       *
       * @param ctx The context creating this session.
       *    <br>Cannot be <jk>null</jk>.
       */
      protected Builder(XmlSerializer ctx) {
         super(reqnn("ctx", ctx));
         this.ctx = ctx;
         addNamespaceUrisToRoot = ctx.isAddNamespaceUrlsToRoot();
         autoDetectNamespaces = ctx.isAutoDetectNamespaces();
         defaultNamespace = ctx.getDefaultNamespace() == null ? null : ctx.getDefaultNamespace().toString();
         enableNamespaces = ctx.isEnableNamespaces();
         textNodeDelimiter = ctx.getTextNodeDelimiter();
      }

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

      /**
       * Add namespace URLs to the root element.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public SELF addNamespaceUrisToRoot(boolean value) {
         addNamespaceUrisToRoot = value;
         return self();
      }

      /**
       * Auto-detect namespace usage.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public SELF autoDetectNamespaces(boolean value) {
         autoDetectNamespaces = value;
         return self();
      }

      /**
       * Default namespace.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public SELF defaultNamespace(String value) {
         defaultNamespace = value;
         return self();
      }

      /**
       * Enable support for XML namespaces.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public SELF enableNamespaces(boolean value) {
         enableNamespaces = value;
         return self();
      }

      /**
       * Text node delimiter.
       *
       * @param value The new value for this setting.
       * @return This object.
       */
      public SELF textNodeDelimiter(String value) {
         textNodeDelimiter = value == null ? "" : value;
         return self();
      }

      @Override /* Overridden from Builder */
      public SELF property(String key, Object value) {
         if (key == null) { super.property(key, value); return self(); }
         switch (key) {
            case "addNamespaceUrisToRoot", "XmlSerializerSession.addNamespaceUrisToRoot":
               return addNamespaceUrisToRoot(cvt(value, Boolean.class));
            case "autoDetectNamespaces", "XmlSerializerSession.autoDetectNamespaces":
               return autoDetectNamespaces(cvt(value, Boolean.class));
            case "defaultNamespace", "XmlSerializerSession.defaultNamespace":
               return defaultNamespace(cvt(value, String.class));
            case "enableNamespaces", "XmlSerializerSession.enableNamespaces":
               return enableNamespaces(cvt(value, Boolean.class));
            case "textNodeDelimiter", "XmlSerializerSession.textNodeDelimiter":
               return textNodeDelimiter(cvt(value, String.class));
            default:
               super.property(key, value);
               return self();
         }
      }

   }

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

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

   /**
    * Identifies what the contents were of a serialized bean.
    */
   public enum ContentResult {
      CR_VOID,      // No content...append "/>" to the start tag.
      CR_EMPTY,     // No content...append "/>" to the start tag if XML, "/></end>" if HTML.
      CR_MIXED,     // Mixed content...don't add whitespace.
      CR_ELEMENTS   // Elements...use normal whitespace rules.
   }

   enum JsonType {
      STRING("string"), BOOLEAN("boolean"), NUMBER("number"), ARRAY("array"), OBJECT("object"), NULL("null");

      private final String value;

      JsonType(String value) {
         this.value = value;
      }

      @Override
      public String toString() {
         return value;
      }

      @SuppressWarnings({
         "java:S1871" // return true is the only correct action here; coincidental match with isXmlText is not a logic error
      })
      boolean isOneOf(JsonType...types) {
         for (var type : types)
            if (type == this)
               return true;
         return false;
      }
   }

   /**
    * 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(XmlSerializer ctx) {
      return new DefaultBuilder(reqnn("ctx", ctx));
   }

   private final String textNodeDelimiter;
   private final boolean addNamespaceUrisToRoot;
   private final boolean autoDetectNamespaces;
   private final boolean enableNamespaces;
   private final XmlSerializer ctx;
   private Namespace defaultNamespace;
   private List<Namespace> namespaces = l();

   /**
    * Constructor.
    *
    * @param builder The builder for this object.
    */
   protected XmlSerializerSession(Builder<?> builder) {
      super(builder);
      ctx = builder.ctx;
      addNamespaceUrisToRoot = builder.addNamespaceUrisToRoot;
      autoDetectNamespaces = builder.autoDetectNamespaces;
      enableNamespaces = builder.enableNamespaces;
      textNodeDelimiter = builder.textNodeDelimiter;
      // namespaces must be populated BEFORE findDefaultNamespace() runs below -- it resolves a name-only
      // or URI-only default namespace by searching getNamespaces(), which otherwise still sees the
      // field initializer's empty list here, so both search loops always iterate zero times and the
      // namespace is returned unresolved (missing whichever of name/uri wasn't supplied).
      namespaces = new ArrayList<>(ctx.getNamespaces());
      defaultNamespace = findDefaultNamespace(
         builder.defaultNamespace != null ? Namespace.create(builder.defaultNamespace) : ctx.getDefaultNamespace()
      );
   }

   /**
    * Returns the language-specific metadata on the specified bean.
    *
    * @param bm The bean to return the metadata on.
    * @return The metadata.
    */
   public XmlBeanMeta getXmlBeanMeta(BeanMeta<?> bm) {
      return ctx.getXmlBeanMeta(bm);
   }

   /**
    * Returns the language-specific metadata on the specified bean property.
    *
    * @param bpm The bean property to return the metadata on.
    * @return The metadata.
    */
   public XmlBeanPropertyMeta getXmlBeanPropertyMeta(BeanPropertyMeta bpm) {
      return bpm == null ? XmlBeanPropertyMeta.DEFAULT : ctx.getXmlBeanPropertyMeta(bpm);
   }

   /**
    * Returns the language-specific metadata on the specified class.
    *
    * @param cm The class to return the metadata on.
    * @return The metadata.
    */
   public XmlClassMeta getXmlClassMeta(ClassMeta<?> cm) {
      return ctx.getXmlClassMeta(cm);
   }

   /**
    * Converts the specified output target object to an {@link XmlWriter}.
    *
    * @param out The output target object.
    *    <br>Must not be <jk>null</jk>.
    * @return The output target object wrapped in an {@link XmlWriter}.
    */
   public final XmlWriter<?> getXmlWriter(SerializerPipe out) {
      var output = out.getRawOutput();
      if (output instanceof XmlWriter<?> output2)
         return output2;
      var w = new BasicXmlWriter(out.getWriter(), isUseWhitespace(), getMaxIndent(), isTrimStrings(), getQuoteChar(), getUriResolver(), isEnableNamespaces(), defaultNamespace);
      out.setWriter(w);
      return w;
   }

   /**
    * Add a namespace to this session.
    *
    * @param ns The namespace being added.
    */
   private void addNamespace(Namespace ns) {
      if (ns == defaultNamespace)
         return;

      for (var n : namespaces)
         if (n == ns)
            return;

      if (nn(defaultNamespace) && (ns.uri.equals(defaultNamespace.uri) || ns.name.equals(defaultNamespace.name)))
         defaultNamespace = ns;
      else
         namespaces = addAll(namespaces, ns);
   }

   private Namespace findDefaultNamespace(Namespace n) {
      if (n == null)
         return null;
      if (nn(n.name) && nn(n.uri))
         return n;
      if (n.uri == null) {
         for (var n2 : getNamespaces())
            if (n2.name.equals(n.name))
               return n2;
      }
      if (n.name == null) {
         for (var n2 : getNamespaces())
            if (n2.uri.equals(n.uri))
               return n2;
      }
      return n;
   }

   /**
    * Checks if an object is a text node (String or primitive type).
    */
   private static boolean isTextNode(Object o) {
      if (o == null)
         return false;
      var c = o.getClass();
      // Text nodes are strings and primitives (not beans, collections, arrays, or other complex types)
      return CharSequence.class.isAssignableFrom(c) || Number.class.isAssignableFrom(c) || Boolean.class.isAssignableFrom(c) || c.isPrimitive();
   }

   private boolean isXmlText(XmlFormat format, ClassMeta<?> sType) {
      if (format == XMLTEXT)
         return true;
      var xcm = getXmlClassMeta(sType);
      if (xcm == null)
         return false;
      return xcm.getFormat() == XMLTEXT;
   }

   private boolean isRawText(XmlFormat format, ClassMeta<?> sType) {
      if (format == RAWTEXT)
         return true;
      var xcm = getXmlClassMeta(sType);
      if (xcm == null)
         return false;
      return xcm.getFormat() == RAWTEXT;
   }

   private Optional<Map.Entry<String,Object>> getPropertyKeyValueIfNotIgnored(BeanPropertyValue p, BeanPropertyMeta pMeta) {
      var key = p.getName();
      var value = p.getValue();
      if (nn(p.getThrown()))
         onBeanGetterException(pMeta, p.getThrown());
      if (canIgnoreValue(pMeta, key, value))
         return oe();
      return o(new SimpleEntry<>(key, value));
   }

   private ContentResult writeBeanMap(XmlWriter<?> out, BeanMap<?> m, Namespace elementNs, boolean isCollapsed, boolean isMixedOrText) throws SerializeException {
      boolean hasChildren = false;
      var bm = m.getMeta();

      var lp = new ArrayList<BeanPropertyValue>();

      var checkNull = (Predicate<Object>)(x -> isKeepNullProperties() || nn(x));
      m.forEachValue(checkNull, (pMeta, key, value, thrown) -> lp.add(new BeanPropertyValue(pMeta, key, value, thrown)));

      var xbm = getXmlBeanMeta(bm);

      // @formatter:off
      Set<String> attrs = xbm.getAttrPropertyNames();
      Set<String> elements = xbm.getElementPropertyNames();
      Set<String> collapsedElements = xbm.getCollapsedPropertyNames();
      var attrsProperty = xbm.getAttrsPropertyName();
      var contentProperty = xbm.getContentPropertyName();
      // @formatter:on

      XmlFormat cf = null;

      Object content = null;
      ClassMeta<?> contentType = null;
      for (var p : lp) {
         var n = p.getName();
         if (attrs.contains(n) || attrs.contains("*") || n.equals(attrsProperty)) {
            var pMeta = p.getMeta();
            if (pMeta.canRead()) {
               var kv = getPropertyKeyValueIfNotIgnored(p, pMeta);
               if (kv.isEmpty())
                  continue;
               var key = kv.get().getKey();
               var value = kv.get().getValue();
               var bpXml = getXmlBeanPropertyMeta(pMeta);
               var ns = (isEnableNamespaces() && bpXml.getNamespace() != elementNs ? bpXml.getNamespace() : null);

               if (pMeta.isUri()) {
                  out.attrUri(ns, key, value);
               } else if (n.equals(attrsProperty)) {
                  if (value instanceof BeanMap<?> value2) {
                     value2.forEachValue(x -> true, (pMeta2, key2, value3, thrown2) -> {
                        if (nn(thrown2))
                           onBeanGetterException(pMeta, thrown2);
                        out.attr(ns, key2, value3);
                     });
                  } else /* Map */ {
                     var m2 = (Map)value;
                     if (nn(m2))
                        m2.forEach((k, v) -> out.attr(ns, s(k), v));
                  }
               } else {
                  out.attr(ns, key, value);
               }
            }
         }
      }

      boolean hasContent = false;
      boolean preserveWhitespace = false;
      boolean isVoidElement = xbm.getContentFormat() == VOID;

      for (var p : lp) {
         BeanPropertyMeta pMeta = p.getMeta();
         if (pMeta.canRead()) {
            ClassMeta<?> cMeta = (ClassMeta<?>) p.getBeanInfo();

            var n = p.getName();
            if (n.equals(contentProperty)) {
               content = p.getValue();
               contentType = (ClassMeta<?>) p.getBeanInfo();
               hasContent = true;
               cf = xbm.getContentFormat();
               if (cf.isOneOf(MIXED, MIXED_PWS, TEXT, TEXT_PWS, XMLTEXT, RAWTEXT))
                  isMixedOrText = true;
               if (cf.isOneOf(MIXED_PWS, TEXT_PWS))
                  preserveWhitespace = true;
               if ((contentType.isCollection() && ((Collection)content).isEmpty()) || (contentType.isArray() && Array.getLength(content) == 0))
                  hasContent = false;
            } else if (elements.contains(n) || collapsedElements.contains(n) || elements.contains("*") || collapsedElements.contains("*")) {
               var kv = getPropertyKeyValueIfNotIgnored(p, pMeta);
               if (kv.isEmpty())
                  continue;
               var key = kv.get().getKey();
               var value = kv.get().getValue();
               if (! hasChildren) {
                  hasChildren = true;
                  out.appendIf(! isCollapsed, '>').nlIf(! isMixedOrText, indent);
               }

               var bpXml = getXmlBeanPropertyMeta(pMeta);
               writeAnything(out, value, cMeta, key, null, bpXml.getNamespace(), false, bpXml.getXmlFormat(), isMixedOrText, false, pMeta);
            }
         }
      }
      if (contentProperty == null && ! hasContent) {
         if (hasChildren) {
            return CR_ELEMENTS;
         } else if (isVoidElement) {
            return CR_VOID;
         } else {
            return CR_EMPTY;
         }
      }

      // Serialize XML content.
      if (nn(content)) {
         out.w('>').nlIf(! isMixedOrText, indent);
         if (contentType == null) {
            // No content type specified - skip content serialization
         } else if (contentType.isCollection()) {
            var c = (Collection)content;
            boolean previousWasTextNode = false;
            for (var value : c) {
               boolean currentIsTextNode = isTextNode(value);
               // Insert delimiter between consecutive text nodes
               if (previousWasTextNode && currentIsTextNode && nn(textNodeDelimiter) && ! textNodeDelimiter.isEmpty()) {
                  out.append(textNodeDelimiter);
               }
               writeAnything(out, value, contentType.getElementType(), null, null, null, false, cf, isMixedOrText, preserveWhitespace, null);
               previousWasTextNode = currentIsTextNode;
            }
         } else if (contentType.isArray()) {
            var c = toList(Object[].class, content);
            boolean previousWasTextNode = false;
            for (var value : c) {
               boolean currentIsTextNode = isTextNode(value);
               // Insert delimiter between consecutive text nodes
               if (previousWasTextNode && currentIsTextNode && nn(textNodeDelimiter) && ! textNodeDelimiter.isEmpty()) {
                  out.append(textNodeDelimiter);
               }
               writeAnything(out, value, contentType.getElementType(), null, null, null, false, cf, isMixedOrText, preserveWhitespace, null);
               previousWasTextNode = currentIsTextNode;
            }
         } else {
            writeAnything(out, content, contentType, null, null, null, false, cf, isMixedOrText, preserveWhitespace, null);
         }
      } else {
         // A null FREEFORM content property represents an empty container element (e.g. an empty HTML <table> or
         // <thead>), which must render as an empty element rather than an explicit null.  Emitting nil='true' here
         // is surprising for such containers.  Other content formats (TEXT/TEXT_PWS/XMLTEXT for null-vs-empty-string
         // round-tripping, and MIXED/MIXED_PWS) retain the nil marker to preserve existing behavior.
         if (isAddJsonTags() && xbm.getContentFormat() != FREEFORM)
            out.attr("nil", "true");
         out.w('>').nlIf(! isMixedOrText, indent);
      }
      return isMixedOrText ? CR_MIXED : CR_ELEMENTS;
   }

   private XmlWriter<?> writeCollection(XmlWriter<?> out, Object in, ClassMeta<?> sType, ClassMeta<?> eType, BeanPropertyMeta ppMeta, boolean isMixed) throws SerializeException {

      var eeType = eType.getElementType();

      var c = (sType.isCollection() ? (Collection)in : toList(sType.inner(), in));

      String type2 = null;

      var eName = Holder.of(type2);
      var eNs = Holder.<Namespace>empty();

      if (nn(ppMeta)) {
         XmlBeanPropertyMeta bpXml = getXmlBeanPropertyMeta(ppMeta);
         eName.set(bpXml.getChildName());
         eNs.set(bpXml.getNamespace());
      }

      // Track if previous element was a text node for delimiter insertion
      var previousWasTextNode = Holder.of(false);

      forEachEntry(c, x -> {
         var currentIsTextNode = isTextNode(x);

         // Insert delimiter between consecutive text nodes
         if (isTrue(previousWasTextNode.get()) && currentIsTextNode && nn(textNodeDelimiter) && ! textNodeDelimiter.isEmpty()) {
            out.append(textNodeDelimiter);
         }

         writeAnything(out, x, eeType, null, eName.get(), eNs.get(), false, XmlFormat.DEFAULT, isMixed, false, null);
         previousWasTextNode.set(currentIsTextNode);
      });

      return out;
   }

   private XmlWriter<?> writeStreamable(XmlWriter<?> out, Object in, ClassMeta<?> sType, ClassMeta<?> eType, BeanPropertyMeta ppMeta, boolean isMixed) throws SerializeException {

      var eeType = eType.getElementType();

      var eName = Holder.<String>empty();
      var eNs = Holder.<Namespace>empty();

      if (nn(ppMeta)) {
         XmlBeanPropertyMeta bpXml = getXmlBeanPropertyMeta(ppMeta);
         eName.set(bpXml.getChildName());
         eNs.set(bpXml.getNamespace());
      }

      var previousWasTextNode = Holder.of(false);

      forEachStreamableEntry(in, sType, x -> {
         var currentIsTextNode = isTextNode(x);

         if (isTrue(previousWasTextNode.get()) && currentIsTextNode && nn(textNodeDelimiter) && ! textNodeDelimiter.isEmpty()) {
            out.append(textNodeDelimiter);
         }

         writeAnything(out, x, eeType, null, eName.get(), eNs.get(), false, XmlFormat.DEFAULT, isMixed, false, null);
         previousWasTextNode.set(currentIsTextNode);
      });

      return out;
   }

   private ContentResult writeMap(XmlWriter<?> out, Map m, ClassMeta<?> sType, ClassMeta<?> eKeyType, ClassMeta<?> eValueType, boolean isMixed) throws SerializeException {

      var keyType = eKeyType == null ? sType.getKeyType() : eKeyType;
      var valueType = eValueType == null ? sType.getValueType() : eValueType;

      var hasChildren = Flag.create();
      forEachEntry(m, e -> {

         var k = e.getKey();
         if (k == null) {
            k = "\u0000";
         } else {
            k = generalize(k, keyType);
            if (isTrimStrings() && k instanceof String)
               k = k.toString().trim();
         }

         var value = e.getValue();

         hasChildren.ifNotSet(() -> out.w('>').nlIf(! isMixed, indent)).set();
         writeAnything(out, value, valueType, toString(k), null, null, false, XmlFormat.DEFAULT, isMixed, false, null);
      });

      return hasChildren.isSet() ? CR_ELEMENTS : CR_EMPTY;
   }

   @Override /* Overridden from Serializer */
   protected void doWrite(SerializerPipe out, Object o) throws IOException, SerializeException {
      if (isEnableNamespaces() && isAutoDetectNamespaces())
         findNsfMappings(o);
      writeAnything(getXmlWriter(out), o, getExpectedRootType(o), null, null, null, isEnableNamespaces() && isAddNamespaceUrisToRoot(), XmlFormat.DEFAULT, false, false, null);
   }

   /**
    * Opens a whole-value push generator targeting XML output, bound to this live session.
    *
    * <p>
    * Because XML's wire format (attributes, namespaces, mixed content) is non-trivial to expose
    * as a fine-grained token writer, this implementation supports only the cursor-level POJO
    * bridge &mdash; {@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);
   }

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

   /**
    * Recursively searches for the XML namespaces on the specified POJO and adds them to the serializer context object.
    *
    * @param o The POJO to check.
    * @throws SerializeException Thrown if bean recursion occurred.
    */
   protected final void findNsfMappings(Object o) throws SerializeException {
      ClassMeta<?> aType = null;                // The actual type

      try {
         aType = push(null, o, null);
      } catch (MarshallingRecursionException e) {
         throw new SerializeException(e);
      }

      if (nn(aType)) {
         var ns = getXmlClassMeta(aType).getNamespace();
         if (nn(ns) && nn(ns.uri))
            addNamespace(ns);
      }

      // Handle recursion
      if (nn(aType) && ! aType.isPrimitive()) {

         BeanMap<?> bm = null;
         if (aType.isBeanMap()) {
            bm = (BeanMap<?>)o;
         } else if (aType.isBean()) {
            bm = toBeanMap(o);
         } else if (aType.isDelegate()) {
            var innerType = (ClassMeta<?>)((Delegate<?>)o).getBeanInfo();
            var ns = Holder.of(getXmlClassMeta(innerType).getNamespace());
            if (ns.isPresent()) {
               if (nn(ns.get().uri))
                  addNamespace(ns.get());
               else
                  ns.getAndUnset();
            }

            if (innerType.isBean()) {
               innerType.getBeanMeta().getProperties().values().stream().filter(BeanPropertyMeta::canRead).forEach(x -> {
                  ns.set(getXmlBeanPropertyMeta(x).getNamespace());
                  if (ns.isPresent() && nn(ns.get().uri))
                     addNamespace(ns.get());
               });
            } else if (innerType.isMap()) {
               ((Map<?,?>)o).forEach((k, v) -> findNsfMappings(v));
            } else if (innerType.isCollection()) {
               ((Collection<?>)o).forEach(this::findNsfMappings);
            }

         } else if (aType.isMap()) {
            ((Map<?,?>)o).forEach((k, v) -> findNsfMappings(v));
         } else if (aType.isCollection()) {
            ((Collection<?>)o).forEach(this::findNsfMappings);
         } else if (aType.isArray() && ! aType.getElementType().isPrimitive()) {
            for (var o2 : ((Object[])o))
               findNsfMappings(o2);
         }
         if (nn(bm)) {
            var checkNull = (Predicate<Object>)(x -> isKeepNullProperties() || nn(x));
            bm.forEachValue(checkNull, (pMeta, key, value, thrown) -> {
               var ns = getXmlBeanPropertyMeta(pMeta).getNamespace();
               if (nn(ns) && nn(ns.uri))
                  addNamespace(ns);

               try {
                  findNsfMappings(value);
               } catch (@SuppressWarnings("unused") Exception x) {
                  // Ignore
               }
            });
         }
      }

      pop();
   }

   /**
    * Default namespace.
    *
    * @see XmlSerializer.Builder#defaultNamespace(Namespace)
    * @return
    *    The default namespace URI for this document.
    */
   protected final Namespace getDefaultNamespace() { return defaultNamespace; }

   /**
    * Default namespaces.
    *
    * @see XmlSerializer.Builder#namespaces(Namespace...)
    * @return
    *    The default list of namespaces associated with this serializer.
    *    <br>Never <jk>null</jk>.
    *    <br>List is modifiable (namespaces can be added during serialization).
    */
   protected final List<Namespace> getNamespaces() { return namespaces == null ? l() : namespaces; }

   @Override
   public boolean isAddBeanTypes() { return super.isAddBeanTypes(); }

   /**
    * Add JSON type tags.
    *
    * @see XmlSerializer.Builder#disableJsonTags()
    * @return
    *    <jk>true</jk> if plain strings will be wrapped in <js>&lt;string&gt;</js> tags when serialized as root elements.
    */
   protected final boolean isAddJsonTags() { return ctx.addJsonTags; }

   /**
    * Add namespace URLs to the root element.
    *
    * @see XmlSerializer.Builder#addNamespaceUrisToRoot()
    * @return
    *    <jk>true</jk> if {@code xmlns:x} attributes are added to the root element for the default and all mapped namespaces.
    */
   protected final boolean isAddNamespaceUrisToRoot() { return addNamespaceUrisToRoot; }

   /**
    * Auto-detect namespace usage.
    *
    * @see XmlSerializer.Builder#disableAutoDetectNamespaces()
    * @return
    *    <jk>true</jk> if namespace usage is detected before serialization.
    */
   protected final boolean isAutoDetectNamespaces() { return autoDetectNamespaces; }

   /**
    * Enable support for XML namespaces.
    *
    * @see XmlSerializer.Builder#enableNamespaces()
    * @return
    *    <jk>false</jk> if XML output will not contain any namespaces regardless of any other settings.
    */
   protected final boolean isEnableNamespaces() { return enableNamespaces; }

   /**
    * Returns <jk>true</jk> if we're serializing HTML.
    *
    * <p>
    * The difference in behavior is how empty non-void elements are handled.
    * The XML serializer will produce a collapsed tag, whereas the HTML serializer will produce a start and end tag.
    *
    * @return <jk>true</jk> if we're generating HTML.
    */
   protected boolean isHtmlMode() { return false; }

   /**
    * Workhorse method.
    *
    * @param out The writer to send the output to.
    *    <br>Must not be <jk>null</jk>.
    * @param o The object to serialize.
    *    <br>Can be <jk>null</jk> (written as the XML null representation, e.g. <c>type='null'</c>).
    * @param eType The expected type if this is a bean property value being serialized.
    *    <br>Can be <jk>null</jk> (treated as the generic {@link Object} type).
    * @param keyName The property name or map key name.
    *    <br>Can be <jk>null</jk> (the element is written without a separate property/key name).
    * @param elementName The root element name.
    *    <br>Can be <jk>null</jk> (falls back to the bean dictionary name, then <c>keyName</c>, then the JSON type name).
    * @param elementNamespace The namespace of the element.
    *    <br>Can be <jk>null</jk> (resolved from the serialized type's, then the actual type's, then the session's default namespace).
    * @param addNamespaceUris Flag indicating that namespace URIs need to be added.
    * @param format The format to serialize the output to.
    *    <br>Must not be <jk>null</jk>.
    * @param isMixedOrText We're serializing mixed content, so don't use whitespace.
    * @param preserveWhitespace
    *    <jk>true</jk> if we're serializing {@link XmlFormat#MIXED_PWS} or {@link XmlFormat#TEXT_PWS}.
    * @param pMeta The bean property metadata if this is a bean property being serialized.
    *    <br>Can be <jk>null</jk> (no bean-property-level URI/child-name/namespace metadata is applied).
    * @return The same writer passed in so that calls to the writer can be chained.
    * @throws SerializeException General serialization error occurred.
    */
   @SuppressWarnings({
      "java:S107" // Method has many parameters; acceptable for builder/configuration methods
   })
   protected ContentResult writeAnything(XmlWriter<?> out, Object o, ClassMeta<?> eType, String keyName, String elementName, Namespace elementNamespace, boolean addNamespaceUris, XmlFormat format,
      boolean isMixedOrText, boolean preserveWhitespace, BeanPropertyMeta pMeta) throws SerializeException {

      JsonType type = null;              // The type string (e.g. <type> or <x x='type'>
      int i = isMixedOrText ? 0 : indent;       // Current indentation
      ClassMeta<?> aType = null;     // The actual type
      ClassMeta<?> wType = null;     // The wrapped type (delegate)
      ClassMeta<?> sType; // The serialized type

      aType = push2(keyName, o, eType);

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

      // Handle recursion
      if (aType == null) {
         o = null;
         aType = object();
      }

      // Handle Optional<X>
      if (isOptional(aType)) {
         o = getOptionalValue(o);
         eType = getOptionalType(eType);
         aType = getClassMetaForObject(o, object());
      }

      if (nn(o)) {

         if (aType.isDelegate()) {
            wType = aType;
            eType = aType = (ClassMeta<?>)((Delegate<?>)o).getBeanInfo();
         }

         sType = aType;

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

            // If the getSwapClass() method returns Object, we need to figure out
            // the actual type now.
            if (sType.isObject())
               sType = getClassMetaForObject(o);
         }
      } else {
         sType = eType.getSerializedClassMeta(this);
      }

      // Does the actual type match the expected type?
      boolean isExpectedType = true;
      if (o == null || ! eType.same(aType)) {
         if (eType.isNumber())
            isExpectedType = aType.isNumber();
         else if (eType.isMap())
            isExpectedType = aType.isMap();
         else if (eType.isCollectionOrArray() || eType.isStreamable())
            isExpectedType = aType.isCollectionOrArray() || aType.isStreamable();
         else
            isExpectedType = false;
      }

      var resolvedDictionaryName = isExpectedType ? null : aType.getBeanDictionaryName();

      // Note that the dictionary name may be specified on the actual type or the serialized type.
      // HTML templates will have them defined on the serialized type.
      var dictionaryName = aType.getBeanDictionaryName();
      if (dictionaryName == null)
         dictionaryName = sType.getBeanDictionaryName();

      // char '\0' is interpreted as null.
      if (nn(o) && sType.isChar() && ((Character)o).charValue() == 0)
         o = null;

      boolean isCollapsed = false;     // If 'true', this is a collection and we're not rendering the outer element.
      boolean isRaw = (sType.isReader() || sType.isInputStream() || o instanceof RawContent) && nn(o);

      // Get the JSON type string.
      if (o == null) {
         type = NULL;
      } else if (sType.isCharSequence() || sType.isChar()) {
         type = STRING;
      } else if (sType.isNumber()) {
         type = NUMBER;
      } else if (sType.isBoolean()) {
         type = BOOLEAN;
      } else if (sType.isMapOrBean()) {
         isCollapsed = getXmlClassMeta(sType).getFormat() == COLLAPSED;
         type = OBJECT;
      } else if (sType.isCollectionOrArray() || sType.isStreamable()) {
         isCollapsed = (format == COLLAPSED && ! addNamespaceUris);
         type = ARRAY;
      } else {
         type = STRING;
      }

      if (format.isOneOf(MIXED, MIXED_PWS, TEXT, TEXT_PWS, XMLTEXT, RAWTEXT) && type.isOneOf(NULL, STRING, NUMBER, BOOLEAN))
         isCollapsed = true;

      // Is there a name associated with this bean?

      var name = keyName;
      if (elementName == null && nn(dictionaryName)) {
         elementName = dictionaryName;
         isExpectedType = nn(o);  // preserve type='null' when it's null.
      }

      if (elementName == null) {
         elementName = name;
         name = null;
      }

      if (eq(name, elementName))
         name = null;

      if (isEnableNamespaces()) {
         if (elementNamespace == null)
            elementNamespace = getXmlClassMeta(sType).getNamespace();
         if (elementNamespace == null)
            elementNamespace = getXmlClassMeta(aType).getNamespace();
         if (elementNamespace == null)
            elementNamespace = defaultNamespace;
      } else {
         elementNamespace = null;
      }

      // Do we need a carriage return after the start tag?
      boolean cr = nn(o) && (sType.isMapOrBean() || sType.isCollectionOrArray()) && ! isMixedOrText;

      var en = elementName;
      if (en == null && ! isRaw && isAddJsonTags()) {
         en = type.toString();
         type = null;
      }

      boolean encodeEn = nn(elementName);
      var ns = (elementNamespace == null ? null : elementNamespace.name);
      String dns = null;
      String elementNs = null;
      if (isEnableNamespaces()) {
         dns = elementName == null && nn(defaultNamespace) ? defaultNamespace.name : null;
         elementNs = elementName == null ? dns : ns;
         if (elementName == null)
            elementNamespace = null;
      }

      // Render the start tag.
      if (! isCollapsed) {
         if (nn(en)) {
            out.oTag(i, elementNs, en, encodeEn);
            if (addNamespaceUris) {
               out.attr((String)null, "xmlns", defaultNamespace.getUri());

               for (var n : namespaces)
                  out.attr("xmlns", n.getName(), n.getUri());
            }
            if (! isExpectedType) {
               if (nn(resolvedDictionaryName))
                  out.attr(dns, getBeanTypePropertyName(eType), resolvedDictionaryName);
               else if (nn(type) && type != STRING)
                  out.attr(dns, getBeanTypePropertyName(eType), type);
            }
            if (nn(name))
               out.attr(MarshallingSession.NAME_PROPERTY_NAME, name);
         } else {
            out.i(i);
         }
         if (o == null && (sType.isBoolean() || sType.isNumber()) && ! sType.isNullable())
            o = sType.getPrimitiveDefault();

         if (nn(o) && ! (sType.isMapOrBean() || en == null))
            out.w('>');

         if (cr && ! (sType.isMapOrBean()))
            out.nl(i + 1);
      }

      var rc = CR_ELEMENTS;

      // Render the tag contents.
      if (nn(o)) {
         if (o instanceof RawContent) {
            // Re-serializable, String-backed raw content: emit verbatim (no entity/whitespace encoding), like the Reader path.
            out.append(o.toString());
         } else if (sType.isBean()) {
            rc = writeBeanMap(out, toBeanMap(o), elementNamespace, isCollapsed, isMixedOrText);
         } else if (sType.isMap() || (nn(wType) && wType.isMap())) {
            if (o instanceof BeanMap o2)
               rc = writeBeanMap(out, o2, elementNamespace, isCollapsed, isMixedOrText);
            else
               rc = writeMap(out, (Map)o, sType, eType.getKeyType(), eType.getValueType(), isMixedOrText);
         } else if (sType.isCollection() || sType.isArray() || (nn(wType) && (wType.isCollection() || wType.isArray()))) {
            if (isCollapsed)
               indent--;
            writeCollection(out, o, sType, eType, pMeta, isMixedOrText);
            if (isCollapsed)
               indent++;
         } else if (sType.isUri() || (nn(pMeta) && pMeta.isUri())) {
            // Must come before isCharSequence/isChar: @Uri-annotated String properties (where sType is String but pMeta.isUri() is true) need to route here for URI text emission.
            out.textUri(o);
         } else if (sType.isCharSequence() || sType.isChar()) {
            if (isXmlText(format, sType) || isRawText(format, sType))
               out.append(o);
            else
               out.text(o, preserveWhitespace);
         } else if (sType.isNumber() || sType.isBoolean()) {
            out.append(o);
         } else if (sType.isDate()) {
            out.text(writeDate((Date)o, sType));
         } else if (sType.isCalendar()) {
            out.text(writeCalendar(o, sType));
         } else if (sType.isTemporal()) {
            out.text(writeTemporal((TemporalAccessor)o, sType));
         } else if (sType.isDuration()) {
            out.text(writeDuration((Duration)o));
         } else if (sType.isPeriod()) {
            out.text(writePeriod((Period)o));
         } else if (sType.isStreamable()) {
            if (isCollapsed)
               indent--;
            writeStreamable(out, o, sType, eType, pMeta, isMixedOrText);
            if (isCollapsed)
               indent++;
         } else if (sType.isReader()) {
            pipe((Reader)o, out, SerializerSession::handleThrown);
         } else if (sType.isInputStream()) {
            pipe((InputStream)o, out, SerializerSession::handleThrown);
         } else {
            if (isXmlText(format, sType) || isRawText(format, sType))
               out.append(toString(o));
            else
               out.text(toString(o));
         }
      }

      pop();

      // Render the end tag.
      if (! isCollapsed) {
         if (nn(en)) {
            if (rc == CR_EMPTY) {
               if (isHtmlMode())
                  out.w('>').eTag(elementNs, en, encodeEn);
               else
                  out.w('/').w('>');
            } else if (rc == CR_VOID || o == null) {
               out.w('/').w('>');
            } else
               out.ie(cr && rc != CR_MIXED ? i : 0).eTag(elementNs, en, encodeEn);
         }
         if (! isMixedOrText)
            out.nl(i);
      }

      return rc;
   }
}