// Copyright © 2021 The CefSharp Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading.Tasks;

namespace CefSharp.SchemeHandler
{
    //Shorthand for Owin pipeline func
    using AppFunc = Func<IDictionary<string, object>, Task>;

    /// <summary>
    /// <see cref="ResourceHandler"/> implementation that uses an OWIN capable host of fulfilling requests.
    /// Can be used with NancyFx or AspNet Core
    /// </summary>
    /// TODO:
    ///   - Multipart post data
    ///   - Cancellation Token
    public class OwinResourceHandler : ResourceHandler
    {
        private static readonly Dictionary<int, string> StatusCodeToStatusTextMapping = new Dictionary<int, string>
        {
            {200, "OK"},
            {301, "Moved Permanently"},
            {304, "Not Modified"},
            {404, "Not Found"}
        };

        private readonly AppFunc appFunc;

        /// <summary>
        /// OwinResourceHandler
        /// </summary>
        /// <param name="appFunc">Owin pipeline func</param>
        public OwinResourceHandler(AppFunc appFunc)
        {
            this.appFunc = appFunc;
        }

        /// <summary>
        /// Read the request, then process it through the OWEN pipeline
        /// then populate the response properties.
        /// </summary>
        /// <param name="request">request</param>
        /// <param name="callback">callback</param>
        /// <returns>always returns true as we'll handle all requests this handler is registered for.</returns>
        public override CefReturnValue ProcessRequestAsync(IRequest request, ICallback callback)
        {
            // PART 1 - Read the request - here we read the request and create a dictionary
            // that follows the OWEN standard

            var responseStream = new MemoryStream();
            var requestBody = Stream.Null;

            if (request.Method == "POST")
            {
                using (var postData = request.PostData)
                {
                    if (postData != null)
                    {
                        var postDataElements = postData.Elements;


                        var firstPostDataElement = postDataElements.First();

                        var bytes = firstPostDataElement.Bytes;

                        requestBody = new MemoryStream(bytes, 0, bytes.Length);

                        //TODO: Investigate how to process multi part POST data
                        //var charSet = request.GetCharSet();
                        //foreach (var element in elements)
                        //{
                        //    if (element.Type == PostDataElementType.Bytes)
                        //    {
                        //        var body = element.GetBody(charSet);
                        //    }
                        //}
                    }
                }
            }

            //var cancellationTokenSource = new CancellationTokenSource();
            //var cancellationToken = cancellationTokenSource.Token;
            var uri = new Uri(request.Url);
            var requestHeaders = ToDictionary(request.Headers);
            //Add Host header as per http://owin.org/html/owin.html#5-2-hostname
            requestHeaders.Add("Host", new[] { uri.Host + (uri.Port > 0 ? (":" + uri.Port) : "") });

            //http://owin.org/html/owin.html#3-2-environment
            //The Environment dictionary stores information about the request,
            //the response, and any relevant server state.
            //The server is responsible for providing body streams and header collections for both the request and response in the initial call.
            //The application then populates the appropriate fields with response data, writes the response body, and returns when done.
            //Keys MUST be compared using StringComparer.Ordinal.
            var owinEnvironment = new Dictionary<string, object>(StringComparer.Ordinal)
            {
                //Request http://owin.org/html/owin.html#3-2-1-request-data
                {"owin.RequestBody", requestBody},
                {"owin.RequestHeaders", requestHeaders},
                {"owin.RequestMethod", request.Method},
                {"owin.RequestPath", uri.AbsolutePath},
                {"owin.RequestPathBase", "/"},
                {"owin.RequestProtocol", "HTTP/1.1"},
                //To conform to the OWIN spec we need to remove the leading '?'
                {"owin.RequestQueryString", string.IsNullOrEmpty(uri.Query) ? string.Empty : uri.Query.Substring(1)},
                {"owin.RequestScheme", uri.Scheme},
                //Response http://owin.org/html/owin.html#3-2-2-response-data
                {"owin.ResponseHeaders", new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)},
                {"owin.ResponseBody", responseStream},
                //Other Data
                {"owin.Version", "1.0.0"},
                //{"owin.CallCancelled", cancellationToken}
            };

            //PART 2 - Spawn a new task to execute the OWIN pipeline
            //We execute this in an async fashion and return true so other processing
            //can occur
            Task.Run(async () =>
            {
                //Call into the OWEN pipeline
                try
                {
                    await appFunc(owinEnvironment);

                    //Response has been populated - reset the position to 0 so it can be read
                    responseStream.Position = 0;

                    int statusCode;

                    if (owinEnvironment.ContainsKey("owin.ResponseStatusCode"))
                    {
                        statusCode = Convert.ToInt32(owinEnvironment["owin.ResponseStatusCode"]);
                        //TODO: Improve status code mapping - see if CEF has a helper function that can be exposed
                        //StatusText = StatusCodeToStatusTextMapping[response.StatusCode];
                    }
                    else
                    {
                        statusCode = (int)HttpStatusCode.OK;
                        //StatusText = "OK";
                    }

                    //Grab a reference to the ResponseHeaders
                    var responseHeaders = (Dictionary<string, string[]>)owinEnvironment["owin.ResponseHeaders"];

                    //Populate the response properties
                    Stream = responseStream;
                    ResponseLength = responseStream.Length;
                    StatusCode = statusCode;

                    if(responseHeaders.ContainsKey("Content-Type"))
                    {
                        var contentType = responseHeaders["Content-Type"].First();
                        MimeType = contentType.Split(';').First();
                    }
                    else
                    {
                        MimeType = DefaultMimeType;
                    }                    

                    //Add the response headers from OWIN to the Headers NameValueCollection
                    foreach (var responseHeader in responseHeaders)
                    {
                        //It's possible for headers to have multiple values
                        foreach (var val in responseHeader.Value)
                        {
                            Headers.Add(responseHeader.Key, val);
                        }
                    }
                }
                catch(Exception ex)
                {
                    int statusCode = (int)HttpStatusCode.InternalServerError;

                    var responseData = GetByteArray("Error: " + ex.ToString(), System.Text.Encoding.UTF8, true);

                    //Populate the response properties
                    Stream = new MemoryStream(responseData);
                    ResponseLength = responseData.Length;
                    StatusCode = statusCode;
                    MimeType = "text/html";
                }

                //Once we've finished populating the properties we execute the callback
                //Callback wraps an unmanaged resource, so let's explicitly Dispose when we're done    
                using (callback)
                {
                    callback.Continue();
                }
            });

            return CefReturnValue.ContinueAsync;
        }

        private static IDictionary<string, string[]> ToDictionary(NameValueCollection nameValueCollection)
        {
            var dict = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
            foreach (var key in nameValueCollection.AllKeys)
            {
                if (!dict.ContainsKey(key))
                {
                    dict.Add(key, new string[0]);
                }
                var strings = nameValueCollection.GetValues(key);
                if (strings == null)
                {
                    continue;
                }
                foreach (string value in strings)
                {
                    var values = dict[key].ToList();
                    values.Add(value);
                    dict[key] = values.ToArray();
                }
            }
            return dict;
        }
    }
}