using Newtonsoft.Json;
using NLog;
using System;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Web.Script.Serialization;

namespace ARC.GMP.Utils
{
    public class WebServiceStatus
    {
        public object data { get; set; }
        public string message { get; set; }
        public int code { get; set; }
    }

    public class InvokeWebService
    {
        private static ILogger LOGGER = LogManager.GetCurrentClassLogger();

        #region HTTP CLIENT Invokes

        public static async Task<string> GetHttpClientRequestAsync(string url, string oauthToken, string clientId)
        {
            string result = string.Empty;
            HttpClient client = null;
            HttpResponseMessage response = null;
            try
            {
                using (client = new HttpClient())
                {
                    client.BaseAddress = new Uri(url);
                    client.DefaultRequestHeaders.Accept.Clear();
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    client.DefaultRequestHeaders.Add("Authorization", "Bearer " + oauthToken);
                    client.DefaultRequestHeaders.Add("ClientID", clientId);
                    LOGGER.Trace("Start Server call - " + DateTime.Now);
                    using (response = await client.GetAsync(url))
                    {
                        LOGGER.Trace("Start Server call - Response Fetch Start - " + DateTime.Now + url);
                        if (response.IsSuccessStatusCode)
                        {
                            var returnedBytes = await response.Content.ReadAsByteArrayAsync();
                            result = Encoding.UTF8.GetString(returnedBytes);
                            LOGGER.Trace("Start Server call - Response Fetch End - " + DateTime.Now + url);
                        }
                        else
                        {
                            var resultString = "{\"data\":\"" + response.StatusCode + "\",\"message\":\"" + response.Content.ToString() + "\",\"code\": \"1\" }";
                            result = (string)Convert.ChangeType(resultString, typeof(string));
                            LOGGER.Trace(result);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) client.Dispose();
                if (response != null) response.Dispose();
            }
            return result;
        }
        public static async Task<string> GetHttpClientRequestAsync(string url)
        {
            string result = string.Empty;
            HttpClient client = null;
            HttpResponseMessage response = null;
            try
            {
                using (client = new HttpClient())
                {
                    client.BaseAddress = new Uri(url);
                    client.DefaultRequestHeaders.Accept.Clear();
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    LOGGER.Trace("Start Server call - " + DateTime.Now);
                    using (response = await client.GetAsync(url))
                    {
                        LOGGER.Trace("Start Server call - Response Fetch Start - " + DateTime.Now + url);
                        if (response.IsSuccessStatusCode)
                        {
                            var returnedBytes = await response.Content.ReadAsByteArrayAsync();
                            result = Encoding.UTF8.GetString(returnedBytes);
                            LOGGER.Trace("Start Server call - Response Fetch End - " + DateTime.Now + url);
                        }
                        else
                        {
                            result = "{\"data\":\"" + response.StatusCode + "\",\"message\":\"" + response.Content.ToString() + "\",\"code\": \"1\" }";
                            LOGGER.Trace(result);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
                while (ex.InnerException != null)
                {
                    LOGGER.Trace("*** INNER EXCEPTION ***");
                    ex = ex.InnerException;
                    LOGGER.Trace(ex.Message);
                    LOGGER.Trace(ex.StackTrace);
                }
            }
            finally
            {
                if (client != null) client.Dispose();
                if (response != null) response.Dispose();
            }
            return result;
        }
        public static async Task<string> PostHttpClientRequestAsync(string url, string oauthToken, string clientId, string data)
        {
            string result = string.Empty;
            HttpClient client = null;
            HttpResponseMessage response = null;
            try
            {
                var buffer = System.Text.Encoding.UTF8.GetBytes(data);
                var byteContent = new ByteArrayContent(buffer);

                var stringContent = new StringContent(data, Encoding.UTF8, "application/json");

                using (client = new HttpClient())
                {
                    client.Timeout = new TimeSpan(0, 10, 0); //Need to remove this post testing
                    client.BaseAddress = new Uri(url);
                    client.DefaultRequestHeaders.Accept.Clear();
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    client.DefaultRequestHeaders.Add("Authorization", "Bearer " + oauthToken);
                    client.DefaultRequestHeaders.Add("ClientID", clientId);
                    LOGGER.Trace("Start Server call - " + DateTime.Now);
                    using (response = await client.PostAsync(url, stringContent))
                    {
                        LOGGER.Trace("Start Server call - Response Fetch Start - " + DateTime.Now + url);
                        if (response.IsSuccessStatusCode)
                        {
                            var returnedBytes = await response.Content.ReadAsByteArrayAsync();
                            result = Encoding.UTF8.GetString(returnedBytes);
                            LOGGER.Trace("Start Server call - Response Fetch End - " + DateTime.Now + url);
                        }
                        else
                        {
                            var resultString = "{\"data\":\"" + response.StatusCode + "\",\"message\":\"" + response.Content.ToString() + "\",\"code\": \"1\" }";
                            result = (string)Convert.ChangeType(resultString, typeof(string));
                            LOGGER.Trace(result);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) client.Dispose();
                if (response != null) response.Dispose();
            }
            return result;
        }
        public static async Task<string> PostHttpClientRequestAsync(string url, string data)
        {
            string result = string.Empty;
            HttpClient client = null;
            HttpResponseMessage response = null;
            try
            {
                var buffer = System.Text.Encoding.UTF8.GetBytes(data);
                var byteContent = new ByteArrayContent(buffer);

                using (client = new HttpClient())
                {
                    client.BaseAddress = new Uri(url);
                    client.DefaultRequestHeaders.Accept.Clear();
                    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                    LOGGER.Trace("Start Server call - " + DateTime.Now);
                    using (response = await client.PostAsync(url, byteContent))
                    {
                        LOGGER.Trace("Start Server call - Response Fetch Start - " + DateTime.Now + url);
                        if (response.IsSuccessStatusCode)
                        {
                            var returnedBytes = await response.Content.ReadAsByteArrayAsync();
                            result = Encoding.UTF8.GetString(returnedBytes);
                            LOGGER.Trace("Start Server call - Response Fetch End - " + DateTime.Now + url);
                        }
                        else
                        {
                            var resultString = "{\"data\":\"" + response.StatusCode + "\",\"message\":\"" + response.Content.ToString() + "\",\"code\": \"1\" }";
                            result = (string)Convert.ChangeType(resultString, typeof(string));
                            LOGGER.Trace(result);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) client.Dispose();
                if (response != null) response.Dispose();
            }
            return result;
        }

        #endregion

        #region WEB CLIENT Invokes

        public static async Task<string> GetWebClientRequestAsync(string url, string oauthToken, string clientId)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "URL " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    client.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + oauthToken);
                    LOGGER.Log(LogLevel.Trace, "Bearer " + oauthToken);
                    client.Headers.Add("ClientID", clientId);
                    LOGGER.Log(LogLevel.Trace, "ClientID " + clientId);
                    result = Encoding.UTF8.GetString(await client.DownloadDataTaskAsync(new Uri(url)));
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static async Task<string> GetWebClientRequestAsync(string url)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "URL " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    result = Encoding.UTF8.GetString(await client.DownloadDataTaskAsync(new Uri(url)));
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static string GetWebClientRequest(string url, string oauthToken, string clientId)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "GetRequest URL: " + url);
                using (client = new WebClient())
                {
                    client.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + oauthToken);
                    LOGGER.Log(LogLevel.Trace, "Bearer " + oauthToken);
                    client.Headers.Add("ClientID", clientId);
                    LOGGER.Log(LogLevel.Trace, "ClientID " + clientId);
                    result = Encoding.UTF8.GetString(client.DownloadData(new Uri(url)));
                    LOGGER.Log(LogLevel.Trace, "GetRequest: " + result);
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static string GetWebClientRequest(string url)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "GetRequest URL: " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    result = Encoding.UTF8.GetString(client.DownloadData(new Uri(url)));
                    LOGGER.Log(LogLevel.Trace, "GetRequest: " + result);
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static async Task<string> PostWebClientRequestAsync(string url, string oauthToken, string clientId, string data)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "URL " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    client.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + oauthToken);
                    LOGGER.Log(LogLevel.Trace, "Bearer " + oauthToken);
                    client.Headers.Add("ClientID", clientId);
                    LOGGER.Log(LogLevel.Trace, "ClientID " + clientId);
                    client.Headers.Add(HttpRequestHeader.ContentType, "application/Json");
                    result = await client.UploadStringTaskAsync(new Uri(url), "POST", data);
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static async Task<string> PostWebClientRequestAsync(string url, string data)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "URL " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    client.Headers.Add(HttpRequestHeader.ContentType, "application/Json");
                    result = await client.UploadStringTaskAsync(new Uri(url), "POST", data);
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static string PostWebClientRequest(string url, string oauthToken, string clientId, string data)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "URL " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    client.Headers.Add(HttpRequestHeader.Authorization, "Bearer " + oauthToken);
                    LOGGER.Log(LogLevel.Trace, "Bearer " + oauthToken);
                    client.Headers.Add("ClientID", clientId);
                    LOGGER.Log(LogLevel.Trace, "ClientID " + clientId);
                    client.Headers.Add(HttpRequestHeader.ContentType, "application/Json");
                    result = client.UploadString(new Uri(url), "POST", data);
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }
        public static string PostWebClientRequest(string url, string data)
        {
            var result = string.Empty;
            WebClient client = null;
            try
            {
                LOGGER.Log(LogLevel.Trace, "URL " + url);
                using (client = new WebClient() { UseDefaultCredentials = true })
                {
                    client.Headers.Add(HttpRequestHeader.ContentType, "application/Json");
                    result = client.UploadString(new Uri(url), "POST", data);
                }
            }
            catch (Exception ex)
            {
                result = "{\"data\":\"Timedout\",\"message\":\"" + ex.Message + "\",\"code\": \"1\" }";
                LOGGER.Trace(result);
                LOGGER.Trace(ex.StackTrace);
            }
            finally
            {
                if (client != null) { client.Dispose(); }
            }
            return result;
        }

        #endregion
    }
}