using Admin.NET.Core;
using Furion;
using Furion.DatabaseAccessor;
using Furion.DatabaseAccessor.Extensions;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Admin.NET.Application
{
    /// <summary>
    /// 组织机构服务
    /// </summary>
    [ApiDescriptionSettings(Name = "Org", Order = 148)]
    [Route("api")]
    public class SysOrgService : ISysOrgService, IDynamicApiController, ITransient
    {
        private readonly IRepository<SysOrg> _sysOrgRep;  // 组织机构表仓储
        private readonly ISysCacheService _sysCacheService;
        private readonly ISysEmpService _sysEmpService;
        private readonly ISysEmpExtOrgPosService _sysEmpExtOrgPosService;
        private readonly ISysRoleDataScopeService _sysRoleDataScopeService;
        private readonly ISysUserDataScopeService _sysUserDataScopeService;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="sysOrgRep"></param>
        /// <param name="sysCacheService"></param>
        /// <param name="sysEmpService"></param>
        /// <param name="sysEmpExtOrgPosService"></param>
        /// <param name="sysRoleDataScopeService"></param>
        /// <param name="sysUserDataScopeService"></param>
        public SysOrgService(IRepository<SysOrg> sysOrgRep,
                             ISysCacheService sysCacheService,
                             ISysEmpService sysEmpService,
                             ISysEmpExtOrgPosService sysEmpExtOrgPosService,
                             ISysRoleDataScopeService sysRoleDataScopeService,
                             ISysUserDataScopeService sysUserDataScopeService)
        {
            _sysOrgRep = sysOrgRep;
            _sysCacheService = sysCacheService;
            _sysEmpService = sysEmpService;
            _sysEmpExtOrgPosService = sysEmpExtOrgPosService;
            _sysRoleDataScopeService = sysRoleDataScopeService;
            _sysUserDataScopeService = sysUserDataScopeService;
        }

        /// <summary>
        /// 分页查询组织机构
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("sysOrg/page")]
        public async Task<PageResult<OrgOutput>> QueryOrgPageList([FromQuery] OrgPageInput input)
        {
            var dataScopeList = GetDataScopeList(await GetUserDataScopeIdList());

            var name = !string.IsNullOrEmpty(input.Name?.Trim());
            var id = !string.IsNullOrEmpty(input.Id?.Trim());
            var pId = !string.IsNullOrEmpty(input.Pid?.Trim());
            var orgs = await _sysOrgRep.DetachedEntities
                                       .Where((name, u => EF.Functions.Like(u.Name, $"%{input.Name.Trim()}%")), // 根据机构名称模糊查询
                                              (id, u => u.Id == long.Parse(input.Id.Trim())), // 根据机构id查询
                                              (pId, u => EF.Functions.Like(u.Pids, $"%{input.Pid.Trim()}%")
                                                         || u.Id == long.Parse(input.Pid.Trim()))) // 根据父机构id查询
                                       .Where(dataScopeList.Count > 0, u => dataScopeList.Contains(u.Id)) // 非管理员范围限制
                                       .Where(u => u.Status != CommonStatus.DELETED).OrderBy(u => u.Sort)
                                       .ProjectToType<OrgOutput>()
                                       .ToADPagedListAsync(input.PageNo, input.PageSize);
            return orgs;
        }

        /// <summary>
        /// (非管理员)获取当前用户数据范围（机构Id）
        /// </summary>
        /// <param name="dataScopes"></param>
        /// <returns></returns>
        private List<long> GetDataScopeList(List<long> dataScopes)
        {
            var dataScopeList = new List<long>();
            // 如果是超级管理员则获取所有组织机构，否则只获取其数据范围的机构数据
            if (!CurrentUserInfo.IsSuperAdmin)
            {
                if (dataScopes.Count < 1)
                    return dataScopeList;

                // 此处获取所有的上级节点，用于构造完整树
                dataScopes.ForEach(u =>
                {
                    var sysOrg = _sysOrgRep.DetachedEntities.FirstOrDefault(c => c.Id == u);
                    if (sysOrg != null)
                    {
                        var parentAndChildIdListWithSelf = sysOrg.Pids.TrimEnd(',').Replace("[", "").Replace("]", "")
                                                                    .Split(",").Select(u => long.Parse(u)).ToList();
                        parentAndChildIdListWithSelf.Add(sysOrg.Id);
                        dataScopeList.AddRange(parentAndChildIdListWithSelf);
                    }
                });
            }

            return dataScopeList;
        }

        /// <summary>
        /// 获取组织机构列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("sysOrg/list")]
        public async Task<List<OrgOutput>> GetOrgList([FromQuery] OrgListInput input)
        {
            var dataScopeList = GetDataScopeList(await GetUserDataScopeIdList());

            var pId = !string.IsNullOrEmpty(input.Pid?.Trim());
            var orgs = await _sysOrgRep.DetachedEntities
                                       .Where(pId, u => u.Pid == long.Parse(input.Pid))
                                       .Where(dataScopeList.Count > 0, u => dataScopeList.Contains(u.Id))
                                       .Where(u => u.Status != CommonStatus.DELETED)
                                       .OrderBy(u => u.Sort)
                                       .ProjectToType<OrgOutput>()
                                       .ToListAsync();
            return orgs;
        }

        /// <summary>
        /// 增加组织机构
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysOrg/add")]
        public async Task AddOrg(OrgAddInput input)
        {
            var isExist = await _sysOrgRep.DetachedEntities.AnyAsync(u => u.Name == input.Name || u.Code == input.Code);
            if (isExist)
                throw Oops.Oh(ErrorCode.D2002);
            var dataScopes = await GetUserDataScopeIdList();
            if (!CurrentUserInfo.IsSuperAdmin)
            {
                // 如果新增的机构父Id不是0，则进行数据权限校验
                if (input.Pid != "0" && !string.IsNullOrEmpty(input.Pid))
                {
                    // 新增组织机构的父机构不在自己的数据范围内

                    if (dataScopes.Count < 1 || !dataScopes.Contains(long.Parse(input.Pid)))
                        throw Oops.Oh(ErrorCode.D2003);
                }
                else
                    throw Oops.Oh(ErrorCode.D2006);
            }

            var sysOrg = input.Adapt<SysOrg>();
            await FillPids(sysOrg);
            var newOrg = await _sysOrgRep.InsertNowAsync(sysOrg);
            // 当前用户不是超级管理员时，将新增的公司加到用户的数据权限
            if (!CurrentUserInfo.IsSuperAdmin)
            {
                var userId = CurrentUserInfo.UserId;
                new SysUserDataScope
                {
                    SysUserId = userId,
                    SysOrgId = newOrg.Entity.Id
                }.Insert();
                dataScopes.Add(newOrg.Entity.Id);
                await _sysCacheService.SetDataScope(userId, dataScopes); // 缓存新结果
            }
        }

        /// <summary>
        /// 填充父Ids字段
        /// </summary>
        /// <param name="sysOrg"></param>
        /// <returns></returns>
        private async Task FillPids(SysOrg sysOrg)
        {
            if (sysOrg.Pid == 0L)
            {
                sysOrg.Pids = "[" + 0 + "],";
            }
            else
            {
                var t = await _sysOrgRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == sysOrg.Pid);
                sysOrg.Pids = t.Pids + "[" + t.Id + "],";
            }
        }

        /// <summary>
        /// 删除组织机构
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysOrg/delete")]
        [UnitOfWork]
        public async Task DeleteOrg(DeleteOrgInput input)
        {
            var sysOrg = await _sysOrgRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == long.Parse(input.Id));

            // 检测数据范围能不能操作这个机构
            var dataScopes = await GetUserDataScopeIdList();
            if (!CurrentUserInfo.IsSuperAdmin && (dataScopes.Count < 1 || !dataScopes.Contains(sysOrg.Id)))
                throw Oops.Oh(ErrorCode.D2003);

            // 该机构下有员工，则不能删
            var hasOrgEmp = await _sysEmpService.HasOrgEmp(sysOrg.Id);
            if (hasOrgEmp)
                throw Oops.Oh(ErrorCode.D2004);

            // 该机构下面子机构若有员工，则不能删
            var orgIds = await _sysOrgRep.DetachedEntities.Where(u => u.Pids.Contains(input.Id)).Select(u => u.Id).ToListAsync();
            var emps = await _sysEmpService.HasOrgEmp(orgIds);
            if (emps.Count > 0)
                throw Oops.Oh(ErrorCode.D2004);

            // 该附属机构下若有员工，则不能删
            var hasExtOrgEmp = await _sysEmpExtOrgPosService.HasExtOrgEmp(sysOrg.Id);
            if (hasExtOrgEmp)
                throw Oops.Oh(ErrorCode.D2005);

            // 级联删除子节点
            var childIdList = await GetChildIdListWithSelfById(sysOrg.Id);
            var orgs = await _sysOrgRep.Where(u => childIdList.Contains(u.Id)).ToListAsync();
            await _sysOrgRep.DeleteAsync(orgs);

            // 级联删除该机构及子机构对应的角色-数据范围关联信息
            await _sysRoleDataScopeService.DeleteRoleDataScopeListByOrgIdList(childIdList);

            // 级联删除该机构子机构对应的用户-数据范围关联信息
            await _sysUserDataScopeService.DeleteUserDataScopeListByOrgIdList(childIdList);
        }

        /// <summary>
        /// 更新组织机构
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("sysOrg/edit")]
        [UnitOfWork]
        public async Task UpdateOrg(UpdateOrgInput input)
        {
            if (input.Pid != "0" && !string.IsNullOrEmpty(input.Pid))
            {
                var org = await _sysOrgRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == long.Parse(input.Pid));
                _ = org ?? throw Oops.Oh(ErrorCode.D2000);
            }
            if (input.Id == input.Pid)
                throw Oops.Oh(ErrorCode.D2001);

            // 如果是编辑，父id不能为自己的子节点
            var childIdListById = await GetChildIdListWithSelfById(long.Parse(input.Id));
            if (childIdListById.Contains(long.Parse(input.Pid)))
                throw Oops.Oh(ErrorCode.D2001);

            var sysOrg = await _sysOrgRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == long.Parse(input.Id));

            // 检测数据范围能不能操作这个机构
            var dataScopes = await GetUserDataScopeIdList();
            if (!CurrentUserInfo.IsSuperAdmin && (dataScopes.Count < 1 || !dataScopes.Contains(sysOrg.Id)))
                throw Oops.Oh(ErrorCode.D2003);

            var isExist = await _sysOrgRep.DetachedEntities.AnyAsync(u => (u.Name == input.Name || u.Code == input.Code) && u.Id != sysOrg.Id);
            if (isExist)
                throw Oops.Oh(ErrorCode.D2002);

            // 如果名称有变化，则修改对应员工的机构相关信息
            if (!sysOrg.Name.Equals(input.Name))
                await _sysEmpService.UpdateEmpOrgInfo(sysOrg.Id, sysOrg.Name);

            sysOrg = input.Adapt<SysOrg>();
            await FillPids(sysOrg);
            await sysOrg.UpdateAsync(ignoreNullValues: true);

            //// 将所有子的父id进行更新
            //childIdListById.ForEach(u=> {
            //    var child = _sysOrgRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == u.Id);
            //    var newInput = child.Adapt<UpdateOrgInput>();
            //    UpdateOrg(newInput).GetAwaiter();
            //});
        }

        /// <summary>
        /// 获取组织机构信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("sysOrg/detail")]
        public async Task<SysOrg> GetOrg([FromQuery] QueryOrgInput input)
        {
            return await _sysOrgRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == long.Parse(input.Id));
        }

        /// <summary>
        /// 根据节点Id获取所有子节点Id集合，包含自己
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        private async Task<List<long>> GetChildIdListWithSelfById(long id)
        {
            var childIdList = await _sysOrgRep.DetachedEntities
                                              .Where(u => EF.Functions.Like(u.Pids, $"%{id}%"))
                                              .Select(u => u.Id).ToListAsync();
            childIdList.Add(id);
            return childIdList;
        }

        /// <summary>
        /// 获取组织机构树
        /// </summary>
        /// <returns></returns>
        [HttpGet("sysOrg/tree")]
        public async Task<dynamic> GetOrgTree()
        {
            var dataScopeList = new List<long>();
            if (!CurrentUserInfo.IsSuperAdmin)
            {
                var dataScopes = await GetUserDataScopeIdList();
                if (dataScopes.Count < 1)
                    return dataScopeList;
                dataScopeList = GetDataScopeList(dataScopes);
            }
            var orgs = await _sysOrgRep.DetachedEntities.Where(dataScopeList.Count > 0, u => dataScopeList.Contains(u.Id))
                                                        .Where(u => u.Status == CommonStatus.ENABLE)
                                                        .OrderBy(u => u.Sort)
                                                        .ProjectToType<OrgTreeNode>()
                                                        .ToListAsync();

            return new TreeBuildUtil<OrgTreeNode>().Build(orgs);
        }

        /// <summary>
        /// 根据数据范围类型获取当前用户的数据范围（机构Id）集合
        /// </summary>
        /// <param name="dataScopeType"></param>
        /// <param name="orgId"></param>
        /// <returns></returns>
        [NonAction]
        public async Task<List<long>> GetDataScopeListByDataScopeType(int dataScopeType, long orgId)
        {
            var orgIdList = new List<long>();
            if (orgId < 0)
                return orgIdList;

            // 如果是范围类型是全部数据，则获取当前所有的组织架构Id
            if (dataScopeType == (int)DataScopeType.ALL)
            {
                orgIdList = await _sysOrgRep.DetachedEntities.Where(u => u.Status == CommonStatus.ENABLE).Select(u => u.Id).ToListAsync();
            }
            // 如果范围类型是本部门及以下部门，则查询本节点和子节点集合，包含本节点
            else if (dataScopeType == (int)DataScopeType.DEPT_WITH_CHILD)
            {
                orgIdList = await GetChildIdListWithSelfById(orgId);
            }
            // 如果数据范围是本部门，不含子节点，则直接返回本部门
            else if (dataScopeType == (int)DataScopeType.DEPT)
            {
                orgIdList.Add(orgId);
            }
            return orgIdList;
        }

        /// <summary>
        /// 获取所有的机构组织Id集合
        /// </summary>
        /// <returns></returns>
        [NonAction]
        public async Task<List<long>> GetAllDataScopeIdList()
        {
            return await _sysOrgRep.DetachedEntities.Select(u => u.Id).ToListAsync();
        }

        /// <summary>
        /// 获取用户数据范围（机构Id集合）
        /// </summary>
        /// <returns></returns>
        [NonAction]
        public async Task<List<long>> GetUserDataScopeIdList()
        {
            return await App.GetService<ISysUserService>().GetUserDataScopeIdList();
        }
    }
}