using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.Mvc;
using HazelTree.Framework.General.Helpers;
using HazelTree.Framework.Logging.Infrastructure;
//using HazelTree.Framework.WebApiClient.Config;
using SyncManager.Web.Common.Extensions;
using static HazelTree.Framework.General.Helpers.SafeExecuteHelper;

namespace SyncManager.Web.Controllers
{
    //[System.Web.Http.Authorize]
    public class ProxyController : ApiController
    {
        private readonly IProxyClient _proxyClient;
        private readonly ILoggerProvider _logger;
        public ProxyController(IProxyClient proxyClient, ILoggerProvider logger)
        {
            if (proxyClient == null) throw new ArgumentNullException(nameof(proxyClient));
            if (logger == null) throw new ArgumentNullException(nameof(logger));

            _proxyClient = new ProxyClient(new HttpRequestMessageExtensions.ProxySettings(), new HttpRequestClientFactory());
            _logger = logger;
        }

        [System.Web.Http.AcceptVerbs("POST", "GET", "HEAD", "OPTIONS")]
        //[ValidateAntiForgeryToken]
        public async Task<HttpResponseMessage> Proxy(string url)
        {
            if (string.IsNullOrWhiteSpace(url)) throw new ArgumentNullException(nameof(url));

            try
            {
                string absoluteUrl = Settings.GetValue<string>("location", "syncManager:WebApi", defaultValueEnabled: false) + "/api/v1/" + url + Request.RequestUri.Query;
                _logger.Debug($"Proxy: from {Request.RequestUri.AbsolutePath} to {absoluteUrl}");

                Request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", User.GetToken());

                var result =  await _proxyClient.SendAsync(new Uri(absoluteUrl), Request, CancellationToken.None);
                return result;
            }
            catch (Exception ex)
            {
                SafeExecute(
                    () => _logger.Error(GetFullErrorMessage(ex)),
                    e => _logger.Fatal(GetFullErrorMessage(e))
                );
                throw;
            }
        }

        [System.Web.Http.HttpGet]
        public async Task<HttpResponseMessage> Navigate(string url)
        {
            if (string.IsNullOrWhiteSpace(url)) throw new ArgumentNullException(nameof(url));

            try
            {
                var tokenParam = Request.GetQueryNameValuePairs().FirstOrDefault(x => x.Key == "token");

                if (tokenParam.Key == "token")
                {
                    Request.Headers.Authorization= new AuthenticationHeaderValue("Bearer", tokenParam.Value);
                    string absoluteUrl = Request.RequestUri.Scheme + "://" + Request.RequestUri.Host + ":" + Request.RequestUri.Port + "/" + url;
                    _logger.Debug($"Proxy: from {Request.RequestUri.AbsolutePath} to {absoluteUrl}");
                    return await _proxyClient.SendAsync(new Uri(absoluteUrl), Request, CancellationToken.None);
                }

                return new HttpResponseMessage(HttpStatusCode.BadRequest);
            }
            catch (Exception ex)
            {
                SafeExecute(
                    () => _logger.Error(GetFullErrorMessage(ex)),
                    e => _logger.Fatal(GetFullErrorMessage(e))
                );
                throw;
            }
        }
    }

    public interface IHttpRequestClientFactory
    {
        HttpClient CreateClient();

        HttpClient CreateClient(TimeSpan timeOut);
    }

    public class HttpRequestClientFactory : IHttpRequestClientFactory
    {
        private static HttpMessageHandler _httpMessageHandler;

        public HttpClient CreateClient()
        {
            HttpClient httpClient = _httpMessageHandler == null ? new HttpClient() : new HttpClient(HttpRequestClientFactory._httpMessageHandler);
            httpClient.DefaultRequestHeaders.Add("Keep-Alive", "false");
            return httpClient;
        }

        public HttpClient CreateClient(TimeSpan timeOut)
        {
            HttpClient client = this.CreateClient();
            client.Timeout = timeOut;
            return client;
        }

        public static void UseHttpMessageHandler(HttpMessageHandler httpMessageHandler)
        {
            _httpMessageHandler = httpMessageHandler;
        }
    }

    public interface IProxyClient
    {
        Task<HttpResponseMessage> SendAsync(
            Uri targetUri,
            HttpRequestMessage request,
            CancellationToken cancellationToken);
    }

    public class ProxyClient : IProxyClient
    {
        private static readonly HashSet<HttpMethod> WithNoContentMethods = new HashSet<HttpMethod>()
        {
            HttpMethod.Get,
            HttpMethod.Head
        };
        private readonly IHttpRequestClientFactory _httpRequestClientFactory;
        private readonly IProxySettings _proxySettings;

        public ProxyClient(
            IProxySettings proxySettings,
            IHttpRequestClientFactory httpRequestClientFactory)
        {
            this._proxySettings = proxySettings;
            this._httpRequestClientFactory = httpRequestClientFactory;
        }

        public async Task<HttpResponseMessage> SendAsync(
            Uri targetUri,
            HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            var proxySettings = new HashSet<HttpMethod>()
            {
                HttpMethod.Get,
                HttpMethod.Head
            };
            if (targetUri == (Uri)null)
                throw new ArgumentNullException(nameof(targetUri));
            if (request == null)
                throw new ArgumentNullException(nameof(request));
            if (proxySettings.Contains(request.Method))
                request.Content = (HttpContent)null;
            HttpRequestMessage requestToSend = request.Clone(true);
            requestToSend.Headers.Host = targetUri.Authority;
            requestToSend.RequestUri = targetUri;
            HttpResponseMessage result = await this._httpRequestClientFactory.CreateClient(this._proxySettings.HttpClientTimeoutSec > 0 ? TimeSpan.FromSeconds((double)this._proxySettings.HttpClientTimeoutSec) : TimeSpan.FromSeconds(30.0)).SendAsync(requestToSend, cancellationToken).ConfigureAwait(false);
            return result;
        }
    }

     internal static class HttpRequestMessageExtensions
  {
    public static HttpRequestMessage Clone(
      this HttpRequestMessage req,
      bool cloneContent = false)
    {
      HttpRequestMessage httpRequestMessage = new HttpRequestMessage(req.Method, req.RequestUri)
      {
        Version = req.Version
      };
      if (req.Content != null)
      {
        httpRequestMessage.Content = (HttpContent) new ByteArrayContent(req.Content.ReadAsByteArrayAsync().RunSync<byte[]>());
        foreach (KeyValuePair<string, IEnumerable<string>> header in (HttpHeaders) req.Content.Headers)
          httpRequestMessage.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
      }
      foreach (KeyValuePair<string, object> property in (IEnumerable<KeyValuePair<string, object>>) req.Properties)
        httpRequestMessage.Properties.Add(property);
      foreach (KeyValuePair<string, IEnumerable<string>> header in (HttpHeaders) req.Headers)
        httpRequestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value);
      return httpRequestMessage;
    }

    public class ProxySettings : IProxySettings
    {
        public int HttpClientTimeoutSec
        {
            get
            {
                return Settings.GetValue<int>(nameof(HttpClientTimeoutSec), (string)null, true);
            }
        }
    }
    }

     public interface IProxySettings
     {
         int HttpClientTimeoutSec { get; }
     }
}