namespace Common.Logic.Extensions.Http
{
    using Common.Logic.Extensions.Http.Interfaces;

    using Newtonsoft.Json;

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net.Http;
    using System.Net.Http.Headers;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Web;

    public abstract class HttpRequest : IHttpRequest
    {
        private readonly String url;
        private readonly HttpMethod method;
        private readonly ICollection<String> query;
        private readonly HttpRequestMessage message;

        public HttpRequest(String url, HttpMethod method)
        {
            this.url = url;
            this.method = method;
            this.query = new List<String>();
            this.message = new HttpRequestMessage();
        }

        public IHttpRequest AddQueryParameter(String name, Object value)
        {
            query.Add($"{name}={HttpUtility.UrlEncode($"{value}")}");

            return this;
        }

        public IHttpResponse<T> GetResponse<T>()
        {
            var httpResponse = new HttpResponse<T>();

            try
            {
                using (var httpRequestMessage = this.GetHttpRequestMessage())
                {
                    using (var httpResponseMessage = HttpClient.Current.SendAsync(httpRequestMessage).Result)
                    {
                        httpResponse.StatusCode = httpResponseMessage.StatusCode;
                        httpResponse.Succeeded = httpResponseMessage.IsSuccessStatusCode;

                        try
                        {
                            var content = httpResponseMessage.Content.ReadAsStringAsync().Result;

                            if (!String.IsNullOrWhiteSpace(content))
                            {
                                if (httpResponse.Succeeded)
                                {
                                    httpResponse.Value = JsonConvert.DeserializeObject<T>(content);
                                }
                                else
                                {
                                    try
                                    {
                                        httpResponse.Errors = JsonConvert.DeserializeObject<Dictionary<String, String>>(content);
                                    }
                                    catch
                                    {
                                        httpResponse.Errors[$"{httpResponse.StatusCode}"] = content;
                                    }
                                }
                            }
                        }
                        catch (Exception x)
                        {
                            while (x.InnerException != null)
                            {
                                x = x.InnerException;
                            }

                            httpResponse.Exception = x;
                        }
                    }
                }
            }
            catch (Exception e)
            {
                httpResponse.Exception = e;
            }

            return httpResponse;
        }

        public void Send()
        {
            Task.Factory
                .StartNew(state =>
                {
                    if (state is HttpRequest httpRequest)
                    {
                        using (var httpRequestMessage = httpRequest.GetHttpRequestMessage())
                        {
                            HttpClient
                                .Current
                                .SendAsync(httpRequestMessage)
                                .Wait();
                        }
                    }

                }, this, CancellationToken.None);
        }

        public IHttpRequest WithJsonBody(Object body)
        {
            var content = JsonConvert.SerializeObject(body);
            this.message.Content = new StringContent(content);
            this.message.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

            return this;
        }

        public IHttpRequest WithPlainBody(String body)
        {
            this.message.Content = new StringContent(body);
            this.message.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

            return this;
        }

        private HttpRequestMessage GetHttpRequestMessage()
        {
            var requestURL = this.url;

            if (this.query.Any())
            {
                requestURL += $"?{String.Join("&", this.query)}";
            }

            this.message.RequestUri = new Uri(requestURL, UriKind.RelativeOrAbsolute);
            this.message.Method = this.method;

            return this.message;
        }
    }
}