using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.Script.Serialization;
using System.Xml;
using System.Xml.Serialization;

namespace QRWL.Web.Common
{
    /// <summary>
    /// DataTable相关方法
    /// </summary>
    public class DataTableHelper
    {
        #region 克隆数据行
        /// <summary>
        /// 克隆数据行
        /// </summary>
        /// <param name="sourceRow">被复制的行数据</param>
        /// <param name="newRow">新的行数据</param>
        /// <param name="fieldNames">要复制的字段</param>
        /// <returns></returns>
        private static DataRow createRowClone(DataRow sourceRow, DataRow newRow, string[] fieldNames)
        {
            foreach (string field in fieldNames)
            {
                newRow[field] = sourceRow[field];
            }
            return newRow;
        }
        #endregion

        #region DataRow转HashTable
        /// <summary>
        /// DataRow转HashTable
        /// </summary>
        /// <param name="dr">DataRow数据源</param>
        /// <returns></returns>
        public static Hashtable DataRowToHashTable(DataRow dr)
        {
            Hashtable htReturn = new Hashtable(dr.ItemArray.Length);
            foreach (DataColumn dc in dr.Table.Columns)
            {
                htReturn.Add(dc.ColumnName, dr[dc.ColumnName]);
            }
            return htReturn;
        }
        #endregion

        #region DataTable转ArrayList
        /// <summary>
        /// DataTable转ArrayList
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <returns></returns>
        public static IList<Hashtable> DataTableToArrayList(DataTable dt)
        {
            if (dt == null)
            {
                return new List<Hashtable>();
            }
            IList<Hashtable> datas = new List<Hashtable>();
            foreach (DataRow dr in dt.Rows)
            {
                Hashtable ht = DataRowToHashTable(dr);
                datas.Add(ht);
            }
            return datas;
        }
        #endregion

        #region DataTable转Hashtable
        /// <summary>
        /// DataTable转Hashtable
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <returns></returns>
        public static Hashtable DataTableToHashtable(DataTable dt)
        {
            Hashtable ht = new Hashtable();
            foreach (DataRow dr in dt.Rows)
            {
                for (int i = 0; i < dt.Columns.Count; i++)
                {
                    string key = dt.Columns[i].ColumnName;
                    ht[key.ToUpper()] = dr[key];
                }
            }
            return ht;
        }
        #endregion

        #region 将DataTable指定字段内容转换成Hashtable
        /// <summary>
        /// 将DataTable指定字段内容转换成Hashtable
        /// 存储表中对应字段的内容到Hashtable
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <param name="keyField">字段名称</param>
        /// <param name="valFiled">字段键值</param>
        /// <returns></returns>
        public static Hashtable DataTableToHashtableByKeyValue(DataTable dt, string keyField, string valFiled)
        {
            Hashtable ht = new Hashtable();
            if (dt != null)
            {
                foreach (DataRow dr in dt.Rows)
                {
                    string key = dr[keyField].ToString();
                    ht[key] = dr[valFiled];
                }
            }
            return ht;
        }
        #endregion

        #region 数据行对象转化成泛型
        /// <summary>
        /// 数据行对象转化成泛型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dt">DataTable数据源</param>
        /// <returns></returns>
        public static IList DataTableToIList<T>(DataTable dt)
        {
            IList list = new List<T>();
            string tempName = "";
            foreach (DataRow dr in dt.Rows)
            {
                T obj = Activator.CreateInstance<T>();
                PropertyInfo[] propertys = obj.GetType().GetProperties();
                foreach (PropertyInfo pi in propertys)
                {
                    tempName = pi.Name;
                    if (dt.Columns.Contains(tempName) && pi.CanWrite)
                    {
                        object value = dr[tempName];
                        if (value != DBNull.Value)
                        {
                            pi.SetValue(obj, value, null);
                        }
                    }
                }
                list.Add(obj);
            }
            return list;
        }
        #endregion

        #region DataTable转化成xml
        /// <summary>
        /// DataTable 转化成xml
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <returns></returns>
        public static string DataTableToXML(DataTable dt)
        {
            if (dt != null)
            {
                StringBuilder sb = new StringBuilder();
                XmlWriter writer = XmlWriter.Create(sb);
                new XmlSerializer(typeof(DataTable)).Serialize(writer, dt);
                writer.Close();
                return sb.ToString();
            }
            return string.Empty;
        }
        #endregion

        #region 比较对象是否一致
        /// <summary>
        /// 比较对象是否一致
        /// </summary>
        /// <param name="lastValues">对比的数据内容</param>
        /// <param name="currentRow">对比的数据行</param>
        /// <param name="fieldNames">比较的字段</param>
        /// <returns></returns>
        private static bool fieldValuesAreEqual(object[] lastValues, DataRow currentRow, string[] fieldNames)
        {
            for (int i = 0; i < fieldNames.Length; i++)
            {
                if (!((lastValues[i] != null) && lastValues[i].Equals(currentRow[fieldNames[i]])))
                {
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region 根据条件获取新DataTable
        /// <summary>
        /// 根据条件获取新DataTable
        /// </summary>
        /// <param name="dt">被复制的DataTable</param>
        /// <param name="condition">查询条件</param>
        /// <returns></returns>
        public static DataTable GetNewDataTable(DataTable dt, string condition)
        {
            if (IsExistRows(dt))
            {
                if (condition.Trim() == "")
                {
                    return dt;
                }
                DataTable newdt = dt.Clone();
                DataRow[] dr = dt.Select(condition);
                for (int i = 0; i < dr.Length; i++)
                {
                    newdt.ImportRow(dr[i]);
                }
                return newdt;
            }
            return null;
        }
        #endregion

        #region DataTable分页
        /// <summary>
        /// DataTable分页
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <param name="PageIndex">当前页</param>
        /// <param name="PageSize">页码</param>
        /// <returns></returns>
        public static DataTable GetPagedTable(DataTable dt, int PageIndex, int PageSize)
        {
            if (PageIndex == 0)
            {
                return dt;
            }
            DataTable newdt = dt.Copy();
            newdt.Clear();
            int rowbegin = (PageIndex - 1) * PageSize;
            int rowend = PageIndex * PageSize;
            if (rowbegin < dt.Rows.Count)
            {
                if (rowend > dt.Rows.Count)
                {
                    rowend = dt.Rows.Count;
                }
                for (int i = rowbegin; i <= (rowend - 1); i++)
                {
                    DataRow newdr = newdt.NewRow();
                    DataRow dr = dt.Rows[i];
                    foreach (DataColumn column in dt.Columns)
                    {
                        newdr[column.ColumnName] = dr[column.ColumnName];
                    }
                    newdt.Rows.Add(newdr);
                }
            }
            return newdt;
        }
        #endregion

        #region 判断是否有数据行
        /// <summary>
        /// 判断是否有数据行
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <returns></returns>
        public static bool IsExistRows(DataTable dt)
        {
            return ((dt != null) && (dt.Rows.Count > 0));
        }
        #endregion

        #region 获取去重后的数据源
        /// <summary>
        /// 获取去重后的数据源
        /// </summary>
        /// <param name="SourceTable">DataTable数据源</param>
        /// <param name="FieldNames">查重字段</param>
        /// <returns></returns>
        public static DataTable SelectDistinct(DataTable SourceTable, string[] FieldNames)
        {
            return SelectDistinct(SourceTable, FieldNames, false);
        }

        /// <summary>
        /// 获取去重后的数据源
        /// </summary>
        /// <param name="SourceTable">DataTable数据源</param>
        /// <param name="FieldNames">查重字段</param>
        /// <param name="TypeofString">返回字段类型是否都是字符串</param>
        /// <returns></returns>
        public static DataTable SelectDistinct(DataTable SourceTable, string[] FieldNames, bool TypeofString)
        {
            if ((FieldNames == null) || (FieldNames.Length == 0))
            {
                throw new ArgumentNullException("FieldNames");
            }
            object[] lastValues = new object[FieldNames.Length];
            DataTable newTable = new DataTable();
            foreach (string fieldName in FieldNames)
            {
                newTable.Columns.Add(fieldName, TypeofString ? typeof(string) : SourceTable.Columns[fieldName].DataType);
            }
            DataRow[] orderedRows = SourceTable.Select("", string.Join(",", FieldNames));
            foreach (DataRow row in orderedRows)
            {
                if (!fieldValuesAreEqual(lastValues, row, FieldNames))
                {
                    newTable.Rows.Add(createRowClone(row, newTable.NewRow(), FieldNames));
                    setLastValues(lastValues, row, FieldNames, TypeofString);
                }
            }
            return newTable;
        }

        #region 获取指定字段的内容
        /// <summary>
        /// 获取指定字段的内容
        /// </summary>
        /// <param name="lastValues">返回的数据集</param>
        /// <param name="sourceRow">DataRow数据源</param>
        /// <param name="fieldNames">指定的字段</param>
        /// <param name="TypeofString">返回字段类型是否都是字符串</param>
        private static void setLastValues(object[] lastValues, DataRow sourceRow, string[] fieldNames, bool TypeofString = false)
        {
            for (int i = 0; i < fieldNames.Length; i++)
            {
                lastValues[i] = TypeofString ? sourceRow[fieldNames[i]].ToString() : sourceRow[fieldNames[i]];
            }
        }
        #endregion

        #endregion

        #region 将DataTable进行正序排序
        /// <summary>
        /// 将DataTable进行正序排序
        /// </summary>
        /// <param name="dt">DataTable数据源</param>
        /// <param name="sorts">排序字段，数组类型</param>
        /// <returns></returns>
        public static DataTable SortedTable(DataTable dt, params string[] sorts)
        {
            if (dt.Rows.Count > 0)
            {
                string tmp = "";
                for (int i = 0; i < sorts.Length; i++)
                {
                    tmp = tmp + sorts[i] + ",";
                }
                dt.DefaultView.Sort = tmp.TrimEnd(new char[] { ',' });
            }
            return dt;
        }
        #endregion

        #region 根据枚举转化对应的DataTable
        /// <summary>
        /// 根据枚举转化对应的DataTable
        /// </summary>
        public static void DataTableTanslate(DataTable dataTable, Dictionary<string, Dictionary<string, string>> dictionary)
        {
            if (dictionary == null)
            {
                return;
            }
            string str = "_" + Guid.NewGuid().ToString().Substring(0, 10).Replace("-", "_");
            foreach (DataRow dataRow in dataTable.Rows)
            {
                foreach (string current in dictionary.Keys)
                {
                    if (dataTable.Columns.IndexOf(current) >= 0)
                    {
                        if (dataTable.Columns.IndexOf(current + str) < 0)
                        {
                            dataTable.Columns[current].ColumnName = current + str;
                            dataTable.Columns.Add(current, typeof(string));
                        }
                        string text = "";
                        if (dictionary[current].TryGetValue(dataRow[current + str].ToString(), out text))
                        {
                            dataRow[current] = text;
                        }
                        else
                        {
                            string[] array = dataRow[current + str].ToString().Split(new char[]
                            {
                                ','
                            });
                            if (array.Length > 1)
                            {
                                for (int i = 0; i < array.Length; i++)
                                {
                                    if (dictionary[current].TryGetValue(array[i].ToString(), out text))
                                    {
                                        array[i] = text;
                                    }
                                }
                            }
                            dataRow[current] = string.Join(",", array);
                        }
                    }
                }
            }
        }
        #endregion

        #region 转换DataTable字段类型
        /// <summary>
        /// 转换DataTable字段类型
        /// </summary>
        /// <param name="table">DataTable数据源</param>
        /// <returns></returns>
        public static DataTable ConvertOraclTableToDoNetTable(DataTable table)
        {
            DataTable dt = new DataTable();
            foreach (DataColumn dc in table.Columns)
            {
                DataColumn column = new DataColumn();
                column.DataType = GetDataType(dc.DataType);
                column.ColumnName = dc.ColumnName;
                column.Caption = dc.Caption;
                dt.Columns.Add(column);
            }
            dt.TableName = table.TableName;
            dt.Merge(table, false, MissingSchemaAction.Ignore);
            return dt;
        }
        #endregion

        #region 解析字段类型
        /// <summary>
        /// 解析字段类型
        /// </summary>
        /// <param name="dataType">字段类型</param>
        /// <returns></returns>
        public static Type GetDataType(Type dataType)
        {
            switch (dataType.ToString())
            {
                case "System.Double":
                    return System.Type.GetType("System.Decimal");
                case "System.Int32":
                    return System.Type.GetType("System.Decimal");
                case "System.Int16":
                    return System.Type.GetType("System.Decimal");
                case "System.Int64":
                    return System.Type.GetType("System.Decimal");
                default:
                    return dataType;
            }
        }
        #endregion

        #region DataRow转DataTable
        /// <summary>
        /// DataRow转DataTable
        /// </summary>
        /// <param name="dt">数据来源DataTable</param>
        /// <param name="strWhere">过滤成DataRow的条件</param>
        /// <returns></returns>
        public static DataTable DataRowToDataTable(DataTable dt, string strWhere)
        {
            DataTable dtNew = dt.Clone();         //复制数据源的表结构
            DataRow[] dr = dt.Select(strWhere);  //strWhere条件筛选出需要的数据！
            for (int i = 0; i < dr.Length; i++)
            {
                dtNew.Rows.Add(dr[i].ItemArray);  // 将DataRow添加到DataTable中
            }
            return dtNew;
        }
        #endregion

        #region 判断DataTale中判断某个字段中包含某个数据
        /// <summary>
        /// 判断DataTale中判断某个字段中包含某个数据
        /// </summary>
        /// <param name="dt">数据来源DataTable</param>
        /// <param name="columnName">需要比较的列</param>
        /// <param name="fieldData">需要比较的具体数据</param>
        /// <returns></returns>
        public static Boolean IsColumnIncludeData(DataTable dt, String columnName, string fieldData)
        {
            if (dt == null)
            {
                return false;
            }
            else
            {
                DataRow[] dataRows = dt.Select(columnName + "='" + fieldData + "'");
                if (dataRows.Length.Equals(1))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        #endregion

        #region 方法 -> 获取指定页码Datatable数据
        /// <summary>
        /// 获取指定页码Datatable数据
        /// </summary>
        /// <param name="dtOrigin">源数据</param>
        /// <param name="pageSize">每页返回的数量</param>
        /// <param name="pageIndex">返回第几页数据</param>
        /// <returns>Datatable数据格式</returns>
        public static DataTable GetDataTableWithPageSize(DataTable dtOrigin, int pageSize, int pageIndex)
        {
            if (pageIndex == 0)
            {
                pageIndex = 1;
            }
            if (pageSize == 0)
            {
                pageSize = 10;
            }
            //克隆数据源
            DataTable dtClone = dtOrigin.Clone();
            dtClone.Columns.Add("RN", typeof(int));
            //开始插入数据源
            for (int RowCount = 0; RowCount < pageSize; RowCount++)
            {
                //获取当前数据源行数
                int RN = pageSize * (pageIndex - 1) + RowCount;
                //如果行数大于数据源实际数量，则直接跳过
                if (RN >= dtOrigin.Rows.Count)
                {
                    break;
                }
                //获取当前数据源内容
                DataRow EndAccountDataRow = dtOrigin.Rows[RN];
                //创建一个新 System.Data.DataRow 具有与表相同的架构
                DataRow _DataRow = dtClone.NewRow();
                //开始插入数据
                for (int ColumnsCount = 0; ColumnsCount < dtOrigin.Columns.Count; ColumnsCount++)
                {
                    _DataRow[ColumnsCount] = EndAccountDataRow[ColumnsCount];
                }
                _DataRow["RN"] = RN + 1;
                //将数据加入到克隆的DataTable中
                dtClone.Rows.Add(_DataRow);
            }

            return dtClone;
        }
        #endregion

        #region 方法 -> 【Json字符串】转换为DataTable数据集合
        /// <summary>
        /// 【Json字符串】转换为DataTable数据集合
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static DataTable ToDataTable(string json)
        {
            DataTable dataTable = new DataTable();  //实例化
            DataTable result;
            try
            {
                JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
                javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
                if (!string.IsNullOrEmpty(json))
                {
                    ArrayList arrayList = javaScriptSerializer.Deserialize<ArrayList>(json);
                    if (arrayList.Count > 0)
                    {
                        foreach (Dictionary<string, object> dictionary in arrayList)
                        {
                            if (dictionary.Keys.Count == 0)
                            {
                                result = dataTable;
                                return result;
                            }
                            //Columns
                            if (dataTable.Columns.Count == 0)
                            {
                                foreach (string current in dictionary.Keys)
                                {
                                    if (IsType(dictionary[current].GetType(), "System.Nullable`1[System.Int16]") ||
                                       IsType(dictionary[current].GetType(), "System.Nullable`1[System.Int32]") ||
                                       IsType(dictionary[current].GetType(), "System.Nullable`1[System.Int64]") ||
                                       IsType(dictionary[current].GetType(), "System.Nullable`1[System.Double]") ||
                                       IsType(dictionary[current].GetType(), "System.Nullable`1[System.Decimal]") ||
                                       dictionary[current].GetType() == typeof(System.Int16) ||
                                       dictionary[current].GetType() == typeof(System.Int32) ||
                                       dictionary[current].GetType() == typeof(System.Int64) ||
                                       dictionary[current].GetType() == typeof(System.Double) ||
                                       dictionary[current].GetType() == typeof(System.Decimal))
                                    {
                                        dataTable.Columns.Add(current, typeof(System.Decimal));
                                    }
                                    else
                                    {
                                        dataTable.Columns.Add(current, dictionary[current].GetType());
                                    }
                                }
                            }
                            //Rows
                            DataRow dataRow = dataTable.NewRow();
                            foreach (string current in dictionary.Keys)
                            {
                                try
                                {
                                    dataRow[current] = dictionary[current];
                                }
                                catch { }
                            }
                            dataTable.Rows.Add(dataRow); //循环添加行到DataTable中
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                SuperMap.RealEstate.Utility.ErrorLogHelper.Write(ex);
            }
            result = dataTable;
            return result;
        }
        #endregion

        #region 方法 -> 【object】转换为DataTable数据集合
        /// <summary>
        /// object转换为DataTable数据集合
        /// </summary>
        /// <param name="obj">数据对象</param>
        /// <returns></returns>
        public static DataTable ObjectToTable(object obj)
        {
            Type t;
            //获取对象数据类型
            if (obj.GetType().IsGenericType)
            {
                //泛型
                t = obj.GetType().GetGenericTypeDefinition();
            }
            else
            {
                t = obj.GetType();
            }
            if (t == typeof(List<>) || t == typeof(IEnumerable<>))
            {
                //是列表或者枚举
                DataTable dt = new DataTable();
                IEnumerable<object> lstenum = obj as IEnumerable<object>;
                if (lstenum.Count() > 0)
                {
                    var ob1 = lstenum.GetEnumerator();
                    ob1.MoveNext();
                    //遍历泛型列表字段，生成DataTable的Column
                    foreach (var item in ob1.Current.GetType().GetProperties())
                    {
                        dt.Columns.Add(new DataColumn() { ColumnName = item.Name });
                    }
                    //绑定数据
                    foreach (var item in lstenum)
                    {
                        DataRow row = dt.NewRow();
                        foreach (var sub in item.GetType().GetProperties())
                        {
                            row[sub.Name] = sub.GetValue(item, null);
                        }
                        dt.Rows.Add(row);
                    }
                    return dt;
                }
            }
            else if (t == typeof(DataTable))
            {
                return (DataTable)obj;
            }
            else
            {
                DataTable dt = new DataTable();
                //遍历object的字段，生成DataTable的Column
                foreach (var item in obj.GetType().GetProperties())
                {
                    dt.Columns.Add(new DataColumn() { ColumnName = item.Name });
                }
                //绑定数据
                DataRow row = dt.NewRow();
                foreach (var item in obj.GetType().GetProperties())
                {
                    row[item.Name] = item.GetValue(obj, null);
                }
                dt.Rows.Add(row);
                return dt;
            }

            return null;
        }
        #endregion

        #region 方法 -> 获取两个DataTable的字段集合
        public static List<string> GetDataTableColumns(DataTable dtFTable, DataTable dtSTable)
        {
            List<string> TableColumnList = new List<string>();
            //遍历第一个DataTable，加载他的字段
            foreach(DataColumn dataColumn in dtFTable.Columns)
            {
                if (!TableColumnList.Contains(dataColumn.ColumnName))
                {
                    TableColumnList.Add(dataColumn.ColumnName);
                }
            }
            //遍历第二个DataTable，加载他的字段
            foreach(DataColumn dataColumn in dtSTable.Columns)
            {
                if (!TableColumnList.Contains(dataColumn.ColumnName))
                {
                    TableColumnList.Add(dataColumn.ColumnName);
                }
            }

            return TableColumnList;
        }
        #endregion

        #region 方法 -> 类型匹配
        /// <summary>
        /// 类型匹配
        /// </summary>
        /// <param name="type">类型</param>
        /// <param name="typeName">类型名称</param>
        /// <returns></returns>
        public static bool IsType(Type type, string typeName)
        {
            if (type.ToString() == typeName)
                return true;
            if (type.ToString() == "System.Object")
                return false;
            return IsType(type.BaseType, typeName);
        }
        #endregion
    }
}