/*
 * 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.maven.doxia.sink.impl;

import javax.swing.text.AttributeSet;

import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;

import org.apache.maven.doxia.sink.SinkEventAttributes;

/**
 * Implementation of MutableAttributeSet using a LinkedHashMap.
 *
 * @author ltheussl
 * @since 1.1
 */
public class SinkEventAttributeSet implements SinkEventAttributes, Cloneable {
    /**
     * An unmodifiable attribute set containing only an underline attribute.
     */
    public static final SinkEventAttributes UNDERLINE;

    /**
     * An unmodifiable attribute set containing only an overline attribute.
     */
    public static final SinkEventAttributes OVERLINE;

    /**
     * An unmodifiable attribute set containing only a linethrough attribute.
     */
    public static final SinkEventAttributes LINETHROUGH;

    /**
     * An unmodifiable attribute set containing only a source attribute.
     */
    public static final SinkEventAttributes SOURCE;

    /**
     * An unmodifiable attribute set containing only a bold attribute.
     */
    public static final SinkEventAttributes BOLD;

    /**
     * An unmodifiable attribute set containing only an italic attribute.
     */
    public static final SinkEventAttributes ITALIC;

    /**
     * An unmodifiable attribute set containing only a monospaced attribute.
     */
    public static final SinkEventAttributes MONOSPACED;

    /**
     * An unmodifiable attribute set containing only a left attribute.
     */
    public static final SinkEventAttributes LEFT;

    /**
     * An unmodifiable attribute set containing only a right attribute.
     */
    public static final SinkEventAttributes RIGHT;

    /**
     * An unmodifiable attribute set containing only a center attribute.
     */
    public static final SinkEventAttributes CENTER;

    /**
     * An unmodifiable attribute set containing only a justify attribute.
     */
    public static final SinkEventAttributes JUSTIFY;

    static {
        UNDERLINE = new SinkEventAttributeSet(DECORATION, "underline").unmodifiable();
        OVERLINE = new SinkEventAttributeSet(DECORATION, "overline").unmodifiable();
        LINETHROUGH = new SinkEventAttributeSet(DECORATION, "line-through").unmodifiable();
        SOURCE = new SinkEventAttributeSet(DECORATION, "source").unmodifiable();

        BOLD = new SinkEventAttributeSet(STYLE, "bold").unmodifiable();
        ITALIC = new SinkEventAttributeSet(STYLE, "italic").unmodifiable();
        MONOSPACED = new SinkEventAttributeSet(STYLE, "monospaced").unmodifiable();

        LEFT = new SinkEventAttributeSet(ALIGN, "left").unmodifiable();
        RIGHT = new SinkEventAttributeSet(ALIGN, "right").unmodifiable();
        CENTER = new SinkEventAttributeSet(ALIGN, "center").unmodifiable();
        JUSTIFY = new SinkEventAttributeSet(ALIGN, "justify").unmodifiable();
    }

    private Map<String, Object> attribs;

    private AttributeSet resolveParent;

    /**
     * Constructs a new, empty SinkEventAttributeSet with default size 5.
     */
    public SinkEventAttributeSet() {
        this(5);
    }

    /**
     * Constructs a new, empty SinkEventAttributeSet with the specified initial size.
     *
     * @param size the initial number of attribs.
     */
    public SinkEventAttributeSet(int size) {
        attribs = new LinkedHashMap<>(size);
    }

    /**
     * Constructs a new SinkEventAttributeSet with the attribute name-value
     * mappings as given by the specified String array.
     *
     * @param attributes the specified String array. If the length of this array
     * is not an even number, an IllegalArgumentException is thrown.
     */
    public SinkEventAttributeSet(String... attributes) {
        int n = attributes.length;

        if ((n % 2) != 0) {
            throw new IllegalArgumentException("Missing attribute!");
        }

        attribs = new LinkedHashMap<>(n / 2);

        for (int i = 0; i < n; i += 2) {
            attribs.put(attributes[i], attributes[i + 1]);
        }
    }

    /**
     * Constructs a new SinkEventAttributeSet with the same attribute name-value
     * mappings as in the specified AttributeSet.
     *
     * @param attributes the specified AttributeSet.
     */
    public SinkEventAttributeSet(AttributeSet attributes) {
        attribs = new LinkedHashMap<>(attributes.getAttributeCount());

        Enumeration<?> names = attributes.getAttributeNames();

        while (names.hasMoreElements()) {
            Object name = names.nextElement();

            attribs.put(name.toString(), attributes.getAttribute(name));
        }
    }

    /**
     * Replace this AttributeSet by an unmodifiable view of itself.
     * Any subsequent attempt to add, remove or modify the underlying mapping
     * will result in an UnsupportedOperationException.
     *
     * @return an unmodifiable view of this AttributeSet.
     * @since 1.1.1
     */
    public SinkEventAttributeSet unmodifiable() {
        this.attribs = Collections.unmodifiableMap(attribs);

        return this;
    }

    /**
     * Checks whether the set of attribs is empty.
     *
     * @return true if the set is empty.
     */
    public boolean isEmpty() {
        return attribs.isEmpty();
    }

    /**
     * {@inheritDoc}
     *
     * @return a int.
     */
    public int getAttributeCount() {
        return attribs.size();
    }

    /** {@inheritDoc} */
    public boolean isDefined(Object attrName) {
        return attribs.containsKey(attrName);
    }

    /** {@inheritDoc} */
    public boolean isEqual(AttributeSet attr) {
        return ((getAttributeCount() == attr.getAttributeCount()) && containsAttributes(attr));
    }

    /**
     * {@inheritDoc}
     *
     * @return a {@link javax.swing.text.AttributeSet} object.
     */
    public AttributeSet copyAttributes() {
        return ((AttributeSet) clone());
    }

    /**
     * {@inheritDoc}
     *
     * @return a {@link java.util.Enumeration} object.
     */
    public Enumeration<String> getAttributeNames() {
        return Collections.enumeration(attribs.keySet());
    }

    /** {@inheritDoc} */
    public Object getAttribute(Object key) {
        Object value = attribs.get(key);

        if (value == null) {
            AttributeSet parent = getResolveParent();

            if (parent != null) {
                value = parent.getAttribute(key);
            }
        }

        return value;
    }

    /** {@inheritDoc} */
    public boolean containsAttribute(Object name, Object value) {
        return value.equals(getAttribute(name));
    }

    /** {@inheritDoc} */
    public boolean containsAttributes(AttributeSet attributes) {
        boolean result = true;

        Enumeration<?> names = attributes.getAttributeNames();

        while (result && names.hasMoreElements()) {
            Object name = names.nextElement();
            result = attributes.getAttribute(name).equals(getAttribute(name));
        }

        return result;
    }

    /**
     * {@inheritDoc}
     *
     * Adds an attribute with the given name and value.
     */
    public void addAttribute(Object name, Object value) {
        attribs.put(name.toString(), value);
    }

    /** {@inheritDoc} */
    public void addAttributes(AttributeSet attributes) {
        if (attributes == null || attributes.getAttributeCount() == 0) {
            return;
        }

        Enumeration<?> names = attributes.getAttributeNames();

        while (names.hasMoreElements()) {
            Object name = names.nextElement();

            addAttribute(name, attributes.getAttribute(name));
        }
    }

    /** {@inheritDoc} */
    public void removeAttribute(Object name) {
        attribs.remove(name);
    }

    /** {@inheritDoc} */
    public void removeAttributes(Enumeration<?> names) {
        while (names.hasMoreElements()) {
            removeAttribute(names.nextElement());
        }
    }

    /**
     * {@inheritDoc}
     *
     * @param attributes a {@link javax.swing.text.AttributeSet} object.
     */
    public void removeAttributes(AttributeSet attributes) {
        if (attributes == null) {
            return;
        } else if (attributes == this) {
            attribs.clear();
        } else {
            Enumeration<?> names = attributes.getAttributeNames();

            while (names.hasMoreElements()) {
                Object name = names.nextElement();
                Object value = attributes.getAttribute(name);

                if (value.equals(getAttribute(name))) {
                    removeAttribute(name);
                }
            }
        }
    }

    /**
     * {@inheritDoc}
     *
     * @return a {@link javax.swing.text.AttributeSet} object.
     */
    public AttributeSet getResolveParent() {
        return this.resolveParent;
    }

    /** {@inheritDoc} */
    public void setResolveParent(AttributeSet parent) {
        this.resolveParent = parent;
    }

    /** {@inheritDoc} */
    @Override
    public Object clone() {
        SinkEventAttributeSet attr = new SinkEventAttributeSet(attribs.size());
        attr.attribs = new LinkedHashMap<>(attribs);

        if (resolveParent != null) {
            attr.resolveParent = resolveParent.copyAttributes();
        }

        return attr;
    }

    /** {@inheritDoc} */
    @Override
    public int hashCode() {
        final int parentHash = (resolveParent == null ? 0 : resolveParent.hashCode());

        return attribs.hashCode() + parentHash;
    }

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

        if (obj instanceof SinkEventAttributeSet) {
            return isEqual((SinkEventAttributeSet) obj);
        }

        return false;
    }

    /** {@inheritDoc} */
    @Override
    public String toString() {
        StringBuilder s = new StringBuilder();
        Enumeration<String> names = getAttributeNames();

        while (names.hasMoreElements()) {
            String key = names.nextElement();
            String value = getAttribute(key).toString();

            s.append(' ').append(key).append('=').append(value);
        }

        return s.toString();
    }

    /**
     * Attribute sets for the semantic attribute.
     */
    public static class Semantics {
        /**
         * An unmodifiable attribute set containing only an emphasis attribute.
         */
        public static final SinkEventAttributes EMPHASIS;

        /**
         * An unmodifiable attribute set containing only a strong attribute.
         */
        public static final SinkEventAttributes STRONG;

        /**
         * An unmodifiable attribute set containing only a small attribute.
         */
        public static final SinkEventAttributes SMALL;

        /**
         * An unmodifiable attribute set containing only a line-through attribute.
         */
        public static final SinkEventAttributes LINE_THROUGH;

        /**
         * An unmodifiable attribute set containing only a citation attribute.
         */
        public static final SinkEventAttributes CITATION;

        /**
         * An unmodifiable attribute set containing only a quote attribute.
         */
        public static final SinkEventAttributes QUOTE;

        /**
         * An unmodifiable attribute set containing only a definition attribute.
         */
        public static final SinkEventAttributes DEFINITION;

        /**
         * An unmodifiable attribute set containing only an abbreviation attribute.
         */
        public static final SinkEventAttributes ABBREVIATION;

        /**
         * An unmodifiable attribute set containing only an italic attribute.
         */
        public static final SinkEventAttributes ITALIC;

        /**
         * An unmodifiable attribute set containing only a bold attribute.
         */
        public static final SinkEventAttributes BOLD;

        /**
         * An unmodifiable attribute set containing only a monospaced attribute.
         */
        public static final SinkEventAttributes MONOSPACED;

        /**
         * An unmodifiable attribute set containing only a code attribute.
         */
        public static final SinkEventAttributes CODE;

        /**
         * An unmodifiable attribute set containing only a variable attribute.
         */
        public static final SinkEventAttributes VARIABLE;

        /**
         * An unmodifiable attribute set containing only a sample attribute.
         */
        public static final SinkEventAttributes SAMPLE;

        /**
         * An unmodifiable attribute set containing only a keyboard attribute.
         */
        public static final SinkEventAttributes KEYBOARD;

        /**
         * An unmodifiable attribute set containing only a superscript attribute.
         */
        public static final SinkEventAttributes SUPERSCRIPT;

        /**
         * An unmodifiable attribute set containing only a subscript attribute.
         */
        public static final SinkEventAttributes SUBSCRIPT;

        /**
         * An unmodifiable attribute set containing only an annotation attribute.
         */
        public static final SinkEventAttributes ANNOTATION;

        /**
         * An unmodifiable attribute set containing only a highlight attribute.
         */
        public static final SinkEventAttributes HIGHLIGHT;

        /**
         * An unmodifiable attribute set containing only a ruby attribute.
         */
        public static final SinkEventAttributes RUBY;

        /**
         * An unmodifiable attribute set containing only a rubyBase attribute.
         */
        public static final SinkEventAttributes RUBY_BASE;

        /**
         * An unmodifiable attribute set containing only a rubyText attribute.
         */
        public static final SinkEventAttributes RUBY_TEXT;

        /**
         * An unmodifiable attribute set containing only a rubyTextContainer attribute.
         */
        public static final SinkEventAttributes RUBY_TEXT_CONTAINER;

        /**
         * An unmodifiable attribute set containing only a rubyParentheses attribute.
         */
        public static final SinkEventAttributes RUBY_PARANTHESES;

        /**
         * An unmodifiable attribute set containing only a bidirectionalIsolation attribute.
         */
        public static final SinkEventAttributes BIDIRECTIONAL_ISOLATION;

        /**
         * An unmodifiable attribute set containing only a bidirectionalOverride attribute.
         */
        public static final SinkEventAttributes BIDIRECTIONAL_OVERRIDE;

        /**
         * An unmodifiable attribute set containing only a phrase attribute.
         */
        public static final SinkEventAttributes PHRASE;

        /**
         * An unmodifiable attribute set containing only an insert attribute.
         */
        public static final SinkEventAttributes INSERT;

        /**
         * An unmodifiable attribute set containing only a delete attribute.
         */
        public static final SinkEventAttributes DELETE;

        static {
            EMPHASIS = new SinkEventAttributeSet(SEMANTICS, "emphasis").unmodifiable();
            STRONG = new SinkEventAttributeSet(SEMANTICS, "strong").unmodifiable();
            SMALL = new SinkEventAttributeSet(SEMANTICS, "small").unmodifiable();
            LINE_THROUGH = new SinkEventAttributeSet(SEMANTICS, "line-through").unmodifiable();
            CITATION = new SinkEventAttributeSet(SEMANTICS, "citation").unmodifiable();
            QUOTE = new SinkEventAttributeSet(SEMANTICS, "quote").unmodifiable();
            DEFINITION = new SinkEventAttributeSet(SEMANTICS, "definition").unmodifiable();
            ABBREVIATION = new SinkEventAttributeSet(SEMANTICS, "abbreviation").unmodifiable();
            ITALIC = new SinkEventAttributeSet(SEMANTICS, "italic").unmodifiable();
            BOLD = new SinkEventAttributeSet(SEMANTICS, "bold").unmodifiable();
            MONOSPACED = new SinkEventAttributeSet(SEMANTICS, "monospaced").unmodifiable();
            CODE = new SinkEventAttributeSet(SEMANTICS, "code").unmodifiable();
            VARIABLE = new SinkEventAttributeSet(SEMANTICS, "variable").unmodifiable();
            SAMPLE = new SinkEventAttributeSet(SEMANTICS, "sample").unmodifiable();
            KEYBOARD = new SinkEventAttributeSet(SEMANTICS, "keyboard").unmodifiable();
            SUPERSCRIPT = new SinkEventAttributeSet(SEMANTICS, "superscript").unmodifiable();
            SUBSCRIPT = new SinkEventAttributeSet(SEMANTICS, "subscript").unmodifiable();
            ANNOTATION = new SinkEventAttributeSet(SEMANTICS, "annotation").unmodifiable();
            HIGHLIGHT = new SinkEventAttributeSet(SEMANTICS, "highlight").unmodifiable();
            RUBY = new SinkEventAttributeSet(SEMANTICS, "ruby").unmodifiable();
            RUBY_BASE = new SinkEventAttributeSet(SEMANTICS, "rubyBase").unmodifiable();
            RUBY_TEXT = new SinkEventAttributeSet(SEMANTICS, "rubyText").unmodifiable();
            RUBY_TEXT_CONTAINER = new SinkEventAttributeSet(SEMANTICS, "rubyTextContainer").unmodifiable();
            RUBY_PARANTHESES = new SinkEventAttributeSet(SEMANTICS, "rubyParentheses").unmodifiable();
            BIDIRECTIONAL_ISOLATION = new SinkEventAttributeSet(SEMANTICS, "bidirectionalIsolation").unmodifiable();
            BIDIRECTIONAL_OVERRIDE = new SinkEventAttributeSet(SEMANTICS, "bidirectionalOverride").unmodifiable();
            PHRASE = new SinkEventAttributeSet(SEMANTICS, "phrase").unmodifiable();
            INSERT = new SinkEventAttributeSet(SEMANTICS, "insert").unmodifiable();
            DELETE = new SinkEventAttributeSet(SEMANTICS, "delete").unmodifiable();
        }
    }
}
