//------------------------------------------------------------------------------
// <copyright file="XmlAttributeCollection.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
// <owner current="true" primary="true">[....]</owner>
//------------------------------------------------------------------------------


namespace System.Xml {
    using System;
    using System.Collections;
    using System.Diagnostics;
    
    // Represents a collection of attributes that can be accessed by name or index.
    public sealed class XmlAttributeCollection: XmlNamedNodeMap, ICollection {
        internal XmlAttributeCollection( XmlNode parent ): base( parent ) {
        }

        // Gets the attribute with the specified index.
        [System.Runtime.CompilerServices.IndexerName ("ItemOf")]
        public XmlAttribute this[ int i ] {
            get { 
                try {
                    return (XmlAttribute)nodes[i];
                } catch ( ArgumentOutOfRangeException ) {
                    throw new IndexOutOfRangeException(Res.GetString(Res.Xdom_IndexOutOfRange));
                }
            }
        }

        // Gets the attribute with the specified name.
        [System.Runtime.CompilerServices.IndexerName ("ItemOf")]
        public XmlAttribute this[ string name ]
        {
            get {
                int hash = XmlName.GetHashCode(name);
                
                for (int i = 0; i < nodes.Count; i++) {
                    XmlAttribute node = (XmlAttribute) nodes[i];

                    if (hash == node.LocalNameHash
                        && name == node.Name )
                    {
                        return node;
                    }
                }

                return null;
            }
        }

        // Gets the attribute with the specified LocalName and NamespaceUri.
        [System.Runtime.CompilerServices.IndexerName ("ItemOf")]
        public XmlAttribute this[ string localName, string namespaceURI ]
        {
            get {
                int hash = XmlName.GetHashCode(localName);
                
                for (int i = 0; i < nodes.Count; i++) {
                    XmlAttribute node = (XmlAttribute) nodes[i];

                    if (hash == node.LocalNameHash
                        && localName == node.LocalName 
                        && namespaceURI == node.NamespaceURI)
                    {
                        return node;
                    }
                }

                return null;
            }
        }

        internal int FindNodeOffset( XmlAttribute node ) {
            for (int i = 0; i < nodes.Count; i++) {
                XmlAttribute tmp = (XmlAttribute) nodes[i];

                if (tmp.LocalNameHash == node.LocalNameHash
                    && tmp.Name == node.Name 
                    && tmp.NamespaceURI == node.NamespaceURI )
                {
                    return i;
                }
            }
            return -1;
        }

        internal int FindNodeOffsetNS(XmlAttribute node) {
            for (int i = 0; i < nodes.Count; i++) {
                XmlAttribute tmp = (XmlAttribute) nodes[i];
                if (tmp.LocalNameHash == node.LocalNameHash
                    && tmp.LocalName == node.LocalName 
                    && tmp.NamespaceURI == node.NamespaceURI) {
                    return i;
                }
            }
            return -1;
        }

        // Adds a XmlNode using its Name property
        public override XmlNode SetNamedItem(XmlNode node) {
            if (node != null && !(node is XmlAttribute))
                throw new ArgumentException(Res.GetString(Res.Xdom_AttrCol_Object));

            int offset = FindNodeOffset( node.LocalName, node.NamespaceURI );
            if (offset == -1) {
                return InternalAppendAttribute( (XmlAttribute) node );
            }
            else {
                XmlNode oldNode = base.RemoveNodeAt( offset );
                InsertNodeAt( offset, node );
                return oldNode;
            }
        }

        // Inserts the specified node as the first node in the collection.
        public XmlAttribute Prepend( XmlAttribute node ) {
            if (node.OwnerDocument != null && node.OwnerDocument != parent.OwnerDocument)
                throw new ArgumentException(Res.GetString(Res.Xdom_NamedNode_Context));

            if (node.OwnerElement != null)
                Detach( node );

            RemoveDuplicateAttribute( node );

            InsertNodeAt( 0, node );
            return node;
        }

        // Inserts the specified node as the last node in the collection.
        public XmlAttribute Append(XmlAttribute node) {
            XmlDocument doc = node.OwnerDocument;
            if (doc == null || doc.IsLoading == false) {
                if (doc != null && doc != parent.OwnerDocument) {
                    throw new ArgumentException(Res.GetString(Res.Xdom_NamedNode_Context));
                }
                if (node.OwnerElement != null) {
                    Detach(node);
                }
                AddNode(node);
            }
            else {
                base.AddNodeForLoad(node, doc);
                InsertParentIntoElementIdAttrMap(node);
            }
            return node; 
        }

        // Inserts the specified attribute immediately before the specified reference attribute.
        public XmlAttribute InsertBefore( XmlAttribute newNode, XmlAttribute refNode ) {
            if ( newNode == refNode )
                return newNode;

            if (refNode == null)
                return Append(newNode);

            if (refNode.OwnerElement != parent)
                throw new ArgumentException(Res.GetString(Res.Xdom_AttrCol_Insert));

            if (newNode.OwnerDocument != null && newNode.OwnerDocument != parent.OwnerDocument)
                throw new ArgumentException(Res.GetString(Res.Xdom_NamedNode_Context));

            if (newNode.OwnerElement != null)
                Detach( newNode );

            int offset = FindNodeOffset( refNode.LocalName, refNode.NamespaceURI );
            Debug.Assert( offset != -1 ); // the if statement above guarantees that the ref node is in the collection

            int dupoff = RemoveDuplicateAttribute( newNode );
            if ( dupoff >= 0 && dupoff < offset )
                offset--;
            InsertNodeAt( offset, newNode );

            return newNode;
        }

        // Inserts the specified attribute immediately after the specified reference attribute.
        public XmlAttribute InsertAfter( XmlAttribute newNode, XmlAttribute refNode ) {
            if ( newNode == refNode )
                return newNode;

            if (refNode == null)
                return Prepend(newNode);

            if (refNode.OwnerElement != parent)
                throw new ArgumentException(Res.GetString(Res.Xdom_AttrCol_Insert));

            if (newNode.OwnerDocument != null && newNode.OwnerDocument != parent.OwnerDocument)
                throw new ArgumentException(Res.GetString(Res.Xdom_NamedNode_Context));

            if (newNode.OwnerElement != null)
                Detach( newNode );

            int offset = FindNodeOffset( refNode.LocalName, refNode.NamespaceURI );
            Debug.Assert( offset != -1 ); // the if statement above guarantees that the ref node is in the collection

            int dupoff = RemoveDuplicateAttribute( newNode );
            if ( dupoff >= 0 && dupoff < offset )
                offset--;
            InsertNodeAt( offset+1, newNode );

            return newNode;
        }

        // Removes the specified attribute node from the map.
        public XmlAttribute Remove( XmlAttribute node ) {
            int cNodes = nodes.Count;
            for (int offset = 0; offset < cNodes; offset++) {
                if (nodes[offset] == node) {
                    RemoveNodeAt( offset );
                    return node;
                }
            }
            return null;
        }

        // Removes the attribute node with the specified index from the map.
        public XmlAttribute RemoveAt( int i ) {
            if (i < 0 || i >= Count)
                return null;

            return(XmlAttribute) RemoveNodeAt( i );
        }

        // Removes all attributes from the map.
        public void RemoveAll() {
            int n = Count;
            while (n > 0) {
                n--;
                RemoveAt( n );
            }
        }

        void ICollection.CopyTo(Array array, int index) {
            for (int i=0, max=Count; i<max; i++, index++)
                array.SetValue(nodes[i], index);
        }

        bool ICollection.IsSynchronized {
            get { return false; }
        }

        object ICollection.SyncRoot {
            get { return this; }
        }

        int ICollection.Count {
            get { return base.Count; }
        }
        
        public void CopyTo(XmlAttribute[] array, int index) {
            for (int i=0, max=Count; i<max; i++, index++)
                array[index] = (XmlAttribute)(((XmlNode)nodes[i]).CloneNode(true));
        }        

        internal override XmlNode AddNode( XmlNode node ) {
            //should be sure by now that the node doesn't have the same name with an existing node in the collection
            RemoveDuplicateAttribute( (XmlAttribute)node );
            XmlNode retNode = base.AddNode( node );
            Debug.Assert( retNode is XmlAttribute );
            InsertParentIntoElementIdAttrMap( (XmlAttribute) node );
            return retNode;
        }            

        internal override XmlNode InsertNodeAt( int i, XmlNode node ) {
            XmlNode retNode = base.InsertNodeAt(i, node);
            InsertParentIntoElementIdAttrMap( (XmlAttribute)node );
            return retNode;
        }
        
        internal override XmlNode RemoveNodeAt( int i ) {
            //remove the node without checking replacement
            XmlNode retNode = base.RemoveNodeAt( i );   
            Debug.Assert(retNode is XmlAttribute);
            RemoveParentFromElementIdAttrMap( (XmlAttribute) retNode );
            // after remove the attribute, we need to check if a default attribute node should be created and inserted into the tree
            XmlAttribute defattr = parent.OwnerDocument.GetDefaultAttribute( (XmlElement)parent, retNode.Prefix, retNode.LocalName, retNode.NamespaceURI );
            if ( defattr != null )
                InsertNodeAt( i, defattr );
            return retNode;
        }

        internal void Detach( XmlAttribute attr ) {
            attr.OwnerElement.Attributes.Remove( attr );
        }

        //insert the parent element node into the map
        internal void InsertParentIntoElementIdAttrMap(XmlAttribute attr)
        {
            XmlElement parentElem = parent as XmlElement;
            if (parentElem != null)
            {
                if (parent.OwnerDocument == null)
                    return;
                XmlName attrname = parent.OwnerDocument.GetIDInfoByElement(parentElem.XmlName);
                if (attrname != null && attrname.Prefix == attr.XmlName.Prefix && attrname.LocalName == attr.XmlName.LocalName) {
                    parent.OwnerDocument.AddElementWithId(attr.Value, parentElem); //add the element into the hashtable
                }
            }
        }

        //remove the parent element node from the map when the ID attribute is removed
        internal void RemoveParentFromElementIdAttrMap(XmlAttribute attr)
        {
            XmlElement parentElem = parent as XmlElement;
            if (parentElem != null)
            {
                if (parent.OwnerDocument == null)
                    return;
                XmlName attrname = parent.OwnerDocument.GetIDInfoByElement(parentElem.XmlName);
                if (attrname != null && attrname.Prefix == attr.XmlName.Prefix && attrname.LocalName == attr.XmlName.LocalName) {
                    parent.OwnerDocument.RemoveElementWithId(attr.Value, parentElem); //remove the element from the hashtable
                }
            }
        }

        //the function checks if there is already node with the same name existing in the collection
        // if so, remove it because the new one will be inserted to replace this one (could be in different position though ) 
        //  by the calling function later
        internal int RemoveDuplicateAttribute( XmlAttribute attr ) {
            int ind = FindNodeOffset( attr.LocalName, attr.NamespaceURI );
            if ( ind != -1 ) {
                XmlAttribute at = (XmlAttribute)nodes[ind];
                base.RemoveNodeAt( ind );                
                RemoveParentFromElementIdAttrMap( at );
            }
            return ind;
        }

        internal bool PrepareParentInElementIdAttrMap(string attrPrefix, string attrLocalName) {
            XmlElement parentElem = parent as XmlElement;
            Debug.Assert( parentElem != null );
            XmlDocument doc = parent.OwnerDocument;
            Debug.Assert( doc != null );
            //The returned attrname if not null is the name with namespaceURI being set to string.Empty
            //Because DTD doesn't support namespaceURI so all comparisons are based on no namespaceURI (string.Empty);
            XmlName attrname = doc.GetIDInfoByElement(parentElem.XmlName);
            if (attrname != null && attrname.Prefix == attrPrefix && attrname.LocalName == attrLocalName) {
                return true;
            }
            return false;
        }

        internal void ResetParentInElementIdAttrMap(string oldVal, string newVal) {
            XmlElement parentElem = parent as XmlElement;
            Debug.Assert( parentElem != null );
            XmlDocument doc = parent.OwnerDocument;
            Debug.Assert( doc != null );
            doc.RemoveElementWithId(oldVal, parentElem); //add the element into the hashtable
            doc.AddElementWithId(newVal, parentElem);
        }

        // WARNING: 
        //  For performance reasons, this function does not check
        //  for xml attributes within the collection with the same full name.
        //  This means that any caller of this function must be sure that
        //  a duplicate attribute does not exist.
        internal XmlAttribute InternalAppendAttribute( XmlAttribute node ) {
            // a duplicate node better not exist
            Debug.Assert( -1 == FindNodeOffset( node ));    

            XmlNode retNode = base.AddNode( node );
            Debug.Assert( retNode is XmlAttribute );
            InsertParentIntoElementIdAttrMap( (XmlAttribute) node );
            return (XmlAttribute)retNode;
        }
    }
}