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

namespace Update.Utils
{
    public static class Http
    {
        public struct Response
        {
            public HttpStatusCode code;
            public HttpContent message;
            public string url;
        }

        public struct Request
        {
            /// <summary>
            /// 请求的网址
            /// </summary>
            public string uri;
            /// <summary>
            /// 头信息
            /// </summary>
            public Dictionary<string, object> headers;
            /// <summary>
            /// 请求的数据
            /// </summary>
            public Dictionary<string, object> data;
            /// <summary>
            /// 上传的文件
            /// </summary>
            public Dictionary<string, string> files;
            /// <summary>
            /// 上传的文件二进制流
            /// </summary>
            public Dictionary<string, byte[]> fileStream;
            /// <summary>
            /// 请求类型
            /// </summary>
            public RequestContentType contentType;
            /// <summary>
            /// 请求方式
            /// </summary>
            public Method method;

            public void Init()
            {
                uri = "";
                headers = new Dictionary<string, object>();
                data = new Dictionary<string, object>();
                files = new Dictionary<string, string>();
                fileStream = new Dictionary<string, byte[]>();
                contentType = RequestContentType.Default;
                method = Method.Get;
            }

            public Request(string uri, Method method)
            {
                this.uri = uri;
                this.method = method;
                this.headers = new Dictionary<string, object>();
                this.data = null;
                files = null;
                fileStream = null;
                contentType = RequestContentType.Default;
            }


            public Request(string uri, Method method, Dictionary<string, object> data)
            {
                this.uri = uri;
                this.method = method;
                this.headers = new Dictionary<string, object>();
                this.data = data;
                files = null;
                fileStream = null;
                contentType = RequestContentType.Default;
            }

            public Request(string uri, Method method, Dictionary<string, object> headers, Dictionary<string, object> data)
            {
                this.uri = uri;
                this.method = method;
                this.headers = headers;
                this.data = data;
                files = null;
                fileStream = null;
                contentType = RequestContentType.Default;
            }

            public Request(string uri, Method method, RequestContentType contentType, Dictionary<string, object> headers, Dictionary<string, object> data)
            {
                this.uri = uri;
                this.method = method;
                this.headers = headers;
                this.data = data;
                files = null;
                fileStream = null;
                this.contentType = contentType;
            }

            public Request(string uri, Method method, Dictionary<string, object> headers, Dictionary<string, object> data, Dictionary<string, string> files)
            {
                this.uri = uri;
                this.method = method;
                this.headers = headers;
                this.data = data;
                this.files = files;
                fileStream = null;
                contentType = RequestContentType.Default;
            }

            public Request(string uri, Method method, Dictionary<string, object> headers, Dictionary<string, object> data, Dictionary<string, string> files, Dictionary<string, byte[]> fileStream)
            {
                this.uri = uri;
                this.method = method;
                this.headers = headers;
                this.data = data;
                this.files = files;
                this.fileStream = fileStream;
                contentType = RequestContentType.Default;
            }


        }

        /// <summary>
        /// 请求内容类型
        /// </summary>
        public enum RequestContentType
        {
            Default, Json
        }

        /// <summary>
        /// 请求方法
        /// </summary>
        public enum Method
        {
            Get, Post, Put, Delete, Patch
        }

        /// <summary>
        /// 初始化请求头
        /// </summary>
        /// <param name="httpClient"></param>
        /// <param name="headers"></param>
        private static void InitClientHeaders(ref HttpClient httpClient, Dictionary<string, object> headers)
        {
            if (headers != null)
            {
                foreach (var header in headers)
                {
                    if (!string.IsNullOrEmpty(header.Key) && !string.IsNullOrEmpty(header.Value.ToString()))
                    {
                        httpClient.DefaultRequestHeaders.Add(header.Key, header.Value.ToString());
                    }

                }
            }
        }

        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static async Task<HttpResponseMessage> Fetch(Request request)
        {
            HttpResponseMessage response;
            switch (request.method)
            {
                case Method.Post:
                    response = await Post(request);
                    break;
                case Method.Put:
                    response = await Put(request);
                    break;
                case Method.Patch:
                    response = await Patch(request);
                    break;
                case Method.Delete:
                    response = await Delete(request);
                    break;
                default:
                    response = await Get(request);
                    break;
            }
            return response;
        }

        public static async Task<HttpResponseMessage> Get(Request request)
        {
            HttpResponseMessage response = null;
            if (!string.IsNullOrEmpty(request.uri))
            {
                HttpClient client = new HttpClient();
                string url = request.uri;
                InitClientHeaders(ref client, request.headers);
                if (request.data != null)
                {
                    //client.DefaultRequestHeaders.Add()
                    url = string.Concat(url, "?");
                    foreach (var item in request.data)
                    {
                        url = string.Concat(url, $"{item.Key}={HttpUtility.UrlEncode(item.Value.ToString())}&");
                    }
                    url = url.Substring(0, url.Length - 1);
                }
                try
                {
                    response = await client.GetAsync(url);
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                }
                finally
                {
                    client?.Dispose();
                }
            }
            return response;
        }

        private static HttpContent InitNonGetContent(Request request)
        {
            HttpContent content = null;

            if (request.contentType == RequestContentType.Json)
            {
                // 发送json 数据
                HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(request.data), Encoding.UTF8);
                httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                content = httpContent;
            }
            else
            //if (request.files != null || request.fileStream != null)
            {
                // 普通的键值对提交
                MultipartFormDataContent multipartFormDataContent = new MultipartFormDataContent();
                //FormUrlEncodedContent formUrlEncodedContent = new FormUrlEncodedContent();
                if (request.files != null)
                {
                    foreach (var file in request.files)
                    {
                        multipartFormDataContent.Add(new ByteArrayContent(File.ReadAllBytes(file.Value)), file.Key, Path.GetFileName(file.Value));
                    }
                }
                if (request.fileStream != null)
                {
                    foreach (var file in request.fileStream)
                    {
                        multipartFormDataContent.Add(new ByteArrayContent(file.Value), file.Key, file.Key);
                    }
                }

                if (request.data != null)
                {
                    foreach (var d in request.data)
                    {
                        multipartFormDataContent.Add(new StringContent(d.Value.ToString(), Encoding.UTF8), d.Key);
                    }
                }
                content = multipartFormDataContent;
            }
            return content;
        }

        public static async Task<HttpResponseMessage> Post(Request request)
        {
            HttpResponseMessage response = null;
            if (!string.IsNullOrEmpty(request.uri))
            {
                HttpClient client = new HttpClient();
                HttpContent content = InitNonGetContent(request);

                try
                {
                    InitClientHeaders(ref client, request.headers);
                    response = await client.PostAsync(request.uri, content);
                    //client.Dispose();
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                }
                finally
                {
                    client?.Dispose();
                }
            }

            return response;
        }

        public static async Task<HttpResponseMessage> Patch(Request request)
        {
            HttpResponseMessage response = null;
            if (!string.IsNullOrEmpty(request.uri))
            {
                HttpClient client = new HttpClient();
                HttpContent content = InitNonGetContent(request);
                HttpRequestMessage httpRequestMessage = new HttpRequestMessage(new HttpMethod("PATCH"), request.uri);

                try
                {
                    InitClientHeaders(ref client, request.headers);
                    httpRequestMessage.Content = content;
                    response = await client.SendAsync(httpRequestMessage);
                    //client.Dispose();
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                }
                finally
                {
                    client?.Dispose();
                }
                httpRequestMessage.Dispose();
            }

            return response;
        }

        public static async Task<HttpResponseMessage> Put(Request request)
        {
            HttpResponseMessage response = null;
            if (!string.IsNullOrEmpty(request.uri))
            {
                HttpClient client = new HttpClient();
                HttpContent content = InitNonGetContent(request);

                try
                {
                    InitClientHeaders(ref client, request.headers);
                    response = await client.PutAsync(request.uri, content);
                    //client.Dispose();
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                }
                finally
                {
                    client?.Dispose();
                }
            }

            return response;
        }

        public static async Task<HttpResponseMessage> Delete(Request request)
        {
            HttpResponseMessage response = null;
            if (!string.IsNullOrEmpty(request.uri))
            {
                HttpClient client = new HttpClient();
                string url = request.uri;

                try
                {
                    InitClientHeaders(ref client, request.headers);
                    if (request.data != null)
                    {
                        url = string.Concat(url, "?");
                        foreach (var item in request.data)
                        {
                            url = string.Concat(url, $"{item.Key}={HttpUtility.UrlEncode(item.Value.ToString())}&");
                        }
                    }
                    response = await client.DeleteAsync(request.uri);
                    //client.Dispose();
                }
                catch (Exception ex)
                {
                    Log.Error(ex);
                }
                finally
                {
                    client?.Dispose();
                }
            }

            return response;
        }

    }
}