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

namespace Dlhis.Basic.Device.Services.Implements;

public class DeviceGroupService : IDeviceGroupService
{
    private readonly IDbContext _dbContext;
    private readonly ICurrentUser _currentUser;
    private readonly IDevicePermissionAnalyzeService _devicePermissionAnalyzeService;
    private readonly ITenantApi _tenantApi;

    public DeviceGroupService(IDbContext dbContext,
        ICurrentUser currentUser,
        IDevicePermissionAnalyzeService devicePermissionAnalyzeService,
        ITenantApi tenantApi)
    {
        _dbContext = dbContext;
        _currentUser = currentUser;
        _devicePermissionAnalyzeService = devicePermissionAnalyzeService;
        _tenantApi = tenantApi;
    }


    public async Task<List<DeviceGroupTreeResponse>> GetTreeAsync(DeviceTypeEnumType type)
    {
        var tenants = await _tenantApi.GetMyTenantsAsync();
        var tenantIds = tenants.Select(x => x.Code).ToList();
        tenantIds.AddRange(tenants.Select(x => x.PCode));

        var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>()
            .Where(x => tenantIds.Contains(x.TenantId))
            .Where(x => x.Type == type)
            .Select<DeviceGroupTreeResponse>()
            .ToListAsync();

        var others = await _dbContext.Client.Queryable<DeviceGroupEntity>()
            .Where(x => x.Type == type)
            .Where(x => x.Name == "*共用区域" || x.Name == "*非共用区域" || x.Name == "*通用考勤设备组" || x.Name == "*专用考勤设备组")
            .Select<DeviceGroupTreeResponse>()
            .ToListAsync();

        deviceGroups.AddRange(others);

        var tops = deviceGroups.Where(x => !x.PCode.HasValue).ToList();
        tops.ForEach(x => { RecursionGetNext(x, deviceGroups); });

        return tops;
    }

    public async Task SaveAsync(DeviceGroupSaveRequest request)
    {
        //检查父级节点
        await CheckPCodeAsync(request);

        if (!request.Id.HasValue)
        {
            var entity = request.Adapt<DeviceGroupEntity>();
            entity.Code = Guid.NewGuid();
            entity.TenantId = _currentUser.GetStringTenantId();

            await _dbContext.InsertAsync(entity);
        }
        else
        {
            var entity = await _dbContext.Queryable<DeviceGroupEntity>().Where(x => x.Id == request.Id).FirstAsync();
            entity.ThrowIfNull("设备分组不存在,无法更新");
            entity.Editable.ThrowIfFalse("不可编辑当前分组");

            if (entity.AsAppointment && request.AsAppointment == false)
            {
                (await _dbContext.Queryable<AppointmentAreaAssignmentEntity>()
                        .Where(x => x.DeviceGroupCode == entity.Code)
                        .AnyAsync()
                    ).ThrowIfTrue("该访客组已被分配,无法取消");
            }

            if (request.Type != entity.Type)
            {
                //检查下级分组type不一致
                var existsDiffNextGroups = await _dbContext.Queryable<DeviceGroupEntity>()
                    .Where(x => x.PCode == entity.Code)
                    .Where(x => x.Type != request.Type)
                    .AnyAsync();

                existsDiffNextGroups.ThrowIfTrue("存在下级分组类型不一致,无法修改");

                var nextDevices = await GetDevicesByGroupCodeAsync(entity.Code);
                nextDevices.Any(x => x.Type != request.Type).ThrowIfTrue("分组设备类型不匹配,无法修改类型");
            }

            request.Adapt(entity);
            await _dbContext.UpdateAsync(entity);
        }
    }


    public async Task<DevicePermissionAssignResponse> AssignDevicesAsync(DeviceAssignRequest request)
    {
        var group = await _dbContext.Queryable<DeviceGroupEntity>().Where(x => x.Code == request.GroupCode).SingleAsync();
        group.ThrowIfNull("设备分组不存在,无法进行分配");

        await CheckNoNextGroupAsync(group.Code);
        await CheckGroupTypeMatchAsync(request, group);
        await CheckAssignToTenantAsync(group, request.DeviceCodes);

        var relationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().Where(x => x.GroupCode == request.GroupCode).ToListAsync();

        var r = await PermissionResetAsync(request.GroupCode, relationships.Select(x => x.DeviceCode).Distinct().ToList(), request.DeviceCodes);

        await _dbContext.DeleteAsync(relationships);
        var entities = request.DeviceCodes.Select(x => new DeviceGroupRelationshipEntity
        {
            GroupCode = request.GroupCode,
            DeviceCode = x,

            TenantId = _currentUser.GetStringTenantId(),
        }).ToList();

        await _dbContext.InsertAsync(entities);

        return r;
    }

    private async Task CheckAssignToTenantAsync(DeviceGroupEntity group, List<Guid> deviceCodes)
    {
        if (await _dbContext.Queryable<DevicePermissionEntity>()
                .Where(x => x.AssignType == AssignTypeEnumType.Tenant)
                .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
                .Where(x => x.UniqueValue == group.Code)
                .AnyAsync())
        {
            (await _dbContext.Queryable<DevicePermissionEntity>()
                .Where(x => x.AssignType != AssignTypeEnumType.Tenant)
                .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Device)
                .Where(x => deviceCodes.Contains(x.UniqueValue))
                .AnyAsync()).ThrowIfTrue("无法分配设备到该设备组:设备组已分配到厂区并且存在设备已分配到其他类型");
        }
        else
        {
            //当前组没有tenant级别

            var currentAssignedToOthers = await _dbContext.Queryable<DevicePermissionEntity>()
                .Where(x => x.AssignType != AssignTypeEnumType.Tenant)
                .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
                .Where(x => x.UniqueValue == group.Code)
                .AnyAsync();

            var groupCodes = await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
                .Where(x => deviceCodes.Contains(x.DeviceCode))
                .Select(x => x.GroupCode).Distinct()
                .ToListAsync();

            if (groupCodes.Any())
            {
                if (await _dbContext.Queryable<DevicePermissionEntity>()
                        .Where(x => x.AssignType == AssignTypeEnumType.Tenant)
                        .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
                        .Where(x => groupCodes.Contains(x.UniqueValue))
                        .AnyAsync() && currentAssignedToOthers)
                {
                    true.ThrowIfTrue("存在设备所在的分组已分配到厂区级别,但当前分组存在其他级别的分配");
                }
            }
        }
    }


    private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode, List<Guid> beforeDeviceCodes, List<Guid> presentDeviceCodes)
    {
        var codesToAdd = presentDeviceCodes.Except(beforeDeviceCodes).ToList();
        var codesToDelete = beforeDeviceCodes.Except(presentDeviceCodes).ToList();
        if (codesToAdd.IsEmpty() && codesToDelete.IsEmpty())
        {
            return new DevicePermissionAssignResponse(0, 0);
        }

        var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
        var deviceGroupCodes = RecursionHelper.HandlerDeviceGroupPreviousCodes(groupCode, deviceGroups);

        var dps = await _dbContext.Queryable<DevicePermissionEntity>()
            .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
            .Where(x => deviceGroupCodes.Contains(x.UniqueValue))
            .ToListAsync();

        if (dps.IsEmpty())
        {
            return new DevicePermissionAssignResponse(0, 0);
        }

        var gainfoNos = await GetPermissionUserNosAsync(dps);

        var userTenantDeviceCodes = codesToDelete.IsPresent() && dps.Exists(x => x.AssignType != AssignTypeEnumType.Tenant)
            ? await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(gainfoNos)
            : new Dictionary<string, List<TenantAssignTypeDeviceCode>>();


        var devicesToAdd = await _dbContext.Queryable<DeviceEntity>().Where(x => codesToAdd.Contains(x.Code)).ToListAsync();
        var devicesToDelete = await _dbContext.Queryable<DeviceEntity>().Where(x => codesToDelete.Contains(x.Code)).ToListAsync();

        var tasksToAdd = new List<DeviceTaskEntity>();
        var tasksToDelete = new List<DeviceTaskEntity>();
        foreach (var gainfoNo in gainfoNos)
        {
            tasksToAdd.AddRange(devicesToAdd.Select(x => new DeviceTaskEntity
            {
                Type = DeviceTaskEnumType.Add,
                DeviceType = x.Type,
                UserId = null,
                UserNo = gainfoNo,
                DeviceUniqueNo = x.UniqueNo,
                Status = DeviceTaskStatusEnumType.Wait,
                Version = 0,
                ResultMessage = null,
                Source = "设备组-设备",
                Priority = 0,
                TenantId = x.TenantId
            }).ToList());

            if (userTenantDeviceCodes.TryGetValue(gainfoNo, out var permissions))
            {
                foreach (var permission in permissions)
                {
                    permission.AssignTypes = permission.AssignTypes.Where(p =>
                    {
                        if (p.UniqueType == DeviceAssignmentTypeEnumType.Device)
                        {
                            return true;
                        }

                        return p.OriginalCodes.IsPresent() && p.OriginalCodes.First() != groupCode;
                    }).ToList();
                }

                var myDeviceCodes = permissions.SelectMany(x => x.AssignTypes.SelectMany(p => p.Codes)).ToList();
                var currentDevicesToDelete = devicesToDelete.Where(p => devicesToDelete.Select(x => x.Code).Except(myDeviceCodes).Contains(p.Code)).ToList();

                tasksToDelete.AddRange(currentDevicesToDelete.Select(x => new DeviceTaskEntity
                {
                    Type = DeviceTaskEnumType.Delete,
                    DeviceType = x.Type,
                    UserId = null,
                    UserNo = gainfoNo,
                    DeviceUniqueNo = x.UniqueNo,
                    Status = DeviceTaskStatusEnumType.Wait,
                    Version = 0,
                    ResultMessage = null,
                    Source = "设备组-设备",
                    Priority = 0,
                    TenantId = x.TenantId
                }).ToList());
            }
        }

        await _dbContext.InsertAsync(tasksToAdd);
        await _dbContext.InsertAsync(tasksToDelete);

        return new DevicePermissionAssignResponse(tasksToAdd.Count, tasksToDelete.Count);
    }

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

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

        //Department
        var tenantDepartmentNos = permissions.Where(x => x.AssignType == AssignTypeEnumType.Department)
            .Where(x => x.AssignValue.Contains(':'))
            .Select(x =>
            {
                var arr = x.AssignValue.Split(':');
                return new
                {
                    Factory = arr[0], DepartmentNo = arr[1]
                };
            })
            .GroupBy(x => x.Factory)
            .ToDictionary(x => x.Key, x => x.Select(p => p.DepartmentNo).Distinct().ToList());

        var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();

        var gainfoByDeptWhere = LinqExpressionExtensions.False<GainfoEntity>();
        foreach ((string factory, List<string> departmentNos) in tenantDepartmentNos)
        {
            var departmentNosToSearch = new List<string>();
            foreach (var d in departmentNos)
            {
                departmentNosToSearch.AddRange(RecursionHelper.HandlerDepartmentNextCodes(d, departments));
            }

            departmentNosToSearch = departmentNosToSearch.Distinct().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 => x.Type != GainfoUserTypeEnumType.External)
            .Where(x => tenants.Contains(x.Factory))
            .Select(x => x.No).ToListAsync();

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


    public async Task<List<DeviceUnderGroupResponse>> GetDevicesByGroupCodeAsync(Guid code)
    {
        var relationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
            .Where(x => x.GroupCode == code)
            .ToListAsync();

        var deviceCodes = relationships.Select(x => x.DeviceCode);

        return await _dbContext.Queryable<DeviceEntity>()
            .LeftJoin<DeviceTemplateEntity>((x, dt) => x.TemplateCode == dt.Code)
            .Where(x => deviceCodes.Contains(x.Code))
            .Select((x, dt) => new DeviceUnderGroupResponse
            {
                UniqueNo = x.UniqueNo,
                Type = x.Type,
                Code = x.Code,
                Enable = x.Enable,
                Brand = dt.Brand,
                DeployPlace = x.DeployPlace,
                ConnectionInfo = x.ConnectionInfo,
            })
            .ToListAsync();
    }


    public async Task<List<DeviceGroupResponse>> GetAppointmentGroupsAsync()
    {
        return await _dbContext.Queryable<DeviceGroupEntity>()
            .Where(x => x.AsAppointment)
            .Where(x => x.Type == DeviceTypeEnumType.Door)
            .Select(x => new DeviceGroupResponse
            {
                Id = x.Id,
                Code = x.Code,
                Name = x.Name,
            })
            .ToListAsync();
    }

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

    /// <summary>
    /// 检查父级分组
    /// </summary>
    /// <param name="request"></param>
    /// <returns></returns>
    private async Task CheckPCodeAsync(DeviceGroupSaveRequest request)
    {
        var pGrp = await _dbContext.Queryable<DeviceGroupEntity>().Where(x => x.Code == request.PCode).FirstAsync();
        if (pGrp != null)
        {
            (!pGrp.AbleSetNext && !request.Id.HasValue).ThrowIfTrue($"{pGrp.Name}不可添加下级");
            var exists = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().Where(x => x.GroupCode == request.PCode).AnyAsync();
            exists.ThrowIfTrue("上级分组存在设备");
        }

        (pGrp != null && pGrp.Type != request.Type).ThrowIfTrue("分组类型必须与上级类型保持一致");
    }

    /// <summary>
    /// 检查分组是否存在下级
    /// </summary>
    /// <param name="currentCode"></param>
    /// <returns></returns>
    private async Task CheckNoNextGroupAsync(Guid currentCode)
    {
        var exists = await _dbContext.Queryable<DeviceGroupEntity>().Where(x => x.PCode == currentCode).AnyAsync();
        exists.ThrowIfTrue("存在下级设备分组,无法分配设备");
    }

    /// <summary>
    /// 检查分组分类匹配
    /// </summary>
    /// <param name="request"></param>
    /// <param name="group"></param>
    /// <returns></returns>
    private async Task CheckGroupTypeMatchAsync(DeviceAssignRequest request, DeviceGroupEntity group)
    {
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => request.DeviceCodes.Contains(x.Code)).ToListAsync();
        //检查分组的分类控制
        devices.Any(x => x.Type != group.Type).ThrowIfTrue($"存在设备类型不一致,无法分配到当前{group.Type.GetDescription()}分组");

        //重新赋值到请求参数中
        request.DeviceCodes = devices.Select(x => x.Code).ToList();
    }


    /// <summary>
    /// 递归获取树
    /// </summary>
    /// <param name="current"></param>
    /// <param name="deviceGroups"></param>
    private static void RecursionGetNext(DeviceGroupTreeResponse current, List<DeviceGroupTreeResponse> deviceGroups)
    {
        var next = deviceGroups.Where(x => x.PCode == current.Code).ToList();

        current.Next = next;
        foreach (var item in next)
        {
            RecursionGetNext(item, deviceGroups);
        }
    }
}