using Dlhis.Basic.DataPermissions;
using Dlhis.Basic.Device.Dtos;
using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Organization.Dto;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.Entity.Sys.Entities;
using Dlhis.Entity.Sys.Enums;
using Dlhis.Sys.Api;
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.Entity;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using SqlSugar;

namespace Dlhis.Basic.Device.Services.Implements;

public class DevicePermissionService : IDevicePermissionService
{
    private readonly IDbContext _dbContext;
    private readonly IMyDataPermissionService _myDataPermissionService;
    private readonly ITenantApi _tenantApi;
    private readonly ICurrentUser _currentUser;
    private readonly ILogger<DevicePermissionService> _logger;

    public DevicePermissionService(IDbContext dbContext, IMyDataPermissionService myDataPermissionService, ITenantApi tenantApi,
        ICurrentUser currentUser, ILogger<DevicePermissionService> logger)
    {
        _dbContext = dbContext;
        _myDataPermissionService = myDataPermissionService;
        _tenantApi = tenantApi;
        _currentUser = currentUser;
        _logger = logger;
    }

    public async Task AssignAsync(DevicePermissionSaveRequest request)
    {
        await GenerateDeviceTasksAsync(async () =>
        {
            var currentTenantId = request.AssignType == AssignTypeEnumType.Department ? request.TenantId : _currentUser.GetStringTenantId();
            var role = _currentUser.GetRole();
            var isAll = role is "admin" or "tenant-admin";
            var deviceCodes = _myDataPermissionService.GetMyDeviceCodes();

            await _dbContext.IgnoreAsync<ITenantId>(async () =>
            {
                //删除当前匹配的基地权限
                var p = await _dbContext.Queryable<DevicePermissionEntity>()
                    .Where(x => x.AssignType == request.AssignType)
                    .Where(x => x.AssignValue == request.AssignValue)
                    .Where(x => x.UniqueType == request.UniqueType)
                    .WhereIF(request.UniqueType == DeviceAssignmentTypeEnumType.Device && !isAll, x => deviceCodes.Contains(x.UniqueValue))
                    .Where(x => x.Type == request.Type)
                    .Where(x => x.TenantId == currentTenantId)
                    .ToListAsync();

                await _dbContext.DeleteAsync(p);

                //保存配置的权限
                if (request.Codes.IsPresent())
                {
                    var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
                    {
                        AssignType = request.AssignType,
                        AssignValue = request.AssignValue,
                        UniqueType = request.UniqueType,
                        UniqueValue = code,
                        Type = request.Type,
                        TenantId = currentTenantId
                    }).ToList();

                    await _dbContext.InsertAsync(devicePermissions);
                }
            });
        }, null);
    }

    public async Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
    {
        await GenerateDeviceTasksAsync(async () =>
        {
            var currentTenantId = _currentUser.GetStringTenantId();

            //删除当前匹配的基地权限
            var p = await _dbContext.Queryable<DevicePermissionEntity>()
                .Where(x => x.UniqueType == request.UniqueType)
                .Where(x => x.UniqueValue == request.UniqueValue)
                .Where(x => x.AssignType == request.AssignType)
                .Where(x => x.Type == request.Type)
                .Where(x => x.TenantId == currentTenantId)
                .ToListAsync();

            await _dbContext.DeleteAsync(p);

            //保存配置的权限
            if (request.Values.IsPresent())
            {
                var gainfoNos = await _dbContext.Queryable<GainfoEntity>()
                    .Where(x => request.Values.Contains(x.Code) || request.Values.Contains(x.No) || request.Values.Contains(x.IdNo))
                    .Select(x => x.No)
                    .ToListAsync();

                (gainfoNos.Count != request.Values.Count).ThrowIfTrue("存在非当前权限访问的人员,操作禁止!");

                var devicePermissions = gainfoNos.Select(v => new DevicePermissionEntity
                {
                    UniqueType = request.UniqueType,
                    UniqueValue = request.UniqueValue,
                    AssignType = request.AssignType,
                    AssignValue = v,
                    TenantId = currentTenantId,
                    Type = request.Type
                }).ToList();

                await _dbContext.InsertAsync(devicePermissions);
            }
        }, null);
    }

    public async Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request)
    {
        var currentTenantId = request.AssignType == AssignTypeEnumType.Department ? request.TenantId : _currentUser.GetStringTenantId();
        var role = _currentUser.GetRole();
        var isAll = role is "admin" or "tenant-admin";
        var deviceCodes = _myDataPermissionService.GetMyDeviceCodes();

        return await _dbContext.Queryable<DevicePermissionEntity>()
            .WhereIF(request.TenantId.IsPresent() && request.AssignType == AssignTypeEnumType.Department, x => x.TenantId == request.TenantId)
            .Where(x => x.AssignType == request.AssignType)
            .Where(x => x.AssignValue == request.AssignValue)
            .Where(x => x.UniqueType == request.UniqueType)
            .WhereIF(request.UniqueType == DeviceAssignmentTypeEnumType.Device && !isAll, x => deviceCodes.Contains(x.UniqueValue))
            .Where(x => x.Type == request.Type)
            .Where(x => x.TenantId == currentTenantId)
            .Select(x => x.UniqueValue)
            .ToListAsync();
    }


    public async Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request)
    {
        var nos = await _dbContext.Queryable<DevicePermissionEntity>()
            .Where(x => x.UniqueType == request.UniqueType)
            .Where(x => x.UniqueValue == request.UniqueValue)
            .Where(x => x.AssignType == AssignTypeEnumType.User)
            .Where(x => x.Type == request.Type)
            .Select(x => x.AssignValue)
            .ToListAsync();

        return await _dbContext.Queryable<GainfoEntity>().Where(x => nos.Contains(x.No)).Select(x => new GainfoDto
        {
            Id = x.Id,
            Code = x.Code,
            Name = x.Name,
            Workplace = x.Workplace,
            Factory = x.Factory
        }).ToListAsync();
    }

    public async Task GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos)
    {
        var tenantId = _currentUser.GetStringTenantId();

        //获取所有人的权限
        if (userNos.IsEmpty())
            userNos = await GetPermissionUserNosAsync();

        var before = await GetAssignDeviceCodesInternalAsync(userNos);
        _logger.LogInformation("{tenant}任务前置人数{count}", tenantId, userNos.Count);

        //业务处理
        _dbContext.Client.QueryFilter.Restore();
        await func();
        _dbContext.Client.QueryFilter.ClearAndBackup<ITenantId>();

        //获取业务处理后所有人的权限
        var nextUserNos = await GetPermissionUserNosAsync();
        if (nextUserNos.Any())
            userNos = userNos.Concat(nextUserNos).Distinct().ToList();

        var current = await GetAssignDeviceCodesInternalAsync(userNos);
        _logger.LogInformation("{tenant}任务后置人数{count}", tenantId, userNos.Count);

        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Enable).ToListAsync();
        var waitAddTasks = new List<DeviceTaskEntity>();
        var waitDeleteTasks = new List<DeviceTaskEntity>();

        foreach (var userNo in userNos)
        {
            before.TryGetValue(userNo, out var beforeTenantDeviceCodes);
            beforeTenantDeviceCodes ??= new();
            current.TryGetValue(userNo, out var currentTenantDeviceCodes);
            currentTenantDeviceCodes ??= new();

            var tenants = new HashSet<string>();
            foreach (var item in beforeTenantDeviceCodes)
                tenants.Add(item.Tenant);
            foreach (var item in currentTenantDeviceCodes)
                tenants.Add(item.Tenant);

            foreach (var tenant in tenants)
            {
                var currentCodes = currentTenantDeviceCodes.FirstOrDefault(x => x.Tenant == tenant)?.Codes ?? new();
                var beforeCodes = beforeTenantDeviceCodes.FirstOrDefault(x => x.Tenant == tenant)?.Codes ?? new();

                //被删除
                var deletedItems = beforeCodes.Where(x => !currentCodes.Contains(x)).ToList();
                //新增
                var addItems = currentCodes.Where(x => !beforeCodes.Contains(x)).ToList();

                if (!deletedItems.Any() && !addItems.Any())
                {
                    continue;
                }

                var deviceCodes = devices.Where(x => deletedItems.Contains(x.Code) || addItems.Contains(x.Code)).Select(x => x.Code).ToList();
                deletedItems = deletedItems.Where(x => deviceCodes.Contains(x)).ToList();
                addItems = addItems.Where(x => deviceCodes.Contains(x)).ToList();

                //下发任务创建
                deletedItems.ForEach(x => waitDeleteTasks.Add(new DeviceTaskEntity
                {
                    DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
                    Status = DeviceTaskStatusEnumType.Wait,
                    Type = DeviceTaskEnumType.Delete,
                    CancellationId = 0,
                    DeviceType = devices.First(item => item.Code == x).Type,
                    UserNo = userNo,
                    Version = 0,
                    TenantId = tenant,
                    Source = DeviceTaskSourceEnumType.Manually
                }));

                addItems.ForEach(x => waitAddTasks.Add(new DeviceTaskEntity
                {
                    DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
                    Status = DeviceTaskStatusEnumType.Wait,
                    Type = DeviceTaskEnumType.Add,
                    DeviceType = devices.First(item => item.Code == x).Type,
                    UserNo = userNo,
                    Version = 0,
                    TenantId = tenant,
                    Source = DeviceTaskSourceEnumType.Manually
                }));
            }
        }

        _logger.LogInformation("{tenant}任务产生新增数量{addCount},删除数量:{delteCount}", tenantId, waitAddTasks.Count, waitDeleteTasks.Count);
        if (waitAddTasks.Any())
        {
            await _dbContext.InsertAsync(waitAddTasks);
        }

        if (waitDeleteTasks.Any())
        {
            await _dbContext.InsertAsync(waitDeleteTasks);
        }
    }

    public async Task<PermissionUsersInfoDto> GetPermissionUsersInfoAsync(List<string> userNos)
    {
        if (userNos.IsEmpty())
            userNos = await GetPermissionUserNosAsync();

        var permissions = await GetAssignDeviceCodesInternalAsync(userNos);

        return new PermissionUsersInfoDto
        {
            UserNos = userNos,
            PermissionInfos = permissions
        };
    }


    public async Task<int> ReGeneratePermissionUsersInfoAsync(PermissionUsersInfoDto beforeDto)
    {
        var userNos = beforeDto.UserNos;
        var before = beforeDto.PermissionInfos.ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);

        var current = await GetAssignDeviceCodesInternalAsync(userNos);

        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Enable).ToListAsync();
        var waitTasks = new List<DeviceTaskEntity>();

        foreach (var userNo in userNos)
        {
            before.TryGetValue(userNo, out var beforeTenantDeviceCodes);
            beforeTenantDeviceCodes ??= new();
            current.TryGetValue(userNo, out var currentTenantDeviceCodes);
            currentTenantDeviceCodes ??= new();

            var tenants = new HashSet<string>();
            foreach (var item in beforeTenantDeviceCodes)
                tenants.Add(item.Tenant);
            foreach (var item in currentTenantDeviceCodes)
                tenants.Add(item.Tenant);

            foreach (var tenant in tenants)
            {
                var currentCodes = currentTenantDeviceCodes.FirstOrDefault(x => x.Tenant == tenant)?.Codes ?? new();
                var beforeCodes = beforeTenantDeviceCodes.FirstOrDefault(x => x.Tenant == tenant)?.Codes ?? new();

                //被删除
                var deletedItems = beforeCodes.Where(x => !currentCodes.Contains(x)).ToList();
                //新增
                var addItems = currentCodes.Where(x => !beforeCodes.Contains(x)).ToList();

                if (!deletedItems.Any() && !addItems.Any())
                {
                    continue;
                }

                var deviceCodes = devices.Where(x => deletedItems.Contains(x.Code) || addItems.Contains(x.Code)).Select(x => x.Code).ToList();
                deletedItems = deletedItems.Where(x => deviceCodes.Contains(x)).ToList();
                addItems = addItems.Where(x => deviceCodes.Contains(x)).ToList();

                //下发任务创建
                deletedItems.ForEach(x => waitTasks.Add(new DeviceTaskEntity
                {
                    DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
                    Status = DeviceTaskStatusEnumType.Wait,
                    Type = DeviceTaskEnumType.Delete,
                    CancellationId = 0,
                    DeviceType = devices.First(item => item.Code == x).Type,
                    UserNo = userNo,
                    Version = 0,
                    TenantId = tenant,
                    Source = DeviceTaskSourceEnumType.Schedule
                }));

                addItems.ForEach(x => waitTasks.Add(new DeviceTaskEntity
                {
                    DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
                    Status = DeviceTaskStatusEnumType.Wait,
                    Type = DeviceTaskEnumType.Add,
                    DeviceType = devices.First(item => item.Code == x).Type,
                    UserNo = userNo,
                    Version = 0,
                    TenantId = tenant,
                    Source = DeviceTaskSourceEnumType.Schedule
                }));
            }
        }

        if (waitTasks.Any())
        {
            await _dbContext.InsertAsync(waitTasks);
        }

        return waitTasks.Count;
    }


    public async Task<Pagination<DeviceGainfoResponse>> GetGainfoPageByDeviceAsync(DeviceWithGainfoRequest request)
    {
        var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.UniqueNo == request.DeviceUniqueNo).SingleAsync();

        //当前设备的分组
        var groups = await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
            .Where(x => x.DeviceCode == device.Code)
            .Select(x => x.GroupCode)
            .ToListAsync();

        var permissions = await _dbContext.Queryable<DevicePermissionEntity>()
            .Where(x => (x.UniqueType == DeviceAssignmentTypeEnumType.Device && x.UniqueValue == device.Code) || (x.UniqueType == DeviceAssignmentTypeEnumType.Group && groups.Contains(x.UniqueValue)))
            .ToListAsync();

        var ids = new List<long>();
        foreach (var permission in permissions)
        {
            switch (permission.AssignType)
            {
                case AssignTypeEnumType.User:
                    ids.Add(await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == permission.AssignValue).Select(x => x.Id).SingleAsync());
                    break;
                case AssignTypeEnumType.Group:
                {
                    var code = Guid.Parse(permission.AssignValue);
                    ids.AddRange(await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.Code == code)
                        .LeftJoin<GainfoGroupRelationshipEntity>((a, b) => a.Code == b.GroupCode)
                        .LeftJoin<GainfoEntity>((a, b, c) => b.UserNo == c.No)
                        .Select((a, b, c) => c.Id).ToListAsync());
                }
                    break;
                case AssignTypeEnumType.Department:
                {
                    ids.AddRange(await _dbContext.Queryable<GainfoEntity>().Where(x => x.DepartmentNo == permission.AssignValue).Select(x => x.Id).ToListAsync());
                }
                    break;
                case AssignTypeEnumType.Tenant:
                {
                    ids.AddRange(await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == permission.AssignValue).Select(x => x.Id).ToListAsync());
                }
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        var page = await _dbContext.Queryable<GainfoEntity>()
            .Where(x => ids.Contains(x.Id))
            .WhereIF(request.Search.IsPresent(), x => x.Code == request.Search || x.Name.Contains(request.Search))
            .Select<DeviceGainfoResponse>()
            .ToPageListAsync(request);

        var userNos = page.Data.Select(x => x.No).ToList();

        var downStatus = await _dbContext.Queryable<DeviceTaskEntity>()
            .Where(x => userNos.Contains(x.UserNo))
            .Where(x => x.DeviceUniqueNo == device.UniqueNo)
            .Select(x => new
            {
                num = SqlFunc.RowNumber(SqlFunc.Desc(x.ModifiedTime), x.UserNo),
                x.UserNo,
                x.Status,
                x.ResultMessage,
                x.ModifiedTime
            }).MergeTable()
            .Where(x => x.num == 1)
            .ToListAsync();

        var tenantsResult = await _tenantApi.GetTenantsInternalAsync();
        var tenants = tenantsResult.Data;

        page.Data.ForEach(x =>
        {
            x.Workplace = tenants.FirstOrDefault(item => item.Code == x.Workplace)?.Name;
            x.Factory = tenants.FirstOrDefault(item => item.Code == x.Factory)?.Name;

            var d = downStatus.FirstOrDefault(item => item.UserNo == x.No);
            if (d == null)
            {
                return;
            }

            x.Status = d.Status;
            x.ResultMessage = d.ResultMessage;
            x.ModifiedTime = d.ModifiedTime;
        });

        return page;
    }

    public async Task GenerateDeviceTasksAsync(string userNo, DeviceTaskEnumType taskType, DeviceTaskSourceEnumType source)
    {
        var deviceCodes = await GetAssignDeviceCodesAsync(userNo);
        if (!deviceCodes.Any()) return;

        var devices = await _dbContext.Queryable<DeviceEntity>()
            .Where(x => x.Enable)
            .Where(x => deviceCodes.Contains(x.Code))
            .ToListAsync();

        var tasks = devices.Select(x => new DeviceTaskEntity
        {
            DeviceUniqueNo = x.UniqueNo,
            Status = DeviceTaskStatusEnumType.Wait,
            Type = taskType,
            DeviceType = x.Type,
            UserNo = userNo,
            CancellationId = 0,
            Priority = 0,
            Version = 0,
            TenantId = x.TenantId,
            Source = source
        }).ToList();

        await _dbContext.InsertAsync(tasks);
    }


    /// <summary>
    /// 获取用户所有设备权限
    /// </summary>
    /// <param name="userNo"></param>
    /// <returns></returns>
    public async Task<List<Guid>> GetAssignDeviceCodesAsync(string userNo)
    {
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Enable).ToListAsync();
        var deviceRegistries = await _dbContext.Queryable<DeviceRegistryEntity>().Where(x => !SqlFunc.IsNullOrEmpty(x.BusinessPlaceCode)).ToListAsync();

        var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == userNo).SingleAsync()
                     ?? await _dbContext.Queryable<GainfoEntity>().AS("GainfoLeave").Where(x => x.No == userNo).SingleAsync();

        var gainfoGroups = await _dbContext.Queryable<GainfoGroupRelationshipEntity>().ToListAsync();

        var devicePermissions = await _dbContext.Queryable<DevicePermissionEntity>().ToListAsync();
        var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
        var deviceGroupCodes = deviceGroups.Select(x => x.Code).ToList();
        var deviceRelationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().Where(x => deviceGroupCodes.Contains(x.GroupCode)).ToListAsync();
        var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();


        var isOutsource = await _dbContext.Queryable<OutsourceEntity>().AnyAsync(x => x.Code == gainfo.Code);

        var enableFactoryPermissions = await _dbContext.Queryable<FactorySettingEntity>().ToListAsync();

        var gainfoDto = new GainfoDto
        {
            Id = gainfo.Id,
            No = gainfo.No,
            Code = gainfo.Code,
            Name = gainfo.Name,
            Workplace = gainfo.Workplace,
            Factory = gainfo.Factory,
            DepartmentNo = gainfo.DepartmentNo,
            IsOutsource = isOutsource,
            EnableFactoryPermission = enableFactoryPermissions.FirstOrDefault(x => x.TenantId == gainfo.Factory)?.EnableOutsourceDown ?? true
        };

        var result = GetAssignDeviceCodesInternal(gainfoDto, gainfoGroups, devicePermissions, deviceGroups, deviceRelationships, deviceRegistries, devices, departments);
        return result.SelectMany(x => x.Codes).ToList();
    }

    //************************************************ help methods *******************************************************

    /// <summary>
    /// 获取当前基地有权限的用户
    /// </summary>
    /// <returns></returns>
    private async Task<List<string>> GetPermissionUserNosAsync()
    {
        var permissions = await _dbContext.Queryable<DevicePermissionEntity>().ToListAsync();
        //User
        var userNos = permissions.Where(x => x.AssignType == AssignTypeEnumType.User).Select(x => x.AssignValue).ToList();

        //Group
        var groupCode = permissions.Where(x => x.AssignType == AssignTypeEnumType.Group).Select(x => Guid.Parse(x.AssignValue)).ToList();
        var userNosByGroup = await _dbContext.Queryable<GainfoGroupRelationshipEntity>()
            .Where(x => groupCode.Contains(x.GroupCode))
            .Select(x => x.UserNo)
            .ToListAsync();

        //Department
        var tenantDepartmentNos = permissions.Where(x => x.AssignType == AssignTypeEnumType.Department)
            .GroupBy(x => x.TenantId)
            .ToDictionary(x => x.Key, x => x.Select(item => item.AssignValue).Distinct().ToList());
        var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();

        var gainfoByDeptWhere = LinqExpressionExtensions.False<GainfoEntity>();
        foreach ((string factory, List<string> departmentNos) in tenantDepartmentNos)
        {
            var matchDepartments = departmentNos.ToHashSet();
            departmentNos.ForEach(x => RecursionGetNextAllDepartment(x, departments, matchDepartments));

            var departmentNosToSearch = matchDepartments.ToList();

            gainfoByDeptWhere = gainfoByDeptWhere.Or(x => x.Factory == factory && departmentNosToSearch.Contains(x.DepartmentNo));
        }

        var userNosByDepartment = await _dbContext.Queryable<GainfoEntity>()
            .Where(gainfoByDeptWhere)
            .Select(x => x.No)
            .ToListAsync();


        //Tenant
        var tenants = permissions.Where(x => x.AssignType == AssignTypeEnumType.Tenant).Select(x => x.AssignValue).Distinct().ToList();
        var userNosByWerk = await _dbContext.Queryable<GainfoEntity>().Where(x => tenants.Contains(x.Factory)).Select(x => x.No).ToListAsync();

        return userNos.Concat(userNosByGroup).Concat(userNosByDepartment).Concat(userNosByWerk).Distinct().ToList();

        void RecursionGetNextAllDepartment(string current, List<DepartmentEntity> data, HashSet<string> result)
        {
            var next = data.Where(x => x.PNo == current);
            foreach (var item in next.Select(x => x.No))
            {
                result.Add(item);
                RecursionGetNextAllDepartment(item, data, result);
            }
        }
    }

    private static List<UserTenantDeviceCodeDto> GetAssignCodesInternal(
        List<DevicePermissionEntity> devicePermissions, List<DeviceGroupEntity> deviceGroups, List<DepartmentEntity> departments,
        DeviceAssignmentTypeEnumType uniqueType, AssignTypeEnumType assignType, string assignValue)
    {
        var tenantDevicePermissions = devicePermissions
            .Where(x => x.UniqueType == uniqueType)
            .Where(x => x.AssignType == assignType)
            .Where(x => x.AssignValue == assignValue)
            .GroupBy(x => x.TenantId)
            .Select(x => new UserTenantDeviceCodeDto { Tenant = x.Key, Codes = x.Select(p => p.UniqueValue).ToList() })
            .ToList();

        //处理获取设备分组的情况
        if (uniqueType == DeviceAssignmentTypeEnumType.Group)
        {
            //开始递归处理
            var tops = deviceGroups.Where(x => !x.PCode.HasValue).ToList();
            tops.ForEach(x => { DeviceGroupRecursionGetNext(x, deviceGroups, tenantDevicePermissions, tenantDevicePermissions.SelectMany(item => item.Codes).Contains(x.Code)); });
        }

        if (assignType == AssignTypeEnumType.Department)
        {
            //递归向上获取 assignValue = department.No
            var departmentNos = new List<string> { assignValue };
            DepartmentRecursionGetPNo(assignValue, departments, departmentNos);

            tenantDevicePermissions = devicePermissions
                .Where(x => x.UniqueType == uniqueType)
                .Where(x => x.AssignType == assignType)
                .Where(x => departmentNos.Contains(x.AssignValue))
                .GroupBy(x => x.TenantId)
                .Select(x => new UserTenantDeviceCodeDto { Tenant = x.Key, Codes = x.Select(p => p.UniqueValue).ToList() })
                .ToList();
        }

        return tenantDevicePermissions.GroupBy(x => x.Tenant).Select(x =>
        {
            var tenant = x.Key;

            return new UserTenantDeviceCodeDto
            {
                Tenant = tenant,
                Codes = x.SelectMany(item => item.Codes).ToList()
            };
        }).ToList();

        void DeviceGroupRecursionGetNext(DeviceGroupEntity current, List<DeviceGroupEntity> currentDeviceGroups, List<UserTenantDeviceCodeDto> result, bool add)
        {
            var next = currentDeviceGroups.Where(x => x.PCode == current.Code).ToList();
            foreach (var item in next)
            {
                if (add)
                {
                    result.Add(new UserTenantDeviceCodeDto { Tenant = item.TenantId, Codes = new List<Guid> { item.Code } });
                }

                DeviceGroupRecursionGetNext(item, currentDeviceGroups, result, result.SelectMany(x => x.Codes).Contains(item.Code));
            }
        }

        void DepartmentRecursionGetPNo(string current, List<DepartmentEntity> data, List<string> result)
        {
            var p = data.FirstOrDefault(x => x.No == current)?.PNo;
            if (!p.IsPresent())
            {
                return;
            }

            result.Add(p);
            DepartmentRecursionGetPNo(p, data, result);
        }
    }

    private async Task<Dictionary<string, List<UserTenantDeviceCodeDto>>> GetAssignDeviceCodesInternalAsync(List<string> userNos)
    {
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Enable).ToListAsync();
        var deviceUniqueNos = devices.Select(x => x.UniqueNo).ToList();
        var registries = await _dbContext.Queryable<DeviceRegistryEntity>()
            .Where(x => deviceUniqueNos.Contains(x.DeviceUniqueNo))
            .Where(x => !SqlFunc.IsNullOrEmpty(x.BusinessPlaceCode))
            .ToListAsync();

        var gainfos = await _dbContext.Queryable<GainfoEntity>().Where(x => userNos.Contains(x.No)).ToListAsync();
        if (!gainfos.Any())
        {
            return new Dictionary<string, List<UserTenantDeviceCodeDto>>();
        }

        var outsourceCodes = await _dbContext.Queryable<GainfoEntity>()
            .Where(x => userNos.Contains(x.No))
            .Where(x => SqlFunc.Subqueryable<OutsourceEntity>().Where(p => p.Code == x.Code).Any())
            .Select(x => x.Code)
            .ToListAsync();

        var enableFactoryPermissions = await _dbContext.Queryable<FactorySettingEntity>().ToListAsync();

        var gainfoGroupRelationships = await _dbContext.Queryable<GainfoGroupRelationshipEntity>().Where(x => userNos.Contains(x.UserNo)).ToListAsync();
        var devicePermissions = await _dbContext.Queryable<DevicePermissionEntity>().ToListAsync();
        var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
        var deviceRelationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().ToListAsync();
        var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();

        var result = new Dictionary<string, List<UserTenantDeviceCodeDto>>(gainfos.Count, StringComparer.OrdinalIgnoreCase);
        foreach (var gainfo in gainfos)
        {
            var gainfoDto = new GainfoDto
            {
                Id = gainfo.Id,
                No = gainfo.No,
                Code = gainfo.Code,
                Name = gainfo.Name,
                Workplace = gainfo.Workplace,
                Factory = gainfo.Factory,
                DepartmentNo = gainfo.DepartmentNo,
                IsOutsource = outsourceCodes.Any(x => x == gainfo.Code),
                EnableFactoryPermission = enableFactoryPermissions.FirstOrDefault(x => x.TenantId == gainfo.Factory)?.EnableOutsourceDown ?? true
            };

            var codes = GetAssignDeviceCodesInternal(gainfoDto, gainfoGroupRelationships, devicePermissions, deviceGroups, deviceRelationships, registries, devices, departments);
            result.Add(gainfo.No, codes);
        }

        return result;
    }

    private static List<UserTenantDeviceCodeDto> GetAssignDeviceCodesInternal(
        GainfoDto gainfo,
        List<GainfoGroupRelationshipEntity> gainfoGroupRelationships,
        List<DevicePermissionEntity> devicePermissions,
        List<DeviceGroupEntity> deviceGroups,
        List<DeviceGroupRelationshipEntity> deviceGroupRelationships,
        List<DeviceRegistryEntity> deviceRegistries,
        List<DeviceEntity> devices, List<DepartmentEntity> departments)
    {
        if (gainfo.IsOutsource)
        {
            //外包人员只允许门禁
            devices = devices.Where(x => x.Type == DeviceTypeEnumType.Door).ToList();
        }

        var userNo = gainfo.No;

        var deviceDtos = new List<UserTenantDeviceCodeDto>();
        var deviceGroupDtos = new List<UserTenantDeviceCodeDto>();
        var businessPlaceDtos = new List<UserTenantDeviceCodeDto>();

        //获取人员的分组,跨基地
        var gainfoGroups = gainfoGroupRelationships.Where(x => x.UserNo == userNo).Select(x => x.GroupCode).ToList();

        //按用户
        var du = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.User, userNo);
        var gu = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.User, userNo);
        var pu = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.BusinessPlace, AssignTypeEnumType.User, userNo);

        deviceDtos.AddRange(du);
        deviceGroupDtos.AddRange(gu);
        businessPlaceDtos.AddRange(pu);

        //按用户组
        foreach (var groupCode in gainfoGroups)
        {
            var dg = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.Group, groupCode.ToString());
            var gg = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.Group, groupCode.ToString());
            var pg = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.BusinessPlace, AssignTypeEnumType.Group, groupCode.ToString());
            deviceDtos.AddRange(dg);
            deviceGroupDtos.AddRange(gg);
            businessPlaceDtos.AddRange(pg);
        }

        //按部门
        var gainfoFactoryDevicePermissions = devicePermissions.Where(x => x.TenantId == gainfo.Factory).ToList();
        var dd = GetAssignCodesInternal(gainfoFactoryDevicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.Department, gainfo.DepartmentNo);
        var gd = GetAssignCodesInternal(gainfoFactoryDevicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.Department, gainfo.DepartmentNo);
        var pd = GetAssignCodesInternal(gainfoFactoryDevicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.BusinessPlace, AssignTypeEnumType.Department, gainfo.DepartmentNo);
        deviceDtos.AddRange(dd);
        deviceGroupDtos.AddRange(gd);
        businessPlaceDtos.AddRange(pd);

        //按厂区
        if (!gainfo.IsOutsource || gainfo.EnableFactoryPermission)
        {
            var dt = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Device, AssignTypeEnumType.Tenant, gainfo.Factory);
            var gt = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.Group, AssignTypeEnumType.Tenant, gainfo.Factory);
            var pt = GetAssignCodesInternal(devicePermissions, deviceGroups, departments, DeviceAssignmentTypeEnumType.BusinessPlace, AssignTypeEnumType.Tenant, gainfo.Factory);
            deviceDtos.AddRange(dt);
            deviceGroupDtos.AddRange(gt);
            businessPlaceDtos.AddRange(pt);
        }

        var deviceGroupCodes = deviceGroupDtos.SelectMany(x => x.Codes).Distinct().ToList();
        var businessPlaceCodes = businessPlaceDtos.SelectMany(x => x.Codes).Distinct().ToList();

        var deviceCodesByGroup = deviceGroupRelationships.Where(x => deviceGroupCodes.Contains(x.GroupCode))
            .GroupBy(x => x.TenantId)
            .Select(x => new UserTenantDeviceCodeDto
            {
                Tenant = x.Key,
                Codes = x.Select(item => item.DeviceCode).Distinct().ToList()
            });

        var placeGroup = deviceRegistries.Where(x => businessPlaceCodes.Contains(x.BusinessPlaceCode!.Value))
            .GroupBy(x => x.TenantId)
            .Select(x =>
            {
                var currentDeviceUniqueNos = x.Select(item => item.DeviceUniqueNo).ToList();

                return new UserTenantDeviceCodeDto
                {
                    Tenant = x.Key,
                    Codes = devices.Where(d => currentDeviceUniqueNos.Contains(d.UniqueNo)).Select(d => d.Code).Distinct().ToList()
                };
            }).ToList();

        deviceDtos.AddRange(deviceCodesByGroup);
        deviceDtos.AddRange(placeGroup);

        return deviceDtos.GroupBy(x => x.Tenant).Select(x =>
        {
            var dto = new UserTenantDeviceCodeDto
            {
                Tenant = x.Key,
                Codes = x.SelectMany(item => item.Codes).Distinct().ToList()
            };

            dto.Codes = dto.Codes.Where(p => devices.Any(item => item.Code == p)).ToList();

            return dto;
        }).ToList();
    }
}