using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using Api.Framework.SDK;
using CsharpHttpHelper;

namespace Api.Framework.Tools
{
    /// <summary>
    /// 用户/机器人上传
    /// </summary>
    public class UserRobotUpLoad
    {
        /// <summary>
        /// host
        /// </summary>
        public static readonly string host = "http://yzinterface.api.52cmg.cn/api/";
        public static readonly int appkey = 334391396;
        public static readonly string appsecret = "b924f8b944694cb8891bcfc7834dedb533436a3776de472cbde99577337902b2";
        public static readonly string appAes = "EDC19B73FEB447929E187243777477913977AB2694394E5B9BC56CD05302C46B";
        public static string UserToken { get; set; }

        /// <summary>
        /// 上传客户信息
        /// </summary>
        /// <param name="inputs"></param>
        /// <returns></returns>
        public static ServiceResult CustomerLink_UpLoadLink(List<CustomerLinkInput> inputs)
        {
            if (inputs == null || inputs.Count <= 0)
            {
                return new ServiceResult()
                {
                    Ok = true
                };
            }
            return HttpAes("CustomerLink/UpLoadLink", "post", inputs);
        }
        /// <summary>
        /// 上传客户机器人信息
        /// </summary>
        /// <param name="inputs"></param>
        /// <returns></returns>
        public static ServiceResult CustomerLink_UpLoadRobot(List<CustomerRobotInput> inputs)
        {
            if (inputs == null || inputs.Count <= 0)
            {
                return new ServiceResult()
                {
                    Ok = true
                };
            }
            return HttpAes("CustomerLink/UpLoadRobot", "post", inputs);
        }

        /// <summary>
        /// AES
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="api"></param>
        /// <param name="method"></param>
        /// <param name="postdata"></param>
        /// <returns></returns>
        private static ServiceResult<T> HttpAes<T>(string api, string method, object postdata = null)
        {
            try
            {
                var result = HttpResultAes(api, method, postdata);
                if (result.StatusCode == HttpStatusCode.OK)
                {
                    return Newtonsoft.Json.JsonConvert.DeserializeObject<ServiceResult<T>>(result.Html);
                }
                return new ServiceResult<T>(default(T))
                {
                    Ok = false,
                    Message = result.Html,
                };
            }
            catch (Exception e)
            {
                return new ServiceResult<T>(default(T))
                {
                    Ok = false,
                    Message = e.ToString(),
                };
            }
        }

        /// <summary>
        /// aes
        /// </summary>
        /// <param name="api"></param>
        /// <param name="method"></param>
        /// <param name="postdata"></param>
        /// <returns></returns>
        private static ServiceResult HttpAes(string api, string method, object postdata = null)
        {
            try
            {
                var result = HttpResultAes(api, method, postdata);
                if (result.StatusCode == HttpStatusCode.OK)
                {
                    return Newtonsoft.Json.JsonConvert.DeserializeObject<ServiceResult>(result.Html);
                }
                return new ServiceResult()
                {
                    Ok = false,
                    Data = result.Html,
                };
            }
            catch (Exception e)
            {
                return new ServiceResult()
                {
                    Ok = false,
                    Data = e.ToString(),
                };
            }
        }

        /// <summary>
        /// http aes
        /// </summary>
        /// <param name="api"></param>
        /// <param name="method"></param>
        /// <param name="postdata"></param>
        /// <returns></returns>
        private static HttpResult HttpResultAes(string api, string method, object postdata = null)
        {
            var data = Newtonsoft.Json.JsonConvert.SerializeObject(postdata);
            var http = new HttpHelper();
            HttpItem item = new HttpItem()
            {
                URL = host + api,
                Method = method,
                Timeout = 100000,
                ReadWriteTimeout = 30000,
                IsToLower = false,
                Cookie = "",
                UserAgent = "Server",
                Accept = "text/html, application/xhtml+xml, */*",
                ContentType = "application/json",
                Referer = "",
                Allowautoredirect = false,
                AutoRedirectCookie = false,
                Postdata = data,
                PostEncoding = Encoding.UTF8,
                //WebProxy = new WebProxy("127.0.0.1:8888")

            };
            var timespan = GetTimespan(DateTime.Now);/*DateTimeHelper.DateTimeToTimeStamp(DateTime.Now)*/;
            item.Postdata = SecurityHelper.AesEncrypt(item.Postdata, appAes);
            var sign = MD5ToString(Encrypt(item.Postdata + appkey + timespan, appsecret, false));
            item.Header.Add("sign", sign);
            item.Header.Add("timestamp", timespan + "");
            item.Header.Add("appkey", appkey + "");
            item.Header.Add("UserToken", UserToken);
            var result = http.GetHtml(item);
            return result;
        }

        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="encryptStr">明文</param>
        /// <param name="key">密钥</param>
        /// <param name="isBase64">是否转为base64（否的情况将采用16进制字符串）</param>
        /// <returns></returns>
        public static string Encrypt(string encryptStr, string key, bool isBase64 = true, bool is32 = true)
        {
            byte[] keyArray = Encoding.UTF8.GetBytes(key.Substring(0, is32 ? 32 : 16));
            byte[] toEncryptArray = Encoding.UTF8.GetBytes(encryptStr);
            RijndaelManaged rDel = new RijndaelManaged();
            rDel.Key = keyArray;
            rDel.Mode = CipherMode.ECB;
            rDel.Padding = PaddingMode.PKCS7;
            ICryptoTransform cTransform = rDel.CreateEncryptor();
            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            return isBase64
                ? Convert.ToBase64String(resultArray, 0, resultArray.Length)
                : ByteArrayToHexString(resultArray);
        }

        /// <summary>
        /// 将一个byte数组转换成16进制字符串
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        private static string ByteArrayToHexString(byte[] data)
        {
            StringBuilder sb = new StringBuilder(data.Length * 3);
            foreach (byte b in data)
            {
                sb.Append(Convert.ToString(b, 16).PadLeft(2, '0'));
            }
            return sb.ToString().ToUpper();
        }

        public static string MD5ToString(string text)
        {
            var retVal = new MD5CryptoServiceProvider().ComputeHash(Encoding.Default.GetBytes(text));
            return string.Join("", retVal.Select(s => s.ToString("x2")));
        }

        /// <summary>
        /// 时间戳（秒）
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public static Int64 GetTimespan(DateTime dateTime)
        {
            TimeSpan ts = dateTime - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds);
        }

        /// <summary>
        /// 加密解密帮助类
        /// </summary>
        public class SecurityHelper
        {
            #region AES加密解密 
            /// <summary>
            /// 128位处理key 
            /// </summary>
            /// <param name="keyArray">原字节</param>
            /// <param name="key">处理key</param>
            /// <returns></returns>
            private static byte[] GetAesKey(byte[] keyArray, string key)
            {
                byte[] newArray = new byte[16];
                if (keyArray.Length < 16)
                {
                    for (int i = 0; i < newArray.Length; i++)
                    {
                        if (i >= keyArray.Length)
                        {
                            newArray[i] = 0;
                        }
                        else
                        {
                            newArray[i] = keyArray[i];
                        }
                    }
                }
                return newArray;
            }
            /// <summary>
            /// 使用AES加密字符串,按128位处理key
            /// </summary>
            /// <param name="content">加密内容</param>
            /// <param name="key">秘钥，需要128位、256位.....</param>
            /// <param name="autoHandle">秘钥，需要128位、256位.....</param>
            /// <returns>Base64字符串结果</returns>
            public static string AesEncrypt(string content, string key, bool autoHandle = true)
            {
                try
                {
                    byte[] keyArray = Encoding.UTF8.GetBytes(key);
                    if (autoHandle)
                    {
                        keyArray = GetAesKey(keyArray, key);
                    }
                    byte[] toEncryptArray = Encoding.UTF8.GetBytes(content);

                    SymmetricAlgorithm des = Aes.Create();
                    des.Key = keyArray;
                    des.Mode = CipherMode.ECB;
                    des.Padding = PaddingMode.PKCS7;
                    ICryptoTransform cTransform = des.CreateEncryptor();
                    byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
                    return Convert.ToBase64String(resultArray);
                }
                catch
                {
                    return "";
                }

            }
            /// <summary>
            /// 使用AES解密字符串,按128位处理key
            /// </summary>
            /// <param name="content">内容</param>
            /// <param name="key">秘钥，需要128位、256位.....</param>
            /// <param name="autoHandle">秘钥，需要128位、256位.....</param>
            /// <returns>UTF8解密结果</returns>
            public static string AesDecrypt(string content, string key, bool autoHandle = true)
            {
                try
                {
                    byte[] keyArray = Encoding.UTF8.GetBytes(key);
                    if (autoHandle)
                    {
                        keyArray = GetAesKey(keyArray, key);
                    }
                    byte[] toEncryptArray = Convert.FromBase64String(content);

                    SymmetricAlgorithm des = Aes.Create();
                    des.Key = keyArray;
                    des.Mode = CipherMode.ECB;
                    des.Padding = PaddingMode.PKCS7;

                    ICryptoTransform cTransform = des.CreateDecryptor();
                    byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

                    return Encoding.UTF8.GetString(resultArray);
                }
                catch
                {
                    return "";
                }
            }
            /// <summary>
            /// 使用AES解密字符串,按128位处理key
            /// </summary>
            /// <param name="content">内容</param>
            /// <param name="key">秘钥，需要128位、256位.....</param>
            /// <param name="autoHandle">秘钥，需要128位、256位.....</param>
            /// <returns>UTF8解密结果</returns>
            public static byte[] AesDecryptByte(string content, string key, bool autoHandle = true)
            {
                try
                {
                    byte[] keyArray = Encoding.UTF8.GetBytes(key);
                    if (autoHandle)
                    {
                        keyArray = GetAesKey(keyArray, key);
                    }
                    byte[] toEncryptArray = Convert.FromBase64String(content);

                    SymmetricAlgorithm des = Aes.Create();
                    des.Key = keyArray;
                    des.Mode = CipherMode.ECB;
                    des.Padding = PaddingMode.PKCS7;

                    ICryptoTransform cTransform = des.CreateDecryptor();
                    byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

                    return resultArray;
                }
                catch
                {
                    return null;
                }
            }
            #endregion
        }

        /// <summary>
        /// 上传机器人客户信息
        /// </summary>
        public class CustomerLinkInput
        {
            /// <summary>
            /// 用户名
            /// </summary>
            [Required]
            [DisplayName("用户名")]
            public string UserName { get; set; }
            /// <summary>
            /// 机器人类型0个人微信 1企业微信 2QQ
            /// </summary>
            [Required]
            [DisplayName("机器人类型0个人微信 1企业微信 2QQ")]
            public int RobotType { get; set; }
            /// <summary>
            /// 头像地址
            /// </summary>
            public string HeadUrl { get; set; }
            /// <summary>
            /// 昵称
            /// </summary>
            public string NickName { get; set; }
            /// <summary>
            ///  备注
            /// </summary>
            public string Remark { get; set; }
            /// <summary>
            /// 机器人账号
            /// </summary>
            [Required]
            [DisplayName("机器人账号")]
            public string RobotName { get; set; }
            /// <summary>
            /// 添加时间
            /// </summary>
            [Required]
            public DateTime CreateTime { get; set; }
        }

        /// <summary>
        /// 转换机器人类型
        /// </summary>
        /// <param name="chatType"></param>
        /// <returns></returns>
        public static int ConvertRobotType(ChatType chatType)
        {
            /*
            未知来源 = 0,
            QQ = 1,
            微信 = 2,
            微信公众号 = 3,
            企业微信 = 4
             */

            switch (chatType)
            {
                case ChatType.QQ:
                    return 2;
                case ChatType.企业微信:
                    return 1;
                case ChatType.微信:
                    return 0;
                case ChatType.微信公众号:
                    return -1;
                case ChatType.未知来源:
                    return -1;
            }
            return -1;
        }

        /// <summary>
        /// 上传机器人信息
        /// </summary>
        public class CustomerRobotInput
        {
            /// <summary>
            /// 用户名
            /// </summary>
            [Required]
            [DisplayName("用户名")]
            public string UserName { get; set; }
            /// <summary>
            /// 机器人类型0个人微信 1企业微信 2QQ
            /// </summary>
            [Required]
            [DisplayName("机器人类型0个人微信 1企业微信 2QQ")]
            public int RobotType { get; set; }
            /// <summary>
            /// 头像地址
            /// </summary>
            public string HeadUrl { get; set; }
            /// <summary>
            /// 昵称
            /// </summary>
            public string NickName { get; set; }
            /// <summary>
            ///  备注
            /// </summary>
            public string Remark { get; set; }
        }


        /// <summary>
        /// 统一服务返回结果
        /// </summary>
        public class ServiceResult
        {
            /// <summary>
            /// 请求是否成功
            /// </summary>
            public bool Ok { get; set; }
            /// <summary>
            /// 数据
            /// </summary>
            public object Data { get; set; }
            /// <summary>
            /// 错误信息
            /// </summary>
            public string Message { get; set; }
        }
        /// <summary>
        /// 统一返回结果
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class ServiceResult<T> : ServiceResult
        {
            /// <summary>
            /// 初始化
            /// </summary>
            /// <param name="data"></param>
            public ServiceResult(T data)
            {
                this.Data = data;
            }
            /// <summary>
            /// 返回数据
            /// </summary>
            public new T Data { get; set; }

        }
    }
}