//------------------------------------------------------------------------------
// <copyright file="DataPointer.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>                                                                
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------
#pragma warning disable 618 // ignore obsolete warning about XmlDataDocument
namespace System.Xml {
    using System;
    using System.Data;
    using System.Diagnostics;
    
    internal sealed class DataPointer : IXmlDataVirtualNode {
        private XmlDataDocument doc;
        private XmlNode node;
        private DataColumn column;
        private bool fOnValue;
        private bool bNeedFoliate = false;
        private bool _isInUse;

        internal DataPointer( XmlDataDocument doc, XmlNode node ) {
            this.doc = doc;
            this.node = node;
            this.column = null;
            this.fOnValue = false;
            bNeedFoliate = false;
            this._isInUse = true;
            AssertValid();
        }

        internal DataPointer( DataPointer pointer ) {
            this.doc = pointer.doc;
            this.node = pointer.node;
            this.column = pointer.column;
            this.fOnValue = pointer.fOnValue;
            this.bNeedFoliate = false;
            this._isInUse = true;
            AssertValid();
        }

        internal void AddPointer() {
            this.doc.AddPointer( (IXmlDataVirtualNode)this );
        }

        // Returns the row element of the region that the pointer points into
        private XmlBoundElement GetRowElement() {
            //AssertValid();

            XmlBoundElement rowElem;
            if ( this.column != null ) {
                rowElem = this.node as XmlBoundElement;
                Debug.Assert( rowElem != null );
                Debug.Assert( rowElem.Row != null );
                return rowElem;
            }

            doc.Mapper.GetRegion( this.node, out rowElem );
            return rowElem;
        }

        private DataRow Row {
            get { 
                //AssertValid();
                XmlBoundElement rowElem = GetRowElement();
                if ( rowElem == null )
                    return null;

                Debug.Assert( rowElem.Row != null );
                return rowElem.Row;
            }
        }

        private static bool IsFoliated( XmlNode node ) {
            if (node != null && node is XmlBoundElement)
                return((XmlBoundElement)node).IsFoliated;
            return true;
        }
        
        internal void MoveTo( DataPointer pointer ) {
            AssertValid();
            // You should not move outside of this document
            Debug.Assert( node == this.doc || node.OwnerDocument == this.doc );

            this.doc = pointer.doc;
            this.node = pointer.node;
            this.column = pointer.column;
            this.fOnValue = pointer.fOnValue;
            AssertValid();
        }
        private void MoveTo( XmlNode node ) {
            //AssertValid();
            // You should not move outside of this document
            Debug.Assert( node == this.doc || node.OwnerDocument == this.doc );

            this.node = node;
            this.column = null;
            this.fOnValue = false;
            AssertValid();
        }
        
        private void MoveTo( XmlNode node, DataColumn column, bool fOnValue ) {
            //AssertValid();
            // You should not move outside of this document
            Debug.Assert( node == this.doc || node.OwnerDocument == this.doc );

            this.node = node;
            this.column = column;
            this.fOnValue = fOnValue;
            AssertValid();
        }

        private DataColumn NextColumn( DataRow row, DataColumn col, bool fAttribute, bool fNulls ) {
            if (row.RowState == DataRowState.Deleted)
                return null;

            DataTable table = row.Table;
            DataColumnCollection columns = table.Columns;
            int iColumn = (col != null) ? col.Ordinal + 1 : 0;
            int cColumns = columns.Count;
            DataRowVersion rowVersion = ( row.RowState == DataRowState.Detached ) ? DataRowVersion.Proposed : DataRowVersion.Current;

            for (; iColumn < cColumns; iColumn++) {
                DataColumn c = columns[iColumn];
                if (!doc.IsNotMapped( c ) && (c.ColumnMapping == MappingType.Attribute) == fAttribute && (fNulls || ! Convert.IsDBNull( row[c, rowVersion] ) ) )
                    return c;
            }

            return null;
        }

        private DataColumn NthColumn( DataRow row, bool fAttribute, int iColumn, bool fNulls ) {
            DataColumn c = null;
            while ((c = NextColumn( row, c, fAttribute, fNulls )) != null) {
                if (iColumn == 0)
                    return c;

                iColumn = checked((int)iColumn-1);
            }
            return null;
        }

        private int ColumnCount( DataRow row, bool fAttribute, bool fNulls ) {
            DataColumn c = null;
            int count = 0;
            while ((c = NextColumn( row, c, fAttribute, fNulls )) != null) {
                count++;
            }
            return count;
        }

        internal bool MoveToFirstChild() {
            RealFoliate();
            AssertValid();
            if (node == null)
                return false;

            if (column != null) {
                if (fOnValue)
                    return false;

                fOnValue = true;
                return true;
            }
            else if (!IsFoliated( node )) {
                // find virtual column elements first
                DataColumn c = NextColumn( Row, null, false, false );
                if (c != null) {
                    MoveTo( node, c, doc.IsTextOnly(c) );
                    return true;
                }
            }

            // look for anything
            XmlNode n = doc.SafeFirstChild( node );
            if (n != null) {
                MoveTo(n);
                return true;
            }

            return false;
        }

        internal bool MoveToNextSibling() {
            RealFoliate();
            AssertValid();
            if (node != null) {
                if (column != null) {
                    if (fOnValue && !doc.IsTextOnly(column))
                        return false;

                    DataColumn c = NextColumn( Row, column, false, false );
                    if (c != null) {
                        MoveTo( this.node, c, false );
                        return true;
                    }

                    XmlNode n = doc.SafeFirstChild( node );
                    if (n != null) {
                        MoveTo( n );
                        return true;
                    }
                }
                else {
                    XmlNode n = doc.SafeNextSibling( node );
                    if (n != null) {
                        MoveTo(n);
                        return true;
                    }
                }
            }

            return false;
        }

        internal bool MoveToParent() {
            RealFoliate();
            AssertValid();
            if (node != null) {
                if (column != null) {
                    if (fOnValue && !doc.IsTextOnly(column)) {
                        MoveTo( node, column, false );
                        return true;
                    }

                    if (column.ColumnMapping != MappingType.Attribute) {
                        MoveTo( node, null, false );
                        return true;
                    }
                }
                else {
                    XmlNode n = node.ParentNode;
                    if (n != null) {
                        MoveTo(n);
                        return true;
                    }
                }
            }
            return false;
        }

        internal bool MoveToOwnerElement() {
            RealFoliate();
            AssertValid();
            if (node != null) {
                if (column != null) {
                    if (fOnValue || doc.IsTextOnly(column) || column.ColumnMapping != MappingType.Attribute)
                        return false;

                    MoveTo( node, null, false );
                    return true;
                }
                else if (node.NodeType == XmlNodeType.Attribute) {
                    XmlNode n = ((XmlAttribute)node).OwnerElement;
                    if (n != null) {
                        MoveTo( n, null, false );
                        return true;
                    }
                }
            }

            return false;
        }


        internal int AttributeCount {
            get {
                RealFoliate();
                AssertValid();
                if (node != null) {
                    if (column == null && node.NodeType == XmlNodeType.Element) {
                        if (!IsFoliated( node )) {
                            return ColumnCount( Row, true, false );
                        }
                        else 
                            return node.Attributes.Count;
                    }
                }
                return 0;
            }            
        }

        internal bool MoveToAttribute( int i ) {
            RealFoliate();
            AssertValid();
            if ( i < 0 ) 
                return false;
            if (node != null) {
                if ((column == null || column.ColumnMapping == MappingType.Attribute) && node.NodeType == XmlNodeType.Element) {
                    if (!IsFoliated( node )) {
                        DataColumn c = NthColumn( Row, true, i, false );
                        if (c != null) {
                            MoveTo( node, c, false );
                            return true;
                        }
                    }
                    else {
                        XmlNode n = node.Attributes.Item(i);
                        if (n != null) {
                            MoveTo( n, null, false );
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        internal XmlNodeType NodeType { 
            get {
                RealFoliate();
                AssertValid();
                if (this.node == null) {
                    return XmlNodeType.None;
                }
                else if (this.column == null) {
                    return this.node.NodeType; 
                }
                else if (this.fOnValue) {
                    return XmlNodeType.Text;
                }
                else if (this.column.ColumnMapping == MappingType.Attribute) {
                    return XmlNodeType.Attribute;
                }
                else {
                    return XmlNodeType.Element;
                }
            }
        }

        internal string LocalName { 
            get {
                RealFoliate();
                AssertValid();
                if (this.node == null) {
                    return string.Empty;
                }else if (this.column == null) {
                    String name = node.LocalName;
                    Debug.Assert( name != null );
                    if ( IsLocalNameEmpty( this.node.NodeType ) )
                        return String.Empty;
                    return name;
                }
                else if (this.fOnValue) {
                    return String.Empty;
                }
                else {
                    return doc.NameTable.Add(column.EncodedColumnName);
                }
            }
        }

        internal string NamespaceURI { 
            get {
                RealFoliate();
                AssertValid();
                if (this.node == null) {
                    return string.Empty;
                }
                else if (this.column == null) {
                    return node.NamespaceURI; 
                }
                else if (this.fOnValue) {
                    return string.Empty;
                }
                else {
                    return doc.NameTable.Add(column.Namespace);
                }
            }
        }
        
        internal string Name { 
            get {
                RealFoliate();
                AssertValid();
                if (this.node == null) {
                    return string.Empty;
                }
                else if (this.column == null) {
                    String name = node.Name;
                    //Again it could be String.Empty at null position
                    Debug.Assert( name != null );
                    if ( IsLocalNameEmpty( this.node.NodeType ) )
                        return String.Empty;
                    return name;
                }
                else {
                    string prefix = Prefix;
                    string lname = LocalName;
                    if (prefix != null && prefix.Length > 0) {
                        if (lname != null && lname.Length > 0) {
                            return doc.NameTable.Add( prefix + ":" + lname );
                        }
                        else {
                            return prefix;
                        }
                    }
                    else {
                        return lname;
                    }
                }
            }
        }
        

        private bool IsLocalNameEmpty ( XmlNodeType nt) {
                switch ( nt ) {
                    case XmlNodeType.None : 
                    case XmlNodeType.Text :  
                    case XmlNodeType.CDATA : 
                    case XmlNodeType.Comment :
                    case XmlNodeType.Document :
                    case XmlNodeType.DocumentFragment : 
                    case XmlNodeType.Whitespace : 
                    case XmlNodeType.SignificantWhitespace :
                    case XmlNodeType.EndElement : 
                    case XmlNodeType.EndEntity :
                        return true;                         
                    case XmlNodeType.Element :
                    case XmlNodeType.Attribute : 
                    case XmlNodeType.EntityReference :
                    case XmlNodeType.Entity : 
                    case XmlNodeType.ProcessingInstruction :  
                    case XmlNodeType.DocumentType :     
                    case XmlNodeType.Notation :
                    case XmlNodeType.XmlDeclaration :
                        return false;                        
                    default :
                        return true;                        
                }                
            }

        internal string Prefix { 
            get {
                RealFoliate();
                AssertValid();
                if (this.node == null) {
                    return string.Empty;
                }
                else if (this.column == null) {
                    return node.Prefix; 
                }
                else {
                    return string.Empty;
                }
            }
        }

        internal string Value { 
            get {
                RealFoliate();
                AssertValid();
                if (this.node == null) {
                    return null;
                }
                else if (this.column == null) {
                    return this.node.Value;
                }
                else if (this.column.ColumnMapping == MappingType.Attribute || this.fOnValue) {
                    DataRow row = this.Row;
                    DataRowVersion rowVersion = ( row.RowState == DataRowState.Detached ) ? DataRowVersion.Proposed : DataRowVersion.Current;
                    object value = row[ this.column, rowVersion ];
                    if ( ! Convert.IsDBNull( value ) )
                        return this.column.ConvertObjectToXml( value );
                    return null;
                }
                else {
                    // column element has no value
                    return null;
                }
            }
        }

        bool IXmlDataVirtualNode.IsOnNode( XmlNode nodeToCheck ) {
            RealFoliate();
            return nodeToCheck == this.node;
        }
        
        bool IXmlDataVirtualNode.IsOnColumn( DataColumn col ) {
            RealFoliate();
            return col == this.column;
        }
        
        internal XmlNode GetNode() {
            return this.node;
        }
        
        internal bool IsEmptyElement { 
            get {
                RealFoliate();
                AssertValid();
                if (node != null && column == null) {
                    // 
                    if (node.NodeType == XmlNodeType.Element) {
                        return((XmlElement)node).IsEmpty;
                    }
                }
                return false;
            }
        }

        internal bool IsDefault { 
            get {
                RealFoliate();
                AssertValid();
                if (node != null && column == null && node.NodeType == XmlNodeType.Attribute) {
                    return !((XmlAttribute)node).Specified;
                }

                return false;
            }
        }

        void IXmlDataVirtualNode.OnFoliated( XmlNode foliatedNode ) {
            // update the pointer if the element node has been foliated
            if (node == foliatedNode) {
                // if already on this node, nothing to do!
                if (column == null)
                    return;
                bNeedFoliate = true;
            }
        }

        internal void RealFoliate() {
            if ( !bNeedFoliate )
                return;

            XmlNode n = null;

            if (doc.IsTextOnly( column )) {
                n = node.FirstChild;
            }
            else {
                if (column.ColumnMapping == MappingType.Attribute) {
                    n = node.Attributes.GetNamedItem( column.EncodedColumnName, column.Namespace );
                }
                else {
                    for (n = node.FirstChild; n != null; n = n.NextSibling) {
                        if (n.LocalName == column.EncodedColumnName && n.NamespaceURI == column.Namespace)
                            break;
                    }
                }

                if (n != null && fOnValue)
                    n = n.FirstChild;
            }

            if (n == null)
                throw new InvalidOperationException(Res.GetString(Res.DataDom_Foliation));

            // Cannot use MoveTo( n ); b/c the initial state for MoveTo is invalid (region is foliated but this is not)
            this.node = n;
            this.column = null;
            this.fOnValue = false;
            AssertValid();
            
            bNeedFoliate = false;
        }

        //for the 6 properties below, only when the this.column == null that the nodetype could be XmlDeclaration node
        internal String PublicId {
            get {
                XmlNodeType nt = NodeType;
                switch ( nt ) {
                    case XmlNodeType.DocumentType : {
                        Debug.Assert( this.column == null );
                        return ( ( XmlDocumentType ) (this.node)).PublicId;
                    }
                    case XmlNodeType.Entity : {
                        Debug.Assert( this.column == null );
                        return ( ( XmlEntity ) (this.node)).PublicId;
                    }
                    case XmlNodeType.Notation : {
                        Debug.Assert( this.column == null );
                        return ( ( XmlNotation ) (this.node)).PublicId;
                    }
                }
                return null;
            }
        }

        internal String SystemId {
            get {
                XmlNodeType nt = NodeType;
                switch ( nt ) {
                    case XmlNodeType.DocumentType : {
                        Debug.Assert( this.column == null );
                        return ( ( XmlDocumentType ) (this.node)).SystemId;
                    }
                    case XmlNodeType.Entity : {
                        Debug.Assert( this.column == null );
                        return ( ( XmlEntity ) (this.node)).SystemId;
                    }
                    case XmlNodeType.Notation : {
                        Debug.Assert( this.column == null );
                        return ( ( XmlNotation ) (this.node)).SystemId;
                    }
                }
                return null;
            }
        }

        internal String InternalSubset {
            get {
                if ( NodeType == XmlNodeType.DocumentType ) {
                    Debug.Assert( this.column == null );
                    return ( ( XmlDocumentType ) (this.node)).InternalSubset;
                }
                return null;
            }
        }

        internal XmlDeclaration Declaration {
            get {
                XmlNode child = doc.SafeFirstChild(doc);
                if ( child != null && child.NodeType == XmlNodeType.XmlDeclaration )
                    return (XmlDeclaration)child;
                return null;
            }
        }
        
        internal String Encoding {
            get {
                if ( NodeType == XmlNodeType.XmlDeclaration ) {
                    Debug.Assert( this.column == null );
                    return ( ( XmlDeclaration ) (this.node)).Encoding;
                } else if ( NodeType == XmlNodeType.Document ) {
                    XmlDeclaration dec = Declaration;
                    if ( dec != null )
                        return dec.Encoding;
                }
                return null;
            }
        }
        
        internal String Standalone {
            get {
                if ( NodeType == XmlNodeType.XmlDeclaration ) {
                    Debug.Assert( this.column == null );
                    return ( ( XmlDeclaration ) (this.node)).Standalone;
                } else if ( NodeType == XmlNodeType.Document ) {
                    XmlDeclaration dec = Declaration;
                    if ( dec != null )
                        return dec.Standalone;
                }
                return null;
            }
        }

        internal String Version {
            get {
                if ( NodeType == XmlNodeType.XmlDeclaration ) {
                    Debug.Assert( this.column == null );
                    return ( ( XmlDeclaration ) (this.node)).Version;
                } else if ( NodeType == XmlNodeType.Document ) {
                    XmlDeclaration dec = Declaration;
                    if ( dec != null )
                        return dec.Version;
                }
                return null;
            }
        }

        [System.Diagnostics.Conditional("DEBUG")]
        private void AssertValid() {
            // This pointer must be int the document list
            if ( this.column != null ) {
                // We must be on a de-foliated region
                XmlBoundElement rowElem = this.node as XmlBoundElement;
                Debug.Assert( rowElem != null );

                DataRow row = rowElem.Row;
                Debug.Assert( row != null );

                ElementState state = rowElem.ElementState;
                Debug.Assert( state == ElementState.Defoliated, "Region is accessed using column, but it's state is FOLIATED" );

                // We cannot be on a column for which the value is DBNull
                DataRowVersion rowVersion = ( row.RowState == DataRowState.Detached ) ? DataRowVersion.Proposed : DataRowVersion.Current;
                Debug.Assert( ! Convert.IsDBNull( row[ this.column, rowVersion ] ) );

                // If we are on the Text column, we should always have fOnValue == true
                Debug.Assert( (this.column.ColumnMapping == MappingType.SimpleContent) ? (this.fOnValue == true) : true );
            }
        }

        bool IXmlDataVirtualNode.IsInUse() {
            return _isInUse;
        }

        internal void SetNoLongerUse() {
            this.node = null;
            this.column = null;
            this.fOnValue = false;
            this.bNeedFoliate = false;
            this._isInUse = false;
        }
        
    }
}