//------------------------------------------------------------------------------
// <copyright file="WebServiceData.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
 
namespace System.Web.Script.Services {
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Diagnostics.CodeAnalysis;
    using System.Globalization;
    using System.IO;
    using System.Reflection;
    using System.Security;
    using System.Web;
    using System.Web.Caching;
    using System.Web.Compilation;
    using System.Web.Configuration;
    using System.Web.Hosting;
    using System.Web.Resources;
    using System.Web.Script.Serialization;
    using System.Web.Services;

    internal class WebServiceData : JavaScriptTypeResolver {
        private WebServiceTypeData _typeData;
        private bool _pageMethods; // True for page methods(which only look at static methods)
        private Dictionary<string, WebServiceMethodData> _methods;

        // this is used to map __type ids in the JSON string to something other than type.FullName
        private Dictionary<string, string> _typeResolverSpecials = new Dictionary<string, string>();
        private Dictionary<string, WebServiceTypeData> _clientTypesDictionary;
        private Dictionary<Type, string> _clientTypeNameDictionary;
        private Dictionary<string, WebServiceEnumData> _enumTypesDictionary;
        private Hashtable _processedTypes;
        private bool _clientTypesProcessed;

        private JavaScriptSerializer _serializer;
        internal JavaScriptSerializer Serializer {
            get {
                return _serializer;
            }
        }


        internal const string _profileServiceFileName = "Profile_JSON_AppService.axd";
        internal const string _authenticationServiceFileName = "Authentication_JSON_AppService.axd";
        internal const string _roleServiceFileName = "Role_JSON_AppService.axd";

        private static WebServiceData GetApplicationService(string appRelativePath) {
            // we only support the application services being accessed at the root level, so that url authorization can be used to control their access.
            // In other words, "~/Profile_JSON_AppService.axd" should work but not "~/SomeSubDir/Profile_JSON_AppService.axd".
            // AppRelativeCurrentExecutionFilePath looks like "~/path/filename.ext".
            // So we can easily detect if the file requested is in the root by ensuring that the last index of "/" is == 1,
            // as in the path "~/rootfile.ext", where "/" is the second character.
            // Note that the WebServiceData object is cached higher in the stack once calculated
            int slashIndex = appRelativePath.LastIndexOf('/');
            if (slashIndex == 1) {
                // it is a root file. Now see if its one of the two built in services
                string name = Path.GetFileName(appRelativePath);

                if (name.Equals(_profileServiceFileName, StringComparison.OrdinalIgnoreCase)) {
                    return new WebServiceData(typeof(System.Web.Profile.ProfileService), false);
                }
                else if (name.Equals(_authenticationServiceFileName, StringComparison.OrdinalIgnoreCase)) {
                    return new WebServiceData(typeof(System.Web.Security.AuthenticationService), false);
                }
                else if (name.Equals(_roleServiceFileName, StringComparison.OrdinalIgnoreCase)) {
                    return new WebServiceData(typeof(System.Web.Security.RoleService), false);
                }
            }

            return null;
        }

        internal static WebServiceData GetWebServiceData(HttpContext context, string virtualPath) {
            return GetWebServiceData(context, virtualPath, true /*failIfNoData*/, false /*pageMethods*/, false/*inlineScript*/);
        }

        private static string GetCacheKey(string virtualPath) {
            return "System.Web.Script.Services.WebServiceData:" + virtualPath;
        }

        internal static WebServiceData GetWebServiceData(HttpContext context, string virtualPath, bool failIfNoData, bool pageMethods) {
            return GetWebServiceData(context, virtualPath, failIfNoData, pageMethods, false /*inlineScript*/);
        }

        [SecuritySafeCritical]
        internal static WebServiceData GetWebServiceData(HttpContext context, string virtualPath, bool failIfNoData, bool pageMethods, bool inlineScript) {
            // Make sure the path is cannonical to avoid doing more work than necessary
            virtualPath = VirtualPathUtility.ToAbsolute(virtualPath);

            string cacheKey = GetCacheKey(virtualPath);
            WebServiceData data = context.Cache[cacheKey] as WebServiceData;

            // Handle the case where the virtualPath exists, for example a real asmx page.
            if (data == null) {
                if (HostingEnvironment.VirtualPathProvider.FileExists(virtualPath)) {
                    Type compiledType = null;
                    try {
                        compiledType = BuildManager.GetCompiledType(virtualPath);

                        // If we can't get the compiled type, try creating an instance (i.e. for no compile pages)
                        if (compiledType == null) {
                            object page = BuildManager.CreateInstanceFromVirtualPath(virtualPath, typeof(System.Web.UI.Page));
                            if (page != null) {
                                compiledType = page.GetType();
                            }
                        }

                    }
                    catch (SecurityException) {
                        // DevDiv 33708: BuildManager requires Medium trust, so we need to no-op rather than
                        // destroying the page.
                    }
                   
                    if (compiledType != null) {
                        data = new WebServiceData(compiledType, pageMethods);
                        BuildDependencySet deps = BuildManager.GetCachedBuildDependencySet(context, virtualPath);
                        if (deps != null) {
                            // Dev10 718863: It's possible 'deps' is null if the service is modified between GetCompiledType and here.
                            // in that case simply do not cache the result so it is re-established next time it is required.
                            CacheDependency cd = HostingEnvironment.VirtualPathProvider.GetCacheDependency(virtualPath, deps.VirtualPaths, DateTime.Now);
                            context.Cache.Insert(cacheKey, data, cd);
                        }
                    }
                }
                else if (virtualPath.EndsWith("_AppService.axd", StringComparison.OrdinalIgnoreCase)) {
                    // File does not exist, but the url may be a request for one of the three built-in services: ProfileService, AuthenticationService, RoleService
                    data = WebServiceData.GetApplicationService(context.Request.AppRelativeCurrentExecutionFilePath);
                    if (data != null) {
                        context.Cache.Insert(cacheKey, data);
                    }
                }
            }

            if (data == null) {
                if (failIfNoData) {
                    if (inlineScript) {
                        //DevDiv 74432: InlineScript = true fails, for WCF serviceReferences: Need an appropriate error message
                        throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.WebService_NoWebServiceDataInlineScript, virtualPath));
                    }
                    else {
                        throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.WebService_NoWebServiceData, virtualPath));
                    }
                }
                else {
                    return null;
                }
            }

            return data;
        }

        internal WebServiceData() {
        }

        private WebServiceData(WebServiceTypeData typeData) {
            _typeData = typeData;
            _serializer = new JavaScriptSerializer(this);
#pragma warning disable 0436
            ScriptingJsonSerializationSection.ApplicationSettings settings = new ScriptingJsonSerializationSection.ApplicationSettings();
#pragma warning restore 0436
            _serializer.MaxJsonLength = settings.MaxJsonLimit;
            _serializer.RecursionLimit = settings.RecursionLimit;
            _serializer.RegisterConverters(settings.Converters);
        }

        // Normal ASMX Atlas codepath for creating webservice data
        internal WebServiceData(Type type, bool pageMethods)
            : this(new WebServiceTypeData(type.Name, type.Namespace, type)) {
            _pageMethods = pageMethods;
            // Pages don't need to have script service attribute
            if (!_pageMethods) {
                object[] attribs = type.GetCustomAttributes(typeof(ScriptServiceAttribute), true);
                if (attribs.Length == 0) {
                    throw new InvalidOperationException(AtlasWeb.WebService_NoScriptServiceAttribute);
                }
            }
        }

        // Indigo entry point for creating WebServiceData
        internal WebServiceData(WebServiceTypeData typeData, Dictionary<string, WebServiceMethodData> methods)
            : this(typeData) {
            _methods = methods;
        }

        private void AddMethod(Dictionary<string, WebServiceMethodData> methods, MethodInfo method) {
            object[] wmAttribs = method.GetCustomAttributes(typeof(WebMethodAttribute), true);

            // Skip it if it doesn't have the WebMethod attribute
            if (wmAttribs.Length == 0)
                return;

            ScriptMethodAttribute sm = null;
            object[] responseAttribs = method.GetCustomAttributes(typeof(ScriptMethodAttribute), true);
            if (responseAttribs.Length > 0) {
                sm = (ScriptMethodAttribute)responseAttribs[0];
            }

            // Create an object to keep track of this method's data
            WebServiceMethodData wmd = new WebServiceMethodData(this, method, (WebMethodAttribute)wmAttribs[0], sm);
            methods[wmd.MethodName] = wmd;
        }

        private void EnsureMethods() {
            // Type will only be null for the Indigo code path
            if (_methods != null || _typeData.Type == null)
                return;

            // Build the method collection on demand
            lock (this) {

                // Need to add the methods of each type in reverse order
                List<Type> typeList = new List<Type>();
                Type current = _typeData.Type;
                typeList.Add(current);
                while (current.BaseType != null) {
                    current = current.BaseType;
                    typeList.Add(current);
                }
                Dictionary<string, WebServiceMethodData> methods = new Dictionary<string, WebServiceMethodData>(StringComparer.OrdinalIgnoreCase);
                BindingFlags flags = BindingFlags.Public | BindingFlags.DeclaredOnly;
                if (_pageMethods) flags |= BindingFlags.Static;
                else flags |= BindingFlags.Instance;

                // Add the methods in reverse order from base to derived
                for (int i = typeList.Count - 1; i >= 0; --i) {
                    MethodInfo[] methodInfos = typeList[i].GetMethods(flags);
                    foreach (MethodInfo method in methodInfos) {
                        AddMethod(methods, method);
                    }
                }
                _methods = methods;
            }
        }

        internal WebServiceTypeData TypeData {
            get { return _typeData; }
        }

        internal ICollection<WebServiceMethodData> MethodDatas {
            get {
                EnsureMethods();
                return _methods.Values;
            }
        }

        internal void ClearProcessedTypes() {
            _processedTypes = null;
        }

        internal void Initialize(WebServiceTypeData typeData, Dictionary<string, WebServiceMethodData> methods) {
            Dictionary<string, WebServiceTypeData> clientTypeDictionary = new Dictionary<string, WebServiceTypeData>();
            _clientTypesDictionary = clientTypeDictionary;
            Dictionary<string, WebServiceEnumData> enumTypeDictionary = new Dictionary<string, WebServiceEnumData>();
            _enumTypesDictionary = enumTypeDictionary;
            _processedTypes = new Hashtable();
            _clientTypesProcessed = true;
            _clientTypeNameDictionary = new Dictionary<Type, string>();
            _typeData = typeData;
            _methods = methods;
        }

        internal WebServiceMethodData GetMethodData(string methodName) {
            EnsureMethods();

            // Fail if the web method doesn't exist
            WebServiceMethodData methodData = null;
            if (!_methods.TryGetValue(methodName, out methodData)) {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, AtlasWeb.WebService_UnknownWebMethod, methodName), "methodName");
            }

            EnsureClientTypesProcessed();
            return methodData;
        }

        private void EnsureClientTypesProcessed() {
            if (_clientTypesProcessed)
                return;

            lock (this) {
                if (_clientTypesProcessed)
                    return;
                ProcessClientTypes();
            }
        }

        private void ProcessClientTypes() {
            Debug.Assert(!_clientTypesProcessed, "ProcessClientTypes shouldn't be called after it has already been successfully run.");

            // List of types that can be instantiated on the client
            _clientTypesDictionary = new Dictionary<string, WebServiceTypeData>();
            _enumTypesDictionary = new Dictionary<string, WebServiceEnumData>();

            _clientTypeNameDictionary = new Dictionary<Type, string>();

            try {
                // _processedTypes is used to avoid processing a Type more than once
                _processedTypes = new Hashtable();

                // Process any GenerateScriptTypes on the Service type
                ProcessIncludeAttributes((GenerateScriptTypeAttribute[])_typeData.Type.GetCustomAttributes(typeof(GenerateScriptTypeAttribute), true));

                foreach (WebServiceMethodData methodData in MethodDatas) {

                    // Process any GenerateScriptTypes on the method
                    ProcessIncludeAttributes((GenerateScriptTypeAttribute[])methodData.MethodInfo.GetCustomAttributes(typeof(GenerateScriptTypeAttribute), true));

                    // Also add any input parameters
                    foreach (WebServiceParameterData paramData in methodData.ParameterDatas) {
                        ProcessClientType(paramData.ParameterInfo.ParameterType);
                    }

                    // Ignore return type if it uses XML instead of JSON
                    if (methodData.UseXmlResponse) continue;
                    ProcessClientType(methodData.ReturnType);
                }

                // DevDiv 60672: Only set to true if the proxies were SUCCESSFULLY processed
                // Only setting _clientTypesProcessed=true on success will cause us to retry creating the proxies each
                // request when there is an exception, and so the same exception will be thrown each time.
                _clientTypesProcessed = true;
            }
            catch {
                // If we have any exception we have to null out our caches
                _clientTypesDictionary = null;
                _enumTypesDictionary = null;
                _clientTypeNameDictionary = null;
                throw;
            }
            finally {
                _processedTypes = null;
            }
        }

        private void ProcessIncludeAttributes(GenerateScriptTypeAttribute[] attributes) {
            foreach (GenerateScriptTypeAttribute attribute in attributes) {
                if (!String.IsNullOrEmpty(attribute.ScriptTypeId))
                    _typeResolverSpecials[attribute.Type.FullName] = attribute.ScriptTypeId;

                Type t = attribute.Type;
                if (t.IsPrimitive || t == typeof(object) || t == typeof(string) ||
                    t == typeof(DateTime) || t == typeof(Guid) ||
                    typeof(IEnumerable).IsAssignableFrom(t) || typeof(IDictionary).IsAssignableFrom(t) ||
                    (t.IsGenericType && t.GetGenericArguments().Length > 1) ||
                    !ObjectConverter.IsClientInstantiatableType(t, _serializer))
                    throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
                        AtlasWeb.WebService_InvalidGenerateScriptType, t.FullName));

                ProcessClientType(t, true);
            }
        }

        private void ProcessClientType(Type t) {
            ProcessClientType(t, false, false);
        }


        private void ProcessClientType(Type t, bool force) {
            ProcessClientType(t, force, false);
        }

        // Force = true is required for when we detect a GenerateScriptType which may supply a new ScriptTypeID
        [SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_clientTypeNameDictionary", Justification = "This is used by ASP.Net web services which is a legacy technology.")]
        internal void ProcessClientType(Type t, bool force, bool isWCF)
        {
            if (!force && _processedTypes.Contains(t))
                return;
            _processedTypes[t] = null;

            // Keep track of all enum Types
            if (t.IsEnum) {
                WebServiceEnumData enumData = null;
                if (isWCF) {
                    enumData = (WebServiceEnumData)WebServiceTypeData.GetWebServiceTypeData(t);
                }
                else {
                    enumData = new WebServiceEnumData(t.Name, t.Namespace, t, Enum.GetNames(t), Enum.GetValues(t), Enum.GetUnderlyingType(t) == typeof(ulong));
                }
                _enumTypesDictionary[GetTypeStringRepresentation(enumData.TypeName, false)] = enumData;
                return;
            }

            // For generics, we only allow generic types with one parameter, which we will try to process
            if (t.IsGenericType) {
                if (isWCF) {
                     ProcessKnownTypes(t);
                }
                else {
                    Type[] genericArgs = t.GetGenericArguments();
                    if (genericArgs.Length > 1) {
                        return;
                    }
                    ProcessClientType(genericArgs[0], false, isWCF);
                }
            }
            // Support arrays explicitly
            else if (t.IsArray) {
                ProcessClientType(t.GetElementType(), false, isWCF);
            }
            else {
                // Ignore primitive types
                // Ignore DateTime, since we have special serialization handling for it in the JavaScriptSerializer
                // Ignore IDctionary and IEnumerables as well
                if (t.IsPrimitive || t == typeof(object) || t == typeof(string) || t == typeof(DateTime) ||
                    t == typeof(void) || t == typeof(System.Decimal) || t == typeof(Guid) ||
                    typeof(IEnumerable).IsAssignableFrom(t) || typeof(IDictionary).IsAssignableFrom(t) ||
                    (!isWCF && !ObjectConverter.IsClientInstantiatableType(t, _serializer)))
                    return;

                // Only add it to the list of client types if it can be instantiated.
                // pass false to skip the lock
                if (isWCF) {
                    ProcessKnownTypes(t);
                }
                else {
                    string typeStringRepresentation = GetTypeStringRepresentation(t.FullName, false);
                    _clientTypesDictionary[typeStringRepresentation] = new WebServiceTypeData(t.Name, t.Namespace, t);
                    _clientTypeNameDictionary[t] = typeStringRepresentation;

                }
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2301:EmbeddableTypesInContainersRule", MessageId = "_clientTypeNameDictionary", Justification = "This is used by ASP.Net web services which is a legacy technology. Fun fact : The current code path suggests that this method is never hit!!")]
        private void ProcessKnownTypes(Type t)
        {
            WebServiceTypeData typeData = WebServiceTypeData.GetWebServiceTypeData(t);
            bool alreadyProcessed = false;
            if (typeData == null) {
                // indicates a type was used that is a built-in type
                return;
            }

            // if T implments IEnumerable or IDictionary, do not include type proxy for it
            // but still continue to get known types. I.e List<MyType> should ignore List<MyType> 
            // but process MyType
            if (!(typeof(IEnumerable).IsAssignableFrom(t) || typeof(IDictionary).IsAssignableFrom(t))) {
                 _clientTypeNameDictionary[t] = GetTypeStringRepresentation(typeData.TypeName);
                 alreadyProcessed = ProcessTypeData(typeData);
            }
            
            if (!alreadyProcessed) {
                IList<WebServiceTypeData> knownTypes = WebServiceTypeData.GetKnownTypes(t, typeData);
                foreach (WebServiceTypeData knownType in knownTypes) {
                    ProcessTypeData(knownType);
                }
            }

        }

        // returns true if typeData already exists in typeDictionary
        private bool ProcessTypeData(WebServiceTypeData typeData) {
            string typeString = GetTypeStringRepresentation(typeData.TypeName);
            bool retval = true;
            if (typeData is WebServiceEnumData) {
                if (!_enumTypesDictionary.ContainsKey(typeString)) {
                    _enumTypesDictionary[typeString] = (WebServiceEnumData)typeData;
                    retval = false;
                }
            }
            else {
                if (!_clientTypesDictionary.ContainsKey(typeString)) {
                    _clientTypesDictionary[typeString] = typeData;
                    retval = false;
                }
            }
            return retval;
        }


        internal IEnumerable<WebServiceTypeData> ClientTypes {
            get {
                return ClientTypeDictionary.Values;
            }
        }

        internal Dictionary<string, WebServiceTypeData> ClientTypeDictionary {
            get {
                EnsureClientTypesProcessed();
                return _clientTypesDictionary;
            }
            set {
                _clientTypesDictionary = value;
            }
        }

        internal Dictionary<Type, string> ClientTypeNameDictionary {
            get {
                EnsureClientTypesProcessed();
                return _clientTypeNameDictionary;
            }
        }

        internal IEnumerable<WebServiceEnumData> EnumTypes {
            get {
                EnsureClientTypesProcessed();
                return _enumTypesDictionary.Values;
            }
        }

        internal Dictionary<string, WebServiceEnumData> EnumTypeDictionary {
            get {
                EnsureClientTypesProcessed();
                return _enumTypesDictionary;
            }
            set {
                _enumTypesDictionary = value;
            }
        }

        public override Type ResolveType(string id) {
            WebServiceTypeData type = null;
            if (ClientTypeDictionary.TryGetValue(id, out type)) {
                if (type != null) {
                    return type.Type;
                }
            }
            return null;
        }

        public override string ResolveTypeId(Type type) {
            string typeString = GetTypeStringRepresentation(type.FullName);

            // If this type is not in the dictionary
            if (!ClientTypeDictionary.ContainsKey(typeString))
                return null;

            return typeString;
        }

        internal string GetTypeStringRepresentation(string typeName) {
            return GetTypeStringRepresentation(typeName, true);
        }

        internal string GetTypeStringRepresentation(string typeName, bool ensure) {
            if (ensure) {
                EnsureClientTypesProcessed();
            }

            // Handle special cases from GenerateScriptType first
            string typeString;
            if (_typeResolverSpecials.TryGetValue(typeName, out typeString)) {
                return typeString;
            }
            return typeName;
        }

        internal string GetTypeStringRepresentation(WebServiceTypeData typeData) {
            //First check if typeData provides its string representaiton ( for WCF case)
            string typeString = typeData.StringRepresentation;
            if (typeString == null) {
                typeString = GetTypeStringRepresentation(typeData.TypeName, true);
            }
            return typeString;
        }
    }
}