using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Data;
using ETD.Log;
using ETD.Frame;

namespace ETD.Frame
{
    public static class DataToModel
    {
        private static Dictionary<string, EntityValue> vl = null;

        #region 将DataTable转换成List列表

        #region 返回一条实体数据

        /// <summary>
        /// DataReader转实体
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="rdr"></param>
        /// <returns></returns>
        public static T Dr2En<T>(IDataReader rdr)
        {
            DataTable dtt = Dr2Dt(rdr);
            return Dt2En<T>(dtt); ;
        }
        /// <summary>
        /// DataReader转Object
        /// </summary>
        /// <param name="rdr"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static object Dr2EnObj(IDataReader rdr, object entity)
        {
            DataTable dtt = Dr2Dt(rdr);
            return Dt2EnObj(dtt, entity);
        }
        /// <summary>
        /// 返回一条实体数据
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="dataTable">表数据</param>
        /// <returns></returns>
        public static T Dt2En<T>(DataTable dataTable)
        {
            Dictionary<string, EntityValue> vl = new Dictionary<string, EntityValue>();
            T obj = Activator.CreateInstance<T>();
            if (dataTable.Rows.Count > 0)
            {
                DataRow row = dataTable.Rows[0];
                obj = (T)DtSetValueField(row, obj);
            }
            return obj;
        }
        /// <summary>
        /// 返回一条实体数据
        /// </summary>
        /// <typeparam name="T">实体</typeparam>
        /// <param name="dataTable">表数据</param>
        /// <returns></returns>
        private static object Dt2EnObj<T>(DataTable dt)
        {
            vl = new Dictionary<string, EntityValue>();

            T obj = Activator.CreateInstance<T>();

            if (dt.Rows.Count > 0)
            {
                DataRow row = dt.Rows[0];
                obj = (T)DtSetValueField(row, obj);
            }
            return obj;
        }

        /// <summary>
        /// 获取一条实体
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="enty"></param>
        /// <returns></returns>
        public static object Dt2EnObj(DataTable dt, object enty)
        {
            object obj = Activator.CreateInstance(enty.GetType());
            if (dt == null) return obj;
            if (dt.Rows.Count == 0) return obj;
            PropertyInfo[] propertys = enty.GetType().GetProperties();
            obj = DtSetValueField(dt.Rows[0], obj);
            return obj;
        }

        #endregion

        #region 返回实体集合
        /// <summary>
        /// DataReader转object
        /// </summary>
        /// <param name="rdr"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static object Dr2EnList(IDataReader rdr, object entity)
        {
            DataTable dtt = Dr2Dt(rdr);
            return Dt2EnList(dtt, entity);
        }
        /// <summary>
        /// DataReader转实体集合
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="rdr"></param>
        /// <returns></returns>
        public static List<T> Dr2EnList<T>(IDataReader rdr)
        {
            DataTable dtt = Dr2Dt(rdr);
            List<T> listobj = Dt2EnList<T>(dtt);
            return listobj;
        }

        /// <summary>
        /// 将DataTable转换为list（用的FOR赋值，效果一样，这种比较复杂）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static List<T> Dt2EnList<T>(DataTable dt)
        {
            List<T> list = new List<T>();
            if (dt == null) return list;
            foreach (DataRow row in dt.Rows)
            {
                T obj = Activator.CreateInstance<T>();
                obj = (T)DtSetValueField(row, obj);
                list.Add(obj);
            }
            return list;
        }

        /// <summary>
        /// DataTable转换成实体列表
        /// </summary>
        /// <typeparam name="T">实体 T </typeparam>
        /// <param name="table">datatable</param>
        /// <returns></returns>
        public static IList<T> DataTableToList<T>(DataTable table)
            where T : class
        {
            if (!IsHaveRows(table))
                return new List<T>();

            IList<T> list = new List<T>();
            T model = default(T);
            foreach (DataRow dr in table.Rows)
            {
                model = Activator.CreateInstance<T>();

                foreach (DataColumn dc in dr.Table.Columns)
                {
                    object drValue = dr[dc.ColumnName];
                    PropertyInfo pi = model.GetType().GetProperty(dc.ColumnName);

                    if (pi != null && pi.CanWrite && (drValue != null && !Convert.IsDBNull(drValue)))
                    {
                        pi.SetValue(model, drValue, null);
                    }
                }

                list.Add(model);
            }
            return list;
        }

        /// <summary>
        /// 将表数据转换成实体集合
        /// </summary>
        /// <param name="dataTable">表数据</param>
        /// <param name="enty">实体</param>
        /// <returns></returns>
        public static object Dt2EnList(DataTable dt, object enty)
        {
            List<object> list = new List<object>();
            if (dt == null) return list;
            foreach (DataRow row in dt.Rows)
            {
                object obj = Activator.CreateInstance(enty.GetType());
                obj = DtSetValueField(row, obj);
                list.Add(obj);
            }
            return list;
        }


        #endregion

        #region 公共调用用DataRow给实体进行赋值
        /// <summary>
        /// 给实体进行赋值
        /// </summary>
        /// <param name="row"></param>
        /// <param name="objj"></param>
        /// <returns></returns>
        private static object DtSetValueField(DataRow row, object objj)
        {
            Dictionary<string, EntityValue> vl = new Dictionary<string, EntityValue>();
            foreach (PropertyInfo pinfo in objj.GetType().GetProperties())
            {
                DataFieldColumnAttribute dfa = Attribute.GetCustomAttribute(pinfo, typeof(DataFieldColumnAttribute)) as DataFieldColumnAttribute;
                if (!object.Equals(dfa, null))
                {
                    try
                    {
                        if (!Convert.IsDBNull(row[pinfo.Name]))
                        {
                            vl = SetChanaged(pinfo.Name, row[pinfo.Name], vl);
                            if (pinfo.PropertyType.ToString().ToLower().Contains("system.int64"))
                                pinfo.SetValue(objj, Convert.ToInt64(row[pinfo.Name]), null);
                            else if (pinfo.PropertyType.ToString().ToLower().Contains("system.int32"))
                                pinfo.SetValue(objj, Convert.ToInt32(row[pinfo.Name]), null);
                            else
                                pinfo.SetValue(objj, row[pinfo.Name], null);
                        }
                        else
                            pinfo.SetValue(objj, null, null);
                    }
                    catch (Exception ex)
                    {
                        pinfo.SetValue(objj, null, null);
                        log.WriteException(ex);
                    }
                }
                if (pinfo.Name.Contains("PersistType"))
                    pinfo.SetValue(objj, EntityPersistType.Update, null);
                if (pinfo.Name.Contains("Values"))
                    pinfo.SetValue(objj, vl, null);
            }
            return objj;
        }
        /// <summary>
        /// 检查DataTable 是否有数据行
        /// </summary>
        /// <param name="dt">DataTable</param>
        /// <returns></returns>
        public static bool IsHaveRows(DataTable dt)
        {
            if (dt != null && dt.Rows.Count > 0)
                return true;

            return false;
        }
        /// <summary>
        /// DataReader转DataTable
        /// </summary>
        /// <param name="rdr"></param>
        /// <returns></returns>
        private static DataTable Dr2Dt(IDataReader rdr)
        {
            DataTable dtReturn = new DataTable();
            DataColumn dc = null;
            DataRow dr = null;
            for (int i = 0; i < rdr.GetSchemaTable().Rows.Count; i++)
            {
                dr = rdr.GetSchemaTable().Rows[i];
                dc = new DataColumn(dr["ColumnName"].ToString(), dr["DataType"] as Type);
                dtReturn.Columns.Add(dc);
            }
            dr = null; dc = null;
            object[] value = new object[rdr.FieldCount];
            while (rdr.Read())
            {
                rdr.GetValues(value);
                dtReturn.LoadDataRow(value, true);
            }
            value = null;
            return dtReturn;
        }

        #endregion


        #endregion

        #region 备份

        ///// <summary>
        ///// 将DataTable转换为list（用的FOR赋值，效果一样，这种比较复杂）
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="dt"></param>
        ///// <returns></returns>
        //public static T DataReader2Mod<T>(IDataReader dr)
        //{
        //    T objj = (T)Activator.CreateInstance(typeof(T));
        //    if (dr == null) return objj;
        //    PropertyInfo[] propertys = objj.GetType().GetProperties();
        //    foreach (PropertyInfo pi in propertys)
        //    {
        //        //DataTable MyDataTable = dr.GetSchemaTable();
        //        //foreach (DataRow row in MyDataTable.Rows)
        //        //{
        //        //    foreach (DataColumn col in MyDataTable.Columns)
        //        //    {
        //        #region 属性与字段名称一致的进行赋值
        //        //        if (pi.Name.ToLower().Equals(row[0].ToString().ToLower()))
        //        //        {
        //        //            try
        //        //            {
        //        //                if (!Convert.IsDBNull(dr[row[0].ToString()]))
        //        //                {
        //        //                    if (pi.PropertyType.ToString().ToLower().Contains("system.int64"))
        //        //                    {
        //        //                        pi.SetValue(obj, Convert.ToInt64(dr[pi.Name]), null);
        //        //                    }
        //        //                    if (pi.PropertyType.ToString().ToLower().Contains("system.int32"))
        //        //                    {
        //        //                        pi.SetValue(obj, dr[pi.Name].ToInt32(), null);
        //        //                    }
        //        //                    else
        //        //                    {
        //        //                        pi.SetValue(obj, row[pi.Name], null);
        //        //                    }
        //        //                }
        //        //                else
        //        //                    pi.SetValue(obj, null, null);//为空，但不为Null
        //        //            }
        //        //            catch (Exception ex)
        //        //            {
        //        //                pi.SetValue(obj, null, null);//为空，但不为Null
        //        //                log.WriteException(ex);
        //        //            }
        //        //        }
        //        #endregion
        //        //    }
        //        //}
        //        for (int k = 0; k < dr.FieldCount; k++)
        //        {
        //            if (!DBNull.Value.Equals(dr.GetValue(k)))
        //            {
        //                if (pi.PropertyType.ToString().ToLower().Contains("system.int64"))
        //                    pi.SetValue(objj, Convert.ToInt64(dr.GetValue(k)), null);
        //                else if (pi.PropertyType.ToString().ToLower().Contains("system.int32"))
        //                    pi.SetValue(objj, dr.GetValue(k).ToInt32(), null);
        //                else
        //                    pi.SetValue(objj, dr.GetValue(k), null);
        //            }
        //        }
        //        if (pi.Name.Contains("PersistType"))
        //        {
        //            pi.SetValue(objj, EntityPersistType.Update, null);
        //        }
        //    }

        //    return objj;
        //}
        ///// <summary>
        ///// 这样也可以不过entity每次的值还在，缺点就是无法清除原先的值
        ///// </summary>
        ///// <param name="dr"></param>
        ///// <param name="md"></param>
        ///// <param name="enty"></param>
        ///// <returns></returns>
        //public static object DataReader2Entity(IDataReader dr, object enty)
        //{
        //    object objj = Activator.CreateInstance(enty.GetType());
        //    if (dr == null) return objj;
        //    PropertyInfo[] propertys = enty.GetType().GetProperties();
        //    foreach (PropertyInfo pi in propertys)
        //    {
        //        DataTable MyDataTable = dr.GetSchemaTable();
        //        foreach (DataRow row in MyDataTable.Rows)
        //        {
        //            foreach (DataColumn col in MyDataTable.Columns)
        //            {
        //                #region 属性与字段名称一致的进行赋值
        //                if (pi.Name.ToLower().Equals(row[0].ToString().ToLower()))
        //                {
        //                    try
        //                    {
        //                        if (!Convert.IsDBNull(dr[row[0].ToString()]))
        //                        {
        //                            if (pi.PropertyType.ToString().ToLower().Contains("system.int64"))
        //                                pi.SetValue(objj, Convert.ToInt64(dr[pi.Name]), null);
        //                            else if (pi.PropertyType.ToString().ToLower().Contains("system.int32"))
        //                                pi.SetValue(objj, dr[pi.Name].ToInt32(), null);
        //                            else
        //                                pi.SetValue(objj, row[pi.Name], null);
        //                        }
        //                        else
        //                            pi.SetValue(objj, null, null);//为空，但不为Null
        //                    }
        //                    catch (Exception ex)
        //                    {
        //                        pi.SetValue(objj, null, null);//为空，但不为Null
        //                        log.WriteException(ex);
        //                    }
        //                }
        //                #endregion
        //            }
        //            if (pi.Name.Contains("PersistType"))
        //            {
        //                pi.SetValue(objj, EntityPersistType.Update, null);
        //            }
        //        }
        //    }
        //    return objj;
        //}

        ///// <summary>
        ///// 将DataTable转换为list（用的FOR赋值，效果一样，这种比较复杂）
        ///// </summary>
        ///// <typeparam name="T"></typeparam>
        ///// <param name="dt"></param>
        ///// <returns></returns>
        //public static List<T> DataTable2List<T>(DataTable dt)
        //{
        //    List<T> result = new List<T>(); string colname = "";
        //    MetaData md = MetaDataManager.GetMetaData(typeof(T));
        //    if (dt == null) return result;
        //    for (int j = 0; j < dt.Rows.Count; j++)
        //    {
        //        T objj = (T)Activator.CreateInstance(typeof(T));
        //        PropertyInfo[] propertys = objj.GetType().GetProperties();
        //        foreach (PropertyInfo pi in propertys)
        //        {
        //            colname = "";
        //            for (int i = 0; i < dt.Columns.Count; i++)
        //            {
        //                if (pi.Name.ToLower().Equals(dt.Columns[i].ColumnName.ToLower()))
        //                {
        //                    colname = pi.Name; break;
        //                }
        //            }
        //            if (!string.IsNullOrEmpty(colname))
        //            {
        //                #region 属性与字段名称一致的进行赋值
        //                //if (dt.Rows[j][colname] != DBNull.Value && dt.Rows[j][colname] != null && !object.Equals(dt.Rows[j][colname], null))
        //                if (!Convert.IsDBNull(dt.Rows[j][colname]))
        //                {
        //                    try
        //                    {
        //                        pi.SetValue(objj, dt.Rows[j][md.FieldMeteDatas[colname].ColumnName], null);
        //                    }
        //                    catch (Exception ex)
        //                    {
        //                        pi.SetValue(objj, null, null);//为空，但不为Null
        //                        log.WriteException(ex);
        //                    }
        //                }
        //                else
        //                {
        //                    pi.SetValue(objj, null, null);//为空，但不为Null
        //                }
        //                #endregion
        //            }
        //            if (pi.Name == "PersistType")
        //            {
        //                pi.SetValue(objj, EntityPersistType.Update, null);
        //            }
        //        }
        //        result.Add(objj);
        //    }
        //    return result;
        //}
        /// <summary>
        /// 暂时不用
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dr"></param>
        /// <returns></returns>
        //public static object DataTable2List<T>(IDataReader dr)
        //{
        //    T obj = (T)Activator.CreateInstance(typeof(T));
        //    MetaData md = MetaDataManager.GetMetaData(typeof(T));
        //    if (dr == null) return obj;
        //    PropertyInfo[] propertys = obj.GetType().GetProperties();
        //    foreach (PropertyInfo pi in propertys)
        //    {
        //        DataTable MyDataTable = dr.GetSchemaTable();
        //        foreach (DataRow row in MyDataTable.Rows)
        //        {
        //            foreach (DataColumn col in MyDataTable.Columns)
        //            {
        //                #region 属性与字段名称一致的进行赋值
        //                if (pi.Name.ToLower().Equals(row[0].ToString().ToLower()))
        //                {
        //                    //if (dr[row[0].ToString()] != DBNull.Value)
        //                    //if (dr[row[0].ToString()] != DBNull.Value && dr[row[0].ToString()] != null && !object.Equals(dr[row[0].ToString()], null))
        //                    if (!Convert.IsDBNull(dr[row[0].ToString()]))
        //                    {
        //                        if (pi.PropertyType.ToString().ToLower().Contains("system.int64"))
        //                        {
        //                            pi.SetValue(obj, Int64.Parse(dr[row[0].ToString()].ToString()), null);
        //                        }
        //                        if (pi.PropertyType.ToString().ToLower().Contains("system.int32"))
        //                        {
        //                            pi.SetValue(obj, Int32.Parse(dr[row[0].ToString()].ToString()), null);
        //                        }
        //                        else if (pi.PropertyType.ToString().ToLower().Contains("system.datetime"))
        //                        {
        //                            pi.SetValue(obj, Convert.ToDateTime(dr[row[0].ToString()].ToString()), null);
        //                        }
        //                        else if (pi.PropertyType.ToString().ToLower().Contains("system.boolean"))
        //                        {
        //                            pi.SetValue(obj, Convert.ToBoolean(dr[row[0].ToString()].ToString()), null);
        //                        }
        //                        else if (pi.PropertyType.ToString().ToLower().Contains("system.single"))
        //                        {
        //                            pi.SetValue(obj, Convert.ToSingle(dr[row[0].ToString()].ToString()), null);
        //                        }
        //                        else if (pi.PropertyType.ToString().ToLower().Contains("system.double"))
        //                        {
        //                            pi.SetValue(obj, Convert.ToDouble(dr[row[0].ToString()].ToString()), null);
        //                        }
        //                        else
        //                        {
        //                            pi.SetValue(obj, dr[md.FieldMeteDatas[pi.Name].ColumnName], null);
        //                        }
        //                    }
        //                    else
        //                        pi.SetValue(obj, null, null);//为空，但不为Null
        //                }
        //                #endregion
        //            }
        //        }
        //        if (pi.Name == "PersistType")
        //        {
        //            pi.SetValue(obj, EntityPersistType.Update, null);
        //        }
        //    }
        //    return obj;
        //}
        #endregion

        /// <summary>
        /// 设置初始值
        /// </summary>
        /// <param name="FieldName">字段名称</param>
        /// <param name="defaultValue">默认值</param>
        private static Dictionary<string, EntityValue> SetChanaged(string FieldName, object defaultValue, Dictionary<string, EntityValue> Values)
        {
            if (!Values.ContainsKey(FieldName))
            {
                EntityValue val = new EntityValue();
                val.OriginalValue = defaultValue;
                val.FieldName = FieldName;
                val.IsChanage = false;
                Values.Add(FieldName, val);
            }
            else
            {
                Values[FieldName].OriginalValue = defaultValue;
                Values[FieldName].IsChanage = false;
            }
            return Values;
        }
    }
}