using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using Newtonsoft.Json;
using System.IO.Compression;
using System.IO.Pipes;

namespace MontoyaTech.Rest.Net
{
    /// <summary>
    /// A set of extensions to help with HttpListenerResponses.
    /// </summary>
    public static class HttpListenerResponseExtensions
    {
        /// <summary>
        /// Sets the response to have no body.
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        public static HttpListenerResponse WithNoBody(this HttpListenerResponse response)
        {
            response.ContentLength64 = 0;

            return response;
        }

        /// <summary>
        /// Sets the response content type to text and writes the given text to it.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="text"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithText(this HttpListenerResponse response, string text)
        {
            response.ContentType = "text/plain; charset=utf-8";

            var bytes = Encoding.UTF8.GetBytes(text);

            response.ContentLength64 = bytes.Length;

            response.OutputStream.Write(bytes, 0, bytes.Length);

            response.OutputStream.Dispose();

            return response;
        }

        /// <summary>
        /// Sets the response content type to text and writes the given text compressed to it.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="text"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCompressedText(this HttpListenerResponse response, string text)
        {
            response.ContentType = "text/plain; charset=utf-8";

            response.Headers.Add("Content-Encoding", "gzip");

            var bytes = Encoding.UTF8.GetBytes(text);

            using (var memoryStream = new MemoryStream())
            {
                using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
                    compressedStream.Write(bytes, 0, bytes.Length);

                response.ContentLength64 = memoryStream.Length;

                memoryStream.Seek(0, SeekOrigin.Begin);

                memoryStream.CopyTo(response.OutputStream);

                response.OutputStream.Dispose();
            }

            return response;
        }

        /// <summary>
        /// Sets the response content type to json and serializes the object as json and writes it.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="obj"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithJson(this HttpListenerResponse response, object obj)
        {
            response.ContentType = "application/json; charset=utf-8";

            var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));

            response.ContentLength64 = bytes.Length;

            response.OutputStream.Write(bytes, 0, bytes.Length);

            response.OutputStream.Dispose();

            return response;
        }

        /// <summary>
        /// Sets the response content type to json and writes the given json compressed to it.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="obj"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCompressedJson(this HttpListenerResponse response, object obj)
        {
            response.ContentType = "application/json; charset=utf-8";
            response.Headers.Add("Content-Encoding", "gzip");

            var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));

            using (var memoryStream = new MemoryStream())
            {
                using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
                    compressedStream.Write(bytes, 0, bytes.Length);

                response.ContentLength64 = memoryStream.Length;

                memoryStream.Seek(0, SeekOrigin.Begin);

                memoryStream.CopyTo(response.OutputStream);

                response.OutputStream.Dispose();
            }

            return response;
        }

        /// <summary>
        /// Sets the response content type to a file and writes the given file content to the response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="filePath">The path of the file to send.</param>
        /// <param name="mimeType">The mime type of the file to send, if null, it will be auto detected if possible.</param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithFile(this HttpListenerResponse response, string filePath, string mimeType = null)
        {
            if (string.IsNullOrWhiteSpace(filePath))
                throw new ArgumentException("filePath must not be null or empty");

            if (string.IsNullOrWhiteSpace(mimeType))
                mimeType = Path.GetExtension(filePath).GetMimeType();

            response.ContentType = mimeType;
            response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");

            using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            {
                response.ContentLength64 = fileStream.Length;

                fileStream.CopyTo(response.OutputStream);

                response.OutputStream.Dispose();
            }

            return response;
        }

        /// <summary>
        /// Sets the response content type to a file and writes the file content with name to the response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="filePath"></param>
        /// <param name="content"></param>
        /// <param name="mimeType"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public static HttpListenerResponse WithFile(this HttpListenerResponse response, string filePath, byte[] content, string mimeType = null)
        {
            if (string.IsNullOrWhiteSpace(filePath))
                throw new ArgumentException("filePath must not be null or empty");

            if (string.IsNullOrWhiteSpace(mimeType))
                mimeType = Path.GetExtension(filePath).GetMimeType();

            response.ContentType = mimeType;
            response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
            response.ContentLength64 = content.Length;

            response.OutputStream.Write(content, 0, content.Length);

            response.OutputStream.Dispose();

            return response;
        }

        /// <summary>
        /// Sets the response content type to a file and compresses the given file content to the response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="filePath">The path of the file to send.</param>
        /// <param name="mimeType">The mime type of the file to send, if null, it will be auto detected if possible.</param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCompressedFile(this HttpListenerResponse response, string filePath, string mimeType = null)
        {
            if (string.IsNullOrWhiteSpace(filePath))
                throw new ArgumentException("filePath must not be null or empty");

            if (string.IsNullOrWhiteSpace(mimeType))
                mimeType = Path.GetExtension(filePath).GetMimeType();

            response.ContentType = mimeType;
            response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
            response.Headers.Add("Content-Encoding", "gzip");

            using (var memoryStream = new MemoryStream())
            {
                using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
                using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
                    fileStream.CopyTo(compressedStream);

                response.ContentLength64 = memoryStream.Length;

                memoryStream.Seek(0, SeekOrigin.Begin);

                memoryStream.CopyTo(response.OutputStream);

                response.OutputStream.Dispose();
            }

            return response;
        }

        /// <summary>
        /// Sets the response content type to a file and writes the file content with name to the response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="filePath"></param>
        /// <param name="content"></param>
        /// <param name="mimeType"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public static HttpListenerResponse WithCompressedFile(this HttpListenerResponse response, string filePath, byte[] content, string mimeType = null)
        {
            if (string.IsNullOrWhiteSpace(filePath))
                throw new ArgumentException("filePath must not be null or empty");

            if (string.IsNullOrWhiteSpace(mimeType))
                mimeType = Path.GetExtension(filePath).GetMimeType();

            response.ContentType = mimeType;
            response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
            response.Headers.Add("Content-Encoding", "gzip");

            using (var memoryStream = new MemoryStream())
            {
                using (var compressedStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
                    compressedStream.Write(content, 0, content.Length);

                response.ContentLength64 = memoryStream.Length;

                memoryStream.Seek(0, SeekOrigin.Begin);

                memoryStream.CopyTo(response.OutputStream);

                response.OutputStream.Dispose();
            }

            return response;
        }

        /// <summary>
        /// Sets the response content type to a precompressed file and writes the file contents to the response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="filePath"></param>
        /// <param name="content"></param>
        /// <param name="mimeType"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentException"></exception>
        public static HttpListenerResponse WithPreCompressedFile(this HttpListenerResponse response, string filePath, byte[] content, string mimeType = null)
        {
            if (string.IsNullOrWhiteSpace(filePath))
                throw new ArgumentException("filePath must not be null or empty");

            if (string.IsNullOrWhiteSpace(mimeType))
                mimeType = Path.GetExtension(filePath).GetMimeType();

            response.ContentType = mimeType;
            response.Headers.Add("Content-Deposition", $@"attachment; filename=""{Path.GetFileName(filePath)}""");
            response.Headers.Add("Content-Encoding", "gzip");
            response.ContentLength64 = content.Length;

            response.OutputStream.Write(content, 0, content.Length);

            response.OutputStream.Dispose();

            return response;
        }

        /// <summary>
        /// Sets the response content type to html and writes the given html to it.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="html"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithHtml(this HttpListenerResponse response, string html)
        {
            response.ContentType = "text/html; charset=utf-8";

            var bytes = Encoding.UTF8.GetBytes(html);

            response.ContentLength64 = bytes.Length;

            response.OutputStream.Write(bytes, 0, bytes.Length);

            return response;
        }

        /// <summary>
        /// Sets the status code for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="status"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithStatus(this HttpListenerResponse response, HttpStatusCode status)
        {
            try
            {
                response.StatusCode = (int)status;
                return response;
            }
            catch
            {
                return response;
            }
        }

        /// <summary>
        /// Sets a cookie for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="name">The name of the cookie</param>
        /// <param name="value">The value of the cookie</param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value)
        {
            response.SetCookie(new Cookie(name, value));

            return response;
        }

        /// <summary>
        /// Sets a cookie for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="expires"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, DateTime expires)
        {
            response.SetCookie(new Cookie(name, value) { Expires = expires });

            return response;
        }
    
        /// <summary>
        /// Sets a cookie for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="httpOnly"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, bool httpOnly)
        {
            response.SetCookie(new Cookie(name, value) { HttpOnly = httpOnly });

            return response;
        }

        /// <summary>
        /// Sets a cookie for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="httpOnly"></param>
        /// <param name="secure"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, bool httpOnly, bool secure)
        {
            response.SetCookie(new Cookie(name, value) { HttpOnly = httpOnly, Secure = secure });

            return response;
        }

        /// <summary>
        /// Sets a cookie for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="httpOnly"></param>
        /// <param name="secure"></param>
        /// <param name="expires"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCookie(this HttpListenerResponse response, string name, string value, bool httpOnly, bool secure, DateTime expires)
        {
            response.SetCookie(new Cookie(name, value) { HttpOnly = httpOnly, Secure = secure, Expires = expires });

            return response;
        }

        /// <summary>
        /// Sets a cookie for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="cookie"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithCookie(this HttpListenerResponse response, Cookie cookie)
        {
            response.SetCookie(cookie);

            return response;
        }

        /// <summary>
        /// Sets a header for a given response.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithHeader(this HttpListenerResponse response, string name, string value)
        {
            response.AddHeader(name, value);

            return response;
        }

        /// <summary>
        /// Sets the status code for a given response to redirect with the url to redirect to.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="url"></param>
        /// <returns>This response.</returns>
        public static HttpListenerResponse WithRedirect(this HttpListenerResponse response, string url)
        {
            try
            {
                response.StatusCode = (int)HttpStatusCode.Redirect;

                response.AddHeader("Location", url);

                return response;
            }
            catch
            {
                return response;
            }
        }

        /// <summary>
        /// Sets the response to bad request with a text message saying the request was null or empty.
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        public static HttpListenerResponse BadRequestNull(this HttpListenerResponse response)
        {
            return response.WithStatus(HttpStatusCode.BadRequest).WithText("Request was null or empty.");
        }

        /// <summary>
        /// Sets the response to a bad request with a text message saying the request was invalid.
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        public static HttpListenerResponse BadRequestInvalid(this HttpListenerResponse response)
        {
            return response.WithStatus(HttpStatusCode.BadRequest).WithText("Request data was invalid.");
        }

        /// <summary>
        /// Sets the response to a bad request with a text message saying the request was out of range.
        /// </summary>
        /// <param name="response"></param>
        /// <returns></returns>
        public static HttpListenerResponse BadRequestOutOfRange(this HttpListenerResponse response)
        {
            return response.WithStatus(HttpStatusCode.BadRequest).WithText("Request data was out of range");
        }

        /// <summary>
        /// Sets the response to a bad request with a text message saying a field in the request was out of range.
        /// </summary>
        /// <param name="response"></param>
        /// <param name="fieldName"></param>
        /// <returns></returns>
        public static HttpListenerResponse BadRequestOutOfRange(this HttpListenerResponse response, string fieldName)
        {
            return response.WithStatus(HttpStatusCode.BadRequest).WithText($"{fieldName} in request is out of range.");
        }

        /// <summary>
        /// Sets the response to serve a file in the context of a multi page application.
        /// </summary>
        /// <param name="response">The response to modify</param>
        /// <param name="basePath">The base path where to serve files from</param>
        /// <param name="request">The request to serve</param>
        /// <param name="indexFile">The name of the index file, default is index.html</param>
        /// <param name="compress">Whether or not to compress files served. Default is false.</param>
        /// <param name="compressExtensions">A collection of file extensions that should be compressed, example: .jpg, default is null. If and compress is true, all files will be compressed.</param>
        /// <returns>The modified response</returns>
        public static HttpListenerResponse ServeMultiPage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html", bool compress = false, HashSet<string> compressExtensions = null)
        {
            if (ResolveMultiPagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
            {
                if (isDirectory)
                {
                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
                }
                else
                {
                    if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
                    {
                        return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
                    }
                    else
                    {
                        if (compress && (compressExtensions == null || compressExtensions.Contains(Path.GetExtension(resolvedPath))))
                            return response.WithStatus(HttpStatusCode.OK).WithCompressedFile(resolvedPath);
                        else
                            return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
                    }
                }
            }
            else
            {
                return response.WithStatus(HttpStatusCode.NotFound);
            }
        }

        internal static bool ResolveMultiPagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
        {
            resolvedPath = null;

            isDirectory = false;

            //If the requestPath is pointing to nothing change that to the index file.
            if (string.IsNullOrWhiteSpace(requestPath) || requestPath == "/" || requestPath == ".")
                requestPath = indexFile;

            //Break th erequest path into it's components so we can enfore staying in the base path.
            var components = requestPath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();

            for (int i = 0; i < components.Count; i++)
            {
                if (components[i].Trim() == "..")
                {
                    components.RemoveAt(i--);

                    if (i >= 0)
                        components.RemoveAt(i--);
                    else
                        return false; //Trying to jump outside of basePath
                }
                else if (components[i].Trim() == "...")
                {
                    components.RemoveAt(i--);

                    if (i >= 0)
                        components.RemoveAt(i--);
                    else
                        return false; //Trying to jump outside of basePath

                    if (i >= 0)
                        components.RemoveAt(i--);
                    else
                        return false; //Trying to jump outside of basePath
                }
                else if (components[i].Trim() == ".")
                {
                    components.RemoveAt(i--);
                }
            }

            if (components.Count == 0)
                return false;

            var absolutePath = Path.Combine(basePath, components.Separate(Path.DirectorySeparatorChar));

            if (File.Exists(absolutePath))
            {
                resolvedPath = absolutePath;

                return true;
            }
            else if (Directory.Exists(absolutePath))
            {
                resolvedPath = absolutePath;

                isDirectory = true;

                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Sets the response to serve a file in the context of a single page application.
        /// </summary>
        /// <param name="response">The response to modify</param>
        /// <param name="basePath">The base path where to serve files from</param>
        /// <param name="request">The request to serve</param>
        /// <param name="indexFile">The name of the index file, default is index.html</param>
        /// <param name="compress">Whether or not to compress files served. Default is false.</param>
        /// <param name="compressExtensions">A collection of file extensions that should be compressed, example: .jpg, default is null. If and compress is true, all files will be compressed.</param>
        /// <returns>The modified response</returns>
        public static HttpListenerResponse ServeSinglePage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html", bool compress = false, HashSet<string> compressExtensions = null)
        {
            if (ResolveSinglePagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
            {
                if (isDirectory)
                {
                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
                }
                else
                {
                    if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
                    {
                        return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
                    }
                    else
                    {
                        if (compress && (compressExtensions == null || compressExtensions.Contains(Path.GetExtension(resolvedPath))))
                            return response.WithStatus(HttpStatusCode.OK).WithCompressedFile(resolvedPath);
                        else
                            return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
                    }
                }
            }
            else
            {
                return response.WithStatus(HttpStatusCode.NotFound);
            }
        }

        internal static bool ResolveSinglePagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
        {
            resolvedPath = null;

            isDirectory = false;

            //If the requestPath is pointing to nothing change that to the index file.
            if (string.IsNullOrWhiteSpace(requestPath) || requestPath == "/" || requestPath == ".")
                requestPath = indexFile;

            //Break th erequest path into it's components so we can enfore staying in the base path.
            var components = requestPath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();

            for (int i = 0; i < components.Count; i++)
            {
                if (components[i].Trim() == "..")
                {
                    components.RemoveAt(i--);

                    if (i >= 0)
                        components.RemoveAt(i--);
                    else
                        return false; //Trying to jump outside of basePath
                }
                else if (components[i].Trim() == "...")
                {
                    components.RemoveAt(i--);

                    if (i >= 0)
                        components.RemoveAt(i--);
                    else
                        return false; //Trying to jump outside of basePath

                    if (i >= 0)
                        components.RemoveAt(i--);
                    else
                        return false; //Trying to jump outside of basePath
                }
                else if (components[i].Trim() == ".")
                {
                    components.RemoveAt(i--);
                }
            }

            if (components.Count == 0)
                return false;

            var absolutePath = Path.Combine(basePath, components.Separate(Path.DirectorySeparatorChar));

            if (File.Exists(absolutePath))
            {
                resolvedPath = absolutePath;

                return true;
            }
            else if (Directory.Exists(absolutePath))
            {
                resolvedPath = absolutePath;

                isDirectory = true;

                return true;
            }
            else
            {
                //Try to components that don't exist and try again
                while (components.Count > 0)
                {
                    string path = Path.Combine(basePath, components[0]);

                    if (File.Exists(path) || Directory.Exists(path))
                        break;
                    else
                        components.RemoveAt(0);
                }

                if (components.Count == 0)
                    return false;

                absolutePath = Path.Combine(basePath, components.Separate(Path.PathSeparator));

                if (File.Exists(absolutePath))
                {
                    resolvedPath = absolutePath;

                    return true;
                }
                else if (Directory.Exists(absolutePath))
                {
                    resolvedPath = absolutePath;

                    isDirectory = true;

                    return true;
                }

                return false;
            }
        }
    }
}