using System.Collections;
using System.Data;
using System.Dynamic;
using System.Reflection;
using System.Text;

namespace Admin.NET.Core.Helper;

public static class ListHelper
{
    public static string ListToString<T>(this List<T> listSplicing, string splicing)
    {
        if (listSplicing == null || listSplicing.Count == 0)
        {
            return "";
        }
        if (string.IsNullOrWhiteSpace(splicing))
        {
            splicing = "";
        }
        StringBuilder stringBuilder = new StringBuilder();
        listSplicing.ForEach(list =>
        {
            stringBuilder.Append(list.ToString() + splicing);
        });
        string value = stringBuilder.ToString();
        return value.Substring(0, value.Length - 1);
    }

    public static DataTable ListToDataTable<T>(this List<T> list)
    {
        DataTable result = new();
        if (list is not null && list.Count > 0)
        {
            PropertyInfo[] propertys = list[0].GetType().GetProperties();
            foreach (PropertyInfo pi in propertys)
            {
                //获取类型
                Type colType = pi.PropertyType;
                //当类型为Nullable<>时
                if ((colType.IsGenericType) && (colType.GetGenericTypeDefinition() == typeof(Nullable<>)))
                {
                    colType = colType.GetGenericArguments()[0];
                }
                // var lists= pi.GetCustomAttributes().ToList();
                //var s =  lists.Where(w => w.TypeId.GetType().Name == "Comment").FirstOrDefault();
                // foreach (var item in lists)
                // {
                // }
                result.Columns.Add(pi.Name, colType);
            }
            for (int i = 0; i < list.Count; i++)
            {
                ArrayList tempList = new ArrayList();
                foreach (PropertyInfo pi in propertys)
                {
                    object obj = pi.GetValue(list[i], null);
                    tempList.Add(obj);
                }
                object[] array = tempList.ToArray();
                result.LoadDataRow(array, true);
            }
        }
        return result;
    }

    /// <summary>
    /// 将DataTable 转换成 List<dynamic>
    /// reverse 反转：控制返回结果中是只存在 FilterField 指定的字段,还是排除.
    /// [flase 返回FilterField 指定的字段]|[true 返回结果剔除 FilterField 指定的字段]
    /// FilterField  字段过滤，FilterField 为空 忽略 reverse 参数；返回DataTable中的全部数
    /// </summary>
    /// <param name="table">DataTable</param>
    /// <param name="reverse">
    /// 反转：控制返回结果中是只存在 FilterField 指定的字段,还是排除.
    /// [flase 返回FilterField 指定的字段]|[true 返回结果剔除 FilterField 指定的字段]
    ///</param>
    /// <param name="FilterField">字段过滤，FilterField 为空 忽略 reverse 参数；返回DataTable中的全部数据</param>
    /// <returns>返回List<dynamic></returns>
    public static List<dynamic> ToDynamicList(this DataTable table, bool reverse = true, params string[] FilterField)
    {
        var modelList = new List<dynamic>();
        foreach (DataRow row in table.Rows)
        {
            dynamic model = new ExpandoObject();
            var dict = (IDictionary<string, object>)model;
            foreach (DataColumn column in table.Columns)
            {
                if (FilterField.Length != 0)
                {
                    if (reverse == true)
                    {
                        if (!FilterField.Contains(column.ColumnName))
                        {
                            dict[column.ColumnName] = row[column];
                        }
                    }
                    else
                    {
                        if (FilterField.Contains(column.ColumnName))
                        {
                            dict[column.ColumnName] = row[column];
                        }
                    }
                }
                else
                {
                    dict[column.ColumnName] = row[column];
                }
            }
            modelList.Add(model);
        }
        return modelList;
    }

    /// <summary>
    /// 将DataTable 转换成 List<dynamic>异步方法
    /// reverse 反转：控制返回结果中是只存在 FilterField 指定的字段,还是排除.
    /// [flase 返回FilterField 指定的字段]|[true 返回结果剔除 FilterField 指定的字段]
    /// FilterField  字段过滤，FilterField 为空 忽略 reverse 参数；返回DataTable中的全部数
    /// </summary>
    /// <param name="table">DataTable</param>
    /// <param name="reverse">
    /// 反转：控制返回结果中是只存在 FilterField 指定的字段,还是排除.
    /// [flase 返回FilterField 指定的字段]|[true 返回结果剔除 FilterField 指定的字段]
    ///</param>
    /// <param name="IsNull">IsNull的判断</param>
    /// <param name="FilterField">字段过滤，FilterField 为空 忽略 reverse 参数；返回DataTable中的全部数据</param>
    /// <returns>返回List<dynamic></returns>
    public static async Task<List<dynamic>> ToDynamicListAsync(this DataTable table, bool IsNull = false, bool reverse = true, params string[] FilterField)
    {
        var modelList = new List<dynamic>();
        await Task.Run(() =>
        {
            if (!IsNull)
            {
                foreach (DataRow row in table.Rows)
                {
                    dynamic model = new ExpandoObject();
                    var dict = (IDictionary<string, object>)model;
                    foreach (DataColumn column in table.Columns)
                    {
                        if (FilterField.Length != 0)
                        {
                            if (reverse == true)
                            {
                                if (!FilterField.Contains(column.ColumnName))
                                {
                                    dict[column.ColumnName] = row[column];
                                }
                            }
                            else
                            {
                                if (FilterField.Contains(column.ColumnName))
                                {
                                    dict[column.ColumnName] = row[column];
                                }
                            }
                        }
                        else
                        {
                            dict[column.ColumnName] = row[column];
                        }
                    }
                    modelList.Add(model);
                }
            }
            else
            {
                foreach (DataRow row in table.Rows)
                {
                    dynamic model = new ExpandoObject();
                    var dict = (IDictionary<string, object>)model;

                    foreach (DataColumn column in table.Columns)
                    {
                        if (FilterField.Length != 0)
                        {
                            if (reverse == true)
                            {
                                if (!FilterField.Contains(column.ColumnName))
                                {
                                    dict[column.ColumnName] = row[column];
                                }
                            }
                            else
                            {
                                if (FilterField.Contains(column.ColumnName))
                                {
                                    dict[column.ColumnName] = row[column];
                                }
                            }
                        }
                        else
                        {
                            dict[column.ColumnName] = string.IsNullOrWhiteSpace(row[column].ToString()) ? null : row[column];
                        }
                    }
                    modelList.Add(model);
                }
            }
        });
        return modelList;
    }

    /// <summary>
    /// 将DataTable 转换成 List<T> 方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="dt"></param>
    /// <returns></returns>
    public static List<T> ToDataList<T>(this DataTable dt)
    {
        var list = new List<T>();
        var plist = new List<PropertyInfo>(typeof(T).GetProperties());

        foreach (DataRow item in dt.Rows)
        {
            T s = Activator.CreateInstance<T>();
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                PropertyInfo info = plist.Find(p => p.Name == dt.Columns[i].ColumnName);
                if (info != null)
                {
                    try
                    {
                        if (!Convert.IsDBNull(item[i]))
                        {
                            object v = null;
                            if (info.PropertyType.ToString().Contains("System.Nullable"))
                            {
                                v = Convert.ChangeType(item[i], Nullable.GetUnderlyingType(info.PropertyType));
                            }
                            else
                            {
                                v = Convert.ChangeType(item[i], info.PropertyType);
                            }
                            info.SetValue(s, v, null);
                        }
                    }
                    catch (Exception ex)
                    {
                        throw new Exception("字段[" + info.Name + "]转换出错," + ex.Message);
                    }
                }
            }
            list.Add(s);
        }
        return list;
    }

    /// <summary>
    /// 格式化关键字集合
    /// </summary>
    /// <typeparam name="T">泛型对象</typeparam>
    /// <param name="t">关键字集对象</param>
    /// <returns></returns>
    public static Dictionary<string, string> getProperties<T>(T t)
    {
        Dictionary<string, string> keywords = new Dictionary<string, string>();
        if (t == null)
        {
            return keywords;
        }
        System.Reflection.PropertyInfo[] properties = t.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);

        if (properties.Length <= 0)
        {
            return keywords;
        }
        foreach (System.Reflection.PropertyInfo item in properties)
        {
            string name = item.Name;
            object value = item.GetValue(t, null);
            if (item.PropertyType.IsValueType || item.PropertyType.Name.StartsWith("String"))
            {
                keywords.Add(name, value.ToString());
            }
            else
            {
                getProperties(value);
            }
        }
        return keywords;
    }

}