//------------------------------------------------------------------------------
// <copyright file="CompiledXpathExpr.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
//------------------------------------------------------------------------------
 
namespace MS.Internal.Xml.XPath {
    using System;
    using System.Xml;
    using System.Xml.XPath;
    using System.Diagnostics;
    using System.Globalization;
    using System.Collections;
    using System.Xml.Xsl;
 
    internal class CompiledXpathExpr : XPathExpression {
        Query query;
        string expr;
        bool needContext;
 
        internal CompiledXpathExpr(Query query, string expression, bool needContext) {
            this.query = query;
            this.expr = expression;
            this.needContext = needContext;
        }
 
        internal Query QueryTree {
            get {
                if (needContext) {
                    throw XPathException.Create(Res.Xp_NoContext);
                }
                return query;
            }
        }
 
        public override string Expression {
            get { return expr; }
        }
 
        public virtual void CheckErrors() {
            Debug.Assert(query != null, "In case of error in XPath we create ErrorXPathExpression");
        }
 
        public override void AddSort(object expr, IComparer comparer) {
            // sort makes sense only when we are dealing with a query that
            // returns a nodeset.
	        Query evalExpr;
            if (expr is string) {
                evalExpr = new QueryBuilder().Build((string)expr, out needContext); // this will throw if expr is invalid
            } else if (expr is CompiledXpathExpr) {
                evalExpr = ((CompiledXpathExpr)expr).QueryTree;
	        } else {
                throw XPathException.Create(Res.Xp_BadQueryObject);
            }
            SortQuery sortQuery = query as SortQuery;
            if (sortQuery == null) {
                query = sortQuery = new SortQuery(query);
            }
            sortQuery.AddSort(evalExpr, comparer);
        }
 
        public override void AddSort(object expr, XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) {
            AddSort(expr, new XPathComparerHelper(order, caseOrder, lang, dataType));
        }
 
        public override XPathExpression Clone() {
            return new CompiledXpathExpr(Query.Clone(query), expr, needContext);
        }
 
        public override void SetContext(XmlNamespaceManager nsManager) {
            SetContext((IXmlNamespaceResolver)nsManager);
        }
 
        public override void SetContext(IXmlNamespaceResolver nsResolver) {
            XsltContext xsltContext = nsResolver as XsltContext;
            if(xsltContext == null) {
                if(nsResolver == null) {
                    nsResolver = new XmlNamespaceManager(new NameTable());
                }
                xsltContext = new UndefinedXsltContext(nsResolver);
            }
            query.SetXsltContext(xsltContext);
 
            needContext = false;
        }
 
        public override XPathResultType ReturnType { get { return query.StaticType; } }
 
        private class UndefinedXsltContext : XsltContext {
            private IXmlNamespaceResolver nsResolver;
 
            public UndefinedXsltContext(IXmlNamespaceResolver nsResolver) : base(/*dummy*/false) {
                this.nsResolver = nsResolver;
            }
            //----- Namespace support -----
            public override string DefaultNamespace {
                get { return string.Empty; }
            }
            public override string LookupNamespace(string prefix) {
                Debug.Assert(prefix != null);
                if (prefix.Length == 0) {
                    return string.Empty;
                }
                string ns = this.nsResolver.LookupNamespace(prefix);
                if (ns == null) {
                    throw XPathException.Create(Res.XmlUndefinedAlias, prefix);
                }
                return ns;
            }
            //----- XsltContext support -----
            public override IXsltContextVariable ResolveVariable(string prefix, string name) {
                throw XPathException.Create(Res.Xp_UndefinedXsltContext);
            }
            public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] ArgTypes) {
                throw XPathException.Create(Res.Xp_UndefinedXsltContext);
            }
            public override bool Whitespace { get{ return false; } }
            public override bool PreserveWhitespace(XPathNavigator node) { return false; }
            public override int CompareDocument (string baseUri, string nextbaseUri) {
                return string.CompareOrdinal(baseUri, nextbaseUri);
            }
        }
    }
 
    internal sealed class XPathComparerHelper : IComparer {
        private XmlSortOrder order;
        private XmlCaseOrder caseOrder;
        private CultureInfo  cinfo;
        private XmlDataType  dataType;
 
        public XPathComparerHelper(XmlSortOrder order, XmlCaseOrder caseOrder, string lang, XmlDataType dataType) {
            if (lang == null) {
                this.cinfo = System.Threading.Thread.CurrentThread.CurrentCulture;
            } else {
                try {
                    this.cinfo = new CultureInfo(lang);
                }
                catch (System.ArgumentException) {
                    throw;  // Throwing an XsltException would be a breaking change
				}
            }
 
            if (order == XmlSortOrder.Descending) {
                if (caseOrder == XmlCaseOrder.LowerFirst) {
                    caseOrder = XmlCaseOrder.UpperFirst;
                }
                else if (caseOrder == XmlCaseOrder.UpperFirst) {
                    caseOrder = XmlCaseOrder.LowerFirst;
                }
            }
 
            this.order     = order;
            this.caseOrder = caseOrder;
            this.dataType  = dataType;
        }
 
        public int Compare(object x, object y) {
            switch (this.dataType) {
            case XmlDataType.Text:
                string s1 = Convert.ToString(x, this.cinfo);
                string s2 = Convert.ToString(y, this.cinfo);
                int result = string.Compare(s1, s2, /*ignoreCase:*/ this.caseOrder != XmlCaseOrder.None, this.cinfo);
 
                if (result != 0 || this.caseOrder == XmlCaseOrder.None)
                    return (this.order == XmlSortOrder.Ascending) ? result : -result;
 
                // If we came this far, it means that strings s1 and s2 are
                // equal to each other when case is ignored. Now it's time to check
                // and see if they differ in case only and take into account the user
                // requested case order for sorting purposes.
                result = string.Compare(s1, s2, /*ignoreCase:*/ false, this.cinfo);
                return (this.caseOrder == XmlCaseOrder.LowerFirst) ? result : -result;
 
            case XmlDataType.Number:
                double r1 = XmlConvert.ToXPathDouble(x);
                double r2 = XmlConvert.ToXPathDouble(y);
                result = r1.CompareTo(r2);
                return (this.order == XmlSortOrder.Ascending) ? result : -result;
 
            default:
                // dataType doesn't support any other value
                throw new InvalidOperationException(Res.GetString(Res.Xml_InvalidOperation));
            }
        } // Compare ()
    } // class XPathComparerHelper
}