//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------
#pragma warning disable 1634, 1691
namespace System.ServiceModel.Description
{
    using System.Collections.Generic;
    using System.Linq;
    using System.Net.Mime;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.ServiceModel.Dispatcher;
    using System.ServiceModel.Web;
    using System.Diagnostics;
    using System.ServiceModel.Diagnostics;

    class FormatSelectingMessageInspector : IDispatchMessageInspector
    {
        static readonly IEnumerable<string> wildcardMediaTypes = new List<string>() { "application", "text" };

        List<MultiplexingFormatMapping> mappings;
        Dictionary<string, MultiplexingDispatchMessageFormatter> formatters;
        Dictionary<string, NameValueCache<FormatContentTypePair>> caches;
        bool automaticFormatSelectionEnabled;
        
        // There are technically an infinite number of valid accept headers for just xml and json,
        // but to prevent DOS attacks, we need to set an upper limit. It is assumed that there would 
        // never be more than two dozen valid accept headers actually used out in the wild.
        static readonly int maxCachedAcceptHeaders = 25;

        public FormatSelectingMessageInspector(WebHttpBehavior webHttpBehavior, List<MultiplexingFormatMapping> mappings)
        {
            if (webHttpBehavior == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("webHttpBehavior");
            }
            if (mappings == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("mappings");
            }

            this.automaticFormatSelectionEnabled = webHttpBehavior.AutomaticFormatSelectionEnabled;
            
            this.formatters = new Dictionary<string, MultiplexingDispatchMessageFormatter>();

            this.caches = new Dictionary<string, NameValueCache<FormatContentTypePair>>();

            this.mappings = mappings;
        }

        public void RegisterOperation(string operationName, MultiplexingDispatchMessageFormatter formatter)
        {
            if (formatter == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("formatter");
            }
            Fx.Assert(!this.formatters.ContainsKey(operationName), "An operation should only be registered once.");
            this.formatters.Add(operationName, formatter);
            this.caches.Add(operationName, new NameValueCache<FormatContentTypePair>(maxCachedAcceptHeaders));
        }

        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            if (this.automaticFormatSelectionEnabled)
            {
                MessageProperties messageProperties = OperationContext.Current.IncomingMessageProperties;
                if (messageProperties.ContainsKey(WebHttpDispatchOperationSelector.HttpOperationNamePropertyName))
                {
                    string operationName = messageProperties[WebHttpDispatchOperationSelector.HttpOperationNamePropertyName] as string;
                    if (!string.IsNullOrEmpty(operationName) && this.formatters.ContainsKey(operationName))
                    {

                        string acceptHeader = WebOperationContext.Current.IncomingRequest.Accept;
                        if (!string.IsNullOrEmpty(acceptHeader))
                        {
                            if (TrySetFormatFromCache(operationName, acceptHeader) ||
                                TrySetFormatFromAcceptHeader(operationName, acceptHeader, true /* matchCharSet */) ||
                                TrySetFormatFromAcceptHeader(operationName, acceptHeader, false /* matchCharSet */))
                            {
                                return null;
                            }
                        }
                        if (TrySetFormatFromContentType(operationName))
                        {
                            return null;
                        }
                        SetFormatFromDefault(operationName);
                    }
                }
            }
            return null;
        }

        public void BeforeSendReply(ref Message reply, object correlationState)
        {
            // do nothing
        }

        bool TrySetFormatFromCache(string operationName, string acceptHeader)
        {
            Fx.Assert(this.caches.ContainsKey(operationName), "The calling method is responsible for ensuring that the 'operationName' key exists in the caches dictionary.");
            Fx.Assert(acceptHeader != null, "The calling method is responsible for ensuring that 'acceptHeader' is not null");

            FormatContentTypePair pair = caches[operationName].Lookup(acceptHeader.ToUpperInvariant());
            if (pair != null)
            {
                SetFormatAndContentType(pair.Format, pair.ContentType);
                return true;
            }
            return false;
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Given that media types are generally in lowercase, it is awkward to normalize to uppercase.")]
        bool TrySetFormatFromAcceptHeader(string operationName, string acceptHeader, bool matchCharSet)
        {
            Fx.Assert(this.formatters.ContainsKey(operationName), "The calling method is responsible for ensuring that the 'operationName' key exists in the formatters dictionary.");
            
            IList<ContentType> acceptHeaderElements = WebOperationContext.Current.IncomingRequest.GetAcceptHeaderElements();

            for (int i = 0; i < acceptHeaderElements.Count; i++)
            {
                string[] typeAndSubType = acceptHeaderElements[i].MediaType.Split('/');
                string type = typeAndSubType[0].Trim().ToLowerInvariant();
                string subType = typeAndSubType[1].Trim();
                
                if ((subType[0] == '*' && subType.Length == 1) &&
                     ((type[0] == '*' && type.Length == 1) ||
                      wildcardMediaTypes.Contains(type)))
                {
                    SetFormatFromDefault(operationName, acceptHeader);
                    return true;
                }

                foreach (MultiplexingFormatMapping mapping in mappings)
                {
                    ContentType contentType;
                    WebMessageFormat format = mapping.MessageFormat;
                    if (this.formatters[operationName].SupportsMessageFormat(format) &&
                        mapping.CanFormatResponse(acceptHeaderElements[i], matchCharSet, out contentType))
                    {
                        string contentTypeStr = contentType.ToString();
                        this.caches[operationName].AddOrUpdate(acceptHeader.ToUpperInvariant(), new FormatContentTypePair(format, contentTypeStr));
                        SetFormatAndContentType(format, contentTypeStr);
                        return true;
                    }
                }
            }
            return false;
        }

        bool TrySetFormatFromContentType(string operationName)
        {
            Fx.Assert(this.formatters.ContainsKey(operationName), "The calling method is responsible for ensuring that the 'operationName' key exists in the formatters dictionary.");
            
            string contentTypeStr = WebOperationContext.Current.IncomingRequest.ContentType;
            if (contentTypeStr != null)
            {
                ContentType contentType = Web.Utility.GetContentType(contentTypeStr);
                if (contentType != null)
                {
                    foreach (MultiplexingFormatMapping mapping in mappings)
                    {
                        ContentType responseContentType;
                        if (this.formatters[operationName].SupportsMessageFormat(mapping.MessageFormat) &&
                            mapping.CanFormatResponse(contentType, false, out responseContentType))
                        {
                            SetFormatAndContentType(mapping.MessageFormat, responseContentType.ToString());
                            return true;
                        }
                    }
                }
            }

            return false;
        }

        void SetFormatFromDefault(string operationName)
        {
            SetFormatFromDefault(operationName, null);
        }

        void SetFormatFromDefault(string operationName, string acceptHeader)
        {
            Fx.Assert(this.formatters.ContainsKey(operationName), "The calling method is responsible for ensuring that the 'operationName' key exists in the formatters dictionary.");
            WebMessageFormat format = this.formatters[operationName].DefaultFormat;
            
            if (!string.IsNullOrEmpty(acceptHeader))
            {
                this.caches[operationName].AddOrUpdate(acceptHeader.ToUpperInvariant(), new FormatContentTypePair(format, null));
            }

            WebOperationContext.Current.OutgoingResponse.Format = format;

            if (DiagnosticUtility.ShouldTraceInformation)
            {
                TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.AutomaticFormatSelectedOperationDefault, SR2.GetString(SR2.TraceCodeAutomaticFormatSelectedOperationDefault, format.ToString()));
            }
        }

        void SetFormatAndContentType(WebMessageFormat format, string contentType)
        {
            OutgoingWebResponseContext outgoingResponse = WebOperationContext.Current.OutgoingResponse;
            outgoingResponse.Format = format;
            outgoingResponse.AutomatedFormatSelectionContentType = contentType;

            if (DiagnosticUtility.ShouldTraceInformation)
            {
                TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.AutomaticFormatSelectedRequestBased, SR2.GetString(SR2.TraceCodeAutomaticFormatSelectedRequestBased, format.ToString(), contentType));
            }
        }

        class FormatContentTypePair
        {
            WebMessageFormat format;
            string contentType;

            public FormatContentTypePair(WebMessageFormat format, string contentType)
            {
                this.format = format;
                this.contentType = contentType;
            }

            public WebMessageFormat Format
            {
                get { return this.format; }
            }

            public string ContentType
            {
                get { return this.contentType; }
            }
        }
    }
}