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

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Xml.Xsl.Qil;
using System.Xml.Xsl.Runtime;

namespace System.Xml.Xsl.IlGen {

    /// <summary>
    /// This internal class maintains a list of unique values.  Each unique value is assigned a unique ID, which can
    /// be used to quickly access the value, since it corresponds to the value's position in the list.
    /// </summary>
    internal class UniqueList<T> {
        private Dictionary<T, int> lookup = new Dictionary<T, int>();
        private List<T> list = new List<T>();

        /// <summary>
        /// If "value" is already in the list, do not add it.  Return the unique ID of the value in the list.
        /// </summary>
        public int Add(T value) {
            int id;

            if (!this.lookup.ContainsKey(value)) {
                // The value does not yet exist, so add it to the list
                id = list.Count;
                this.lookup.Add(value, id);
                this.list.Add(value);
            }
            else {
                id = this.lookup[value];
            }

            return id;
        }

        /// <summary>
        /// Return an array of the unique values.
        /// </summary>
        public T[] ToArray() {
            return list.ToArray();
        }
    }


    /// <summary>
    /// Manages all static data that is used by the runtime.  This includes:
    ///   1. All NCName and QName atoms that will be used at run-time
    ///   2. All QName filters that will be used at run-time
    ///   3. All Xml types that will be used at run-time
    ///   4. All global variables and parameters
    /// </summary>
    internal class StaticDataManager {
        private UniqueList<string> uniqueNames;
        private UniqueList<Int32Pair> uniqueFilters;
        private List<StringPair[]> prefixMappingsList;
        private List<string> globalNames;
        private UniqueList<EarlyBoundInfo> earlyInfo;
        private UniqueList<XmlQueryType> uniqueXmlTypes;
        private UniqueList<XmlCollation> uniqueCollations;

        /// <summary>
        /// Add "name" to the list of unique names that are used by this query.  Return the index of
        /// the unique name in the list.
        /// </summary>
        public int DeclareName(string name) {
            if (this.uniqueNames == null)
                this.uniqueNames = new UniqueList<string>();

            return this.uniqueNames.Add(name);
        }

        /// <summary>
        /// Return an array of all names that are used by the query (null if no names).
        /// </summary>
        public string[] Names {
            get { return (this.uniqueNames != null) ? this.uniqueNames.ToArray() : null; }
        }

        /// <summary>
        /// Add a name filter to the list of unique filters that are used by this query.  Return the index of
        /// the unique filter in the list.
        /// </summary>
        public int DeclareNameFilter(string locName, string nsUri) {
            if (this.uniqueFilters == null)
                this.uniqueFilters = new UniqueList<Int32Pair>();

            return this.uniqueFilters.Add(new Int32Pair(DeclareName(locName), DeclareName(nsUri)));
        }

        /// <summary>
        /// Return an array of all name filters, where each name filter is represented as a pair of integer offsets (localName, namespaceUri)
        /// into the Names array (null if no name filters).
        /// </summary>
        public Int32Pair[] NameFilters {
            get { return (this.uniqueFilters != null) ? this.uniqueFilters.ToArray() : null; }
        }

        /// <summary>
        /// Add a list of QilExpression NamespaceDeclarations to an array of strings (prefix followed by namespace URI).
        /// Return index of the prefix mappings within this array.
        /// </summary>
        public int DeclarePrefixMappings(IList<QilNode> list) {
            StringPair[] prefixMappings;

            // Fill mappings array
            prefixMappings = new StringPair[list.Count];
            for (int i = 0; i < list.Count; i++) {
                // Each entry in mappings array must be a constant NamespaceDeclaration
                QilBinary ndNmspDecl = (QilBinary) list[i];
                Debug.Assert(ndNmspDecl != null);
                Debug.Assert(ndNmspDecl.Left is QilLiteral && ndNmspDecl.Right is QilLiteral);

                prefixMappings[i] = new StringPair((string) (QilLiteral) ndNmspDecl.Left, (string) (QilLiteral) ndNmspDecl.Right);
            }

            // Add mappings to list and return index
            if (this.prefixMappingsList == null)
                this.prefixMappingsList = new List<StringPair[]>();

            this.prefixMappingsList.Add(prefixMappings);
            return this.prefixMappingsList.Count - 1;
        }

        /// <summary>
        /// Return an array of all prefix mappings that are used by the query to compute names (null if no mappings).
        /// </summary>
        public StringPair[][] PrefixMappingsList {
            get { return (this.prefixMappingsList != null) ? this.prefixMappingsList.ToArray() : null; }
        }

        /// <summary>
        /// Declare a new global variable or parameter.
        /// </summary>
        public int DeclareGlobalValue(string name) {
            int idx;

            if (this.globalNames == null)
                this.globalNames = new List<string>();

            idx = this.globalNames.Count;
            this.globalNames.Add(name);
            return idx;
        }

        /// <summary>
        /// Return an array containing the names of all global variables and parameters.
        /// </summary>
        public string[] GlobalNames {
            get { return (this.globalNames != null) ? this.globalNames.ToArray() : null; }
        }

        /// <summary>
        /// Add early bound information to a list that is used by this query.  Return the index of
        /// the early bound information in the list.
        /// </summary>
        public int DeclareEarlyBound(string namespaceUri, Type ebType) {
            if (this.earlyInfo == null)
                this.earlyInfo = new UniqueList<EarlyBoundInfo>();

            return this.earlyInfo.Add(new EarlyBoundInfo(namespaceUri, ebType));
        }

        /// <summary>
        /// Return an array of all early bound information that is used by the query (null if none is used).
        /// </summary>
        public EarlyBoundInfo[] EarlyBound {
            get {
                if (this.earlyInfo != null)
                    return this.earlyInfo.ToArray();

                return null;
            }
        }

        /// <summary>
        /// Add "type" to the list of unique types that are used by this query.  Return the index of
        /// the unique type in the list.
        /// </summary>
        public int DeclareXmlType(XmlQueryType type) {
            if (this.uniqueXmlTypes == null)
                this.uniqueXmlTypes = new UniqueList<XmlQueryType>();

            XmlQueryTypeFactory.CheckSerializability(type);
            return this.uniqueXmlTypes.Add(type);
        }

        /// <summary>
        /// Return an array of all types that are used by the query (null if no names).
        /// </summary>
        public XmlQueryType[] XmlTypes {
            get { return (this.uniqueXmlTypes != null) ? this.uniqueXmlTypes.ToArray() : null; }
        }

        /// <summary>
        /// Add "collation" to the list of unique collations that are used by this query.  Return the index of
        /// the unique collation in the list.
        /// </summary>
        public int DeclareCollation(string collation) {
            if (this.uniqueCollations == null)
                this.uniqueCollations = new UniqueList<XmlCollation>();

            return this.uniqueCollations.Add(XmlCollation.Create(collation));
        }

        /// <summary>
        /// Return an array of all collations that are used by the query (null if no names).
        /// </summary>
        public XmlCollation[] Collations {
            get { return (this.uniqueCollations != null) ? this.uniqueCollations.ToArray() : null; }
        }
    }
}