using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Maki.Rest
{
    public class WebRequest : IDisposable
    {
        private const string USER_AGENT = @"DiscordBot (https://github.com/flashwave/maki, 1.0.0.0)";
        private const string GENERIC_CONTENT_TYPE = @"application/octet-stream";
        private const string JSON_CONTENT_TYPE = @"application/json";

        private const int MAX_RETRIES = 1;
        private const int TIMEOUT = 10000;

        public int Timeout { get; set; } = TIMEOUT;

        public event Action Started;
        public event Action Finished;
        public event Action<Exception> Failed;

        public event Action<long, long> DownloadProgress;
        public event Action<long, long> UploadProgress;

        public bool IsAborted { get; private set; }

        public string Accept { get; set; }

        private bool PrivateCompleted;
        public bool IsCompleted
        {
            get => PrivateCompleted;
            private set
            {
                PrivateCompleted = value;

                if (!PrivateCompleted)
                    return;

                Started = null;
                Finished = null;
                DownloadProgress = null;
                UploadProgress = null;
            }
        }

        private string PrivateUrl;
        private string Url
        {
            get => PrivateUrl;
            set
            {
                if (!value.StartsWith(@"http://") && !value.StartsWith(@"https://"))
                    value = RestEndpoints.BASE_URL + RestEndpoints.BASE_PATH  + value;

                PrivateUrl = value;
            }
        }

        private const int BUFFER_SIZE = 4096;
        private byte[] Buffer;

        private static HttpClient HttpClient;

        public readonly HttpMethod Method;
        private bool HasBody => Method == HttpMethod.PUT || Method == HttpMethod.POST || Method == HttpMethod.PATCH;

        public string ContentType { get; set; } = GENERIC_CONTENT_TYPE;

        [Obsolete]
        public long ContentLength => Response.Content.Headers.ContentLength ?? BytesDownloaded;

        [Obsolete]
        internal static string Authorisation { get; set; }

        private readonly Dictionary<string, string> Headers = new Dictionary<string, string>();
        private readonly Dictionary<string, string> Parameters = new Dictionary<string, string>();
        private readonly Dictionary<string, byte[]> Files = new Dictionary<string, byte[]>();

        private long BytesUploaded = 0;
        private long BytesDownloaded = 0;

        private HttpResponseMessage Response;

        private MemoryStream RawRequestBody;

        private Stream RequestStream;
        private Stream ResponseStream;

        private CancellationTokenSource AbortToken;
        private CancellationTokenSource TimeoutToken;

        public int Retries { get; private set; } = 0;

        private byte[] PrivateResponseBytes;
        public byte[] ResponseBytes
        {
            get
            {
                if (PrivateResponseBytes == null)
                    using (MemoryStream ms = new MemoryStream())
                    {
                        byte[] bytes = new byte[4096];
                        int read = 0;

                        while ((read = ResponseStream.Read(bytes, 0, bytes.Length)) > 0)
                            ms.Write(bytes, 0, read);

                        ms.Seek(0, SeekOrigin.Begin);
                        PrivateResponseBytes = new byte[ms.Length];
                        ms.Read(PrivateResponseBytes, 0, PrivateResponseBytes.Length);
                    }

                return PrivateResponseBytes;
            }
        }

        private string PrivateResponseString = string.Empty;
        public string ResponseString
        {
            get
            {
                if (string.IsNullOrEmpty(PrivateResponseString))
                    PrivateResponseString = Encoding.UTF8.GetString(ResponseBytes);

                return PrivateResponseString;
            }
        }

        public T ResponseJson<T>() =>
            JsonConvert.DeserializeObject<T>(ResponseString);

        [Obsolete]
        public short Status => (short)Response?.StatusCode;

        static WebRequest()
            => CreateHttpClientInstance();

        public WebRequest(HttpMethod method, string url)
        {
            Method = method;
            Url = url;
        }

        private static void CreateHttpClientInstance()
        {
            HttpClient?.Dispose();

            HttpClient = new HttpClient(new HttpClientHandler
            {
                AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
            });

            HttpClient.DefaultRequestHeaders.UserAgent.ParseAdd(USER_AGENT);
            HttpClient.DefaultRequestHeaders.ExpectContinue = true;
            HttpClient.Timeout = new TimeSpan(0, 0, 0, 0, System.Threading.Timeout.Infinite);
        }

        public void AddRaw(Stream stream)
        {
            if (stream == null)
                throw new ArgumentNullException(nameof(stream));

            RawRequestBody?.Dispose();
            RawRequestBody = new MemoryStream();

            stream.CopyTo(RawRequestBody);
        }

        public void AddRaw(byte[] bytes)
        {
            using (MemoryStream ms = new MemoryStream(bytes))
                AddRaw(ms);
        }

        public void AddRaw(string str) =>
            AddRaw(Encoding.UTF8.GetBytes(str));

        public void AddJson(object obj)
        {
            ContentType = JSON_CONTENT_TYPE;
            AddRaw(JsonConvert.SerializeObject(obj));
        }

        public void AddParam(string name, string contents) =>
            Parameters.Add(name, contents);

        public void AddFile(string name, byte[] bytes) =>
            Files.Add(name, bytes);

        public void AddHeader(string name, string value)
        {
            if (string.IsNullOrEmpty(name))
                throw new ArgumentNullException(nameof(name));

            if (value == null)
                throw new ArgumentNullException(nameof(value));

            if (Headers.ContainsKey(name))
                Headers[name] = value;
            else
                Headers.Add(name, value);
        }

        public void Abort()
        {
            IsAborted = true;
            IsCompleted = true;

            try
            {
                AbortToken?.Cancel();
            }
            catch (ObjectDisposedException)
            {
                // just do nothign in this case
            }
        }

        private System.Net.Http.HttpMethod FromInternalHttpMethod(HttpMethod method)
        {
            switch (method)
            {
                case HttpMethod.GET:
                    return System.Net.Http.HttpMethod.Get;

                case HttpMethod.DELETE:
                    return System.Net.Http.HttpMethod.Delete;

                case HttpMethod.POST:
                    return System.Net.Http.HttpMethod.Post;

                case HttpMethod.PATCH:
                    return new System.Net.Http.HttpMethod(@"PATCH");

                case HttpMethod.PUT:
                    return System.Net.Http.HttpMethod.Put;
            }

            throw new InvalidOperationException($"Unsupported HTTP method {method}.");
        }

        private void PrivatePerform()
        {
            using (AbortToken = new CancellationTokenSource())
            using (TimeoutToken = new CancellationTokenSource())
            using (CancellationTokenSource linkedToken = CancellationTokenSource.CreateLinkedTokenSource(AbortToken.Token, TimeoutToken.Token))
            {
                try
                {
                    string requestUri = Url;
                    HttpRequestMessage request = new HttpRequestMessage(FromInternalHttpMethod(Method), requestUri);

                    foreach (KeyValuePair<string, string> h in Headers)
                        request.Headers.Add(h.Key, h.Value);

                    if (!string.IsNullOrEmpty(Accept))
                        request.Headers.Accept.TryParseAdd(Accept);

                    if (HasBody)
                    {
                        Stream bodyContent;

                        if (RawRequestBody == null)
                        {
                            MultipartFormDataContent formData = new MultipartFormDataContent();

                            foreach (KeyValuePair<string, string> p in Parameters)
                                formData.Add(new StringContent(p.Value), p.Key);

                            foreach (KeyValuePair<string, byte[]> f in Files)
                            {
                                ByteArrayContent bac = new ByteArrayContent(f.Value);
                                bac.Headers.Add("Content-Type", GENERIC_CONTENT_TYPE);
                                formData.Add(bac, f.Key, f.Key);
                            }

                            bodyContent = formData.ReadAsStreamAsync().Result;
                        } else
                        {
                            if (Parameters.Count > 0 || Files.Count > 0)
                                throw new InvalidOperationException($"You cannot use {nameof(AddRaw)} at the same time as {nameof(AddParam)} or {nameof(AddFile)}");

                            bodyContent = new MemoryStream();
                            RawRequestBody.Seek(0, SeekOrigin.Begin);
                            RawRequestBody.CopyTo(bodyContent);
                            bodyContent.Seek(0, SeekOrigin.Begin);
                        }

                        request.Content = new StreamContent(RequestStream);

                        if (!string.IsNullOrEmpty(ContentType))
                            request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(ContentType);
                    }
                    else
                    {
                        if (Parameters.Count > 1)
                        {
                            StringBuilder urlBuilder = new StringBuilder();
                            urlBuilder.Append(Url);

                            if (!Url.Contains('?'))
                                urlBuilder.Append('?');

                            foreach (KeyValuePair<string, string> param in Parameters)
                            {
                                urlBuilder.Append(param.Key);
                                urlBuilder.Append('=');
                                urlBuilder.Append(param.Value);
                                urlBuilder.Append('&');
                            }

                            urlBuilder.Length -= 1;
                            requestUri = urlBuilder.ToString();
                        }
                    }

                    ReportProgress();

                    using (request)
                        Response = HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, linkedToken.Token).Result;

                    ResponseStream = new MemoryStream();

                    if (HasBody)
                    {
                        ReportProgress();
                        UploadProgress?.Invoke(0, BytesUploaded);
                    }

                    HandleResponse(linkedToken.Token);
                } catch (Exception) when (AbortToken.IsCancellationRequested)
                {
                    Complete(new WebException(string.Format("Request to {0} was aborted by the user.", Url), WebExceptionStatus.RequestCanceled));
                } catch (Exception) when (TimeoutToken.IsCancellationRequested)
                {
                    Complete(new WebException(string.Format("Request to {0} timed out after {1:N0} seconds idle (read {2:N0} bytes).", Url, TimeSinceLastAction / 1000, BytesDownloaded), WebExceptionStatus.Timeout));
                } catch (Exception ex)
                {
                    if (IsCompleted)
                        throw;

                    Complete(ex);
                }
            }
        }

        public async Task PerformAsync()
        {
            if (IsCompleted)
                throw new InvalidOperationException($"{nameof(WebRequest)} has already been run, you can't reuse WebRequest objects.");

            try
            {
                await Task.Factory.StartNew(PrivatePerform, TaskCreationOptions.LongRunning);
            }
            catch (AggregateException ex)
            {
                if (ex.InnerExceptions.Count != 1)
                    throw ex;

                while (ex.InnerExceptions.Count == 1)
                {
                    AggregateException innerEx = ex.InnerException as AggregateException;
                    ex = innerEx ?? throw innerEx.InnerException;
                }

                throw ex;
            }
        }

        public void Perform()
            => PerformAsync().Wait();

        private void HandleResponse(CancellationToken cancellationToken)
        {
            using (Stream responseStream = Response.Content.ReadAsStreamAsync().Result)
            {
                Started?.Invoke();

                Buffer = new byte[BUFFER_SIZE];

                while (true)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    int read = responseStream.Read(Buffer, 0, BUFFER_SIZE);

                    ReportProgress();

                    if (read > 0)
                    {
                        ResponseStream.Write(Buffer, 0, read);
                        BytesDownloaded += read;
                        DownloadProgress?.Invoke(BytesDownloaded, Response.Content.Headers.ContentLength ?? BytesDownloaded);
                    } else
                    {
                        ResponseStream.Seek(0, SeekOrigin.Begin);
                        break;
                    }
                }
            }
        }

        private void Complete(Exception exception = null)
        {
            if (IsAborted || IsCompleted)
                return;

            bool allowRetry = true;

            if (exception != null)
            {
                allowRetry = exception is WebException && (exception as WebException)?.Status == WebExceptionStatus.Timeout;
            } else if (!Response.IsSuccessStatusCode)
            {
                exception = new WebException($@"HTTP {Response.StatusCode}");

                switch (Response.StatusCode)
                {
                    case HttpStatusCode.NotFound:
                    case HttpStatusCode.MethodNotAllowed:
                    case HttpStatusCode.Forbidden:
                    case HttpStatusCode.Unauthorized:
                        allowRetry = false;
                        break;                    
                }
            }

            if (exception != null)
                if (allowRetry && Retries < MAX_RETRIES && BytesDownloaded < 1)
                {
                    ++Retries;
                    PrivatePerform();
                }

            try
            {
                // process
            } catch (Exception ex)
            {
                exception = exception == null ? ex : new AggregateException(exception, ex);
            }

            IsCompleted = true;

            if (exception != null)
            {
                IsAborted = true;
                Failed?.Invoke(exception);
                throw exception;
            }

            Finished?.Invoke();
        }

        #region Timeout
        private long LastReportedAction = 0;
        private long TimeSinceLastAction => (DateTime.Now.Ticks - LastReportedAction) / TimeSpan.TicksPerMillisecond;

        private void ReportProgress()
        {
            LastReportedAction = DateTime.Now.Ticks;
            TimeoutToken.CancelAfter(Timeout);
        }
        #endregion

        #region Disposal
        public bool IsDisposed { get; private set; } = false;
        
        private void Dispose(bool disposing)
        {
            if (IsDisposed)
                return;

            IsDisposed = true;
            // TODO: reimplement disposal

            if (disposing)
                GC.SuppressFinalize(this);
        }

        ~WebRequest()
            => Dispose(false);

        public void Dispose()
            => Dispose(true);
        #endregion
    }
}