using NLog;
using RestSharp;
using System;
using System.Diagnostics;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace IOB_UT_NEXT.Services.Networking
{
    /// <summary>
    /// Servizio dedicato alla gestione delle chiamate HTTP.
    /// </summary>
    public class HttpService
    {
        #region Public Methods

        /// <summary>
        /// Effettua chiamata URL e restituisce risultato, SE NON E' in veto send.
        /// </summary>
        public static string CallUrl(string url)
        {
            if (baseUtils.dtVetoSend < DateTime.Now)
            {
                return CallUrlGet(url);
            }
            return string.Empty;
        }

        /// <summary>
        /// Effettua chiamata URL e restituisce risultato con payload.
        /// </summary>
        public static string CallUrl(string url, string payload)
        {
            if (baseUtils.dtVetoSend < DateTime.Now)
            {
                return CallUrlPost(url, payload);
            }
            return string.Empty;
        }

        /// <summary>
        /// Metodo chiamata URL con POST async.
        /// </summary>
        public static async Task<string> CallUrlAsync(string url, string payload, CancellationToken ct = default)
        {
            try
            {
                Stopwatch sw = Stopwatch.StartNew();
                var content = new StringContent(payload, Encoding.UTF8, "application/json");

                using (var client = new HttpClient()) // Note: In a real app, use IHttpClientFactory
                {
                    HttpResponseMessage response = await client.PostAsync(url, content, ct);
                    response.EnsureSuccessStatusCode();

                    sw.Stop();
                    baseUtils.TrackUrlCall(url, sw.Elapsed);

                    return await response.Content.ReadAsStringAsync();
                }
            }
            catch (OperationCanceledException)
            {
                return "Canceled";
            }
            catch (Exception ex)
            {
                return $"Error: {ex.Message}";
            }
        }

        /// <summary>
        /// Metodo chiamata URL con GET async.
        /// </summary>
        public static async Task<string> CallUrlAsync(string url, CancellationToken ct = default)
        {
            try
            {
                Stopwatch sw = Stopwatch.StartNew();
                using (var client = new HttpClient())
                {
                    HttpResponseMessage response = await client.GetAsync(url, ct);
                    response.EnsureSuccessStatusCode();

                    sw.Stop();
                    baseUtils.TrackUrlCall(url, sw.Elapsed);
                    return await response.Content.ReadAsStringAsync();
                }
            }
            catch (OperationCanceledException)
            {
                return "Canceled";
            }
            catch (Exception ex)
            {
                return $"Error: {ex.Message}";
            }
        }

        /// <summary>
        /// Effettua chiamata URL IMMEDIATAMENTE (GET) e restituisce risultato.
        /// </summary>
        public static string CallUrlGet(string url)
        {
            try
            {
                HttpClientHandler handler = new HttpClientHandler();
                if (url.Contains("10.74.82."))
                {
                    handler.ServerCertificateCustomValidationCallback =
                        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
                }

                using (var client = new HttpClient(handler))
                {
                    Stopwatch sw = Stopwatch.StartNew();
                    client.Timeout = TimeSpan.FromMilliseconds(5000);
                    client.DefaultRequestHeaders.UserAgent.ParseAdd(baseUtils.CRS("appName"));

                    var response = client.GetAsync(url).Result;
                    string answ = response.Content.ReadAsStringAsync().Result;

                    sw.Stop();
                    baseUtils.TrackUrlCall(url, sw.Elapsed);

                    return answ;
                }
            }
            catch (Exception exc)
            {
                int pauseSendMSec = baseUtils.nextPauseSendMSec;
                baseUtils.dtVetoSend = DateTime.Now.AddMilliseconds(pauseSendMSec);

                if (baseUtils.logValuePermit(url))
                {
                    baseUtils.lg.Error($"CallUrlGet | Errore chiamando {url} | wait {pauseSendMSec} ms{Environment.NewLine}Eccezione:{Environment.NewLine}{exc}");
                }

                return "";
            }
        }

        /// <summary>
        /// Effettua chiamata IMMEDIATAMENTE URL (POST) e restituisce risultato.
        /// </summary>
        public static string CallUrlPost(string url, string payload)
        {
            string answ = "";
            Stopwatch sw = Stopwatch.StartNew();

            try
            {
                HttpClientHandler handler = new HttpClientHandler();
                if (url.Contains("10.74."))
                {
                    handler.ServerCertificateCustomValidationCallback =
                        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
                }

                using (var client = new HttpClient(handler))
                {
                    client.Timeout = TimeSpan.FromMilliseconds(5000);
                    client.DefaultRequestHeaders.UserAgent.ParseAdd($"{baseUtils.CRS("appName")}-PAYLOAD");

                    var content = new StringContent(payload, Encoding.UTF8, "application/json");
                    var response = client.PostAsync(url, content).Result;

                    answ = response.Content.ReadAsStringAsync().Result;

                    if (answ != "OK")
                    {
                        if (baseUtils.logValuePermit($"{url}|[{answ}]"))
                        {
                            baseUtils.lg.Error($"CallUrlPost | POST fallito | ans: [{answ}]:{Environment.NewLine}- URL{Environment.NewLine}{url}{Environment.NewLine}- payload{Environment.NewLine}{payload}");
                        }
                    }
                }
            }
            catch (Exception exc)
            {
                int pauseSendMSec = baseUtils.nextPauseSendMSec;
                baseUtils.dtVetoSend = DateTime.Now.AddMilliseconds(pauseSendMSec);

                if (baseUtils.logValuePermit(url))
                {
                    baseUtils.lg.Error($"CallUrlPost | Errore chiamando {url} | wait {pauseSendMSec} ms | Dump Payload:{Environment.NewLine}{payload}{Environment.NewLine}Eccezione:{Environment.NewLine}{exc}");
                }
            }

            sw.Stop();
            baseUtils.TrackUrlCall(url, sw.Elapsed);
            return answ;
        }

        /// <summary>
        /// Effettua chiamata URL tramite RestSharp (GET)
        /// </summary>
        public static string ExecCallGet(string url, bool fastCall = false)
        {
            string answ = "";
            Uri uri = new Uri(url);
            string baseUrl = $"{uri.Scheme}://{uri.Host}{(uri.IsDefaultPort ? "" : $":{uri.Port}")}";
            string resource = uri.AbsolutePath;
            RestClientOptions restOptStd = new RestClientOptions
            {
                BaseUrl = new Uri(baseUrl),
                Timeout = TimeSpan.FromSeconds(60)
            };
            if (fastCall) restOptStd.Timeout = TimeSpan.FromSeconds(5);

            try
            {
                using (var client = new RestClient(restOptStd))
                {
                    var actReq = new RestRequest(resource, Method.Get);
                    var currResp = client.Get(actReq);
                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
                    {
                        answ = currResp.Content;
                    }
                }
            }
            catch (Exception exc)
            {
                baseUtils.lg.Error($"Eccezione in ExecCallGet{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <summary>
        /// Effettua chiamata URL tramite RestSharp (POST JSON)
        /// </summary>
        public static string ExecCallPostJson(string url, string payload, bool fastCall = false)
        {
            string answ = "";
            Uri uri = new Uri(url);
            string baseUrl = $"{uri.Scheme}://{uri.Host}{(uri.IsDefaultPort ? "" : $":{uri.Port}")}";
            string resource = uri.AbsolutePath;
            RestClientOptions restOptStd = new RestClientOptions
            {
                BaseUrl = new Uri(baseUrl),
                Timeout = TimeSpan.FromSeconds(60)
            };
            if (fastCall) restOptStd.Timeout = TimeSpan.FromSeconds(5);

            Stopwatch sw = Stopwatch.StartNew();
            try
            {
                using (var client = new RestClient(restOptStd))
                {
                    var actReq = new RestRequest(resource, Method.Post);
                    actReq.AddJsonBody(payload);
                    var currResp = client.Post(actReq);
                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
                    {
                        answ = currResp.Content;
                    }
                }
            }
            catch (Exception exc)
            {
                baseUtils.lg.Error($"Eccezione in ExecCallPostJson{Environment.NewLine}{exc}");
            }
            sw.Stop();
            baseUtils.TrackUrlCall(url, sw.Elapsed);
            return answ;
        }

        /// <summary>
        /// Effettua chiamata URL tramite RestSharp (POST Plain)
        /// </summary>
        public static string ExecCallPostPlain(string url, string payload, bool fastCall = false)
        {
            string answ = "";
            Uri uri = new Uri(url);
            string baseUrl = $"{uri.Scheme}://{uri.Host}{(uri.IsDefaultPort ? "" : $":{uri.Port}")}";
            string resource = uri.AbsolutePath;
            RestClientOptions restOptStd = new RestClientOptions
            {
                BaseUrl = new Uri(baseUrl),
                Timeout = TimeSpan.FromSeconds(60)
            };
            if (fastCall) restOptStd.Timeout = TimeSpan.FromSeconds(5);

            Stopwatch sw = Stopwatch.StartNew();
            try
            {
                using (var client = new RestClient(restOptStd))
                {
                    var actReq = new RestRequest(resource, Method.Post);
                    actReq.AddStringBody(payload, ContentType.Plain);
                    var currResp = client.Post(actReq);
                    if (currResp.StatusCode == System.Net.HttpStatusCode.OK && currResp.Content != null)
                    {
                        answ = currResp.Content;
                    }
                }
            }
            catch (Exception exc)
            {
                baseUtils.lg.Error($"Eccezione in ExecCallPostPlain | rawUrl: {url} {Environment.NewLine}{exc}");
            }
            sw.Stop();
            baseUtils.TrackUrlCall(url, sw.Elapsed);
            return answ;
        }

        #endregion Public Methods
    }
}