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

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Xml.Schema;

namespace System.Xml {
    enum DocumentXmlWriterType {
        InsertSiblingAfter,
        InsertSiblingBefore,
        PrependChild,
        AppendChild,
        AppendAttribute,
        ReplaceToFollowingSibling,
    }

    // Implements a XmlWriter that augments a XmlDocument.
    sealed class DocumentXmlWriter : XmlRawWriter, IXmlNamespaceResolver {
        enum State {
            Error,
            Attribute,
            Prolog,
            Fragment,
            Content,

            Last, // always last
        }

        enum Method {
            WriteXmlDeclaration,
            WriteStartDocument,
            WriteEndDocument,
            WriteDocType,
            WriteStartElement,
            WriteEndElement,
            WriteFullEndElement,
            WriteStartAttribute,
            WriteEndAttribute,
            WriteStartNamespaceDeclaration,
            WriteEndNamespaceDeclaration,
            WriteCData,
            WriteComment,
            WriteProcessingInstruction,
            WriteEntityRef,
            WriteWhitespace,
            WriteString,
        }

        DocumentXmlWriterType type; // writer type
        XmlNode start; // context node
        XmlDocument document; // context document 
        XmlNamespaceManager namespaceManager; // context namespace manager
        State state; // current state
        XmlNode write; // current node 
        List<XmlNode> fragment; // top level node cache
        XmlWriterSettings settings; // wrapping writer settings
        DocumentXPathNavigator navigator; // context for replace 
        XmlNode end; // context for replace 

        public DocumentXmlWriter(DocumentXmlWriterType type, XmlNode start, XmlDocument document) {
            this.type = type;
            this.start = start;
            this.document = document;

            state = StartState(); 
            fragment = new List<XmlNode>();
            settings = new XmlWriterSettings();
            settings.ReadOnly = false;
            settings.CheckCharacters = false;
            settings.CloseOutput = false;
            settings.ConformanceLevel = (state == State.Prolog ? ConformanceLevel.Document : ConformanceLevel.Fragment);
            settings.ReadOnly = true;
        }

        public XmlNamespaceManager NamespaceManager {
            set { 
                namespaceManager = value; 
            }
        }

        public override XmlWriterSettings Settings {
            get { 
                return settings; 
            }
        }

        internal void SetSettings(XmlWriterSettings value) {
            settings = value;
        }

        public DocumentXPathNavigator Navigator {
            set {
                navigator = value;
            }
        }

        public XmlNode EndNode {
            set {
                end = value;
            }
        }

        internal override void WriteXmlDeclaration(XmlStandalone standalone) {
            VerifyState(Method.WriteXmlDeclaration);
            if (standalone != XmlStandalone.Omit) {
                XmlNode node = document.CreateXmlDeclaration("1.0", string.Empty, standalone == XmlStandalone.Yes ? "yes" : "no");  
                AddChild(node, write);
            }
        }

        internal override void WriteXmlDeclaration(string xmldecl) {
            VerifyState(Method.WriteXmlDeclaration);
            string version, encoding, standalone;
            XmlLoader.ParseXmlDeclarationValue(xmldecl, out version, out encoding, out standalone);
            XmlNode node = document.CreateXmlDeclaration(version, encoding, standalone);
            AddChild(node, write);
        }

        public override void WriteStartDocument() {
            VerifyState(Method.WriteStartDocument);
        }

        public override void WriteStartDocument(bool standalone) {
            VerifyState(Method.WriteStartDocument);
        }

        public override void WriteEndDocument() {
            VerifyState(Method.WriteEndDocument);
        }

        public override void WriteDocType(string name, string pubid, string sysid, string subset) {
            VerifyState(Method.WriteDocType);
            XmlNode node = document.CreateDocumentType(name, pubid, sysid, subset);
            AddChild(node, write); 
        }

        public override void WriteStartElement(string prefix, string localName, string ns) {
            VerifyState(Method.WriteStartElement);
            XmlNode node = document.CreateElement(prefix, localName, ns);
            AddChild(node, write);
            write = node; 
        }

        public override void WriteEndElement() {
            VerifyState(Method.WriteEndElement);
            if (write == null) {
                throw new InvalidOperationException();
            }
            write = write.ParentNode;
        }

        internal override void WriteEndElement(string prefix, string localName, string ns) {
            WriteEndElement();
        }

        public override void WriteFullEndElement() {
            VerifyState(Method.WriteFullEndElement);
            XmlElement elem = write as XmlElement;
            if (elem == null) {
                throw new InvalidOperationException();
            }
            elem.IsEmpty = false;
            write = elem.ParentNode;
        }

        internal override void WriteFullEndElement(string prefix, string localName, string ns) {
            WriteFullEndElement();
        }

        internal override void StartElementContent() {
            // nop
        }

        public override void WriteStartAttribute(string prefix, string localName, string ns) {
            VerifyState(Method.WriteStartAttribute);
            XmlAttribute attr = document.CreateAttribute(prefix, localName, ns);
            AddAttribute(attr, write);
            write = attr;
        }

        public override void WriteEndAttribute() {
            VerifyState(Method.WriteEndAttribute);
            XmlAttribute attr = write as XmlAttribute;
            if (attr == null) {
                throw new InvalidOperationException();
            }
            if (!attr.HasChildNodes) {
                XmlNode node = document.CreateTextNode(string.Empty); 
                AddChild(node, attr);
            }
            write = attr.OwnerElement;
        }

        internal override void WriteNamespaceDeclaration(string prefix, string ns) {
            this.WriteStartNamespaceDeclaration(prefix);
            this.WriteString(ns);
            this.WriteEndNamespaceDeclaration();
        }

        internal override bool SupportsNamespaceDeclarationInChunks {
            get {
                return true;
            }
        }

        internal override void WriteStartNamespaceDeclaration(string prefix) {
            VerifyState(Method.WriteStartNamespaceDeclaration);
            XmlAttribute attr;
            if (prefix.Length == 0) {
                attr = document.CreateAttribute(prefix, document.strXmlns, document.strReservedXmlns);
            }
            else {
                attr = document.CreateAttribute(document.strXmlns, prefix, document.strReservedXmlns);
            }
            AddAttribute(attr, write);
            write = attr;
        }

        internal override void WriteEndNamespaceDeclaration() {
            VerifyState(Method.WriteEndNamespaceDeclaration);
            XmlAttribute attr = write as XmlAttribute;
            if (attr == null) {
                throw new InvalidOperationException();
            }
            if (!attr.HasChildNodes) {
                XmlNode node = document.CreateTextNode(string.Empty);
                AddChild(node, attr);
            }
            write = attr.OwnerElement;
        }

        public override void WriteCData(string text) {
            VerifyState(Method.WriteCData);
            XmlConvert.VerifyCharData(text, ExceptionType.ArgumentException);
            XmlNode node = document.CreateCDataSection(text);
            AddChild(node, write);
        }

        public override void WriteComment(string text) {
            VerifyState(Method.WriteComment);
            XmlConvert.VerifyCharData(text, ExceptionType.ArgumentException);
            XmlNode node = document.CreateComment(text);
            AddChild(node, write);
        }

        public override void WriteProcessingInstruction(string name, string text) {
            VerifyState(Method.WriteProcessingInstruction);
            XmlConvert.VerifyCharData(text, ExceptionType.ArgumentException);
            XmlNode node = document.CreateProcessingInstruction(name, text);
            AddChild(node, write);
        }

        public override void WriteEntityRef(string name) {
            VerifyState(Method.WriteEntityRef);
            XmlNode node = document.CreateEntityReference(name);
            AddChild(node, write);
            // 
        }

        public override void WriteCharEntity(char ch) {
            WriteString(new string(ch, 1));
        }

        public override void WriteWhitespace(string text) {
            VerifyState(Method.WriteWhitespace);
            XmlConvert.VerifyCharData(text, ExceptionType.ArgumentException);
            if (document.PreserveWhitespace) {
                XmlNode node = document.CreateWhitespace(text);
                AddChild(node, write);
            }
        }

        public override void WriteString(string text) {
            VerifyState(Method.WriteString);
            XmlConvert.VerifyCharData(text, ExceptionType.ArgumentException);
            XmlNode node = document.CreateTextNode(text);
            AddChild(node, write);
        }

        public override void WriteSurrogateCharEntity(char lowCh, char highCh) {
            WriteString(new string(new char[] {highCh, lowCh}));
        }

        public override void WriteChars(char[] buffer, int index, int count) {
            WriteString(new string(buffer, index, count));
        }

        public override void WriteRaw(char[] buffer, int index, int count) {
            WriteString(new string(buffer, index, count));
        }

        public override void WriteRaw(string data) {
            WriteString(data);
        }

        public override void Close() {
            // nop
        }

        internal override void Close(WriteState currentState) {
            if (currentState == WriteState.Error) {
                return;
            }
            try {
                switch (type) {
                    case DocumentXmlWriterType.InsertSiblingAfter:
                        XmlNode parent = start.ParentNode;
                        if (parent == null) {
                            throw new InvalidOperationException(Res.GetString(Res.Xpn_MissingParent));
                        }
                        for (int i = fragment.Count - 1; i >= 0; i--) {
                            parent.InsertAfter(fragment[i], start);
                        }
                        break;
                    case DocumentXmlWriterType.InsertSiblingBefore:
                        parent = start.ParentNode;
                        if (parent == null) {
                            throw new InvalidOperationException(Res.GetString(Res.Xpn_MissingParent));
                        }
                        for (int i = 0; i < fragment.Count; i++) {
                            parent.InsertBefore(fragment[i], start);
                        }
                        break;
                    case DocumentXmlWriterType.PrependChild:
                        for (int i = fragment.Count - 1; i >= 0; i--) {
                            start.PrependChild(fragment[i]);
                        }
                        break;
                    case DocumentXmlWriterType.AppendChild:
                        for (int i = 0; i < fragment.Count; i++) {
                            start.AppendChild(fragment[i]);
                        }
                        break;
                    case DocumentXmlWriterType.AppendAttribute:
                        CloseWithAppendAttribute();
                        break;
                    case DocumentXmlWriterType.ReplaceToFollowingSibling:
                        if (fragment.Count == 0) {
                            throw new InvalidOperationException(Res.GetString(Res.Xpn_NoContent));
                        }
                        CloseWithReplaceToFollowingSibling();
                        break;
                }
            }
            finally {
                fragment.Clear();
            }
        }

        private void CloseWithAppendAttribute() {
            XmlElement elem = start as XmlElement;
            Debug.Assert(elem != null);
            XmlAttributeCollection attrs = elem.Attributes;
            for (int i = 0; i < fragment.Count; i++) {
                XmlAttribute attr = fragment[i] as XmlAttribute; 
                Debug.Assert(attr != null);
                int offset = attrs.FindNodeOffsetNS(attr);
                if (offset != -1
                    && ((XmlAttribute)attrs.nodes[offset]).Specified) {
                    throw new XmlException(Res.Xml_DupAttributeName, attr.Prefix.Length == 0 ? attr.LocalName : string.Concat(attr.Prefix, ":", attr.LocalName));
                }
            }
            for (int i = 0; i < fragment.Count; i++) {
                XmlAttribute attr = fragment[i] as XmlAttribute; 
                Debug.Assert(attr != null);
                attrs.Append(attr);
            }
        }

        private void CloseWithReplaceToFollowingSibling() {
            XmlNode parent = start.ParentNode;
            if (parent == null) {
                throw new InvalidOperationException(Res.GetString(Res.Xpn_MissingParent));
            }
            if (start != end) {
                if (!DocumentXPathNavigator.IsFollowingSibling(start, end)) {
                    throw new InvalidOperationException(Res.GetString(Res.Xpn_BadPosition));
                }
                if (start.IsReadOnly) {
                    throw new InvalidOperationException(Res.GetString(Res.Xdom_Node_Modify_ReadOnly));
                }
                DocumentXPathNavigator.DeleteToFollowingSibling(start.NextSibling, end);
            }
            XmlNode fragment0 = fragment[0];
            parent.ReplaceChild(fragment0, start);
            for (int i = fragment.Count - 1; i >= 1; i--) {
                parent.InsertAfter(fragment[i], fragment0);
            }
            navigator.ResetPosition(fragment0);
        }

        public override void Flush() {
            // nop
        }

        IDictionary<string,string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope) {
            return namespaceManager.GetNamespacesInScope(scope);
        }

        string IXmlNamespaceResolver.LookupNamespace(string prefix) {
            return namespaceManager.LookupNamespace(prefix);
        }

        string IXmlNamespaceResolver.LookupPrefix(string namespaceName) {
            return namespaceManager.LookupPrefix(namespaceName);
        }

        void AddAttribute(XmlAttribute attr, XmlNode parent) {
            if (parent == null) {
                fragment.Add(attr);
            }
            else {
                XmlElement elem = parent as XmlElement; 
                if (elem == null) {
                    throw new InvalidOperationException();
                }
                elem.Attributes.Append(attr);
            }
        }

        void AddChild(XmlNode node, XmlNode parent) {
            if (parent == null) {
                fragment.Add(node);
            }
            else {
                parent.AppendChild(node);
            }
        }

        State StartState() {
            XmlNodeType nodeType = XmlNodeType.None;

            switch (type) {
                case DocumentXmlWriterType.InsertSiblingAfter:
                case DocumentXmlWriterType.InsertSiblingBefore:
                    XmlNode parent = start.ParentNode;
                    if (parent != null) { 
                        nodeType = parent.NodeType; 
                    }
                    if (nodeType == XmlNodeType.Document) {
                        return State.Prolog;
                    }
                    else if (nodeType == XmlNodeType.DocumentFragment)  {
                        return State.Fragment;
                    }
                    break;
                case DocumentXmlWriterType.PrependChild:
                case DocumentXmlWriterType.AppendChild:
                    nodeType = start.NodeType; 
                    if (nodeType == XmlNodeType.Document) {
                        return State.Prolog;
                    }
                    else if (nodeType == XmlNodeType.DocumentFragment)  {
                        return State.Fragment;
                    }
                    break;
                case DocumentXmlWriterType.AppendAttribute:
                    return State.Attribute;
                case DocumentXmlWriterType.ReplaceToFollowingSibling:
                    break;
            }
            return State.Content;
        }

        static State[] changeState = {
//          State.Error,    State.Attribute,State.Prolog,   State.Fragment, State.Content,  

// Method.XmlDeclaration:
            State.Error,    State.Error,    State.Prolog,   State.Content,  State.Error,    
// Method.StartDocument:
            State.Error,    State.Error,    State.Error,    State.Error,    State.Error,    
// Method.EndDocument:
            State.Error,    State.Error,    State.Error,    State.Error,    State.Error,    
// Method.DocType:
            State.Error,    State.Error,    State.Prolog,   State.Error,    State.Error,    
// Method.StartElement:
            State.Error,    State.Error,    State.Content,  State.Content,  State.Content,  
// Method.EndElement:
            State.Error,    State.Error,    State.Error,    State.Error,    State.Content,  
// Method.FullEndElement:
            State.Error,    State.Error,    State.Error,    State.Error,    State.Content,  
// Method.StartAttribute:
            State.Error,    State.Content,  State.Error,    State.Error,    State.Content,  
// Method.EndAttribute:
            State.Error,    State.Error,    State.Error,    State.Error,    State.Content,  
// Method.StartNamespaceDeclaration:
            State.Error,    State.Content,  State.Error,    State.Error,    State.Content,  
// Method.EndNamespaceDeclaration:
            State.Error,    State.Error,    State.Error,    State.Error,    State.Content,  
// Method.CData:
            State.Error,    State.Error,    State.Error,    State.Content,  State.Content,  
// Method.Comment:
            State.Error,    State.Error,    State.Prolog,   State.Content,  State.Content,  
// Method.ProcessingInstruction:
            State.Error,    State.Error,    State.Prolog,   State.Content,  State.Content,  
// Method.EntityRef:
            State.Error,    State.Error,    State.Error,    State.Content,  State.Content,  
// Method.Whitespace:
            State.Error,    State.Error,    State.Prolog,   State.Content,  State.Content,  
// Method.String:
            State.Error,    State.Error,    State.Error,    State.Content,  State.Content,  
        };

        void VerifyState(Method method) {
            state = changeState[(int)method * (int)State.Last + (int)state]; 
            if (state == State.Error) {
                throw new InvalidOperationException(Res.GetString(Res.Xml_ClosedOrError));
            }
        }
    }
}