using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Drawing;
using System.IO;
using System.Reflection;
using System.Text;

namespace CSFrameworkV5.Core.Common
{
    public static class DataConverter
    {
        //图片 转为    base64编码的文本
        public static string ImgToBase64String(string Imagefilename)
        {
            Bitmap bmp = null;
            try
            {
                using (bmp = new Bitmap(Imagefilename))
                {
                    using (var ms = new MemoryStream())
                    {
                        bmp.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                        var arr = new byte[ms.Length];
                        ms.Position = 0;
                        ms.Read(arr, 0, (int)ms.Length);
                        ms.Close();
                        return Convert.ToBase64String(arr);
                    }
                }
            }
            catch (Exception ex)
            {
                return null;
            }
            finally
            {
                if (bmp != null) bmp.Dispose();
            }
        }

        //base64编码的文本 转为    图片
        public static Bitmap Base64StringToImage(string inputStr)
        {
            try
            {
                var arr = Convert.FromBase64String(inputStr);
                var ms = new MemoryStream(arr);
                return new Bitmap(ms);
            }
            catch
            {
                return null;
            }
        }

        //base64编码的文本 转为    图片
        public static bool Base64StringToFile(string inputStr, string FilePath,
            string FileName)
        {
            FileStream fs = null;

            try
            {
                var extension = Path.GetExtension(FilePath + "/" + FileName);
                var SaveFileName = Guid.NewGuid().ToStringEx() + extension;

                fs = File.Create(FilePath + FileName);

                var arr = Convert.FromBase64String(inputStr);
                using (var ms = new MemoryStream(arr))
                {
                    ms.WriteTo(fs);
                }

                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                    fs.Dispose();
                    fs = null;
                }
            }
        }

        /// <summary>
        /// 返回时间戳，秒
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public static long GetUtcTrick(DateTime time)
        {
            var fs = new DateTimeOffset(time);
            var trick = (fs.UtcTicks - 621355968000000000) / 10000000; //秒值
            return trick;
        }

        public static IEnumerable<T> ConvertObject<T>(DataTable dt)
            where T : new()
        {
            var v = typeof(T).GetProperties(BindingFlags.Public |
                                            BindingFlags.Instance);
            var Fields = new List<PropertyInfo>();
            foreach (var s in v)
                if (dt.Columns.Contains(s.Name))
                    Fields.Add(s);

            foreach (DataRow dr in dt.Rows)
            {
                var t = new T();
                foreach (var s in Fields)
                {
                    if (Equals(dr[s.Name], DBNull.Value)) continue;
                    var tv = System.ComponentModel.TypeDescriptor
                        .GetConverter(s.PropertyType)
                        .ConvertFromString(dr[s.Name].ToStringEx());
                    s.SetValue(t, tv, null);
                }

                yield return t;
            }
        }


        public static T ConvertObject<T>(DataRow dr) where T : new()
        {
            var v = typeof(T).GetProperties(BindingFlags.Public |
                                            BindingFlags.Instance);

            var t = new T();
            foreach (var s in v)
                if (dr.Table.Columns.Contains(s.Name))
                {
                    if (Equals(dr[s.Name], DBNull.Value)) continue;
                    {
                        var tv = System.ComponentModel.TypeDescriptor
                            .GetConverter(s.PropertyType)
                            .ConvertFromString(dr[s.Name].ToStringEx());
                        s.SetValue(t, tv, null);
                    }
                }

            return t;
        }

        public static T ConvertObjectIgnoreCase<T>(
            Dictionary<string, object> dic) where T : new()
        {
            var v = typeof(T).GetProperties(BindingFlags.Public |
                                            BindingFlags.Instance);

            var fr = new Dictionary<string, string>();

            foreach (var key in dic.Keys) fr.Add(key.ToLower(), key);

            var t = new T();
            foreach (var s in v)
                if (fr.ContainsKey(s.Name.ToLower()))
                {
                    var key = fr[s.Name.ToLower()];
                    var value = dic[key];
                    if (Equals(value, DBNull.Value) || value == null) continue;
                    try
                    {
                        var tv = System.ComponentModel.TypeDescriptor
                            .GetConverter(s.PropertyType)
                            .ConvertFromString(value.ToStringEx());
                        s.SetValue(t, tv, null);
                    }
                    catch
                    {
                        s.SetValue(t, value, null);
                    }
                }

            return t;
        }


        public static T Convert2Object<T>(DbDataReader row) where T : new()
        {
            var t = new T();

            var dic = new Dictionary<string, object>();

            var type = typeof(T);

            string fname;
            object tv;
            object fvalue;

            for (var i = 0; i < row.FieldCount; i++)
            {
                fname = row.GetName(i);
                fvalue = row.GetValue(i);
                dic.Add(fname.ToLower(), fvalue);

                var p = type.GetProperty(fname,
                    BindingFlags.Public | BindingFlags.Instance |
                    BindingFlags.IgnoreCase);
                if (p != null)
                {
                    if (string.IsNullOrEmpty(fvalue.ToStringEx()))
                        tv = p.PropertyType.IsValueType
                            ? Activator.CreateInstance(p.PropertyType)
                            : null;
                    else
                        tv = System.ComponentModel.TypeDescriptor
                            .GetConverter(p.PropertyType)
                            .ConvertFromString(fvalue.ToStringEx());
                    p.SetValue(t, tv, null);
                }
            }

            return t;
        }

        public static T GetKey<T>(Dictionary<string, object> data, string key)
        {
            try
            {
                if (data.ContainsKey(key))
                {
                    var tv = System.ComponentModel.TypeDescriptor
                        .GetConverter(typeof(T))
                        .ConvertFrom(data[key].ToStringEx());
                    return (T)tv;
                }
                else
                {
                    return default;
                }
            }
            catch //(Exception ex)
            {
                return default;
            }
        }

        public static string GetTableColumnValue(DataTable dt,
            string ColumnName)
        {
            var str = new StringBuilder();
            foreach (DataRow dr in dt.Rows) str.Append("," + dr[ColumnName]);
            if (str.Length > 0)
                str.Remove(0, 1);
            return str.ToStringEx();
        }
    }
}