// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#nullable disable

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Xaml;
using System.Xaml.MS.Impl;
using System.Xaml.Schema;
using System.Xml;
using MS.Internal.Xaml.Context;

namespace MS.Internal.Xaml.Parser
{
    class XamlScanner
    {
        XmlReader _xmlReader;
        IXmlLineInfo _xmlLineInfo;

        // XamlParserContext vs. XamlScannerStack
        // The XamlScannerStack belongs to the Scanner (aka XamlScanner) exclusively.
        // It has its own stack because it necessarily will read ahead sometimes.
        //
        // The XamlParserContext belongs to the Parser (aka XamlParser).
        // Except the scanner loads namespaces into the Parser's XamlParserContext,
        // and reads from it to resolve type names and namespace prefixes.
        //
        XamlScannerStack _scannerStack;
        XamlParserContext _parserContext;

        XamlText _accumulatedText;
        List<XamlAttribute> _attributes;
        int _nextAttribute;
        XamlScannerNode _currentNode;
        Queue<XamlScannerNode> _readNodesQueue;
        XamlXmlReaderSettings _settings;
        XamlAttribute _typeArgumentAttribute;
        bool _hasKeyAttribute;

        internal XamlScanner(XamlParserContext context, XmlReader xmlReader, XamlXmlReaderSettings settings)
        {
            _xmlReader = xmlReader;
            _xmlLineInfo = settings.ProvideLineInfo ? (xmlReader as IXmlLineInfo) : null;  //consider removing the "settings" check

            _parserContext = context;

            _scannerStack = new XamlScannerStack();
            _readNodesQueue = new Queue<XamlScannerNode>();

            _settings = settings;
            if (settings.XmlSpacePreserve)
            {
                _scannerStack.CurrentXmlSpacePreserve = true;
            }
        }

        public void Read()
        {
            LoadQueue();
            _currentNode = _readNodesQueue.Dequeue();
        }

        public ScannerNodeType PeekNodeType
        {
            get
            {
                LoadQueue();
                return _readNodesQueue.Peek().NodeType;
            }
        }

        public XamlType PeekType
        {
            get
            {
                LoadQueue();
                return _readNodesQueue.Peek().Type;
            }
        }

        public ScannerNodeType NodeType
        {
            get { return _currentNode.NodeType; }
        }

        public XamlType Type
        {
            get { return _currentNode.Type; }
        }

        public XamlMember PropertyAttribute
        {
            get { return _currentNode.PropertyAttribute; }
        }

        public XamlText PropertyAttributeText
        {
            get { return _currentNode.PropertyAttributeText; }
        }

        public bool IsCtorForcingMember
        {
            get { return _currentNode.IsCtorForcingMember; }
        }

        public XamlMember PropertyElement
        {
            get { return _currentNode.PropertyElement; }
        }

        public XamlText TextContent
        {
            get { return _currentNode.TextContent; }
        }

        public bool IsXDataText
        {
            get { return _currentNode.IsXDataText; }
        }

        public bool HasKeyAttribute
        {
            get
            {
                return _hasKeyAttribute;
            }
        }

        public string Prefix
        {
            get { return _currentNode.Prefix; }
        }

        public string Namespace
        {
            get { return _currentNode.TypeNamespace; }
        }

        public int LineNumber
        {
            get { return _currentNode.LineNumber; }
        }

        public int LinePosition
        {
            get { return _currentNode.LinePosition; }
        }

        // ===================================================================

        private void LoadQueue()
        {
            if (_readNodesQueue.Count == 0)
            {
                DoXmlRead();
            }
        }

        private void DoXmlRead()
        {
            while (_readNodesQueue.Count == 0)
            {
                if (_xmlReader.Read())
                {
                    ProcessCurrentXmlNode();
                }
                else
                {
                    // false from XML Read() is the same as reading .None.
                    ReadNone();
                }
            }
        }

        private void ProcessCurrentXmlNode()
        {
            XmlNodeType xmlNodeType = _xmlReader.NodeType;
            switch (xmlNodeType)
            {
            case XmlNodeType.Element:
                ReadElement();
                break;

            case XmlNodeType.EndElement:
                ReadEndElement();
                break;

            case XmlNodeType.Text:
            case XmlNodeType.CDATA:
                ReadText();
                break;

            case XmlNodeType.SignificantWhitespace:
            case XmlNodeType.Whitespace:
                ReadWhitespace();
                break;

            case XmlNodeType.None:
                ReadNone();
                break;

            default:
                break;
            }
        }
        // ============= Private ==================================

        private XamlText AccumulatedText
        {
            get
            {
                if (_accumulatedText == null)
                {
                    _accumulatedText = new XamlText(_scannerStack.CurrentXmlSpacePreserve);
                }
                return _accumulatedText;
            }
        }

        private void ClearAccumulatedText()
        {
            _accumulatedText = null;
        }

        private bool HaveAccumulatedText
        {
            get { return _accumulatedText != null && !_accumulatedText.IsEmpty; }
        }

        // ============= Element Processing ==================================

        private void ReadElement()
        {
            // Accumulated text is enqueued a piece of content before this element
            EnqueueAnyText();
            _hasKeyAttribute = false;
            // Empty Elements are by definition leaf elements and they
            // don't nest.  So we don't need to stack this state.
            bool isEmptyTag = _xmlReader.IsEmptyElement;

            string prefix = _xmlReader.Prefix;
            string strippedName = _xmlReader.LocalName;
            if (XamlName.ContainsDot(strippedName))
            {
                Debug.Assert(_xmlReader.NodeType == XmlNodeType.Element);
                XamlPropertyName name = XamlPropertyName.Parse(_xmlReader.Name, _xmlReader.NamespaceURI);
                if (_scannerStack.CurrentType == null)
                {
                    throw LineInfo(new XamlParseException(SR.Format(SR.ParentlessPropertyElement, _xmlReader.Name)));
                }
                ReadPropertyElement(name, _scannerStack.CurrentType, _scannerStack.CurrentTypeNamespace, isEmptyTag);
            }
            else
            {
                XamlName name = new XamlQualifiedName(prefix, strippedName);
                ReadObjectElement(name, isEmptyTag);
            }
        }

        // ReadObjectElement: reads the entire start tag.  This may result in
        // more than one Scanner Nodes.   The results are enqueued onto a list
        // rather than returned directly, then the caller can de-queue the nodes
        // one at a time.
        private void ReadObjectElement(XamlName name, bool isEmptyTag)
        {
            _typeArgumentAttribute = null;
            XamlScannerNode node = new XamlScannerNode(_xmlLineInfo);

            // Scan for xmlns(s) before attempting to resolve the type.
            // So while we are there, collect up all the attributes.
            // Enqueue the xmlns attributes first.
            // PostProcess and Enqueue the other attributes after.
            PreprocessAttributes();

            node.Prefix = name.Prefix;
            node.IsEmptyTag = isEmptyTag;

            // It is possible for an application to provide XML nodes via XmlNodeReader
            // where the URI is defined but there was no xmlns attribute for use to resolve against.
            // See app Paperboy
            Debug.Assert(_xmlReader.NodeType == XmlNodeType.Element);
            string xamlNs = _xmlReader.NamespaceURI;
            if (xamlNs == null)
            {
                ReadObjectElement_NoNamespace(name, node);
            }
            else  // if (xamlNs != null)
            {
                node.TypeNamespace = xamlNs;

                // First check if the XML element is a
                // Directive Property  <x:Key>
                //
                XamlSchemaContext schemaContext = _parserContext.SchemaContext;
                XamlMember dirProperty = schemaContext.GetXamlDirective(xamlNs, name.Name);
                if (dirProperty != null)
                {
                    ReadObjectElement_DirectiveProperty(dirProperty, node);
                }
                else  // normal Element Case.
                {
                    bool sawXData = ReadObjectElement_Object(xamlNs, name.Name, node);
                    if (sawXData)
                    {
                        return;
                    }
                }
            }

            _readNodesQueue.Enqueue(node);

            // Now add the processed attributes from the rest of the start tag.
            while (HaveUnprocessedAttributes)
            {
                EnqueueAnotherAttribute(isEmptyTag);
            }
        }

        private void ReadObjectElement_NoNamespace(XamlName name, XamlScannerNode node)
        {
            XamlType errType = CreateErrorXamlType(name, string.Empty);
            node.Type = errType;

            PostprocessAttributes(node);

            if (!node.IsEmptyTag)
            {
                node.NodeType = ScannerNodeType.ELEMENT;
                _scannerStack.Push(node.Type, node.TypeNamespace);
            }
            else
            {
                node.NodeType = ScannerNodeType.EMPTYELEMENT;
            }
        }

        private void ReadObjectElement_DirectiveProperty(XamlMember dirProperty, XamlScannerNode node)
        {
            node.PropertyElement = dirProperty;

            // node.Type is not set so any found attributes are and error.
            // We don't want to skip them silently.
            PostprocessAttributes(node);

            if (_scannerStack.Depth > 0)
            {
                // A property Element tag will be the end of content.
                _scannerStack.CurrentlyInContent = false;
            }

            if (!node.IsEmptyTag)
            {
                _scannerStack.CurrentProperty = node.PropertyElement;
            }
            node.NodeType = ScannerNodeType.PROPERTYELEMENT;
            node.IsCtorForcingMember = false;
        }

        private bool ReadObjectElement_Object(string xmlns, string name, XamlScannerNode node)
        {
            if (IsXDataElement(xmlns, name))
            {
                // If XData don't Enqueue the <x:XData> node.
                // just queue the InnerXml as TEXT (w/ IsTextXML == true).
                // This will advance the "current" xml node to the </x:XData>
                // which will be skipped when we return and the main loop
                // Read()s to the "next" XmlNode.
                ReadInnerXDataSection();
                return true;
            }

            IList<XamlTypeName> typeArgs = null;
            if (_typeArgumentAttribute != null)
            {
                string error;
                typeArgs = XamlTypeName.ParseListInternal(_typeArgumentAttribute.Value, _parserContext.FindNamespaceByPrefix, out error);
                if (typeArgs == null)
                {
                    throw new XamlParseException(_typeArgumentAttribute.LineNumber, _typeArgumentAttribute.LinePosition, error);
                }
            }
            XamlTypeName typeName = new XamlTypeName(xmlns, name, typeArgs);
            node.Type = _parserContext.GetXamlType(typeName, true);

            // Finish initializing the attributes in the context of the
            // current Element.
            PostprocessAttributes(node);

            if (_scannerStack.Depth > 0)
            {
                // Sub-elements (and Text) are the definition of Content
                _scannerStack.CurrentlyInContent = true;
            }

            if (!node.IsEmptyTag)
            {
                node.NodeType = ScannerNodeType.ELEMENT;
                _scannerStack.Push(node.Type, node.TypeNamespace);
            }
            else
            {
                node.NodeType = ScannerNodeType.EMPTYELEMENT;
            }
            return false;
        }

        private void ReadPropertyElement(XamlPropertyName name, XamlType tagType, string tagNamespace, bool isEmptyTag)
        {
            // <Button>   <== currentElement
            //   <FrameworkElement.Width>   <== FrameworkElement is ownerType

            XamlScannerNode node = new XamlScannerNode(_xmlLineInfo);

            // Attributes aren't allowed on property elements.
            // but if they are there we need to scan them so the
            // XamlParser can error, or whatever.
            // (don't want to skip them w/o error)
            PreprocessAttributes();

            // It is possible for an application to provide XML nodes via XmlNodeReader
            // where the URI is defined but there was no xmlns attribute for use to resolve against.
            // See app Paperboy
            Debug.Assert(_xmlReader.NodeType == XmlNodeType.Element);
            string ownerNamespace = _xmlReader.NamespaceURI;
            XamlMember property = null;

            bool tagIsRoot = _scannerStack.Depth == 1; // PEs are processed after frame is pushed
            property = _parserContext.GetDottedProperty(tagType, tagNamespace, name, tagIsRoot);

            node.Prefix = name.Prefix;
            node.TypeNamespace = ownerNamespace;
            node.IsEmptyTag = isEmptyTag;

            // node.Type is not set (this is a property)
            // so this processing does less.
            PostprocessAttributes(node);

            if (_scannerStack.Depth > 0)
            {
                // A property Element tag will be the end of content.
                // This also allows to to start content again.
                // That is an error, but at least the parser/scanner can
                // understand what is going on.
                _scannerStack.CurrentlyInContent = false;
            }

            node.PropertyElement = property;

            node.IsCtorForcingMember = !property.IsAttachable;

            if (!node.IsEmptyTag)
            {
                _scannerStack.CurrentProperty = node.PropertyElement;
                node.NodeType = ScannerNodeType.PROPERTYELEMENT;
            }
            else
            {
                node.NodeType = ScannerNodeType.EMPTYPROPERTYELEMENT;
            }

            _readNodesQueue.Enqueue(node);

            while (HaveUnprocessedAttributes)
            {
                EnqueueAnotherAttribute(isEmptyTag);
            }
        }

        private void ReadEndElement()
        {
            // Accumulated text is enqued at start of tags (element and property)
            // and at end tags.
            EnqueueAnyText();

            // if we are ending a property element tag clear the current property
            // if we are ending an element then pop off the current frame.
            if (_scannerStack.CurrentProperty != null)
            {
                _scannerStack.CurrentProperty = null;
                // List of Content is considered separately for each property.
                _scannerStack.CurrentlyInContent = false;
            }
            else
            {
                _scannerStack.Pop();
            }

            XamlScannerNode node = new XamlScannerNode(_xmlLineInfo);
            node.NodeType = ScannerNodeType.ENDTAG;
            _readNodesQueue.Enqueue(node);
        }

        private void ReadText()
        {
            // Trim the leading whitespace from the text if it is the first bit on content.
            bool isFirstTextInContent = !_scannerStack.CurrentlyInContent;
            AccumulatedText.Paste(_xmlReader.Value, isFirstTextInContent);
            _scannerStack.CurrentlyInContent = true;
        }

        private void ReadWhitespace()
        {
            bool isFirstTextInContent = !_scannerStack.CurrentlyInContent;
            AccumulatedText.Paste(_xmlReader.Value, isFirstTextInContent);
            // Whitespace, by itself, does not change the "InContent" state.
        }

        private void ReadNone()
        {
            XamlScannerNode node = new XamlScannerNode(_xmlLineInfo);
            node.NodeType = ScannerNodeType.NONE;
            _readNodesQueue.Enqueue(node);
        }

        private void ReadInnerXDataSection()
        {
            XamlScannerNode node = new XamlScannerNode(_xmlLineInfo);
            _xmlReader.MoveToContent(); // skip whitespaces
            string xmlData = _xmlReader.ReadInnerXml();
            xmlData = xmlData.Trim();
            node.NodeType = ScannerNodeType.TEXT;
            node.IsXDataText = true;
            XamlText xmlText = new XamlText(true);
            xmlText.Paste(xmlData, false);
            node.TextContent = xmlText;
            _readNodesQueue.Enqueue(node);

            // Read InnerXml will advance over the End xData tag and
            // we need to process the current XML state w/o going back for a Read().
            ProcessCurrentXmlNode();
        }

        private XamlType CreateErrorXamlType(XamlName name, string xmlns)
        {
            return new XamlType(xmlns, name.Name, null, _parserContext.SchemaContext);
        }

        // ======== Attribute Processing =============================

        private void PreprocessAttributes()
        {
            // Collect up all the attributes.
            bool b = _xmlReader.MoveToFirstAttribute();

            if (!b)
            {
                return;
            }

            List<XamlAttribute> list = new List<XamlAttribute>();
            do
            {
                string xmlName = _xmlReader.Name;
                string val = _xmlReader.Value;

                XamlPropertyName propName = XamlPropertyName.Parse(xmlName);

                if (propName == null)
                {
                    throw new XamlParseException(SR.Format(SR.InvalidXamlMemberName, xmlName));
                }

                XamlAttribute attr = new XamlAttribute(propName, val, _xmlLineInfo);

                if (attr.Kind == ScannerAttributeKind.Namespace)
                {
                    EnqueuePrefixDefinition(attr);
                }
                else
                {
                    list.Add(attr);
                }

                b = _xmlReader.MoveToNextAttribute();
            } while (b);

            PreprocessForTypeArguments(list);

            if (list.Count > 0)
            {
                _attributes = list;
            }
            // Restore the XML reader’s position to the Element after reading the
            // attributes so that the rest of the code can always assume it is on an Element
            _xmlReader.MoveToElement();
        }

        private void PreprocessForTypeArguments(List<XamlAttribute> attrList)
        {
            int typeArgsIdx = -1;
            for (int i = 0; i < attrList.Count; i++)
            {
                XamlAttribute attr = attrList[i];

                // Find x:TypeArguments if it was present.
                if (KS.Eq(attr.Name.Name, XamlLanguage.TypeArguments.Name))
                {
                    string attrNamespace = _parserContext.FindNamespaceByPrefix(attr.Name.Prefix);
                    XamlMember directiveProperty = _parserContext.ResolveDirectiveProperty(attrNamespace, attr.Name.Name);
                    if (directiveProperty != null)
                    {
                        typeArgsIdx = i;
                        _typeArgumentAttribute = attr;
                        break;
                    }
                }
            }
            if (typeArgsIdx >= 0)
            {
                attrList.RemoveAt(typeArgsIdx);
            }
        }

        private void PostprocessAttributes(XamlScannerNode node)
        {
            if (_attributes == null)
            {
                return;
            }

            _nextAttribute = 0;

            // Attributes on Properties are errors
            // and don't need this detailed processing.
            if (node.Type == null)
            {
                if (_settings.IgnoreUidsOnPropertyElements)
                {
                    StripUidProperty();
                }
                return;
            }


            bool tagIsRoot = _scannerStack.Depth == 0; // Attributes are processed before frame is pushed
            foreach (XamlAttribute attr in _attributes)
            {
                attr.Initialize(_parserContext, node.Type, node.TypeNamespace, tagIsRoot);
            }

            // Sort the Attributes into the order the XAML parser likes.

            List<XamlAttribute> ctorDirectivesList = null;
            List<XamlAttribute> otherDirectivesList = null;
            List<XamlAttribute> otherPropertiesList = null;
            XamlAttribute nameAttribute = null;

            // The Name attribute
            foreach (XamlAttribute attr in _attributes)
            {
                switch(attr.Kind)
                {
                case ScannerAttributeKind.Name:
                    nameAttribute = attr;
                        break;

                case ScannerAttributeKind.CtorDirective:
                    if (ctorDirectivesList == null)
                    {
                        ctorDirectivesList = new List<XamlAttribute>();
                    }
                    ctorDirectivesList.Add(attr);
                        break;

                case ScannerAttributeKind.Directive:
                case ScannerAttributeKind.XmlSpace:
                    if (attr.Property == XamlLanguage.Key)
                    {
                        _hasKeyAttribute = true;
                    }

                    if (otherDirectivesList == null)
                    {
                        otherDirectivesList = new List<XamlAttribute>();
                    }
                    otherDirectivesList.Add(attr);
                    break;

                default:
                    if (otherPropertiesList == null)
                    {
                        otherPropertiesList = new List<XamlAttribute>();
                    }
                    otherPropertiesList.Add(attr);
                    break;
                }
            }

            _attributes = new List<XamlAttribute>();

            // First the Construction Directives
            if (ctorDirectivesList != null)
            {
                _attributes.AddRange(ctorDirectivesList);
            }

            if (otherDirectivesList != null)
            {
                _attributes.AddRange(otherDirectivesList);
            }

            // Next the aliased Name property before any other "real" properties.
            // (this is a WPF template requirement)
            if (nameAttribute != null)
            {
                _attributes.Add(nameAttribute);
            }

            // Then everything else
            if (otherPropertiesList != null)
            {
                _attributes.AddRange(otherPropertiesList);
            }
        }

        private void StripUidProperty()
        {
            for (int i = _attributes.Count - 1; i >= 0; i--)
            {
                if (KS.Eq(_attributes[i].Name.ScopedName, XamlLanguage.Uid.Name))
                {
                    _attributes.RemoveAt(i);
                }
            }
            if (_attributes.Count == 0)
            {
                _attributes = null;
            }
        }

        private bool HaveUnprocessedAttributes
        {
            get { return _attributes != null; }
        }

        private void EnqueueAnotherAttribute(bool isEmptyTag)
        {
            XamlAttribute attr = _attributes[_nextAttribute++];
            XamlScannerNode node = new XamlScannerNode(attr);

            switch (attr.Kind)
            {
            case ScannerAttributeKind.Directive:
            case ScannerAttributeKind.Name:
            case ScannerAttributeKind.CtorDirective:
                node.NodeType = ScannerNodeType.DIRECTIVE;
                break;

            case ScannerAttributeKind.XmlSpace:
                // Empty tags don't have a stack frame to write on.
                // Empty XML tags don't have content to process spaces.
                if (!isEmptyTag)
                {
                    if (KS.Eq(attr.Value, KnownStrings.Preserve))
                        _scannerStack.CurrentXmlSpacePreserve = true;
                    else
                        _scannerStack.CurrentXmlSpacePreserve = false;
                }
                node.NodeType = ScannerNodeType.DIRECTIVE;
                break;

            case ScannerAttributeKind.Event:
            case ScannerAttributeKind.Property:
                node.IsCtorForcingMember = true;
                node.NodeType = ScannerNodeType.ATTRIBUTE;
                break;

           case ScannerAttributeKind.Unknown:
                XamlMember prop = attr.Property;
                Debug.Assert(prop.IsUnknown);
                // force use of Ctor for unknown simple properties only
                node.IsCtorForcingMember = !prop.IsAttachable && !prop.IsDirective;
                node.NodeType = ScannerNodeType.ATTRIBUTE;
                break;

            case ScannerAttributeKind.AttachableProperty:
                node.NodeType = ScannerNodeType.ATTRIBUTE;
                break;

            default:
                throw new XamlInternalException(SR.AttributeUnhandledKind);
            }

            // (GetFixedDocumentSequence raises Exception "UnicodeString property does not
            // contain enough characters to correspond to the contents of Indices property.")
            //
            // XamlText.Paste normally converts CRLF to LF, even in attribute values.
            // When the property is Glyphs.UnicodeString, disable this;
            // the length of the string must correspond to the number of entries in
            // the corresponding Glyphs.Indices property.
            XamlMember attrProperty = attr.Property;
            bool convertCRLFtoLF =
                !(attrProperty != null &&
                  attrProperty.Name == "UnicodeString" &&
                  attrProperty.DeclaringType.Name == "Glyphs");

            node.PropertyAttribute = attrProperty;
            XamlText xamlText = new XamlText(true);  // Don't collapse spaces in attributes
            xamlText.Paste(attr.Value, false, convertCRLFtoLF);
            node.PropertyAttributeText = xamlText;
            node.Prefix = attr.Name.Prefix;

            _readNodesQueue.Enqueue(node);

            if (_nextAttribute >= _attributes.Count)
            {
                _attributes = null;
                _nextAttribute = -1;
            }
        }

        private void EnqueueAnyText()
        {
            if (HaveAccumulatedText)
            {
                // some consideration of _scannerStack.CurrentXmlSpacePreserve
                // it will cause Whitespace here but we only enqueue it if
                // we are In a Whitespace significant collection.
                EnqueueTextNode();
            }
            ClearAccumulatedText();
        }

        private void EnqueueTextNode()
        {
            Debug.Assert(_accumulatedText != null, "Creating unnecessary XamlText objects");

            // Don't send the text if it is Whitespace outside the root tag.
            if (!(_scannerStack.Depth == 0 && AccumulatedText.IsWhiteSpaceOnly))
            {
                XamlScannerNode node = new XamlScannerNode(_xmlLineInfo);
                node.NodeType = ScannerNodeType.TEXT;
                node.TextContent = AccumulatedText;
                _readNodesQueue.Enqueue(node);
            }
        }

        private void EnqueuePrefixDefinition(XamlAttribute attr)
        {
            string prefix = attr.XmlNsPrefixDefined;
            string xamlNamespace = attr.XmlNsUriDefined;
            _parserContext.AddNamespacePrefix(prefix, xamlNamespace);

            XamlScannerNode node = new XamlScannerNode(attr);
            node.NodeType = ScannerNodeType.PREFIXDEFINITION;
            node.Prefix = prefix;
            node.TypeNamespace = xamlNamespace;

            _readNodesQueue.Enqueue(node);
        }

        private bool IsXDataElement(string xmlns, string name)
        {
            return
                XamlLanguage.XamlNamespaces.Contains(xmlns) &&
                KS.Eq(XamlLanguage.XData.Name, name);
        }

        XamlException LineInfo(XamlException e)
        {
            if (_xmlLineInfo != null)
            {
                e.SetLineInfo(_xmlLineInfo.LineNumber, _xmlLineInfo.LinePosition);
            }
            return e;
        }
    }
}
