using Magicodes.ExporterAndImporter.Core;
using Magicodes.ExporterAndImporter.Excel;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using TaskManager.Entity;
using TaskManager.EntityFramework;
using TaskManager.EntityFramework.Repository;
using Wood.Util;

namespace Wood.Service.Controllers
{
    [AllowAnonymous]
    public  class NormalBaseController<T>:ControllerBase where T:BaseEntity 
    {

        protected readonly JobDbContext _context;
        protected readonly IServiceProvider _builder;
        protected readonly IConfiguration _configuration;
        protected readonly IRepository<T> _repository;

       
        public NormalBaseController(JobDbContext context, IServiceProvider builder, IConfiguration configuration, IRepository<T> repository)
        {
            _builder = builder;
            _context = context;
            _configuration = configuration;
            _repository = repository;
        }


        /// <summary>
        /// 通过UID获得实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("{id}")]
        public async Task<ActionResult<T>> GetById(int id)
        {
            var entity = await _repository.GetByIdAsync(id);
            if (entity == null) return NotFound();
            return entity;
        }

        /// <summary>
        /// 创建实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<ActionResult<T>> Create(T entity)
        {
            entity.CreationTime = DateTime.Now;
            var createdEntity = await _repository.AddAsync(entity);
            return new JsonResult(new { Code = 200, Message = "创建成功!" });
        }
        /// <summary>
        /// 更新实体UID
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPut("{id}")]
        public async Task<IActionResult> Update(T entity)
        {
            var _first = await _repository.GetByIdAsync(entity.UId);
            if (_first == null)
            {
                return new JsonResult(new { Code = 400, Message = "修改失败!" });
            }


            await _repository.UpdateAsync(entity);
            return new JsonResult(new { Code = 200, Message = "修改成功!" });
        }
        /// <summary>
        /// 删除实体通过UID
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id)
        {
            await _repository.DeleteAsync(id);
            return new JsonResult(new { Code = 200, Message = "删除成功!" }); ;
        }


        [HttpGet]
        public async Task<ActionResult<TaskManager.EntityFramework.Repository.PagedResult<T>>> GetPaged(
        [FromQuery] int pageNumber = 1,
        [FromQuery] int pageSize = 10,
        [FromQuery] string sortBy = "",
        [FromQuery] bool isAscending = true,
        [FromQuery] Dictionary<string, string> filters = null)
        {
            var pagingParams = new PagingParams
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                SortBy = sortBy,
                IsAscending = isAscending,
                Filters = filters
            };

            // 可以在这里构建表达式树过滤条件
            Expression<Func<T, bool>> filter = null;

            var pagedResult = await _repository.GetPagedAsync(filter, pagingParams);
            return Ok(pagedResult);
        }

        [HttpGet]
        public async Task<FileStreamResult> Export([FromQuery] int pageNumber = 1,
        [FromQuery] int pageSize = 10,
        [FromQuery] string sortBy = "",
        [FromQuery] bool isAscending = true,
        [FromQuery] Dictionary<string, string> filters = null) 
        {
            var pagingParams = new PagingParams
            {
                PageNumber = pageNumber,
                PageSize = pageSize,
                SortBy = sortBy,
                IsAscending = isAscending,
                Filters = filters
            };

            // 可以在这里构建表达式树过滤条件
            Expression<Func<T, bool>> filter = null;

            var pagedResult = await _repository.GetPagedAsync(null, pagingParams);

            var dataTable=pagedResult.Data.ToDataTable();



            return await ExportFile(dataTable, Guid.NewGuid().ToString() + ".xlsx");


        }
        protected async Task<FileStreamResult> ExportFile(DataTable dtos, string fileName) 
        {
            var excelExporter = HttpContext.RequestServices.GetRequiredService<IExcelExporter>();
            var res = await excelExporter.ExportAsByteArray(dtos);
            return new FileStreamResult(new MemoryStream(res), "application/octet-stream") { FileDownloadName = DateTime.Now.ToString("yyyyMMddHHmm") + "_" + fileName };
        }


        //[HttpGet]
      
        //public async Task<IActionResult> GetImportTemplate() 
        //{
        //    try
        //    {
        //        // 创建导入模板生成器
        //        var importer = new ExcelImporter();

        //        // 生成导入模板流（这里假设使用 YourModel 作为导入模型）
        //        byte[] by = await importer.GenerateTemplate<T>;
        //        using var stream = new MemoryStream(by);
        //        stream.Seek(0, SeekOrigin.Begin);

        //        // 设置友好的文件名，例如："导入模板_20250530.xlsx"
        //        var fileName = $"导入模板_{DateTime.Now:yyyyMMdd}.xlsx";

        //        // 返回文件流结果
        //        return File(
        //            fileStream: stream,
        //            contentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        //            fileDownloadName: fileName);
        //    }
        //    catch (Exception ex)
        //    {
        //        // 记录异常日志
        //        Console.WriteLine($"生成导入模板时出错: {ex.Message}");

        //        // 返回错误响应
        //        return StatusCode(500, "生成导入模板时发生错误");
        //    }
        //}





    }

    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;
            }
        }
    }
}