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

using System;
using System.IO;
using System.Text;
using System.Security;
#if !SILVERLIGHT
using System.Xml.Schema;
#endif
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Collections.Generic;
using System.Runtime.Versioning;

#if SILVERLIGHT
using BufferBuilder=System.Xml.BufferBuilder;
#else
using BufferBuilder = System.Text.StringBuilder;
#endif

namespace System.Xml {

    internal partial class XmlTextReaderImpl  {

//
// ParsingState
//
        // Parsing state (aka. scanner data) - holds parsing buffer and entity input data information
        private struct ParsingState {
            // character buffer
            internal char[] chars;
            internal int    charPos;
            internal int    charsUsed;
            internal Encoding encoding;
            internal bool   appendMode;
            
            // input stream & byte buffer
            internal Stream  stream;
            internal Decoder decoder;
            internal byte[]  bytes;
            internal int     bytePos;
            internal int     bytesUsed;

            // input text reader
            internal TextReader textReader;

            // current line number & position
            internal int   lineNo;
            internal int   lineStartPos;

            // base uri of the current entity
            internal string baseUriStr;
            internal Uri    baseUri;

            // eof flag of the entity
            internal bool   isEof;
            internal bool   isStreamEof;

            // entity type & id
            internal IDtdEntityInfo entity;
            internal int            entityId;

            // normalization
            internal bool   eolNormalized;

#if !SILVERLIGHT // Needed only for XmlTextReader (reporting of entities)
            // EndEntity reporting
            internal bool   entityResolvedManually;
#endif

            internal void Clear() {
                chars = null;
                charPos = 0;
                charsUsed = 0;
                encoding = null;
                stream = null;
                decoder = null;
                bytes = null;
                bytePos = 0;
                bytesUsed = 0;
                textReader = null;
                lineNo = 1;
                lineStartPos = -1;
                baseUriStr = string.Empty;
                baseUri = null;
                isEof = false;
                isStreamEof = false;
                eolNormalized = true;
#if !SILVERLIGHT // Needed only for XmlTextReader (reporting of entities)
                entityResolvedManually = false;
#endif
            }

            internal void Close( bool closeInput ) {
                if ( closeInput ) {
                    if ( stream != null ) {
                        stream.Close();
                    }
                    else if ( textReader != null ) {
                        textReader.Close();
                    }
                }
            }

            internal int LineNo {
                get {
                    return lineNo;
                }
            }

            internal int LinePos {
                get {
                    return charPos - lineStartPos;
                }
            }
        }

//
// XmlContext
//
        private class XmlContext  {
            internal XmlSpace xmlSpace;
            internal string xmlLang;
            internal string defaultNamespace;
            internal XmlContext previousContext;

            internal XmlContext() {
                xmlSpace = XmlSpace.None;
                xmlLang = string.Empty;
                defaultNamespace = string.Empty;
                previousContext = null;
            }

            internal XmlContext( XmlContext previousContext ) {
                this.xmlSpace = previousContext.xmlSpace;
                this.xmlLang = previousContext.xmlLang;
                this.defaultNamespace = previousContext.defaultNamespace;
                this.previousContext = previousContext;
            }
        }

#if !SILVERLIGHT // Needed only for XmlTextReader
//
// NoNamespaceManager
//
        private class NoNamespaceManager : XmlNamespaceManager {    
            public NoNamespaceManager() : base () {}
            public override string DefaultNamespace { get { return string.Empty; } }
            public override void PushScope() {}
            public override bool PopScope() { return false; }
            public override void AddNamespace( string prefix, string uri ) {}
            public override void RemoveNamespace( string prefix, string uri ) {}
            public override IEnumerator GetEnumerator() { return null; }
            public override IDictionary<string,string> GetNamespacesInScope( XmlNamespaceScope scope ) { return null; }
            public override string LookupNamespace( string prefix ) { return string.Empty; }
            public override string LookupPrefix( string uri ) { return null; }
            public override bool HasNamespace( string prefix ) { return false; }
        }
#endif

//
// DtdParserProxy: IDtdParserAdapter proxy for XmlTextReaderImpl
//
#if SILVERLIGHT
        internal partial class DtdParserProxy : IDtdParserAdapter {
#else
        internal partial class DtdParserProxy : IDtdParserAdapterV1 {
#endif

            // Fields
            private XmlTextReaderImpl reader;

        // Constructors
            internal DtdParserProxy( XmlTextReaderImpl reader ) {
                this.reader = reader;
            }

        // IDtdParserAdapter proxies
            XmlNameTable IDtdParserAdapter.NameTable { 
                get { return reader.DtdParserProxy_NameTable; } 
            }

            IXmlNamespaceResolver IDtdParserAdapter.NamespaceResolver {
                get { return reader.DtdParserProxy_NamespaceResolver; }
            }
            
            Uri IDtdParserAdapter.BaseUri {
                // SxS: DtdParserProxy_BaseUri property on the reader may expose machine scope resources. This property
                // is just returning the value of the other property, so it may expose machine scope resource as well.
#if !SILVERLIGHT
                [ResourceConsumption(ResourceScope.Machine)]
                [ResourceExposure(ResourceScope.Machine)]
#endif
                get { return reader.DtdParserProxy_BaseUri; } 
            }
            
            bool IDtdParserAdapter.IsEof { 
                get { return reader.DtdParserProxy_IsEof; } 
            }
            
            char[] IDtdParserAdapter.ParsingBuffer { 
                get { return reader.DtdParserProxy_ParsingBuffer; } 
            }
            
            int IDtdParserAdapter.ParsingBufferLength { 
                get { return reader.DtdParserProxy_ParsingBufferLength; } 
            }
            
            int IDtdParserAdapter.CurrentPosition { 
                get { return reader.DtdParserProxy_CurrentPosition; } 
                set { reader.DtdParserProxy_CurrentPosition = value; } 
            }

            int IDtdParserAdapter.EntityStackLength { 
                get { return reader.DtdParserProxy_EntityStackLength; } 
            }
            
            bool IDtdParserAdapter.IsEntityEolNormalized { 
                get { return reader.DtdParserProxy_IsEntityEolNormalized; } 
            }
            
            void IDtdParserAdapter.OnNewLine( int pos ) { 
                reader.DtdParserProxy_OnNewLine( pos ); 
            }
            
            int IDtdParserAdapter.LineNo { 
                get { return reader.DtdParserProxy_LineNo; } 
            }
            
            int IDtdParserAdapter.LineStartPosition { 
                get { return reader.DtdParserProxy_LineStartPosition; } 
            }

			 int  IDtdParserAdapter.ReadData() { 
                return reader.DtdParserProxy_ReadData(); 
            }

             int  IDtdParserAdapter.ParseNumericCharRef( BufferBuilder internalSubsetBuilder ) { 
                return reader.DtdParserProxy_ParseNumericCharRef( internalSubsetBuilder ); 
            }
            
             int  IDtdParserAdapter.ParseNamedCharRef( bool expand, BufferBuilder internalSubsetBuilder ) { 
                return reader.DtdParserProxy_ParseNamedCharRef( expand, internalSubsetBuilder ); 
            }
            
            void IDtdParserAdapter.ParsePI( BufferBuilder sb ) { 
                reader.DtdParserProxy_ParsePI( sb ); 
            }
            
            void IDtdParserAdapter.ParseComment( BufferBuilder sb ) { 
                reader.DtdParserProxy_ParseComment( sb ); 
            }
            
             bool  IDtdParserAdapter.PushEntity( IDtdEntityInfo entity, out int entityId ) { 

                return reader.DtdParserProxy_PushEntity( entity, out entityId ); 

            }

			bool IDtdParserAdapter.PopEntity( out IDtdEntityInfo oldEntity, out int newEntityId ) { 
                return reader.DtdParserProxy_PopEntity( out oldEntity, out newEntityId ); 
            }

             bool  IDtdParserAdapter.PushExternalSubset( string systemId, string publicId ) { 
                return reader.DtdParserProxy_PushExternalSubset( systemId, publicId ); 
            }

			void IDtdParserAdapter.PushInternalDtd( string baseUri, string internalDtd ) {
                Debug.Assert(internalDtd != null);
                reader.DtdParserProxy_PushInternalDtd( baseUri, internalDtd ); 
            }

            void IDtdParserAdapter.Throw( Exception e ) { 
                reader.DtdParserProxy_Throw( e ); 
            }
            
            void IDtdParserAdapter.OnSystemId( string systemId, LineInfo keywordLineInfo, LineInfo systemLiteralLineInfo ) { 
                reader.DtdParserProxy_OnSystemId( systemId, keywordLineInfo, systemLiteralLineInfo ); 
            }

            void IDtdParserAdapter.OnPublicId( string publicId, LineInfo keywordLineInfo, LineInfo publicLiteralLineInfo ) { 
                reader.DtdParserProxy_OnPublicId( publicId, keywordLineInfo, publicLiteralLineInfo ); 
            }

#if !SILVERLIGHT
            bool IDtdParserAdapterWithValidation.DtdValidation { 
                get { return reader.DtdParserProxy_DtdValidation; } 
            }

            IValidationEventHandling IDtdParserAdapterWithValidation.ValidationEventHandling {
                get { return reader.DtdParserProxy_ValidationEventHandling; }
            }

            bool IDtdParserAdapterV1.Normalization { 
                get { return reader.DtdParserProxy_Normalization; } 
            }

            bool IDtdParserAdapterV1.Namespaces { 
                get { return reader.DtdParserProxy_Namespaces; } 
            }

            bool IDtdParserAdapterV1.V1CompatibilityMode { 
                get { return reader.DtdParserProxy_V1CompatibilityMode; } 
            }
#endif

        }

//
// NodeData
//
        private class NodeData : IComparable  {
            // static instance with no data - is used when XmlTextReader is closed
            static volatile NodeData s_None;

            // NOTE: Do not use this property for reference comparison. It may not be unique.
            internal static NodeData None {
                get {
                    if ( s_None == null ) {
                        // no locking; s_None is immutable so it's not a problem that it may get initialized more than once
                        s_None = new NodeData();
                    }
                    return s_None;
                }
            }

            // type
            internal XmlNodeType type;

            // name
            internal string localName;
            internal string prefix;
            internal string ns;
            internal string nameWPrefix;

            // value:
            // value == null -> the value is kept in the 'chars' buffer starting at valueStartPos and valueLength long
            string value;          
            char[] chars;
            int    valueStartPos;   
            int    valueLength;
            
            // main line info
            internal LineInfo   lineInfo;

            // second line info
            internal LineInfo   lineInfo2;

            // quote char for attributes
            internal char   quoteChar;

            // depth
            internal int    depth;

            // empty element / default attribute
            bool   isEmptyOrDefault;

            // entity id
            internal int    entityId;

            // helper members
            internal bool   xmlContextPushed;

#if !SILVERLIGHT // Needed only for XmlTextReader (reporting of entities)
            // attribute value chunks
            internal NodeData nextAttrValueChunk;
#endif

            // type info
            internal object schemaType;
            internal object typedValue;

            internal NodeData() {
                Clear( XmlNodeType.None );
                xmlContextPushed = false;
            }

            internal int LineNo { 
                get { 
                    return lineInfo.lineNo;
                }
            }

            internal int LinePos { 
                get { 
                    return lineInfo.linePos;
                }
            }

            internal bool IsEmptyElement {
                get {
                    return type == XmlNodeType.Element && isEmptyOrDefault;
                }
                set {
                    Debug.Assert( type == XmlNodeType.Element );
                    isEmptyOrDefault = value;
                }
            }

            internal bool IsDefaultAttribute {
                get {
                    return type == XmlNodeType.Attribute && isEmptyOrDefault;
                }
                set {
                    Debug.Assert( type == XmlNodeType.Attribute );
                    isEmptyOrDefault = value;
                }
            }

            internal bool ValueBuffered {
                get { 
                    return value == null;
                }
            }

            internal string StringValue {
                get {
                    Debug.Assert( valueStartPos >= 0 || this.value != null, "Value not ready." );

                    if ( this.value == null ) {
                        this.value = new string( chars, valueStartPos, valueLength );
                    }
                    return this.value;
                }
            }

            internal void TrimSpacesInValue() {
                if ( ValueBuffered ) {
                    XmlTextReaderImpl.StripSpaces( chars, valueStartPos, ref valueLength );
                }
                else {
                    value = XmlTextReaderImpl.StripSpaces(value);
                }
            }

            internal void Clear( XmlNodeType type ) {
                this.type = type;
                ClearName();
                value = string.Empty;  
                valueStartPos = -1;
                nameWPrefix = string.Empty;
                schemaType = null;
                typedValue = null;
            }

            internal void ClearName() {
                localName = string.Empty;
                prefix = string.Empty;
                ns = string.Empty;
                nameWPrefix = string.Empty;
            }

            internal void SetLineInfo( int lineNo, int linePos ) {
                lineInfo.Set( lineNo, linePos );
            }

            internal void SetLineInfo2( int lineNo, int linePos ) {
                lineInfo2.Set( lineNo, linePos );
            }

            internal void SetValueNode( XmlNodeType type, string value ) {
                Debug.Assert( value != null );

                this.type = type;
                ClearName();
                this.value = value;
                this.valueStartPos = -1;
            }

            internal void SetValueNode( XmlNodeType type, char[] chars, int startPos, int len ) {
                this.type = type;
                ClearName();
                
                this.value = null;
                this.chars = chars;
                this.valueStartPos = startPos;
                this.valueLength = len;
            }

            internal void SetNamedNode( XmlNodeType type, string localName ) {
                SetNamedNode( type, localName, string.Empty, localName );
            }

            internal void SetNamedNode( XmlNodeType type, string localName, string prefix, string nameWPrefix ) {
                Debug.Assert( localName != null );
                Debug.Assert( localName.Length > 0 );

                this.type = type;
                this.localName = localName;
                this.prefix = prefix;
                this.nameWPrefix = nameWPrefix;
                this.ns = string.Empty;
                this.value = string.Empty;
                this.valueStartPos = -1;
            }

            internal void SetValue( string value ) {
                this.valueStartPos = -1;
                this.value = value;
            }

            internal void SetValue( char[] chars, int startPos, int len ) {
                this.value = null;
                this.chars = chars;
                this.valueStartPos = startPos;
                this.valueLength = len;
            }

            internal void OnBufferInvalidated() {
                if ( this.value == null ) {
                    Debug.Assert( valueStartPos != -1 );
                    Debug.Assert( chars != null );
                    this.value = new string( chars, valueStartPos, valueLength );
                }
                valueStartPos = -1;
            }

            internal void CopyTo( int valueOffset, BufferBuilder sb ) {
                if ( value == null ) {
                    Debug.Assert( valueStartPos != -1 );
                    Debug.Assert( chars != null );
                    sb.Append( chars, valueStartPos + valueOffset, valueLength - valueOffset );
                }
                else {
                    if ( valueOffset <= 0 ) {
                        sb.Append( value );
                    }
                    else {
                        sb.Append( value, valueOffset, value.Length - valueOffset );
                    }
                }
            }

            internal int CopyTo( int valueOffset, char[] buffer, int offset, int length ) {
                if ( value == null ) {
                    Debug.Assert( valueStartPos != -1 );
                    Debug.Assert( chars != null );
                    int copyCount = valueLength - valueOffset;
                    if ( copyCount > length ) {
                        copyCount = length;
                    }
                    XmlTextReaderImpl.BlockCopyChars( chars, valueStartPos + valueOffset, buffer, offset, copyCount );
                    return copyCount;
                }
                else {
                    int copyCount = value.Length - valueOffset;
                    if ( copyCount > length ) {
                        copyCount = length;
                    }
                    value.CopyTo( valueOffset, buffer, offset, copyCount );
                    return copyCount;
                }
            }

            internal int CopyToBinary( IncrementalReadDecoder decoder, int valueOffset ) {
                if ( value == null ) {
                    Debug.Assert( valueStartPos != -1 );
                    Debug.Assert( chars != null );
                    return decoder.Decode( chars, valueStartPos + valueOffset, valueLength - valueOffset );
                }
                else {
                    return decoder.Decode( value, valueOffset, value.Length - valueOffset );
                }
            }

            internal void AdjustLineInfo( int valueOffset, bool isNormalized, ref LineInfo lineInfo ) {
                if ( valueOffset == 0 ) {
                    return;
                }
                if ( valueStartPos != -1 ) {
                    XmlTextReaderImpl.AdjustLineInfo( chars, valueStartPos, valueStartPos + valueOffset, isNormalized, ref lineInfo );
                }
                else {
                    XmlTextReaderImpl.AdjustLineInfo( value, 0, valueOffset, isNormalized, ref lineInfo );
                }
            }

            // This should be inlined by JIT compiler
            internal string GetNameWPrefix( XmlNameTable nt ) { 
                if ( nameWPrefix != null ) {
                    return nameWPrefix;
                }
                else {
                    return CreateNameWPrefix( nt );
                }
            }

            internal string CreateNameWPrefix( XmlNameTable nt ) { 
                Debug.Assert( nameWPrefix == null );
                if ( prefix.Length == 0 ) {
                    nameWPrefix = localName;
                }
                else {
                    nameWPrefix = nt.Add( string.Concat( prefix, ":", localName ) );
                }
                return nameWPrefix;
            }

            int IComparable.CompareTo( object obj ) {
                NodeData other = obj as NodeData;
                if ( other != null ) {
                    if ( Ref.Equal( localName, other.localName ) ) {
                        if ( Ref.Equal( ns, other.ns ) ) {
                            return 0;
                        }
                        else {
                            return string.CompareOrdinal( ns, other.ns );
                        }
                    }
                    else {
                        return string.CompareOrdinal( localName, other.localName );
                    }
                }
                else {
                    Debug.Assert( false, "We should never get to this point." );
                    // 'other' is null, 'this' is not null. Always return 1, like "".CompareTo(null).
                    return 1;
                }
            }
        }

        // 
        // DtdDefaultAttributeInfoToNodeDataComparer
        // 
        // Compares IDtdDefaultAttributeInfo to NodeData
        private class DtdDefaultAttributeInfoToNodeDataComparer : IComparer<object> {
            private static IComparer<object> s_instance = new DtdDefaultAttributeInfoToNodeDataComparer();

            internal static IComparer<object> Instance {
                get { return s_instance; }
            }

            public int Compare(object x, object y) {
                Debug.Assert(x == null || x is NodeData || x is IDtdDefaultAttributeInfo);
                Debug.Assert(y == null || y is NodeData || y is IDtdDefaultAttributeInfo);

                string localName, localName2;
                string prefix, prefix2;

                if (x == null) {
                    return y == null ? 0 : -1;
                }
                else if (y == null) {
                    return 1;
                }

                NodeData nodeData = x as NodeData;
                if (nodeData != null) {
                    localName = nodeData.localName;
                    prefix = nodeData.prefix;
                }
                else {
                    IDtdDefaultAttributeInfo attrDef = x as IDtdDefaultAttributeInfo;
                    if (attrDef != null) {
                        localName = attrDef.LocalName;
                        prefix = attrDef.Prefix;
                    }
                    else {
                        throw new XmlException(Res.Xml_DefaultException, string.Empty);
                    }
                }

                nodeData = y as NodeData;
                if (nodeData != null) {
                    localName2 = nodeData.localName;
                    prefix2 = nodeData.prefix;
                }
                else {
                    IDtdDefaultAttributeInfo attrDef = y as IDtdDefaultAttributeInfo;
                    if (attrDef != null) {
                        localName2 = attrDef.LocalName;
                        prefix2 = attrDef.Prefix;
                    }
                    else {
                        throw new XmlException(Res.Xml_DefaultException, string.Empty);
                    }
                }

                // string.Compare does reference euqality first for us, so we don't have to do it here
                int result = string.Compare(localName, localName2, StringComparison.Ordinal);
                if (result != 0) {
                    return result;
                }

                return string.Compare(prefix, prefix2, StringComparison.Ordinal);
            }
        }

#if !SILVERLIGHT
//
// OnDefaultAttributeUse delegate
//
        internal delegate void OnDefaultAttributeUseDelegate(IDtdDefaultAttributeInfo defaultAttribute, XmlTextReaderImpl coreReader);
#endif

    }
}