//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------

namespace System.ServiceModel.Web
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Net.Mime;
    using System.Runtime;
    using System.Text;
    using System.Globalization;
    using System.ServiceModel.Channels;
    
    static class Utility
    {
        public const string applicationXml = "application/xml";
        public const string textXml = "text/xml";
        public const string applicationJson = "application/json";
        public const string textJson = "text/json";
        public const string GET = "GET";
        

        public static bool IsXmlContent(this string contentType)
        {
            if (contentType == null)
            {
                return true;
            }

            string contentTypeProcessed = contentType.Trim();

            return contentTypeProcessed.StartsWith(applicationXml, StringComparison.OrdinalIgnoreCase)
                || contentTypeProcessed.StartsWith(textXml, StringComparison.OrdinalIgnoreCase);
        }

        public static bool IsJsonContent(this string contentType)
        {
            if (contentType == null)
            {
                return true;
            }

            string contentTypeProcessed = contentType.Trim();

            return contentTypeProcessed.StartsWith(applicationJson, StringComparison.OrdinalIgnoreCase)
                || contentTypeProcessed.StartsWith(textJson, StringComparison.OrdinalIgnoreCase);
        }

        public static string CombineUri(string former, string latter)
        {
            // Appending the latter string to the form string,
            // while making sure there is a single slash char seperating the latter and the former.
            // This method behaves differently than new Uri(baseUri, relativeUri)
            // as CombineUri simply appends, whereas new Uri() actually replaces the last segment
            // of the its base path with the relative uri.

            StringBuilder builder = new StringBuilder();
            if (former.Length > 0 && latter.Length > 0)
            {
                if (former[former.Length - 1] == '/' && latter[0] == '/')
                {
                    builder.Append(former, 0, former.Length - 1);
                    builder.Append(latter);
                    return builder.ToString();
                }

                if (former[former.Length - 1] != '/' && latter[0] != '/')
                {
                    builder.Append(former);
                    builder.Append('/');
                    builder.Append(latter);
                    return builder.ToString();
                }
            }

            return former + latter;
        }
        public static List<string> QuoteAwareStringSplit(string str)
        {
            List<string> subStrings = new List<string>();
            int offset = 0;
            while (true)
            {
                string subString = QuoteAwareSubString(str, ref offset);
                if (subString == null)
                {
                    break;
                }
                subStrings.Add(subString);
            }

            return subStrings;
        }

        // This method extracts substrings from a string starting at the offset
        // and up until the next comma in the string.  The sub string extraction is 
        // quote aware such that commas inside quoted-strings are ignored.  On return, 
        // offset points to the next char beyond the comma of the substring returned 
        // and may point beyond the length of the header.
        public static string QuoteAwareSubString(string str, ref int offset)
        {
            // this method will filter out empty-string and white-space-only items in 
            // the header.  For example "x,,y" and "x, ,y" would result in just "x" and "y"
            // substrings being returned.

            if (string.IsNullOrEmpty(str) || offset >= str.Length)
            {
                return null;
            }

            int startIndex = (offset > 0) ? offset : 0;

            // trim whitespace and commas from the begining of the item
            while (char.IsWhiteSpace(str[startIndex]) || str[startIndex] == ',')
            {
                startIndex++;
                if (startIndex >= str.Length)
                {
                    return null;
                }
            }

            int endIndex = startIndex;
            bool insideQuotes = false;

            while (endIndex < str.Length)
            {
                if (str[endIndex] == '\"' &&
                   (!insideQuotes || endIndex == 0 || str[endIndex - 1] != '\\'))
                {
                    insideQuotes = !insideQuotes;
                }
                else if (str[endIndex] == ',' && !insideQuotes)
                {
                    break;
                }
                endIndex++;
            }
            offset = endIndex + 1;

            // trim whitespace from the end of the item; the substring is guaranteed to
            // have at least one non-whitespace character
            while (char.IsWhiteSpace(str[endIndex - 1]))
            {
                endIndex--;
            }

            return str.Substring(startIndex, endIndex - startIndex);
        }

        public static ContentType GetContentType(string contentType)
        {
            string contentTypeTrimmed = contentType.Trim();
            if (!string.IsNullOrEmpty(contentTypeTrimmed))
            {
                return GetContentTypeOrNull(contentTypeTrimmed);
            }
            return null;
        }

        public static ContentType GetContentTypeOrNull(string contentType)
        {
            try
            {
                Fx.Assert(contentType == contentType.Trim(), "The ContentType input argument should already be trimmed.");
                Fx.Assert(!string.IsNullOrEmpty(contentType), "The ContentType input argument should not be null or empty.");
                
                ContentType contentTypeToReturn = new ContentType(contentType);

                // Need to check for "*/<Something-other-than-*>" because the ContentType constructor doesn't catch this
                string[] typeAndSubType = contentTypeToReturn.MediaType.Split('/');
                Fx.Assert(typeAndSubType.Length == 2, "The creation of the ContentType would have failed if there wasn't a type and subtype.");
                if (typeAndSubType[0][0] == '*' && typeAndSubType[0].Length == 1 &&
                    !(typeAndSubType[1][0] == '*' && typeAndSubType[1].Length == 1))
                {
                    // 



                    // throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new FormatException(
                    // SR2.GetString(SR2.InvalidContentType, contentType)));
                    return null;
                }
                return contentTypeToReturn;
            }
            catch (FormatException e)
            {
                // Return null to indicate that the content type creation failed
                System.ServiceModel.DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
            }
            return null;
        }

        public static string IEnumerableToCommaSeparatedString(IEnumerable<string> items)
        {
            Fx.Assert(items != null, "The 'items' argument should never be null.");
            return string.Join(", ", items);
        }

        public static void AddRange<T>(ICollection<T> list, IEnumerable<T> itemsToAdd)
        {
            Fx.Assert(list != null, "The 'list' argument should never be null.");
            Fx.Assert(itemsToAdd != null, "The 'itemsToAdd' argument should never be null.");

            foreach (T item in itemsToAdd)
            {
                list.Add(item);
            }
        }
    }
}