package org.codehaus.plexus.util.xml;

/*
 * Copyright The Codehaus Foundation.
 *
 * Licensed 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.
 */

import java.io.IOException;
import java.io.Serializable;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

import org.codehaus.plexus.util.xml.pull.XmlSerializer;

/**
 *  NOTE: remove all the util code in here when separated, this class should be pure data.
 */
public class Xpp3Dom implements Serializable {
    private static final long serialVersionUID = 2567894443061173996L;

    protected String name;

    protected String value;

    protected Map<String, String> attributes;

    protected final List<Xpp3Dom> childList;

    protected Xpp3Dom parent;

    /**
     * @since 3.2.0
     */
    protected Object inputLocation;

    private static final String[] EMPTY_STRING_ARRAY = new String[0];

    private static final Xpp3Dom[] EMPTY_DOM_ARRAY = new Xpp3Dom[0];

    public static final String CHILDREN_COMBINATION_MODE_ATTRIBUTE = "combine.children";

    public static final String CHILDREN_COMBINATION_MERGE = "merge";

    public static final String CHILDREN_COMBINATION_APPEND = "append";

    /**
     * This default mode for combining children DOMs during merge means that where element names match, the process will
     * try to merge the element data, rather than putting the dominant and recessive elements (which share the same
     * element name) as siblings in the resulting DOM.
     */
    public static final String DEFAULT_CHILDREN_COMBINATION_MODE = CHILDREN_COMBINATION_MERGE;

    public static final String SELF_COMBINATION_MODE_ATTRIBUTE = "combine.self";

    public static final String SELF_COMBINATION_OVERRIDE = "override";

    public static final String SELF_COMBINATION_MERGE = "merge";

    public static final String SELF_COMBINATION_REMOVE = "remove";

    /**
     * This default mode for combining a DOM node during merge means that where element names match, the process will
     * try to merge the element attributes and values, rather than overriding the recessive element completely with the
     * dominant one. This means that wherever the dominant element doesn't provide the value or a particular attribute,
     * that value or attribute will be set from the recessive DOM node.
     */
    public static final String DEFAULT_SELF_COMBINATION_MODE = SELF_COMBINATION_MERGE;

    public Xpp3Dom(String name) {
        this.name = name;
        childList = new ArrayList<>();
    }

    /**
     * @since 3.2.0
     * @param inputLocation The input location.
     * @param name The name of the Dom.
     */
    public Xpp3Dom(String name, Object inputLocation) {
        this(name);
        this.inputLocation = inputLocation;
    }

    /**
     * Copy constructor.
     * @param src The source Dom.
     */
    public Xpp3Dom(Xpp3Dom src) {
        this(src, src.getName());
    }

    /**
     * Copy constructor with alternative name.
     * @param src The source Dom.
     * @param name The name of the Dom.
     */
    public Xpp3Dom(Xpp3Dom src, String name) {
        this.name = name;
        this.inputLocation = src.inputLocation;

        int childCount = src.getChildCount();

        childList = new ArrayList<Xpp3Dom>(childCount);

        setValue(src.getValue());

        String[] attributeNames = src.getAttributeNames();
        for (String attributeName : attributeNames) {
            setAttribute(attributeName, src.getAttribute(attributeName));
        }

        for (int i = 0; i < childCount; i++) {
            addChild(new Xpp3Dom(src.getChild(i)));
        }
    }

    // ----------------------------------------------------------------------
    // Name handling
    // ----------------------------------------------------------------------

    public String getName() {
        return name;
    }

    // ----------------------------------------------------------------------
    // Value handling
    // ----------------------------------------------------------------------

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    // ----------------------------------------------------------------------
    // Attribute handling
    // ----------------------------------------------------------------------

    public String[] getAttributeNames() {
        if (null == attributes || attributes.isEmpty()) {
            return EMPTY_STRING_ARRAY;
        } else {
            return attributes.keySet().toArray(EMPTY_STRING_ARRAY);
        }
    }

    public String getAttribute(String name) {
        return (null != attributes) ? attributes.get(name) : null;
    }

    /**
     *
     * @param name name of the attribute to be removed
     * @return <code>true</code> if the attribute has been removed
     * @since 3.4.0
     */
    public boolean removeAttribute(String name) {
        return StringUtils.isEmpty(name) ? false : attributes.remove(name) == null;
    }

    /**
     * Set the attribute value
     *
     * @param name String not null
     * @param value String not null
     */
    public void setAttribute(String name, String value) {
        if (null == value) {
            throw new NullPointerException("Attribute value can not be null");
        }
        if (null == name) {
            throw new NullPointerException("Attribute name can not be null");
        }
        if (null == attributes) {
            attributes = new HashMap<String, String>();
        }

        attributes.put(name, value);
    }

    // ----------------------------------------------------------------------
    // Child handling
    // ----------------------------------------------------------------------

    public Xpp3Dom getChild(int i) {
        return childList.get(i);
    }

    public Xpp3Dom getChild(String name) {
        if (name != null) {
            ListIterator<Xpp3Dom> it = childList.listIterator(childList.size());
            while (it.hasPrevious()) {
                Xpp3Dom child = it.previous();
                if (name.equals(child.getName())) {
                    return child;
                }
            }
        }
        return null;
    }

    public void addChild(Xpp3Dom xpp3Dom) {
        xpp3Dom.setParent(this);
        childList.add(xpp3Dom);
    }

    public Xpp3Dom[] getChildren() {
        if (null == childList || childList.isEmpty()) {
            return EMPTY_DOM_ARRAY;
        } else {
            return childList.toArray(EMPTY_DOM_ARRAY);
        }
    }

    public Xpp3Dom[] getChildren(String name) {
        return getChildrenAsList(name).toArray(EMPTY_DOM_ARRAY);
    }

    private List<Xpp3Dom> getChildrenAsList(String name) {
        if (null == childList) {
            return Collections.emptyList();
        } else {
            ArrayList<Xpp3Dom> children = null;

            for (Xpp3Dom configuration : childList) {
                if (name.equals(configuration.getName())) {
                    if (children == null) {
                        children = new ArrayList<Xpp3Dom>();
                    }
                    children.add(configuration);
                }
            }

            if (children != null) {
                return children;
            } else {
                return Collections.emptyList();
            }
        }
    }

    public int getChildCount() {
        if (null == childList) {
            return 0;
        }

        return childList.size();
    }

    public void removeChild(int i) {
        Xpp3Dom child = getChild(i);
        childList.remove(i);
        // In case of any dangling references
        child.setParent(null);
    }

    public void removeChild(Xpp3Dom child) {
        childList.remove(child);
        // In case of any dangling references
        child.setParent(null);
    }

    // ----------------------------------------------------------------------
    // Parent handling
    // ----------------------------------------------------------------------

    public Xpp3Dom getParent() {
        return parent;
    }

    public void setParent(Xpp3Dom parent) {
        this.parent = parent;
    }

    // ----------------------------------------------------------------------
    // Input location handling
    // ----------------------------------------------------------------------

    /**
     * @since 3.2.0
     * @return input location
     */
    public Object getInputLocation() {
        return inputLocation;
    }

    /**
     * @since 3.2.0
     * @param inputLocation input location to set
     */
    public void setInputLocation(Object inputLocation) {
        this.inputLocation = inputLocation;
    }

    // ----------------------------------------------------------------------
    // Helpers
    // ----------------------------------------------------------------------

    public void writeToSerializer(String namespace, XmlSerializer serializer) throws IOException {
        // TODO: WARNING! Later versions of plexus-utils psit out an <?xml ?> header due to thinking this is a new
        // document - not the desired behaviour!
        SerializerXMLWriter xmlWriter = new SerializerXMLWriter(namespace, serializer);
        Xpp3DomWriter.write(xmlWriter, this);
        if (xmlWriter.getExceptions().size() > 0) {
            throw (IOException) xmlWriter.getExceptions().get(0);
        }
    }

    /**
     * Merges one DOM into another, given a specific algorithm and possible override points for that algorithm.<p>
     * The algorithm is as follows:
     * <ol>
     * <li> if the recessive DOM is null, there is nothing to do... return.</li>
     * <li> Determine whether the dominant node will suppress the recessive one (flag=mergeSelf).
     *   <ol type="A">
     *   <li> retrieve the 'combine.self' attribute on the dominant node, and try to match against 'override'...
     *        if it matches 'override', then set mergeSelf == false...the dominant node suppresses the recessive one
     *        completely.</li>
     *   <li> otherwise, use the default value for mergeSelf, which is true...this is the same as specifying
     *        'combine.self' == 'merge' as an attribute of the dominant root node.</li>
     *   </ol></li>
     * <li> If mergeSelf == true
     *   <ol type="A">
     *   <li> if the dominant root node's value is empty, set it to the recessive root node's value</li>
     *   <li> For each attribute in the recessive root node which is not set in the dominant root node, set it.</li>
     *   <li> Determine whether children from the recessive DOM will be merged or appended to the dominant DOM as
     *        siblings (flag=mergeChildren).
     *     <ol type="i">
     *     <li> if childMergeOverride is set (non-null), use that value (true/false)</li>
     *     <li> retrieve the 'combine.children' attribute on the dominant node, and try to match against
     *          'append'...</li>
     *     <li> if it matches 'append', then set mergeChildren == false...the recessive children will be appended as
     *          siblings of the dominant children.</li>
     *     <li> otherwise, use the default value for mergeChildren, which is true...this is the same as specifying
     *         'combine.children' == 'merge' as an attribute on the dominant root node.</li>
     *     </ol></li>
     *   <li> Iterate through the recessive children, and:
     *     <ol type="i">
     *     <li> if mergeChildren == true and there is a corresponding dominant child (matched by element name),
     *          merge the two.</li>
     *     <li> otherwise, add the recessive child as a new child on the dominant root node.</li>
     *     </ol></li>
     *   </ol></li>
     * </ol>
     */
    private static void mergeIntoXpp3Dom(Xpp3Dom dominant, Xpp3Dom recessive, Boolean childMergeOverride) {
        // TODO: share this as some sort of assembler, implement a walk interface?
        if (recessive == null) {
            return;
        }

        boolean mergeSelf = true;

        String selfMergeMode = dominant.getAttribute(SELF_COMBINATION_MODE_ATTRIBUTE);

        if (SELF_COMBINATION_OVERRIDE.equals(selfMergeMode)) {
            mergeSelf = false;
        }

        if (mergeSelf) {
            if (isEmpty(dominant.getValue()) && !isEmpty(recessive.getValue())) {
                dominant.setValue(recessive.getValue());
                dominant.setInputLocation(recessive.getInputLocation());
            }

            if (recessive.attributes != null) {
                for (String attr : recessive.attributes.keySet()) {
                    if (isEmpty(dominant.getAttribute(attr))) {
                        dominant.setAttribute(attr, recessive.getAttribute(attr));
                    }
                }
            }

            if (recessive.getChildCount() > 0) {
                boolean mergeChildren = true;

                if (childMergeOverride != null) {
                    mergeChildren = childMergeOverride;
                } else {
                    String childMergeMode = dominant.getAttribute(CHILDREN_COMBINATION_MODE_ATTRIBUTE);

                    if (CHILDREN_COMBINATION_APPEND.equals(childMergeMode)) {
                        mergeChildren = false;
                    }
                }

                if (!mergeChildren) {
                    Xpp3Dom[] dominantChildren = dominant.getChildren();
                    // remove these now, so we can append them to the recessive list later.
                    dominant.childList.clear();

                    for (int i = 0, recessiveChildCount = recessive.getChildCount(); i < recessiveChildCount; i++) {
                        Xpp3Dom recessiveChild = recessive.getChild(i);
                        dominant.addChild(new Xpp3Dom(recessiveChild));
                    }

                    // now, re-add these children so they'll be appended to the recessive list.
                    for (Xpp3Dom aDominantChildren : dominantChildren) {
                        dominant.addChild(aDominantChildren);
                    }
                } else {
                    Map<String, Iterator<Xpp3Dom>> commonChildren = new HashMap<String, Iterator<Xpp3Dom>>();

                    for (Xpp3Dom recChild : recessive.childList) {
                        if (commonChildren.containsKey(recChild.name)) {
                            continue;
                        }
                        List<Xpp3Dom> dominantChildren = dominant.getChildrenAsList(recChild.name);
                        if (dominantChildren.size() > 0) {
                            commonChildren.put(recChild.name, dominantChildren.iterator());
                        }
                    }

                    for (int i = 0, recessiveChildCount = recessive.getChildCount(); i < recessiveChildCount; i++) {
                        Xpp3Dom recessiveChild = recessive.getChild(i);
                        Iterator<Xpp3Dom> it = commonChildren.get(recessiveChild.getName());
                        if (it == null) {
                            dominant.addChild(new Xpp3Dom(recessiveChild));
                        } else if (it.hasNext()) {
                            Xpp3Dom dominantChild = it.next();

                            String dominantChildCombinationMode =
                                    dominantChild.getAttribute(SELF_COMBINATION_MODE_ATTRIBUTE);
                            if (SELF_COMBINATION_REMOVE.equals(dominantChildCombinationMode)) {
                                dominant.removeChild(dominantChild);
                            } else {
                                mergeIntoXpp3Dom(dominantChild, recessiveChild, childMergeOverride);
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Merge two DOMs, with one having dominance in the case of collision.
     *
     * @see #CHILDREN_COMBINATION_MODE_ATTRIBUTE
     * @see #SELF_COMBINATION_MODE_ATTRIBUTE
     * @param dominant The dominant DOM into which the recessive value/attributes/children will be merged
     * @param recessive The recessive DOM, which will be merged into the dominant DOM
     * @param childMergeOverride Overrides attribute flags to force merging or appending of child elements into the
     *            dominant DOM
     * @return merged DOM
     */
    public static Xpp3Dom mergeXpp3Dom(Xpp3Dom dominant, Xpp3Dom recessive, Boolean childMergeOverride) {
        if (dominant != null) {
            mergeIntoXpp3Dom(dominant, recessive, childMergeOverride);
            return dominant;
        }
        return recessive;
    }

    /**
     * Merge two DOMs, with one having dominance in the case of collision. Merge mechanisms (vs. override for nodes, or
     * vs. append for children) is determined by attributes of the dominant root node.
     *
     * @see #CHILDREN_COMBINATION_MODE_ATTRIBUTE
     * @see #SELF_COMBINATION_MODE_ATTRIBUTE
     * @param dominant The dominant DOM into which the recessive value/attributes/children will be merged
     * @param recessive The recessive DOM, which will be merged into the dominant DOM
     * @return merged DOM
     */
    public static Xpp3Dom mergeXpp3Dom(Xpp3Dom dominant, Xpp3Dom recessive) {
        if (dominant != null) {
            mergeIntoXpp3Dom(dominant, recessive, null);
            return dominant;
        }
        return recessive;
    }

    // ----------------------------------------------------------------------
    // Standard object handling
    // ----------------------------------------------------------------------

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }

        if (!(obj instanceof Xpp3Dom)) {
            return false;
        }

        Xpp3Dom dom = (Xpp3Dom) obj;

        if (name == null ? dom.name != null : !name.equals(dom.name)) {
            return false;
        } else if (value == null ? dom.value != null : !value.equals(dom.value)) {
            return false;
        } else if (attributes == null ? dom.attributes != null : !attributes.equals(dom.attributes)) {
            return false;
        } else if (childList == null ? dom.childList != null : !childList.equals(dom.childList)) {
            return false;
        } else {
            return true;
        }
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 37 * result + (name != null ? name.hashCode() : 0);
        result = 37 * result + (value != null ? value.hashCode() : 0);
        result = 37 * result + (attributes != null ? attributes.hashCode() : 0);
        result = 37 * result + (childList != null ? childList.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        // TODO: WARNING! Later versions of plexus-utils psit out an <?xml ?> header due to thinking this is a new
        // document - not the desired behaviour!
        StringWriter writer = new StringWriter();
        XMLWriter xmlWriter = new PrettyPrintXMLWriter(writer, "UTF-8", null);
        Xpp3DomWriter.write(xmlWriter, this);
        return writer.toString();
    }

    public String toUnescapedString() {
        // TODO: WARNING! Later versions of plexus-utils psit out an <?xml ?> header due to thinking this is a new
        // document - not the desired behaviour!
        StringWriter writer = new StringWriter();
        XMLWriter xmlWriter = new PrettyPrintXMLWriter(writer, "UTF-8", null);
        Xpp3DomWriter.write(xmlWriter, this, false);
        return writer.toString();
    }

    public static boolean isNotEmpty(String str) {
        return ((str != null) && (str.length() > 0));
    }

    public static boolean isEmpty(String str) {
        return ((str == null) || (str.trim().length() == 0));
    }
}
