#region

using System;
using System.Collections;
using System.Data;
using System.Reflection;

#endregion

namespace CSFrameworkV5.Common
{
    /// <summary>
    ///     DataTable-Object 互转换工具
    /// </summary>
    public class DataConverter
    {
        /// <summary>
        ///     新增一条记录
        /// </summary>
        /// <param name="dt">数据表</param>
        /// <param name="o">ORM模型</param>
        /// <returns></returns>
        public static DataRow AddDataRowFromObject(DataTable dt, object o)
        {
            var row = dt.NewRow();
            var pinfo = o.GetType().GetProperties();
            foreach (var info in pinfo)
                if (dt.Columns.IndexOf(info.Name) >= 0)
                    SetDataRowValue(row, info.Name, info.GetValue(o, null));

            dt.Rows.Add(row);
            return row;
        }

        /// <summary>
        ///     把一个行的数据新增一个表中
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="dr"></param>
        /// <returns></returns>
        public static DataTable AddTableRowByRow(DataTable dt, DataRow dr)
        {
            var b = false;
            var drNew = dt.NewRow();
            for (var i = 0; i < dr.Table.Columns.Count; i++)
            {
                var colname = dr.Table.Columns[i].ColumnName;
                if (dt.Columns.IndexOf(colname) >= 0)
                {
                    drNew[colname] = dr[colname];
                    b = true;
                }
            }

            if (b) dt.Rows.Add(drNew);

            return dt;
        }

        /// <summary>
        ///     根据对象的属性创建数据表
        /// </summary>
        private static DataTable BuiltTable(PropertyInfo[] pinfo)
        {
            try
            {
                if (pinfo == null) return null;

                var table = new DataTable();
                foreach (var info in pinfo)
                {
                    var type = info.PropertyType;
                    if (info.PropertyType.IsGenericType)
                        type = info.PropertyType.GetGenericArguments()[0];

                    var column = new DataColumn(info.Name, type);
                    column.AllowDBNull = true;
                    table.Columns.Add(column);
                }

                return table;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        ///     指定参数是否可用于浅拷贝
        /// </summary>
        private static bool CanShallowCopyProperty(object propValue)
        {
            if (propValue == null) return true;

            if (propValue.GetType().IsValueType || propValue is string)
                return true;

            return false;
        }

        /// <summary>
        ///     复制对象. 浅拷贝.
        /// </summary>
        public static object CloneObject(object source)
        {
            try
            {
                if (source == null) return null;

                var objType = source.GetType();
                var destObj = objType.Assembly.CreateInstance(objType.FullName);
                var propsSource = objType.GetProperties();
                foreach (var infoSource in propsSource)
                {
                    var value = GetValueOfObject(source, infoSource.Name);
                    if (value != null && CanShallowCopyProperty(value))
                        SetPropertyValue(destObj, infoSource, value);
                }

                return destObj;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        ///     复制一个对象数组.
        /// </summary>
        public static ArrayList CloneObjects(IList source)
        {
            if (source == null) return null;

            var ret = new ArrayList();
            foreach (var o in source) ret.Add(CloneObject(o));

            return ret;
        }

        ///// <summary>
        ///// SQL SERVER数据类型（如：varchar）转换为DbType类型
        ///// </summary>
        ///// <param name="sqlTypeString">SQL SERVER数据类型</param>
        ///// <returns>返回DbType类型</returns>
        //public static DbType SqlTypeString2SqlType(string sqlTypeString)
        //{
        //    DbType dbType = DbType.Object;//默认为Object

        //    switch (sqlTypeString)
        //    {
        //        case "int":
        //            dbType = DbType.Int32;
        //            break;
        //        case "varchar":
        //            dbType = DbType.String;
        //            break;
        //        case "bit":
        //            dbType = DbType.Boolean;
        //            break;
        //        case "datetime":
        //            dbType = DbType.DateTime;
        //            break;
        //        case "decimal":
        //            dbType = DbType.Decimal;
        //            break;
        //        case "float":
        //            dbType = DbType.Float;
        //            break;
        //        case "image":
        //            dbType = DbType.Binary;
        //            break;
        //        case "money":
        //            dbType = DbType.Money;
        //            break;
        //        case "ntext":
        //            dbType = DbType.NText;
        //            break;
        //        case "nvarchar":
        //            dbType = DbType.String;
        //            break;
        //        case "smalldatetime":
        //            dbType = DbType.SmallDateTime;
        //            break;
        //        case "smallint":
        //            dbType = DbType.SmallInt;
        //            break;
        //        case "text":
        //            dbType = DbType.Text;
        //            break;
        //        case "bigint":
        //            dbType = DbType.BigInt;
        //            break;
        //        case "binary":
        //            dbType = DbType.Binary;
        //            break;
        //        case "char":
        //            dbType = DbType.String;
        //            break;
        //        case "nchar":
        //            dbType = DbType.NChar;
        //            break;
        //        case "numeric":
        //            dbType = DbType.Decimal;
        //            break;
        //        case "real":
        //            dbType = DbType.Real;
        //            break;
        //        case "smallmoney":
        //            dbType = DbType.SmallMoney;
        //            break;
        //        case "sql_variant":
        //            dbType = DbType.Variant;
        //            break;
        //        case "timestamp":
        //            dbType = DbType.Timestamp;
        //            break;
        //        case "tinyint":
        //            dbType = DbType.TinyInt;
        //            break;
        //        case "uniqueidentifier":
        //            dbType = DbType.UniqueIdentifier;
        //            break;
        //        case "varbinary":
        //            dbType = DbType.VarBinary;
        //            break;
        //        case "xml":
        //            dbType = DbType.Xml;
        //            break;
        //    }
        //    return dbType;
        //}

        /// <summary>
        ///     数据表是否存在指定的列(Column)
        /// </summary>
        /// <param name="dt">数据表</param>
        /// <param name="columnName">列的名称</param>
        /// <returns></returns>
        public static bool ColumnExists(DataTable dt, string columnName)
        {
            if (dt == null) return false;

            foreach (DataColumn col in dt.Columns)
                if (col.ColumnName.ToLower() == columnName.ToLower())
                    return true;

            return false;
        }

        /// <summary>
        ///     Object to Object. 将一个对象转换为指定类型的对象.
        ///     注意: destination内的Property必需在source内存在.
        /// </summary>
        public static object CopyProperties(object source, Type destination)
        {
            try
            {
                if (source == null) return null;

                var destObj =
                    destination.Assembly.CreateInstance(destination.FullName);
                var propsDest = destObj.GetType().GetProperties();
                foreach (var infoDest in propsDest)
                {
                    var value = GetValueOfObject(source, infoDest.Name);
                    if (value != null && CanShallowCopyProperty(value))
                        SetPropertyValue(destObj, infoDest, value);
                }

                return destObj;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        ///     复制对象属性.
        /// </summary>
        public static void CopyProperties(object source, object destObj)
        {
            try
            {
                if (source == null || destObj == null) return;

                var propsDest = destObj.GetType().GetProperties();
                foreach (var infoDest in propsDest)
                {
                    var value = GetValueOfObject(source, infoDest.Name);
                    if (value != null && CanShallowCopyProperty(value))
                        SetPropertyValue(destObj, infoDest, value);
                }
            }
            catch
            {
            }
        }

        /// <summary>
        ///     根据类型创建表结构
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public static DataTable CreateTable(Type t)
        {
            return BuiltTable(t.GetProperties());
        }

        /// <summary>
        ///     C#.NET数据类型集合
        /// </summary>
        /// <returns></returns>
        public static IList CSharpDataTypes()
        {
            var list = new ArrayList();
            list.Add(typeof(DateTime));
            list.Add(typeof(byte));
            list.Add(typeof(sbyte));
            list.Add(typeof(short));
            list.Add(typeof(int));
            list.Add(typeof(long));
            list.Add(typeof(IntPtr));
            list.Add(typeof(ushort));
            list.Add(typeof(uint));
            list.Add(typeof(ulong));
            list.Add(typeof(UIntPtr));
            list.Add(typeof(float));
            list.Add(typeof(double));
            list.Add(typeof(decimal));
            list.Add(typeof(bool));
            list.Add(typeof(char));
            list.Add(typeof(string));
            return list;
        }

        /// <summary>
        ///     数据行(DataRow)转换为对象,对象的Type由type参数决定.
        /// </summary>
        public static object DataRowToObject(DataRow row, Type type)
        {
            if (null == row) return null;

            try
            {
                var o = type.Assembly.CreateInstance(type.FullName);
                object v;
                var pinfo = type.GetProperties();
                foreach (var info in pinfo)
                {
                    v = GetFieldValue(row, info.Name);
                    if (v != null) SetPropertyValue(o, info, v);
                }

                return o;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        ///     查找对象包含指定属性.
        /// </summary>
        public static bool FindProperty(object obj, string property)
        {
            try
            {
                if (obj == null) return false;

                var type = obj.GetType();
                var pinfo = type.GetProperties();
                foreach (var info in pinfo)
                    if (info.Name.ToUpper() == property.ToUpper())
                        return true;

                return false;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        ///     根据对象的属性取字段的值
        /// </summary>
        private static object GetFieldValue(DataRow row, string propertyName)
        {
            if (row == null) return null;

            if (row.Table.Columns.IndexOf(propertyName) >= 0)
            {
                var value = row[propertyName];
                if (value != null && value is DateTime)
                    if ((DateTime)value <= DateTime.MinValue.AddDays(1))
                        value = null;

                return value;
            }

            return null;
        }

        /// <summary>
        ///     纵对象数据组取出某一个对象. 参数指定关键字段名称(keyPropName)及值(keyValue).
        /// </summary>
        public static object GetObjectByKey(IList objects, string keyPropName,
            object keyValue)
        {
            foreach (var o in objects)
            {
                var value = GetValueOfObject(o, keyPropName);
                if (value == null) continue;

                if (value.ToStringEx().ToLower() ==
                    keyValue.ToStringEx().ToLower()) return o;
            }

            return null;
        }

        /// <summary>
        ///     纵对象数据组取出某一个对象. 返回对象指定属性名称(returnPropName)的值
        /// </summary>
        public static object GetObjectValueByKey(IList objects,
            string keyPropName, object keyValue,
            string returnPropName)
        {
            var o = GetObjectByKey(objects, keyPropName, keyValue);
            if (o != null) return GetValueOfObject(o, returnPropName);

            return null;
        }

        /// <summary>
        ///     获取对象指定属性的值
        /// </summary>
        public static object GetValueOfObject(object obj, string property)
        {
            try
            {
                if (obj == null) return null;

                var type = obj.GetType();
                var pinfo = type.GetProperties();
                foreach (var info in pinfo)
                    if (info.Name.ToUpper() == property.ToUpper())
                        return info.GetValue(obj, null);

                return null;
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        ///     替换记录对应字段的数据。
        /// </summary>
        /// <param name="sourceRow">数据源</param>
        /// <param name="destRow">需要替换的记录</param>
        public static void ReplaceDataRowChanges(DataRow sourceRow,
            DataRow destRow)
        {
            string fieldName;

            //循环处理当前记录的所有字段
            for (var i = 0; i <= sourceRow.Table.Columns.Count - 1; i++)
            {
                fieldName = sourceRow.Table.Columns[i].ColumnName;

                //如果字段名相同，替换对应字段的数据。
                if (destRow.Table.Columns.IndexOf(fieldName) >= 0)
                    destRow[fieldName] = sourceRow[fieldName];
            }
        }

        /// <summary>
        ///     给资料行赋值
        /// </summary>
        /// <param name="row">资料行</param>
        /// <param name="fieldName">字段名</param>
        /// <param name="value">值</param>
        public static void SetDataRowValue(DataRow row, string fieldName,
            object value)
        {
            row[fieldName] = value == null ||
                             ConvertEx.ToString(value) == Globals.DEF_NULL_VALUE
                ? DBNull.Value
                : value;
        }

        /// <summary>
        ///     给对象的属性赋值
        /// </summary>
        /// <param name="instance">对象实例</param>
        /// <param name="prop">属性</param>
        /// <param name="value">值</param>
        public static void SetPropertyValue(object instance, PropertyInfo prop,
            object value)
        {
            try
            {
                if (prop == null) return;

                if (prop.PropertyType.ToStringEx() == "System.String")
                {
                }
                else if (prop.PropertyType.ToStringEx() == "System.Decimal")
                {
                    value = decimal.Parse(value.ToStringEx());
                }
                else if (prop.PropertyType.ToStringEx() == "System.Int32")
                {
                    value = int.Parse(value.ToStringEx());
                }
                else if (prop.PropertyType.ToStringEx() == "System.Single")
                {
                    value = float.Parse(value.ToStringEx());
                }
                else if (prop.PropertyType.ToStringEx() == "System.DateTime")
                {
                    value = DateTime.Parse(value.ToStringEx());
                }

                prop.SetValue(instance, value, null);
            }
            catch
            {
            }
        }

        /// <summary>
        ///     从源行中对相同字段名的列付值
        /// </summary>
        /// <param name="drSouce"></param>
        /// <param name="drTo"></param>
        public static void SetTwoRowSameColValue(DataRow drSource, DataRow drTo)
        {
            for (var i = 0; i < drSource.Table.Columns.Count; i++)
            {
                var fieldname = drSource.Table.Columns[i].ColumnName;
                var col = drTo.Table.Columns[fieldname];
                if (col != null) drTo[fieldname] = drSource[fieldname];
            }
        }

        /// <summary>
        ///     给记录的字段赋值
        /// </summary>
        /// <param name="dr">记录</param>
        /// <param name="field">字段名</param>
        /// <param name="value">值</param>
        public static void SetValueofDataRow(DataRow dr, string field,
            object value)
        {
            try
            {
                if (dr == null) return;

                dr[field] = value;
            }
            catch
            {
            }
        }

        /// <summary>
        ///     设置对象某个属性的值
        /// </summary>
        public static void SetValueOfObject(object obj, string property,
            object value)
        {
            try
            {
                if (obj == null) return;

                var type = obj.GetType();
                var pinfo = type.GetProperties();
                foreach (var info in pinfo)
                    if (info.Name.ToUpper() == property.ToUpper())
                    {
                        SetPropertyValue(obj, info, value);
                        break;
                    }
            }
            catch
            {
            }
        }

        /// <summary>
        ///     数据库中与C#中的数据类型对照
        /// </summary>
        /// <param name="sqlType"></param>
        /// <returns></returns>
        public static string SqlTypeToCSharpType(string sqlType)
        {
            var reval = string.Empty;
            switch (sqlType.ToLower())
            {
                case "int":
                    reval = "Int32";
                    break;
                case "text":
                    reval = "String";
                    break;
                case "bigint":
                    reval = "Int64";
                    break;
                case "binary":
                    reval = "System.Byte[]";
                    break;
                case "bit":
                    reval = "Boolean";
                    break;
                case "char":
                    reval = "String";
                    break;
                case "datetime":
                    reval = "System.DateTime";
                    break;
                case "decimal":
                    reval = "System.Decimal";
                    break;
                case "float":
                    reval = "System.Double";
                    break;
                case "image":
                    reval = "System.Byte[]";
                    break;
                case "money":
                    reval = "System.Decimal";
                    break;
                case "nchar":
                    reval = "String";
                    break;
                case "ntext":
                    reval = "String";
                    break;
                case "numeric":
                    reval = "System.Decimal";
                    break;
                case "nvarchar":
                    reval = "String";
                    break;
                case "real":
                    reval = "System.Single";
                    break;
                case "smalldatetime":
                    reval = "System.DateTime";
                    break;
                case "smallint":
                    reval = "Int16";
                    break;
                case "smallmoney":
                    reval = "System.Decimal";
                    break;
                case "timestamp":
                    reval = "System.DateTime";
                    break;
                case "tinyint":
                    reval = "System.Byte";
                    break;
                case "uniqueidentifier":
                    reval = "System.Guid";
                    break;
                case "varbinary":
                    reval = "System.Byte[]";
                    break;
                case "varchar":
                    reval = "String";
                    break;
                case "Variant":
                    reval = "Object";
                    break;
                default:
                    reval = "String";
                    break;
            }

            return reval;
        }

        /// <summary>
        ///     DataTable转换为DataSet
        /// </summary>
        /// <param name="table">DataTable</param>
        /// <returns></returns>
        public static DataSet TableToDataSet(DataTable table)
        {
            if (table.DataSet != null) return table.DataSet;

            var ds = new DataSet();
            ds.Tables.Add(table);
            return ds;
        }

        /// <summary>
        ///     对象数组转换为ArrayList.
        /// </summary>
        public static ArrayList ToArrayList(IList list)
        {
            if (list == null) return null;

            var arrlist = new ArrayList();
            foreach (var o in list) arrlist.Add(o);

            return arrlist;
        }

        /// <summary>
        ///     对象数组转换为ArrayList.
        /// </summary>
        public static ArrayList ToArrayList(object[] source)
        {
            if (null != source) return new ArrayList(source);

            //如果来源数据为null,返回一个空的ArrayList.
            return new ArrayList();
        }

        /// <summary>
        ///     ArrayList转换为对象数组.
        /// </summary>
        public static object[] ToObjects(IList source)
        {
            if (null == source) return null;

            var ret = new object[source.Count];
            for (var i = 0; i < source.Count; i++) ret[i] = source[i];

            return ret;
        }

        /// <summary>
        ///     把字符串以逗号分格，转换成数据库格式in('a','b')
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string ToSQLInDataFormat(string input)
        {
            var HQL = string.Empty;
            if (input == string.Empty) return HQL;

            var sArray = input.Split(',');
            foreach (var str in sArray)
            {
                if (str.Length == 0) continue;

                HQL += "'" + str + "',";
            }

            if (HQL.Substring(HQL.Length - 1, 1) == ",")
                HQL = HQL.Substring(0, HQL.Length - 1);

            return HQL;
        }

        /// <summary>
        ///     把字符串以逗号分格，转换成数据库格式''a'',''b''
        /// </summary>
        public static string ToSQLInDataFormatTwo(string input)
        {
            var HQL = string.Empty;
            if (input == string.Empty) return HQL;

            var sArray = input.Split(',');
            foreach (var str in sArray)
            {
                if (str.Length == 0) continue;

                HQL += "''" + str + "'',";
            }

            if (HQL.Substring(HQL.Length - 1, 1) == ",")
                HQL = HQL.Substring(0, HQL.Length - 1);

            return HQL;
        }

        /// <summary>
        ///     以逗号分格字符串，返回数组
        ///     如果第一个和最后一个字符为, 去掉
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string[] ToStringSplit(string str)
        {
            if (str.Length > 0)
            {
                if (str[0] == ',') str = str.Substring(1, str.Length - 1);

                if (str[str.Length - 1] == ',')
                    str = str.Substring(0, str.Length - 1);
            }

            var sArray = str.Split(',');
            return sArray;
        }

        /// <summary>
        ///     由某对象更新资料行,字段名称必须与对象属性对应，(ORM模型)
        /// </summary>
        /// <param name="row">资料行</param>
        /// <param name="o">对象实例</param>
        /// <returns></returns>
        public static DataRow UpdateDataRowFromObject(DataRow row, object o)
        {
            var pinfo = o.GetType().GetProperties();
            foreach (var info in pinfo)
                if (row.Table.Columns.IndexOf(info.Name) >= 0)
                    SetDataRowValue(row, info.Name, info.GetValue(o, null));

            return row;
        }

        /// <summary>
        ///     修改对表的某列的值
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="value"></param>
        public static bool UpdateTableCol(DataTable dt, string fieldName,
            object value)
        {
            try
            {
                if (dt.Columns.IndexOf(fieldName) < 0)
                    throw new Exception("表没有" + fieldName + "列！");

                foreach (DataRow dr in dt.Rows) dr[fieldName] = value;

                return true;
            }
            catch
            {
                return false;
            }
        }
    }
}