#nullable enable
using Furion;
using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using iWare.Wms.Core;
using iWare.Wms.Core.Util;
using iWareCommon.Utils;
using Mapster;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel;
using System.Linq.Dynamic.Core;
using System.Reflection;

namespace iWare.Wms.Application
{
    /// <summary>
    /// 字典类型服务
    /// </summary>
    [ApiDescriptionSettings(Name = "DictType", Order = 100)]
    [AllowAnonymous]
    [Route("api")]
    public class SysDictTypeService : ISysDictTypeService, IDynamicApiController, ITransient
    {
        private readonly IRepository<SysDictType> _sysDictTypeRep;  
        private readonly IRepository<SysDictData> _sysDictDataRep;  
        private readonly ISysDictDataService _sysDictDataService;
        private readonly ISysCacheService _sysCacheService;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="sysDictDataService">字典类型表服务</param>
        /// <param name="sysDictDataRep">字典数据表仓储</param>
        /// <param name="sysDictTypeRep">字典类型表仓储</param>
        /// <param name="sysCacheService"></param>
        public SysDictTypeService(ISysDictDataService sysDictDataService, IRepository<SysDictData> sysDictDataRep,
                                  IRepository<SysDictType> sysDictTypeRep, ISysCacheService sysCacheService)
        {
            _sysDictDataService = sysDictDataService;
            _sysDictDataRep = sysDictDataRep;
            _sysDictTypeRep = sysDictTypeRep;
            _sysCacheService = sysCacheService;
        }

        /// <summary>
        /// 分页查询字典类型
        /// </summary>
        /// <returns></returns>
        [HttpGet("sysDictType/page")]
        public async Task<PageResult<SysDictType>> QueryDictTypePageList([FromQuery] DictTypePageInput input)
        {
            bool supperAdmin = CurrentUserInfo.IsSuperAdmin;
            var code = !string.IsNullOrEmpty(input.Code?.Trim());
            var name = !string.IsNullOrEmpty(input.Name?.Trim());

            var c = input.Code?.Trim() ?? "";
            var n = input.Name?.Trim() ?? "";

            var dictTypes = await _sysDictTypeRep.DetachedEntities
                .Where((code, u => EF.Functions.Like(u.Code, $"%{c}%")),(name, u => EF.Functions.Like(u.Name, $"%{n}%")))
                .Where(u => (u.Status != CommonStatus.DELETED && !supperAdmin) || (u.Status <= CommonStatus.DELETED && supperAdmin))
                .OrderBy(u => u.Sort).ToADPagedListAsync(input.PageNo, input.PageSize);
            return dictTypes;
        }

        /// <summary>
        /// 获取字典类型列表
        /// </summary>
        /// <returns></returns>
        [HttpGet("sysDictType/list")]
        public async Task<List<SysDictType>> GetDictTypeList()
        {
            return await _sysDictTypeRep.DetachedEntities.Where(u => u.Status != CommonStatus.DELETED).ToListAsync();
        }

        /// <summary>
        /// 获取字典类型下所有字典值
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("sysDictType/dropDown")]
        public async Task<List<SysDictData>> GetDictTypeDropDown([FromQuery] DropDownDictTypeInput input)
        {
            var dictType = await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Code == input.Code, false);
            if (dictType == null) throw Oops.Oh(ErrorCode.D3000);
            return await _sysDictDataService.GetDictDataListByDictTypeId(dictType.Id);
        }

        /// <summary>
        /// 添加字典类型
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictType/add")]
        public async Task AddDictType(AddDictTypeInput input)
        {
            var isExist = await _sysDictTypeRep.AnyAsync(u => u.Name == input.Name || u.Code == input.Code, false);
            if (isExist) throw Oops.Oh(ErrorCode.D3001);

            var dictType = input.Adapt<SysDictType>();
            await _sysDictTypeRep.InsertAsync(dictType);
        }

        /// <summary>
        /// 删除字典类型
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictType/delete")]
        public async Task DeleteDictType(DeleteDictTypeInput input)
        {
            var dictType = await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
            if (dictType == null) throw Oops.Oh(ErrorCode.D3000);

            if (dictType.Status == CommonStatus.DELETED)
            {
                await dictType.DeleteAsync();
            }
            else
            {
                dictType.Status = CommonStatus.DELETED;
                dictType.IsDeleted = true;
            }
        }

        /// <summary>
        /// 更新字典类型
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictType/edit"),]
        public async Task UpdateDictType(UpdateDictTypeInput input)
        {
            var isExist = await _sysDictTypeRep.AnyAsync(u => u.Id == input.Id, false);
            if (!isExist) throw Oops.Oh(ErrorCode.D3000);

            // 排除自己并且判断与其他是否相同
            isExist = await _sysDictTypeRep.AnyAsync(u => (u.Name == input.Name || u.Code == input.Code) && u.Id != input.Id, false);
            if (isExist) throw Oops.Oh(ErrorCode.D3001);

            var dictType = input.Adapt<SysDictType>();
            await _sysDictTypeRep.UpdateAsync(dictType, ignoreNullValues: true);
        }

        /// <summary>
        /// 字典类型详情
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("sysDictType/detail")]
        public async Task<SysDictType> GetDictType([FromQuery] QueryDictTypeInfoInput input)
        {
            return await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Id == input.Id, false);
        }

        /// <summary>
        /// 更新字典类型状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysDictType/changeStatus")]
        public async Task ChangeDictTypeStatus(ChangeStateDictTypeInput input)
        {
            var dictType = await _sysDictTypeRep.FirstOrDefaultAsync(u => u.Id == input.Id);
            if (dictType == null) throw Oops.Oh(ErrorCode.D3000);

            if (!Enum.IsDefined(typeof(CommonStatus), input.Status))
                throw Oops.Oh(ErrorCode.D3005);

            dictType.Status = input.Status;
            dictType.IsDeleted = false;
        }

        /// <summary>
        /// 字典类型与字典值构造的字典树
        /// </summary>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("sysDictType/tree")]
        public async Task<List<DictTreeOutput>> GetDictTree()
        {
            return await _sysDictTypeRep.DetachedEntities.Select(u => new DictTreeOutput
            {
                Id = u.Id,
                Code = u.Code,
                Name = u.Name,
                Remark = u.Remark,
                Children = u.SysDictDatas.Select(c => new DictTreeOutput
                {
                    Id = c.Id,
                    Pid = c.TypeId,
                    Code = c.Code,
                    Name = c.Value
                }).ToList()
            }).ToListAsync();
        }


        /// <summary>
        /// 根据枚举类型创建数据
        /// </summary>
        /// <param name="className">枚举类型名称</param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpGet("sysDictType/parseDataFromEnumType")]
        public async Task<string> ParseDataFromEnumType([FromQuery] string className)
        {
            
            Type? type = TypeUtil.GetType(className);

            if (type == null) 
            {
                throw new Exception($"类型{className}不存在");
            }

            if(!type.IsEnum)
            {
                throw new Exception($"{className}不是枚举类型");
            }

            var lastDictType = await _sysDictTypeRep.DetachedEntities.OrderByDescending(x => x.Id).FirstOrDefaultAsync();

            var tId = lastDictType?.Id + 1 ?? 1;

            var remark = "无";

            if (type.IsDefined(typeof(DescriptionAttribute), true)) 
            {
                remark = ((DescriptionAttribute?)type.GetCustomAttribute(typeof(DescriptionAttribute), true))?.Description ?? "无";
            }

            
            var lastDictData = await _sysDictDataRep.DetachedEntities.OrderByDescending(x => x.Id).FirstOrDefaultAsync();

            var dId = lastDictData?.Id + 1 ?? 1;
            var sort = 10;
            var folder = App.Configuration["Desktop"];
            string fileName = DateTime.Now.Ticks + ".txt";

            string msgDictType = $"new SysDictType {{ Id={tId}, Name=\"{remark}\", Sort=100, Code=\"{StringUtil.ToUnderLine(type.Name)}\", Remark=\"{remark}\", Status=0, EnumClassName=\"{type.FullName}\" }},";

            FileUtil.WriteLine(folder, fileName, msgDictType);
            FileUtil.WriteLine(folder, fileName, "");


            foreach (var field in type.GetFields()) {  
                if(field.IsDefined(typeof(DescriptionAttribute), true))
                {
                    var descr = ((DescriptionAttribute?)field.GetCustomAttribute(typeof(DescriptionAttribute), true))?.Description ?? "无";

                    string msgDictData = $"new SysDictData {{ Id={dId++}, TypeId={tId}, Value=\"{descr}\", Code=\"{(int)Enum.Parse(type, field.Name)}\", Sort={sort}, Remark=\"{field.Name}\", Status=0}},";
                    FileUtil.WriteLine(folder, fileName, msgDictData);
                    sort += 10;
                }
            }
            return Path.Combine(folder, fileName);
        }

        [NonAction]
        public async Task<List<DictTreeOutput>> GetDictTreeOutput()
        {
            var dictTree = await GetDictTree();

            await _sysCacheService.SetDict(dictTree); // 缓存结果
            return dictTree;
        }
    }
}