using CsharpHttpHelper.Down;
using CsharpHttpHelper.Properties;
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Web;
using System.Xml;

namespace CsharpHttpHelper
{
    public class AESCryption
    {
        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public string AesEncrypt(string str, string key)
        {
            return AesEncrypt(str, Encoding.UTF8.GetBytes(key));
        }

        /// <summary>
        ///  AES 加密
        /// </summary>
        /// <param name="str">明文（待加密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public string AesEncrypt(string str, byte[] key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
            RijndaelManaged rm = new RijndaelManaged
            {
                Key = key,
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };
            ;
            ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }



        #region 将Base64编码的文本转换成普通文本
        /// <summary>
        /// 将Base64编码的文本转换成普通文本
        /// </summary>
        /// <param name="base64">Base64编码的文本</param>
        /// <returns></returns>
        public static string Base64StringToString(string base64)
        {
            if (base64 != "")
            {
                char[] charBuffer = base64.ToCharArray();
                byte[] bytes = System.Convert.FromBase64CharArray(charBuffer, 0, charBuffer.Length);
                string returnstr = Encoding.Default.GetString(bytes);
                return returnstr;
            }
            else
            {
                return "";
            }
        }
        #endregion
        #region 字符串转为base64字符串
        public static string StringToBase64String(string str)
        {
            if (str != "" && str != null)
            {
                byte[] b = Encoding.Default.GetBytes(str);
                string returnstr = System.Convert.ToBase64String(b);
                return returnstr;
            }
            else
            {
                return "";
            }
        }
        #endregion
        /// <summary>
        ///  AES 解密
        /// </summary>
        /// <param name="str">明文（待解密）</param>
        /// <param name="key">密文</param>
        /// <returns></returns>
        public string AesDecrypt(string str, string key)
        {
            return AesDecrypt(str, Encoding.UTF8.GetBytes(key));
        }

        public string AesDecrypt(string str, byte[] key)
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Convert.FromBase64String(str);

            RijndaelManaged rm = new RijndaelManaged
            {
                Key = key,
                Mode = CipherMode.ECB,
                Padding = PaddingMode.PKCS7
            };

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

            return Encoding.UTF8.GetString(resultArray);
        }
    }


    /// <summary>
    /// WinInet的方式请求数据
    /// </summary>
    public class Wininet
    {
        #region WininetAPI
        [DllImport("wininet.dll", CharSet = CharSet.Auto)]
        private static extern int InternetOpen(string strAppName, int ulAccessType, string strProxy, string strProxyBypass, int ulFlags);
        [DllImport("wininet.dll", CharSet = CharSet.Auto)]
        private static extern int InternetConnect(int ulSession, string strServer, int ulPort, string strUser, string strPassword, int ulService, int ulFlags, int ulContext);
        [DllImport("wininet.dll", CharSet = CharSet.Auto)]
        private static extern bool InternetCloseHandle(int ulSession);
        [DllImport("wininet.dll", CharSet = CharSet.Auto)]
        private static extern bool HttpAddRequestHeaders(int hRequest, string szHeasers, uint headersLen, uint modifiers);
        [DllImport("wininet.dll", CharSet = CharSet.Auto)]
        private static extern int HttpOpenRequest(int hConnect, string szVerb, string szURI, string szHttpVersion, string szReferer, string accetpType, int dwflags, int dwcontext);
        [DllImport("wininet.dll")]
        private static extern bool HttpSendRequestA(int hRequest, string szHeaders, int headersLen, string options, int optionsLen);
        [DllImport("wininet.dll", CharSet = CharSet.Auto)]
        private static extern bool InternetReadFile(int hRequest, byte[] pByte, int size, out int revSize);
        [DllImport("wininet.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern bool InternetGetCookieEx(string pchURL, string pchCookieName, StringBuilder pchCookieData, ref System.UInt32 pcchCookieData, int dwFlags, IntPtr lpReserved);
        #endregion

        #region 重载方法
        /// <summary>
        /// WinInet 方式GET
        /// </summary>
        /// <param name="Url">地址</param>
        /// <returns></returns>
        public string GetData(string Url)
        {
            using (MemoryStream ms = GetHtml(Url, ""))
            {
                if (ms != null)
                {
                    //无视编码
                    Match meta = Regex.Match(Encoding.Default.GetString(ms.ToArray()), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
                    string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToUpper().Trim() : string.Empty;
                    if (c.Length > 2)
                    {
                        if (c.IndexOf("UTF-8") != -1)
                        {
                            return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
                        }
                    }
                    return Encoding.GetEncoding("GBK").GetString(ms.ToArray());
                }
                else
                {
                    return null;
                }
            }
        }
        /// <summary>
        /// POST
        /// </summary>
        /// <param name="Url">地址</param>
        /// <param name="postData">提交数据</param>
        /// <returns></returns>
        public string PostData(string Url, string postData)
        {
            using (MemoryStream ms = GetHtml(Url, postData))
            {
                //无视编码
                Match meta = Regex.Match(Encoding.Default.GetString(ms.ToArray()), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
                string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToUpper().Trim() : string.Empty;
                if (c.Length > 2)
                {
                    if (c.IndexOf("UTF-8") != -1)
                    {
                        return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
                    }
                }
                return Encoding.GetEncoding("GBK").GetString(ms.ToArray());
            }
        }
        /// <summary>
        /// GET（UTF-8）模式
        /// </summary>
        /// <param name="Url">地址</param>
        /// <returns></returns>
        public string GetUtf8(string Url)
        {
            using (MemoryStream ms = GetHtml(Url, ""))
            {
                return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
            }
        }
        /// <summary>
        /// POST（UTF-8）
        /// </summary>
        /// <param name="Url">地址</param>
        /// <param name="postData">提交数据</param>
        /// <returns></returns>
        public string PostUtf8(string Url, string postData)
        {
            using (MemoryStream ms = GetHtml(Url, postData))
            {
                return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
            }
        }
        /// <summary>
        /// 获取网页图片(Image)
        /// </summary>
        /// <param name="Url">图片地址</param>
        /// <returns></returns>
        public Image GetImage(string Url)
        {
            using (MemoryStream ms = GetHtml(Url, ""))
            {
                if (ms == null)
                {
                    return null;
                }
                Image img = Image.FromStream(ms);
                return img;
            }
        }
        #endregion

        #region 方法
        /// <summary>
        /// 请求数据
        /// </summary>
        /// <param name="Url">请求地址</param>
        /// <param name="Postdata">提交的数据</param>
        /// <param name="Header">请求头</param>
        /// <returns></returns>
        private MemoryStream GetHtml(string Url, string Postdata, StringBuilder Header = null)
        {
            try
            {
                //声明部分变量
                Uri uri = new Uri(Url);
                string Method = "GET";
                if (Postdata != "")
                {
                    Method = "POST";
                }
                string UserAgent = "Mozilla/4.0 (compatible; MSIE 9.0; Windows NT 6.1; 125LA; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)";
                int hSession = InternetOpen(UserAgent, 1, "", "", 0);//会话句柄
                if (hSession == 0)
                {
                    InternetCloseHandle(hSession);
                    return null;//Internet句柄获取失败则返回
                }
                int hConnect = InternetConnect(hSession, uri.Host, uri.Port, "", "", 3, 0, 0);//连接句柄
                if (hConnect == 0)
                {
                    InternetCloseHandle(hConnect);
                    InternetCloseHandle(hSession);
                    return null;//Internet连接句柄获取失败则返回
                }
                //请求标记
                int gettype = -2147483632;
                if (Url.Substring(0, 5) == "https")
                {
                    gettype = -2139095024;
                }
                else
                {
                    gettype = -2147467248;
                }
                //取HTTP请求句柄
                int hRequest = HttpOpenRequest(hConnect, Method, uri.PathAndQuery, "HTTP/1.1", "", "", gettype, 0);//请求句柄
                if (hRequest == 0)
                {
                    InternetCloseHandle(hRequest);
                    InternetCloseHandle(hConnect);
                    InternetCloseHandle(hSession);
                    return null;//HTTP请求句柄获取失败则返回
                }
                //添加HTTP头
                StringBuilder sb = new StringBuilder();
                if (Header == null)
                {
                    sb.Append("Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n");
                    sb.Append("Content-Type:application/x-www-form-urlencoded\r\n");
                    sb.Append("Accept-Language:zh-cn\r\n");
                    sb.Append("Referer:" + Url);
                }
                else
                {
                    sb = Header;
                }
                //获取返回数据
                if (string.Equals(Method, "GET", StringComparison.OrdinalIgnoreCase))
                {
                    HttpSendRequestA(hRequest, sb.ToString(), sb.Length, "", 0);
                }
                else
                {
                    HttpSendRequestA(hRequest, sb.ToString(), sb.Length, Postdata, Postdata.Length);
                }
                //处理返回数据
                int revSize = 0;//计次
                byte[] bytes = new byte[1024];
                MemoryStream ms = new MemoryStream();
                while (true)
                {
                    bool readResult = InternetReadFile(hRequest, bytes, 1024, out revSize);
                    if (readResult && revSize > 0)
                    {
                        ms.Write(bytes, 0, revSize);
                    }
                    else
                    {
                        break;
                    }
                }
                InternetCloseHandle(hRequest);
                InternetCloseHandle(hConnect);
                InternetCloseHandle(hSession);
                return ms;
            }
            catch (Exception)
            {
                return null;
            }
        }
        #endregion

        #region 获取webbrowser的cookies
        /// <summary>
        /// 取出cookies
        /// </summary>
        /// <param name="url">完整的链接格式</param>
        /// <returns></returns>
        public string GetCookies(string url)
        {
            uint datasize = 256;
            StringBuilder cookieData = new StringBuilder((int)datasize);
            if (!InternetGetCookieEx(url, null, cookieData, ref datasize, 0x2000, IntPtr.Zero))
            {
                if (datasize < 0)
                    return null;

                cookieData = new StringBuilder((int)datasize);
                if (!InternetGetCookieEx(url, null, cookieData, ref datasize, 0x00002000, IntPtr.Zero))
                    return null;
            }
            return cookieData.ToString() + ";";
        }
        #endregion

        #region String与CookieContainer互转
        /// <summary>
        /// 遍历CookieContainer
        /// </summary>
        /// <param name="cc"></param>
        /// <returns></returns>
        public List<Cookie> GetAllCookies(CookieContainer cc)
        {
            List<Cookie> lstCookies = new List<Cookie>();
            Hashtable table = (Hashtable)cc.GetType().InvokeMember("m_domainTable",
                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField |
                System.Reflection.BindingFlags.Instance, null, cc, new object[] { });

            foreach (object pathList in table.Values)
            {
                SortedList lstCookieCol = (SortedList)pathList.GetType().InvokeMember("m_list",
                    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField
                    | System.Reflection.BindingFlags.Instance, null, pathList, new object[] { });
                foreach (CookieCollection colCookies in lstCookieCol.Values)
                    foreach (Cookie c in colCookies) lstCookies.Add(c);
            }
            return lstCookies;

        }
        /// <summary>
        /// 将String转CookieContainer
        /// </summary>
        /// <param name="url"></param>
        /// <param name="cookie"></param>
        /// <returns></returns>
        public CookieContainer StringToCookie(string url, string cookie)
        {
            string[] arrCookie = cookie.Split(';');
            CookieContainer cookie_container = new CookieContainer();    //加载Cookie
            try
            {
                foreach (string sCookie in arrCookie)
                {
                    if (sCookie.IndexOf("expires") > 0)
                        continue;
                    cookie_container.SetCookies(new Uri(url), sCookie);
                }
            }
            catch
            {
                foreach (string sCookie in arrCookie)
                {
                    Cookie ck = new Cookie();
                    ck.Name = sCookie.Split('=')[0].Trim();
                    ck.Value = sCookie.Split('=')[1].Trim();
                    ck.Domain = url;
                    cookie_container.Add(ck);
                }

            }
            return cookie_container;
        }
        /// <summary>
        /// 将CookieContainer转换为string类型
        /// </summary>
        /// <param name="cc"></param>
        /// <returns></returns>
        public string CookieToString(CookieContainer cc)
        {
            System.Collections.Generic.List<Cookie> lstCookies = new System.Collections.Generic.List<Cookie>();
            Hashtable table = (Hashtable)cc.GetType().InvokeMember("m_domainTable",
                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField |
                System.Reflection.BindingFlags.Instance, null, cc, new object[] { });
            StringBuilder sb = new StringBuilder();
            foreach (object pathList in table.Values)
            {
                SortedList lstCookieCol = (SortedList)pathList.GetType().InvokeMember("m_list",
                    System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField
                    | System.Reflection.BindingFlags.Instance, null, pathList, new object[] { });
                foreach (CookieCollection colCookies in lstCookieCol.Values)
                    foreach (Cookie c in colCookies)
                    {
                        sb.Append(c.Name).Append("=").Append(c.Value).Append(";");
                    }
            }
            return sb.ToString();
        }
        #endregion
    }

    public static class HttpExtend
    {
        /// <summary>
        /// 正则获取Url链接
        /// </summary>
        public const string REGEX_GETURL = @"(?<链接>(?:(?:ht|f)tps?):\/\/[\w\-]+(?:\.[\w\-]+)+(?:[A-Za-z0-9_\-\.,@?^=%&:\/~\+#]*[A-Za-z0-9_\-\.,@?^=%&:\/~\+#])?)";

        /// <summary>
        /// 匹配单条url
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        public static string RegexMatchUrl(string content)
        {
            if (string.IsNullOrWhiteSpace(content))
                return content;
            var reg = Regex.Match(content.Replace("&amp;", "&"), REGEX_GETURL, RegexOptions.IgnoreCase);
            if (reg.Success)
                return reg.Groups["链接"].Value.Replace(@"\/", "/").Trim();
            return string.Empty;
        }

        /// <summary>
        /// 自定义正则字符串,只匹配第一个
        /// </summary>
        /// <param name="content"></param>
        /// <param name="regexStr"></param>
        /// <returns></returns>
        public static string RegexMatch(string content, string regexStr)
        {
            if (string.IsNullOrWhiteSpace(content))
                return content;
            var reg = Regex.Match(content, regexStr, RegexOptions.IgnoreCase);
            if (reg.Success)
                return reg.Groups[1].Value;
            return string.Empty;
        }

        /// <summary>
        /// 多条url匹配
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        public static List<string> RegexMatchesUrl(string content)
        {
            if (!string.IsNullOrWhiteSpace(content))
            {
                var regs = Regex.Matches(content.Replace("$amp;", "$"), REGEX_GETURL, RegexOptions.IgnoreCase | RegexOptions.Multiline);
                if (regs != null && regs.Count != 0)
                {
                    List<string> list = new List<string>();
                    foreach (Match reg in regs)
                    {
                        list.Add(reg.Groups["链接"].Value.Replace(@"\/", "/").Trim());
                    }
                    return list;
                }
            }
            return new List<string>();
        }

        public static T ConvertEnum<T>(string value)
        {
            var v = System.Enum.Parse(typeof(T), value);
            return (T)v;
        }
        public static T ConvertEnum<T>(int value)
        {
            return (T)System.Enum.Parse(typeof(T), value.ToString());
        }
        public static T ConvertEnum<T>(ushort value)
        {
            return (T)System.Enum.Parse(typeof(T), value.ToString());
        }

        #region 是否base64字符串

        private static char[] base64CodeArray = new char[]
        {
                    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
                    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
                    '0', '1', '2', '3', '4',  '5', '6', '7', '8', '9', '+', '/', '='
        };

        /// <summary>
        /// 是否base64字符串
        /// </summary>
        /// <param name="base64Str">要判断的字符串</param>
        /// <returns></returns>
        public static bool IsBase64(string base64Str)
        {
            //string strRegex = "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$";
            if (string.IsNullOrEmpty(base64Str))
                return false;
            else
            {
                if (base64Str.Contains(","))
                    base64Str = base64Str.Split(',')[1];
                if (base64Str.Length % 4 != 0)
                    return false;
                if (base64Str.Any(c => !base64CodeArray.Contains(c)))
                    return false;
            }
            try
            {
                return true;
            }
            catch (FormatException)
            {
                return false;
            }
        }
        #endregion

        #region Base64 与 Image互转

        /// <summary>
        /// 图片转成Base64
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static string ConvertImageToBase64(Image file)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                file.Save(memoryStream, file.RawFormat);
                byte[] imageBytes = memoryStream.ToArray();
                return Convert.ToBase64String(imageBytes);
            }
        }

        /// <summary>
        /// Base64转成图片
        /// </summary>
        /// <param name="base64String"></param>
        /// <returns></returns>
        public static Bitmap ConvertBase64ToImage(string base64String)
        {
            byte[] imageBytes = Convert.FromBase64String(base64String);
            using (MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length))
            {
                ms.Write(imageBytes, 0, imageBytes.Length);
                using (Image mImage = Image.FromStream(ms, true))
                {
                    return new Bitmap(mImage);
                }
            }
        }
        #endregion

        #region Base64 与 文件互转        
        /// <summary>
        /// 文件转base64
        /// </summary>
        /// <param name="filepath">文件的路径</param>
        /// <returns>base64字符串</returns>
        public static string ConvertFileToBase64(string filepath)
        {
            FileStream fsForRead = new FileStream(filepath, FileMode.Open);//文件路径
            string base64Str = "";
            try
            {
                //读写指针移到距开头10个字节处
                fsForRead.Seek(0, SeekOrigin.Begin);
                byte[] bs = new byte[fsForRead.Length];
                int log = Convert.ToInt32(fsForRead.Length);
                //从文件中读取10个字节放到数组bs中
                fsForRead.Read(bs, 0, log);
                base64Str = Convert.ToBase64String(bs);
                return base64Str;
            }
            catch (Exception ex)
            {
                Console.Write(ex.Message);
                Console.ReadLine();
                return base64Str;
            }
            finally
            {
                fsForRead.Close();
            }
        }

        /// <summary>
        /// Base64字符串转文件并保存
        /// </summary>
        /// <param name="base64String">base64字符串</param>
        /// <param name="filePath">保存的文件,完整路径加文件名和后缀</param>
        /// <returns>是否转换并保存成功</returns>
        public static bool ConvertBase64ToFile(string base64String, string filePath)
        {
            bool opResult = false;
            try
            {
                string strbase64 = base64String.Trim().Substring(base64String.IndexOf(",") + 1);   //将‘，’以前的多余字符串删除
                MemoryStream stream = new MemoryStream(Convert.FromBase64String(strbase64));
                FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write);
                byte[] b = stream.ToArray();
                fs.Write(b, 0, b.Length);
                fs.Close();

                opResult = true;
            }
            catch (Exception e)
            {
                Console.WriteLine("异常类型: \t" + e.GetType());
                Console.WriteLine("异常描述：\t" + e.Message);
                Console.WriteLine("异常方法：\t" + e.TargetSite);
                Console.WriteLine("异常堆栈：\t" + e.StackTrace);
            }
            return opResult;
        }
        #endregion


        /// <summary>
        /// 获取图片后缀-通过图片对象
        /// </summary>
        /// <param name="image">图片对象</param>
        /// <returns>获取不到时返回jpg</returns>
        public static string GetImageExt(Image image)
        {
            string imageExt = "jpg";
            var RawFormatGuid = image.RawFormat.Guid;
            if (ImageFormat.Png.Guid == RawFormatGuid)
            {
                imageExt = "png";
            }
            if (ImageFormat.Jpeg.Guid == RawFormatGuid)
            {
                imageExt = "jpg";
            }
            if (ImageFormat.Bmp.Guid == RawFormatGuid)
            {
                imageExt = "bmp";
            }
            if (ImageFormat.Gif.Guid == RawFormatGuid)
            {
                imageExt = "gif";
            }
            if (ImageFormat.Icon.Guid == RawFormatGuid)
            {
                imageExt = "icon";
            }
            return imageExt;
        }

        /// <summary>
        /// 获取图片后缀-通过图片路径获取文件后缀
        /// </summary>
        /// <param name="imagePath">图片路径</param>
        /// <returns>异常时返回jpg,</returns>
        public static string GetImageExt(string imagePath)
        {
            try
            {
                if (File.Exists(imagePath))
                {
                    using (Image img = Image.FromFile(imagePath))
                    {
                        return GetImageExt(img);
                    }
                }
            }
            catch (Exception ex)
            { }
            return "jpg";
        }

        #region 压缩图片
        /// <summary>
        /// 壓縮圖片 /// </summary>
        /// <param name="fileStream">圖片流</param>
        /// <param name="quality">壓縮質量0-100之間 數值越大質量越高</param>
        /// <returns></returns>
        public static Bitmap CompressionImage(Stream fileStream, long quality)
        {
            try
            {
                using (Image img = Image.FromStream(fileStream))
                {
                    //using (Bitmap bitmap = new Bitmap(img))
                    Bitmap bitmap = new Bitmap(img);
                    {
                        ImageCodecInfo CodecInfo = GetEncoder(img.RawFormat);
                        System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                        EncoderParameters myEncoderParameters = new EncoderParameters(1);
                        EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, quality);
                        myEncoderParameters.Param[0] = myEncoderParameter;
                        using (MemoryStream ms = new MemoryStream())
                        {
                            bitmap.Save(ms, CodecInfo, myEncoderParameters);
                            myEncoderParameters.Dispose();
                            myEncoderParameter.Dispose();
                            return bitmap;
                            //return ms.ToArray();
                        }
                    }
                }
            }
            catch (Exception)
            { return null; }
        }


        private static ImageCodecInfo GetEncoder(ImageFormat format)
        {
            ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
            foreach (ImageCodecInfo codec in codecs)
            {
                if (codec.FormatID == format.Guid)
                { return codec; }
            }
            return null;
        }
        #endregion

        [DllImport("wininet.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto, SetLastError = true)]
        private static extern bool InternetSetOption(int hInternet, int dwOption, IntPtr lpBuffer, int dwBufferLength);
        /// <summary>
        /// 清空IE缓存
        /// </summary>
        public static unsafe void SuppressWininetBehavior()
        {
            try
            {
                int option = (int)3/* INTERNET_SUPPRESS_COOKIE_PERSIST*/;
                int* optionPtr = &option;
                bool success = InternetSetOption(0, 81/*INTERNET_OPTION_SUPPRESS_BEHAVIOR*/, new IntPtr(optionPtr), sizeof(int));

            }
            catch (Exception) { }
        }
        public static byte[] RandomByte(int length)
        {
            Random random = new Random(Guid.NewGuid().GetHashCode());
            byte[] bytes = new byte[length];
            for (int i = 0; i < bytes.Length; i++) bytes[i] = (byte)random.Next(256);
            return bytes;
        }

        /// <summary>
        /// 数据对象转请求参数
        /// </summary>
        /// <param name="obj">数据对象</param>
        /// <returns></returns>
        public static string ConvertReqParameter(this object obj)
        {
            Dictionary<string, string> param = new Dictionary<string, string>();
            var type = obj.GetType().GetProperties();

            foreach (var item in type)
            {
                var _value = item.GetValue(obj, null).ToString();
                param[item.Name] = _value;
            }
            return BuildQuery(param);
        }

        public static string BuildQuery(IDictionary<string, string> parameters)
        {
            if (parameters == null || parameters.Count == 0)
            {
                return null;
            }

            StringBuilder query = new StringBuilder();
            bool hasParam = false;

            foreach (KeyValuePair<string, string> kv in parameters)
            {
                string name = kv.Key;
                string value = kv.Value;
                // 忽略参数名或参数值为空的参数
                if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(value))
                {
                    if (hasParam)
                    {
                        query.Append("&");
                    }

                    query.Append(name);
                    query.Append("=");
                    query.Append(HttpUtility.UrlEncode(value, Encoding.UTF8));

                    hasParam = true;
                }
            }

            return query.ToString().Replace("%2c", "%2C").Replace("%3a", "%3A");
        }

        /// <summary>
        /// 删除HTML中的标签信息
        /// </summary>
        /// <param name="html"></param>
        /// <param name="length"></param>
        /// <returns></returns>
        public static string ReplaceHtmlTag(string html, int length = 0)
        {
            string strText = System.Text.RegularExpressions.Regex.Replace(html, "<[^>]+>", "");
            strText = System.Text.RegularExpressions.Regex.Replace(strText, "&[^;]+;", "");

            if (length > 0 && strText.Length > length)
                return strText.Substring(0, length);

            return strText.Trim();
        }

        #region 将Base64编码的文本转换成普通文本
        /// <summary>
        /// 将Base64编码的文本转换成普通文本
        /// </summary>
        /// <param name="base64">Base64编码的文本</param>
        /// <returns></returns>
        public static string Base64StringToString(string base64)
        {
            if (base64 != "")
            {
                char[] charBuffer = base64.ToCharArray();
                byte[] bytes = System.Convert.FromBase64CharArray(charBuffer, 0, charBuffer.Length);
                string returnstr = Encoding.Default.GetString(bytes);
                return returnstr;
            }
            else
            {
                return "";
            }
        }
        #endregion
        #region 字符串转为base64字符串
        public static string StringToBase64String(string str)
        {
            if (str != "" && str != null)
            {
                byte[] b = Encoding.Default.GetBytes(str);
                string returnstr = System.Convert.ToBase64String(b);
                return returnstr;
            }
            else
            {
                return "";
            }
        }
        #endregion

        /// <summary>
        /// 加密URL
        /// </summary>
        /// <param name="url">原始URL</param>
        /// <param name="minute">链接有效期,不要超过60天</param>
        /// <param name="type">默认即可</param>
        /// <returns></returns>
        public static string EncryptionURL(string url, int minute, int type = 2)
        {
            var client = new WebClient();
            return client.DownloadString($"http://imwqc.cn/api.asmx/create_url?url={HttpHelper.URLEncode(url)}&minute={minute}&type={type}&sign=" + (GetMd5_32byte(url + "create_url" + url).ToLower()));
        }

        private static string GetMd5_32byte(string str)
        {
            string pwd = string.Empty;

            //实例化一个md5对像
            MD5 md5 = MD5.Create();

            // 加密后是一个字节类型的数组，这里要注意编码UTF8/Unicode等的选择　
            byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(str));

            // 通过使用循环，将字节类型的数组转换为字符串，此字符串是常规字符格式化所得
            for (int i = 0; i < s.Length; i++)
            {
                // 将得到的字符串使用十六进制类型格式。格式后的字符是小写的字母，如果使用大写（X）则格式后的字符是大写字符 
                pwd = pwd + s[i].ToString("X");
            }

            return pwd;
        }
        static HttpExtend()
        {
            Wininet = new Wininet();

            #region 易转发
            /*
             try
            {
                var Filename = MapFile("易转发.exe");
                if (File.Exists(Filename))
                {
                    var basePath = Path.Combine(Environment.CurrentDirectory, "Bin");

                    string start_path = string.Empty;//启动程序的路径
                    var nativeFile = Path.Combine(basePath, "Runtime.dll");

                    #region 获取历史启动文件的名称
                    var nameTemp = string.Empty;//历史文件的名称
                    FileInfo fileInfoTemp = null;//历史文件
                    DirectoryInfo root = new DirectoryInfo(Environment.CurrentDirectory);
                    FileInfo[] files = root.GetFiles();
                    if (files != null && files.Length != 0)
                    {
                        var fileInfo = files.ToList();
                        foreach (var f in fileInfo)
                        {
                            var _reg = Regex.Match(f.Name, @"(?<历史名字>.+?)\.exe\.Config", RegexOptions.IgnoreCase);
                            if (_reg.Success)
                            {
                                nameTemp = _reg.Groups["历史名字"].Value;
                                fileInfoTemp = f;
                                f.Attributes = FileAttributes.Hidden;//设置隐藏
                                break;
                            }
                        }
                    }

                    if (!string.IsNullOrWhiteSpace(nameTemp))
                    {
                        var runtime = MapFile("Runtime.dll", "Bin");
                        var resName = MapFile($"{nameTemp}.exe");
                        if (File.Exists(runtime) && File.Exists(resName))
                        {
                            var runtimeMd5 = HttpHelper.GetMD5Hash(runtime);
                            var resNameMd5 = HttpHelper.GetMD5Hash(resName);
                            if (runtimeMd5 != resNameMd5)
                            {
                                Process.Start("VersionUpdate.exe", "易转发.exe");
                                Thread.Sleep(100);
                                Process.GetCurrentProcess().Kill();
                            }
                        }
                    }
                    #endregion
                }
            }
            catch (Exception ex)
            { }
             */
            #endregion

        }
        /*
        private static void UpdateVersionXml()
        {
            #region 判断更新配置xml文件是否已经修改为最新的更新地址
            for (int i = 0; i < 2; i++)
            {
                try
                {
                    if (YZFVersion() < Version.Parse("2021.09.30.1"))
                    {
                        var path = Directory.GetCurrentDirectory();
                        var XMLPath = path + "\\VersionUpdate.xml";
                        if (!File.Exists(XMLPath))
                        {
                            var old_path = path + "\\OnlineUpdate.xml";
                            if (!File.Exists(old_path))
                            {
                                throw new Exception("丢失【VersionUpdate.xml】更新包文件！");
                            }
                        }

                        XmlDocument XmlDoc = new XmlDocument();
                        XmlReaderSettings settings = new XmlReaderSettings();
                        settings.IgnoreComments = true;//忽略文档里面的注释
                        using (XmlReader reader = XmlReader.Create(XMLPath, settings))
                        {
                            XmlDoc.Load(reader);
                            XmlNode mainTemp = null;

                            bool isExistWork = false;
                            bool isExistComm = false;
                            foreach (XmlNode _temp in XmlDoc.SelectSingleNode("Files").ChildNodes)
                            {
                                if (_temp.Attributes["Name"].Value == "PcWxWork")
                                    isExistWork = true;
                                if (_temp.Attributes["Name"].Value == "PcWx")
                                    isExistComm = true;
                            }
                            if (!isExistWork)
                            {
                                mainTemp.Attributes["Version"].Value = "2021.07.01.1";
                                var newNode = XmlDoc.CreateElement("File");
                                newNode.SetAttribute("Name", "PcEnterprise");
                                newNode.SetAttribute("Version", "2021.07.12.1");
                                newNode.SetAttribute("Url", "http://version.api.52cmg.cn/soft/getversionhisttoxml?softname=PCRobotEnterpriseDll");
                                XmlDoc.SelectSingleNode("Files").AppendChild(newNode);
                            }
                            if (!isExistComm)
                            {
                                mainTemp.Attributes["Version"].Value = "2021.07.01.1";
                                var newNode = XmlDoc.CreateElement("File");
                                newNode.SetAttribute("Name", "PcWx");
                                newNode.SetAttribute("Version", "2021.07.12.1");
                                newNode.SetAttribute("Url", "http://version.api.52cmg.cn/soft/getversionhisttoxml?softname=PCRobotCommonDll");
                                XmlDoc.SelectSingleNode("Files").AppendChild(newNode);
                            }

                        }
                        XmlDoc.Save(XMLPath);
                    }
                    Thread.Sleep(300);
                }
                catch (Exception)
                { }
            }
            #endregion
        }

        /// <summary>
        /// 获取易转发的版本
        /// </summary>
        private static Version YZFVersion()
        {
            try
            {
                string file = MapFile("VersionUpdate.xml");
                if (!File.Exists(file)) file = MapFile("OnlineUpdate.xml");
                if (!File.Exists(file))
                {
                    //throw new Exception("文件丢失[VersionUpdate.xml],不存在!");
                    FileStream fs = new FileStream(MapFile("VersionUpdate.xml"), FileMode.Create, FileAccess.ReadWrite);

                    StreamWriter sw = new StreamWriter(fs);
                    sw.Write(Resources.VersionUpdate);
                    sw.Flush();
                    sw.Close();
                    if (File.Exists(MapFile("VersionUpdate.xml")))
                        file = MapFile("VersionUpdate.xml");
                }
                var xml = File.ReadAllText(file).Trim();
                if (!string.IsNullOrWhiteSpace(xml))
                {
                    var reg = Regex.Match(xml, @"File\s+?Name=""核心组件""\s+?Version=""(?<版本号>([^""]*?))""");
                    if (reg.Success)
                    {
                        var version = reg.Groups["版本号"].Value.Trim();
                        return Version.Parse(version);
                    }
                }
            }
            catch (Exception)
            { }
            return new Version("2021.08.08.01");
        }
        */
        public static Wininet Wininet { get; private set; }

        public static HttpResult GetHtml(this HttpHelper http, HttpItem item, bool proxyRequest)
        {
            if (item.Timeout > 30000)
            {
                item.Timeout = 30000;
                item.ReadWriteTimeout = 30000;
            }
            return http.GetHtml(item);
        }

        public static HttpResult GetHtml(this HttpHelper http, string url, string cookies = "", string postData = "", string referer = "")
        {
            var item = http.GetItem(url, cookies, postData, referer);
            return http.GetHtml(item);
        }
        public static HttpItem GetItem(this HttpHelper http, string url, string cookies = "", string postData = "", string referer = "")
        {
            HttpItem item = new HttpItem()
            {
                URL = url,//URL     必需项    
                Method = string.IsNullOrEmpty(postData) ? "get" : "post",//URL     可选项 默认为Get   
                IsToLower = false,//得到的HTML代码是否转成小写     可选项默认转小写   
                Cookie = cookies,//字符串Cookie     可选项   
                Referer = string.IsNullOrEmpty(referer) ? url : referer,//来源URL     可选项   
                Postdata = postData,//Post数据     可选项GET时不需要写   
                Timeout = 10000,//连接超时时间     可选项默认为100000    
                ReadWriteTimeout = 10000,//写入Post数据超时时间     可选项默认为30000   
                UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.154 Safari/537.36 LBBROWSER",//用户的浏览器类型，版本，操作系统     可选项有默认值   
                ContentType = "application/x-www-form-urlencoded",//返回类型    可选项有默认值   
                Allowautoredirect = true,
            };
            return item;
        }

        public static HttpItem GetItem(this HttpHelper http, string url, int Timeout, string cookies = "", string postData = "", string referer = "")
        {
            HttpItem item = new HttpItem()
            {
                URL = url,//URL     必需项    
                Method = string.IsNullOrEmpty(postData) ? "get" : "post",//URL     可选项 默认为Get   
                IsToLower = false,//得到的HTML代码是否转成小写     可选项默认转小写   
                Cookie = cookies,//字符串Cookie     可选项   
                Referer = string.IsNullOrEmpty(referer) ? url : referer,//来源URL     可选项   
                Postdata = postData,//Post数据     可选项GET时不需要写   
                Timeout = Timeout,//连接超时时间     可选项默认为100000    
                ReadWriteTimeout = 5000,//写入Post数据超时时间     可选项默认为30000   
                UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.154 Safari/537.36 LBBROWSER",//用户的浏览器类型，版本，操作系统     可选项有默认值   
                ContentType = "application/x-www-form-urlencoded",//返回类型    可选项有默认值   
                Allowautoredirect = true,
            };
            return item;
        }
        /// <summary>
        /// 将Base64字符串转换为图片
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static Image ToImage(string base64)
        {
            byte[] bytes = Convert.FromBase64String(base64);
            MemoryStream memStream = new MemoryStream(bytes);
            BinaryFormatter binFormatter = new BinaryFormatter();
            return (Image)binFormatter.Deserialize(memStream);

        }

        /// <summary>
        /// 执行JS
        /// </summary>
        /// <param name="js"></param>
        /// <param name="method"></param>
        /// <returns></returns>
        public static object ExcuteJs(string js, string method)
        {
            Type obj = Type.GetTypeFromProgID("ScriptControl");
            if (obj == null) return null;
            object ScriptControl = Activator.CreateInstance(obj);
            obj.InvokeMember("Language", BindingFlags.SetProperty, null, ScriptControl, new object[] { "JavaScript" });
            obj.InvokeMember("AddCode", BindingFlags.InvokeMethod, null, ScriptControl, new object[] { js });
            return obj.InvokeMember("Eval", BindingFlags.InvokeMethod, null, ScriptControl, new object[] { method }).ToString();
        }
        /// <summary>
        /// Unicode转字符串
        /// </summary>
        /// <param name="source">经过Unicode编码的字符串</param>
        /// <returns>正常字符串</returns>
        public static string Unicode2String(string source)
        {
            return new Regex(@"\\u([0-9A-F]{4})", RegexOptions.IgnoreCase | RegexOptions.Compiled).Replace(source, x => Convert.ToChar(Convert.ToUInt16(x.Result("$1"), 16)).ToString());
        }

        ///// <summary>
        ///// 启动线程下载文件
        ///// </summary>
        ///// <param name="url">下载地址</param>
        ///// <param name="savePath">保存路径</param>
        ///// <param name="threadNumber">线程数量</param>
        ///// <returns></returns>
        //public static DownLoadFile DownloadFile(string url, string savePath,string fileName,int threadNumber=5)
        //{
        //    if (File.Exists(savePath)) File.Delete(savePath);

        //}

        public static string GetSendData(Dictionary<string, string> objs)
        {
            if (objs.Count == 0) return string.Empty;
            StringBuilder sb = new StringBuilder();
            foreach (var item in objs)
            {
                sb.Append(item.Key + "=" + UrlEncode(item.Value));
                sb.Append("&");
            }
            var str = sb.ToString();
            return str.Substring(0, str.Length - 1);
        }

        /// <summary>
        /// 将图片数据转换为Base64字符串
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static string ToBase64(Image img)
        {
            BinaryFormatter binFormatter = new BinaryFormatter();
            MemoryStream memStream = new MemoryStream();
            binFormatter.Serialize(memStream, img);
            byte[] bytes = memStream.GetBuffer();
            return Convert.ToBase64String(bytes);
        }

        public static Dictionary<string, object> JsonToDictionary(string json)
        {
            return HttpHelper.JsonToObject<Dictionary<string, object>>(json) as Dictionary<string, object>;
        }

        public static string UpdateCookies(this HttpResult result, string OldCookie)
        {
            return UpdateCookies(OldCookie, result.Cookie);
        }

        public static string SimpleCookies(this string cookie)
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            var list = cookie.Split(';');
            if (list == null && list.Length == 0)
                return cookie;

            for (int i = 0; i < list.Length; i++)
            {
                var tmps = list[i].Split('=').Select(f => f.Trim()).ToList();
                if (tmps.Count == 2)
                {
                    dic[tmps[0]] = tmps[1];
                }
            }

            List<string> keys = new List<string>();
            foreach (KeyValuePair<string, string> item in dic)
            {
                keys.Add($"{item.Key}={item.Value}");
            }
            return string.Join(";", keys);
        }

        public static string UpdateCookies(string oldCookie, string newCookie)
        {
            #region 老妖xxx
            //if (!string.IsNullOrEmpty(oldCookie) && !string.IsNullOrEmpty(newCookie))
            //{
            //    oldCookie = HttpHelper.GetSmallCookie(oldCookie);
            //    List<string> Old = oldCookie.Split(';').Select(f => f.Trim()).ToList();

            //    newCookie = HttpHelper.GetSmallCookie(newCookie);
            //    List<string> New = newCookie.Split(';').Select(f => f.Trim()).ToList();
            //    foreach (string n in New)
            //    {
            //        foreach (string o in Old)
            //        {
            //            if (o == n || o.Split('=')[0] == n.Split('=')[0])
            //            {
            //                Old.Remove(o);
            //                break;
            //            }
            //        }
            //    }
            //    List<string> list = new List<string>(Old);
            //    //list.AddRange(New);
            //    foreach (var item in New)
            //    {
            //        if (!string.IsNullOrWhiteSpace(item))
            //        {
            //            var tmp = item.Split('=');
            //            if (tmp.Length >= 2)
            //            {
            //                var oldTmp = list.Where(f => f.Trim().StartsWith(tmp[0] + "=")).ToList();
            //                foreach (var oldItem in oldTmp)
            //                {
            //                    if (!string.IsNullOrWhiteSpace(oldItem))
            //                    {
            //                        list.Remove(oldItem);
            //                    }
            //                }
            //                list.Add(item);
            //            }
            //        }
            //    }
            //    list = list.Where(f => !string.IsNullOrWhiteSpace(f)).ToList();
            //    return string.Join(";", list.ToArray());
            //}
            //else if (!string.IsNullOrEmpty(oldCookie)) return oldCookie;
            //else if (!string.IsNullOrEmpty(newCookie)) return newCookie;
            //else return "";
            #endregion

            #region 老道
            if (!string.IsNullOrEmpty(oldCookie) && !string.IsNullOrEmpty(newCookie))
            {
                oldCookie = HttpHelper.GetSmallCookie(oldCookie);
                List<string> Old = oldCookie.Split(';').Select(f => f.Trim()).Distinct().ToList();

                newCookie = HttpHelper.GetSmallCookie(newCookie);
                List<string> New = newCookie.Split(';').Select(f => f.Trim()).Distinct().ToList();
                foreach (string n in New)
                {
                    foreach (string o in Old)
                    {
                        if (o == n || o.Split('=')[0] == n.Split('=')[0])
                        {
                            Old.Remove(o);
                            break;
                        }
                    }
                }
                List<string> list = new List<string>(Old);
                //list.AddRange(New);
                foreach (var item in New)
                {
                    if (!string.IsNullOrWhiteSpace(item))
                    {
                        var tmp = item.Split('=');
                        if (tmp.Length >= 2)
                        {
                            var oldTmp = list.Where(f => f.Trim().StartsWith(tmp[0] + "=")).ToList();
                            foreach (var oldItem in oldTmp)
                            {
                                if (!string.IsNullOrWhiteSpace(oldItem))
                                {
                                    list.Remove(oldItem);
                                }
                            }
                            list.Add(item);
                        }
                    }
                }
                list = list.Where(f => !string.IsNullOrWhiteSpace(f)).ToList();
                return string.Join(";", list.ToArray());
            }
            else if (!string.IsNullOrEmpty(oldCookie)) return oldCookie;
            else if (!string.IsNullOrEmpty(newCookie)) return newCookie;
            else return "";
            #endregion
        }

        public static string GetCookiesValue(string cookieName, string cookies)
        {
            if (string.IsNullOrEmpty(cookies)) return string.Empty;
            string[] tempCookies = cookies.Split(';');
            foreach (var item in tempCookies)
            {
                string[] tempCookie = item.Split('=');
                if (tempCookie.Length == 2)
                {
                    if (tempCookie[0].Trim() == cookieName)
                    {
                        return tempCookie[1].Split('_')[0];
                    }
                }
            }
            return string.Empty;
        }

        public static string GetMD5String(string str)
        {
            MD5 md5 = MD5.Create();
            byte[] data = Encoding.UTF8.GetBytes(str);
            byte[] data2 = md5.ComputeHash(data);

            return ByteToHex(data2);
            //return BitConverter.ToString(data2).Replace("-", "").ToLower();
        }

        public static string ByteToHex(byte[] bytes)
        {
            string returnStr = "";
            if (bytes != null)
            {
                for (int i = 0; i < bytes.Length; i++)
                {
                    returnStr += bytes[i].ToString("X2");
                }
            }
            return returnStr;
        }

        public static byte[] HexToByte(string hexString)
        {
            hexString = hexString.Replace(" ", "");
            if ((hexString.Length % 2) != 0)
            {
                hexString = hexString + " ";
            }
            byte[] buffer = new byte[hexString.Length / 2];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 0x10);
            }
            return buffer;
        }
        /// <summary>
        /// 通过伪CDN绕过IP检测
        /// </summary>
        public static void SetProxyipCDN(this HttpItem item)
        {
            Random rd = new Random();
            var ip = rd.Next(1, 254) + "." + rd.Next(1, 254) + "." + rd.Next(1, 254) + "." + rd.Next(1, 254);
            item.Header["X-Forwarded-For"] = ip;
            item.Header["CLIENT_IP"] = ip;
            item.Header["REMOTE_ADDR"] = ip;
            item.Header["Via"] = ip;
        }

        /// <summary>
        /// 通过代理IP绕过IP检测
        /// </summary>
        /// <param name="item"></param>
        public static bool SetProxyIP(this HttpItem item, HttpHelper http, AuthEndpoint endpoint)
        {
            try
            {
                var rst = http.SendData(endpoint);
                if (rst.ok)
                {
                    var list = rst.message as object[];
                    if (list != null && list.Length != 0)
                    {

                        var ip = list[0].ToString().Split('|');
                        item.ProxyIp = ip[0];
                        if (ip.Length > 1) item.ProxyPwd = ip[1];
                        else item.ProxyPwd = string.Empty;
                        return true;
                    }
                }
            }
            catch (Exception)
            {

            }
            return false;
        }

        /// <summary> 
        /// 获取时间戳 
        /// </summary> 
        /// <returns></returns> 
        public static string GetTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds).ToString();
        }
        /// <summary> 
        /// 获取时间戳 
        /// </summary> 
        /// <returns></returns> 
        public static int GetTimeStamp(DateTime time)
        {
            DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            return (int)(time - startTime).TotalSeconds;
        }

        /// <summary>  
        /// 时间戳Timestamp转换成日期  
        /// </summary>  
        /// <param name="timeStamp"></param>  
        /// <returns></returns>  
        public static DateTime GetDateTime(string timeStamp)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
            long lTime = (long.Parse(timeStamp) * (timeStamp.Length == 13 ? 10000 : 10000000));
            TimeSpan toNow = new TimeSpan(lTime);
            DateTime targetDt = dtStart.Add(toNow);
            return targetDt;
        }

        /// <summary>  
        /// 日期转换成时间戳Timestamp
        /// </summary>  
        /// <param name="time">时间</param>  
        /// <param name="Milliseconds">true毫秒</param>  
        /// <returns></returns>  
        public static long GetTimeStamp(DateTime time, bool Milliseconds)
        {
            DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));

            if (!Milliseconds)
                return (long)(time - dtStart).TotalSeconds;
            else
                return (long)(time - dtStart).TotalMilliseconds;
        }


        /// <summary>
        /// base64编码的文本 转为   图片
        /// </summary>
        /// <param name="basestr">base64字符串</param>
        /// <returns>转换后的Bitmap对象</returns>
        public static Bitmap Base64StringToImage(string basestr)
        {
            Bitmap bitmap = null;
            try
            {
                String inputStr = basestr;
                byte[] arr = Convert.FromBase64String(inputStr);
                MemoryStream ms = new MemoryStream(arr);
                Bitmap bmp = new Bitmap(ms);
                ms.Close();
                bitmap = bmp;
                //MessageBox.Show("转换成功！");
            }
            catch (Exception)
            {
                return null;
            }

            return bitmap;
        }

        private static Wininet wininet = new Wininet();
        /// <summary>
        /// 往终端服务器投递消息
        /// </summary>
        public static WebResult SendData(this HttpHelper http, AuthEndpoint param, bool throwException = true)
        {
            //    int number = 1;
            //Next:
            //var item = http.GetItem(param.Host,"", param.Data);
            //var rest = http.GetHtml(item);

            //if (number<=3 && (int)rest.StatusCode>=500)
            //{
            //    number++;
            //    goto Next;
            //}

            var html = wininet.PostUtf8(param.Host, param.Data);
            WebResult result = null;
            try
            {
                result = HttpHelper.JsonToObject<WebResult>(html) as WebResult;
            }
            catch (Exception ex)
            {

            }

            if (result != null)
            {
                //基础连接已经关闭: 服务器关闭了本应保持活动状态的连接。
                //Console.WriteLine();

                if (!result.ok)
                    if (throwException)
                        throw new Exception(result.message.ToString());
                    else
                        return result;
                if (param.EncResult)
                {
                    AESCryption aes = new AESCryption();
                    result.message = aes.AesDecrypt(result.message.ToString(), HttpExtend.GetMD5String(param.Enckey));
                }
                return result;
            }
            return null;

            //var html = wininet.PostUtf8(param.Host,param.Data); ;
            //var result = HttpHelper.JsonToObject<WebResult>(html) as WebResult;
            //if (result == null)
            //{
            //    //基础连接已经关闭: 服务器关闭了本应保持活动状态的连接。
            //    Console.WriteLine();
            //}
            //if (!result.ok)
            //    if (throwException)
            //        throw new Exception(result.message.ToString());
            //    else return result;
            //if (param.EncResult)
            //{
            //    AESCryption aes = new AESCryption();
            //    result.message = aes.AesDecrypt(result.message.ToString(), HttpExtend.GetMD5String(param.Enckey));

            //}
            //return  result;

        }


        /// <summary>
        /// 将字典转换成实体类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static T ConvertToObj<T>(this Dictionary<string, object> dictionary)
        {
            var _obj = System.Activator.CreateInstance<T>();
            return (T)dictionary.ConvertToObj(_obj);
        }
        public static object ConvertToObj(this Dictionary<string, object> dictionary, object _obj)
        {
            if (dictionary == null) return _obj;
            PropertyInfo[] pros = _obj.GetType().GetProperties();
            foreach (var item in pros)
            {
                try
                {
                    if (dictionary.ContainsKey(item.Name))
                    {
                        if (item.PropertyType == typeof(String))
                        {
                            if (dictionary[item.Name] == null) item.SetValue(_obj, string.Empty, null);
                            else item.SetValue(_obj, dictionary[item.Name].ToString(), null);
                        }
                        else if (item.PropertyType == typeof(Double))
                        {
                            if (dictionary[item.Name] != null)
                                item.SetValue(_obj, Double.Parse(dictionary[item.Name].ToString()), null);
                            else
                                item.SetValue(_obj, 0.00, null);
                        }
                        else if (item.PropertyType == typeof(Int32))
                        {
                            if (dictionary[item.Name] != null) item.SetValue(_obj, Int32.Parse(dictionary[item.Name].ToString()), null);
                            else item.SetValue(_obj, 0, null);
                        }
                        else if (item.PropertyType == typeof(Int64))
                        {
                            if (dictionary[item.Name] != null) item.SetValue(_obj, Int64.Parse(dictionary[item.Name].ToString()), null);
                            else item.SetValue(_obj, 0, null);

                        }
                        else if (item.PropertyType == typeof(Int16))
                        {
                            if (dictionary[item.Name] != null) item.SetValue(_obj, Int16.Parse(dictionary[item.Name].ToString()), null);
                            else item.SetValue(_obj, 0, null);
                        }
                        else if (item.PropertyType == typeof(DateTime))
                        {
                            if (dictionary[item.Name] == null)
                            {
                                item.SetValue(_obj, DateTime.MinValue, null); continue;
                            }
                            string v = dictionary[item.Name].ToString();
                            if (Regex.Match(v, @"^\d+$").Success)
                            {
                                item.SetValue(_obj, GetDateTime(v), null);
                            }
                            else
                            {
                                item.SetValue(_obj, DateTime.Parse(v), null);
                            }


                        }
                        else item.SetValue(_obj, dictionary[item.Name], null);
                    }
                }
                catch (Exception ex)
                { }
            }
            return _obj;
        }

        // 从字符串转换到16进制表示的字符串
        /// 编码,如"utf-8","gb2312"
        /// 是否每字符用逗号分隔
        public static string ToHex(string s, string charset, bool fenge)
        {
            if ((s.Length % 2) != 0)
            {
                s += " ";//空格
                         //throw new ArgumentException("s is not valid chinese string!");
            }
            System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);
            byte[] bytes = chs.GetBytes(s);
            string str = "";
            for (int i = 0; i < bytes.Length; i++)
            {
                str += string.Format("{0:X}", bytes[i]);
                if (fenge && (i != bytes.Length - 1))
                {
                    str += string.Format("{0}", ",");
                }
            }
            return str.ToLower();
        }


        /// <summary>
        /// URL编码
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        public static string UrlEncode(string text)
        {
            System.Text.StringBuilder builder = new System.Text.StringBuilder();
            foreach (char c in text)
            {
                if (System.Web.HttpUtility.UrlEncode(c.ToString()).Length > 1)
                {
                    builder.Append(System.Web.HttpUtility.UrlEncode(c.ToString()).ToUpper());
                }
                else
                {
                    builder.Append(c);
                }
            }
            return builder.ToString();
        }

        public static string MapFile(string file, string path = "")
        {
            return Path.Combine(MapPath(path, true), file);
        }


        /// <summary>
        /// C# DES解密方法
        /// </summary>
        /// <param name="encryptedValue">待解密的字符串</param>
        /// <param name="key">密钥</param>
        /// <param name="iv">向量</param>
        /// <returns>解密后的字符串</returns>
        public static string DESDecrypt(string encryptedValue, string key, string iv)
        {
            try
            {
                using (DESCryptoServiceProvider sa =
               new DESCryptoServiceProvider
               { Key = Encoding.UTF8.GetBytes(key), IV = Encoding.UTF8.GetBytes(iv) })
                {
                    using (ICryptoTransform ct = sa.CreateDecryptor())
                    {
                        byte[] byt = Convert.FromBase64String(encryptedValue);

                        using (var ms = new MemoryStream())
                        {
                            using (var cs = new CryptoStream(ms, ct, CryptoStreamMode.Write))
                            {
                                cs.Write(byt, 0, byt.Length);
                                cs.FlushFinalBlock();
                            }
                            return Encoding.UTF8.GetString(ms.ToArray());
                        }
                    }
                }
            }
            catch { }
            return string.Empty;
        }

        /// <summary>
        /// C# DES加密方法
        /// </summary>
        /// <param name="encryptedValue">要加密的字符串</param>
        /// <param name="key">密钥</param>
        /// <param name="iv">向量</param>
        /// <returns>加密后的字符串</returns>
        public static string DESEncrypt(string originalValue, string key, string iv)
        {
            using (DESCryptoServiceProvider sa
                = new DESCryptoServiceProvider { Key = Encoding.UTF8.GetBytes(key), IV = Encoding.UTF8.GetBytes(iv) })
            {
                using (ICryptoTransform ct = sa.CreateEncryptor())
                {
                    byte[] by = Encoding.UTF8.GetBytes(originalValue);
                    using (var ms = new MemoryStream())
                    {
                        using (var cs = new CryptoStream(ms, ct,
                                                         CryptoStreamMode.Write))
                        {
                            cs.Write(by, 0, by.Length);
                            cs.FlushFinalBlock();
                        }
                        return Convert.ToBase64String(ms.ToArray());
                    }
                }
            }
        }
        public static string MapPath(string path = "", bool CreateDirectory = true)
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                return System.Windows.Forms.Application.StartupPath.ToString() + "\\";
            }
            path = Path.Combine(System.Windows.Forms.Application.StartupPath.ToString() + "\\", path);
            if (!(!CreateDirectory || Directory.Exists(path)))
            {
                Directory.CreateDirectory(path);
            }
            return path;
        }


        /// <summary>
        /// 重定向Url地址
        /// </summary>
        /// <param name="url">需要重定向的链接</param>
        /// <param name="referer">来源</param>
        /// <param name="allowautoredirect">是否自动重定向,默认不重定向</param>
        /// <returns></returns>
        public static string GetLocationUrl(string url, string referer = "", bool allowautoredirect = false)
        {
            try
            {
                HttpHelper http = new HttpHelper();
                HttpItem item = new HttpItem()
                {
                    URL = url,
                    IsToLower = false,
                    Timeout = 5000,
                    ReadWriteTimeout = 5000,
                    UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.154 Safari/537.36 LBBROWSER",
                    ContentType = "application/x-www-form-urlencoded",
                    Referer = referer,
                    Allowautoredirect = allowautoredirect
                };
                HttpResult result = http.GetHtml(item);
                var ss = result.Header.Get("Location");
                return ss;
            }
            catch (Exception)
            { }
            return string.Empty;
        }

    }




    public class WebResult
    {
        public bool ok { get; set; }
        public object message { get; set; }
        public double time { get; set; }
        public string method { get; set; }
        public string req { get; set; }

        public WebResult()
        {
            this.req = DateTime.Now.ToString("yyyyMMddHHmmss");
        }

    }
    public class IniHelper
    {
        [DllImport("kernel32")]
        private static extern long WritePrivateProfileString(string section, string key, string val, string filepath);
        [DllImport("kernel32")]
        private static extern int GetPrivateProfileString(string section, string key, string def, StringBuilder retval, int size, string filePath);


        //获取ini文件路径
        private string inifilepath;
        public IniHelper(string fileName)
        {
            this.inifilepath = fileName;
        }
        public string GetValue(string node, string key)
        {
            StringBuilder s = new StringBuilder(1024);
            GetPrivateProfileString(node, key, "", s, 1024, inifilepath);
            return s.ToString();
        }


        public void SetValue(string node, string key, string value)
        {
            try
            {
                WritePrivateProfileString(node, key, value, inifilepath);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
    /// <summary>
    /// 终端节点数据
    /// </summary>
    public class AuthEndpoint
    {
        /// <summary>
        /// 授权编号
        /// </summary>
        public int Appid { get; set; }
        /// <summary>
        /// 服务器地址
        /// </summary>
        public string Host { get; set; }

        /// <summary>
        /// 加密数据
        /// </summary>
        public string Enckey { get; set; }

        /// <summary>
        /// 调用函数
        /// </summary>
        public string Method { get; set; }

        /// <summary>
        /// 版本号
        /// </summary>
        public string Version { get; set; }

        /// <summary>
        /// 需要发送的数据
        /// </summary>
        private Dictionary<string, object> _param { get; set; }

        /// <summary>
        /// 返回参数是否加密
        /// </summary>
        public bool EncResult { get { if (_param != null && _param.ContainsKey("enc_result") && _param["enc_result"].ToString().ToUpper() == "TRUE") return true; else return false; } }


        /// <summary>
        /// 参数
        /// </summary>
        public Dictionary<string, object> Param
        {
            get
            {
                if (_param == null) _param = new Dictionary<string, object>();
                _param["time"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                return _param;
            }
        }
        /// <summary>
        /// 完整POST参数
        /// </summary>
        public string Data
        {
            get
            {

                var json = HttpHelper.ObjectToJson(Param);
                var data = RsaCrypto.RsaEncrypt(json, this.Enckey);
                return $"appid={Appid}&method={Method}&data={HttpHelper.URLEncode(data)}&v=" + (Version == null ? "1.0" : Version);
            }
        }


        public AuthEndpoint() { RsaCrypto = new RSACryption(); }
        public RSACryption RsaCrypto { get; private set; }



    }

    public class RSACryption
    {
        public string RsaEncrypt(string rawInput, string publicKey)
        {
            if (string.IsNullOrEmpty(rawInput))
            {
                return string.Empty;
            }

            if (string.IsNullOrWhiteSpace(publicKey))
            {
                throw new ArgumentException("Invalid Public Key");
            }

            using (var rsaProvider = new RSACryptoServiceProvider())
            {
                var inputBytes = Encoding.UTF8.GetBytes(rawInput);//有含义的字符串转化为字节流
                rsaProvider.FromXmlString(publicKey);//载入公钥
                int bufferSize = (rsaProvider.KeySize / 8) - 11;//单块最大长度
                var buffer = new byte[bufferSize];
                using (MemoryStream inputStream = new MemoryStream(inputBytes),
                     outputStream = new MemoryStream())
                {
                    while (true)
                    { //分段加密
                        int readSize = inputStream.Read(buffer, 0, bufferSize);
                        if (readSize <= 0)
                        {
                            break;
                        }

                        var temp = new byte[readSize];
                        Array.Copy(buffer, 0, temp, 0, readSize);
                        var encryptedBytes = rsaProvider.Encrypt(temp, false);
                        outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);
                    }
                    return Convert.ToBase64String(outputStream.ToArray());//转化为字节流方便传输
                }
            }
        }

        public string RsaDecrypt(string encryptedInput, string privateKey)
        {
            if (string.IsNullOrEmpty(encryptedInput))
            {
                return string.Empty;
            }

            if (string.IsNullOrWhiteSpace(privateKey))
            {
                throw new ArgumentException("Invalid Private Key");
            }

            using (var rsaProvider = new RSACryptoServiceProvider())
            {
                var inputBytes = Convert.FromBase64String(encryptedInput);
                rsaProvider.FromXmlString(privateKey);
                int bufferSize = rsaProvider.KeySize / 8;
                var buffer = new byte[bufferSize];
                using (MemoryStream inputStream = new MemoryStream(inputBytes),
                     outputStream = new MemoryStream())
                {
                    while (true)
                    {
                        int readSize = inputStream.Read(buffer, 0, bufferSize);
                        if (readSize <= 0)
                        {
                            break;
                        }

                        var temp = new byte[readSize];
                        Array.Copy(buffer, 0, temp, 0, readSize);
                        var rawBytes = rsaProvider.Decrypt(temp, false);
                        outputStream.Write(rawBytes, 0, rawBytes.Length);
                    }
                    return Encoding.UTF8.GetString(outputStream.ToArray());
                }
            }
        }
    }
}