using Serilog;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

namespace Wood.Util
{

    public class PagedResult<T>
    {
        public List<T> Items { get; set; }
        public int TotalItems { get; set; }
        public int PageNumber { get; set; }
        public int PageSize { get; set; }
        public int TotalPages => (int)Math.Ceiling(TotalItems / (double)PageSize);
        public bool HasPreviousPage => PageNumber > 1;
        public bool HasNextPage => PageNumber < TotalPages;

        public PagedResult()
        {
            Items = new List<T>();
        }
    }


    public static class QueryableExtensions
    {
        public static PagedResult<T> ToPagedResult<T>(this IQueryable<T> query, int pageNumber, int pageSize)
        {
            var result = new PagedResult<T>
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                TotalItems = query.Count()
            };

            result.Items = query
                .Skip((pageNumber - 1) * pageSize)
                .Take(pageSize)
                .ToList();

            return result;
        }

        public static IQueryable<T> ApplySorting<T>(this IQueryable<T> query, string sortField, string sortDirection)
        {
            if (string.IsNullOrEmpty(sortField))
                return query;

            var parameter = Expression.Parameter(typeof(T), "x");
            var property = Expression.Property(parameter, sortField);
            var lambda = Expression.Lambda(property, parameter);

            string methodName = sortDirection?.ToLower() == "desc" ? "OrderByDescending" : "OrderBy";
            var resultExpression = Expression.Call(
                typeof(Queryable),
                methodName,
                new[] { typeof(T), property.Type },
                query.Expression,
                Expression.Quote(lambda));

            return query.Provider.CreateQuery<T>(resultExpression);
        }
    }


    public static class DataTableHelper
    {
        /// <summary>
        /// 将泛型列表转换为DataTable
        /// </summary>
        /// <typeparam name="T">实体类型</typeparam>
        /// <param name="list">泛型列表</param>
        /// <param name="config">转换配置（可选）</param>
        /// <returns>DataTable</returns>
        public static DataTable ToDataTable<T>(this List<T> list, Action<DataTableConfig<T>> config = null)
        {
            if (list == null || list.Count == 0)
                return new DataTable();

            var tableConfig = new DataTableConfig<T>();
            config?.Invoke(tableConfig);

            var dataTable = new DataTable();
            var properties = GetProperties(typeof(T), tableConfig);

            // 创建列
            foreach (var property in properties)
            {
                var columnType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                var columnName = tableConfig.ColumnMappings.TryGetValue(property.Name, out var mappedName)
                    ? mappedName
                    : property.Name;

                var column = new DataColumn(columnName, columnType);
                dataTable.Columns.Add(column);
            }

            // 填充数据
            foreach (var item in list)
            {
                var row = dataTable.NewRow();
                foreach (var property in properties)
                {
                    var columnName = tableConfig.ColumnMappings.TryGetValue(property.Name, out var mappedName)
                        ? mappedName
                        : property.Name;

                    var value = property.GetValue(item);
                    row[columnName] = value ?? DBNull.Value;
                }
                dataTable.Rows.Add(row);
            }

            return dataTable;
        }

        /// <summary>
        /// 获取需要转换的属性列表
        /// </summary>
        private static PropertyInfo[] GetProperties(Type type, DataTableConfig config)
        {
            var bindingFlags = BindingFlags.Public | BindingFlags.Instance;
            if (config.IgnoreNonPublicProperties)
                bindingFlags &= ~BindingFlags.NonPublic;

            var properties = type.GetProperties(bindingFlags);

            if (config.IgnoreProperties?.Count > 0)
            {
                properties = Array.FindAll(properties, p => !config.IgnoreProperties.Contains(p.Name));
            }

            if (config.OnlyIncludeProperties?.Count > 0)
            {
                properties = Array.FindAll(properties, p => config.OnlyIncludeProperties.Contains(p.Name));
            }

            return properties;
        }

        /// <summary>
        /// 数据转换配置类
        /// </summary>
        public class DataTableConfig<T> : DataTableConfig
        {
            public new Dictionary<string, string> ColumnMappings { get; } = new Dictionary<string, string>();

            /// <summary>
            /// 设置列映射（属性名 -> 列名）
            /// </summary>
            public DataTableConfig<T> MapColumn(string propertyName, string columnName)
            {
                ColumnMappings[propertyName] = columnName;
                return this;
            }

            /// <summary>
            /// 设置忽略的属性
            /// </summary>
            public new DataTableConfig<T> IgnoreProperty(params string[] propertyNames)
            {
                base.IgnoreProperty(propertyNames);
                return this;
            }

            /// <summary>
            /// 设置只包含的属性
            /// </summary>
            public new DataTableConfig<T> OnlyIncludeProperty(params string[] propertyNames)
            {
                base.OnlyIncludeProperty(propertyNames);
                return this;
            }

            /// <summary>
            /// 设置是否忽略非公共属性（默认忽略）
            /// </summary>
            public new DataTableConfig<T> SetIgnoreNonPublicProperties(bool ignore = true)
            {
                base.SetIgnoreNonPublicProperties(ignore);
                return this;
            }
        }

        /// <summary>
        /// 数据转换配置基类
        /// </summary>
        public class DataTableConfig
        {
            public HashSet<string> IgnoreProperties { get; } = new HashSet<string>();
            public HashSet<string> OnlyIncludeProperties { get; } = new HashSet<string>();
            public Dictionary<string, string> ColumnMappings { get; } = new Dictionary<string, string>();
            public bool IgnoreNonPublicProperties { get; private set; } = true;

            public DataTableConfig IgnoreProperty(params string[] propertyNames)
            {
                foreach (var name in propertyNames)
                    IgnoreProperties.Add(name);
                return this;
            }

            public DataTableConfig OnlyIncludeProperty(params string[] propertyNames)
            {
                OnlyIncludeProperties.Clear();
                foreach (var name in propertyNames)
                    OnlyIncludeProperties.Add(name);
                return this;
            }

            public DataTableConfig SetIgnoreNonPublicProperties(bool ignore = true)
            {
                IgnoreNonPublicProperties = ignore;
                return this;
            }
        }
    }







}