using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Response;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Kurisu.AspNetCore.DataAccess.Dto;
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 DevicePermissionManuallyService : IDevicePermissionManuallyService
{
    private readonly IDbContext _dbContext;
    private readonly ILogger<DevicePermissionManuallyService> _logger;

    public DevicePermissionManuallyService(IDbContext dbContext, ILogger<DevicePermissionManuallyService> logger)
    {
        _dbContext = dbContext;
        _logger = logger;
    }

    /// <inheritdoc />
    public async Task<Pagination<DevicePermissionManuallyResponse>> GetPageAsync(DevicePermissionManuallyRequest requestDto)
    {
        var query = _dbContext.Queryable<DevicePermissionManuallyEntity>()
            .LeftJoin<DeviceEntity>((x, d) => x.DeviceCode == d.Code)
            .LeftJoin<GainfoEntity>((x, d, g) => x.UserNo == g.No)
            .WhereIF(requestDto.Search.IsPresent(), (x, d, g) => g.Code == requestDto.Search || g.Name.Contains(requestDto.Search))
            .WhereIF(requestDto.Type.HasValue, (x, d, g) => d.Type == requestDto.Type)
            .Where(x => SqlFunc.Subqueryable<GainfoEntity>().Where(p => p.No == x.UserNo).Any())
            .Select((x, d, g) => new DevicePermissionManuallyResponse
            {
                Id = x.Id,
                DeviceCode = x.DeviceCode,
                DeviceUniqueNo = d.UniqueNo,
                DeployPlace = d.DeployPlace,
                UserNo = x.UserNo,
                UserName = g.Code + " " + g.Name,
                Type = d.Type,
                ValidDateTime = x.ValidDateTime
            });

        return await query.ToPageListAsync(requestDto);
    }

    /// <inheritdoc />
    public async Task AddAsync(DevicePermissionManuallyAddRequest request)
    {
        var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Code == request.DeviceCode).SingleAsync();
        device.ThrowIfNull("设备不存在");

        var gainfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == request.UserNo).SingleAsync();
        gainfo.ThrowIfNull("人员不存在");
        //var types = new List<GainfoUserTypeEnumType> { GainfoUserTypeEnumType.Normal, GainfoUserTypeEnumType.SecurityWhite };
        //types.Contains(gainfo.Type).ThrowIfFalse($"人员类型为:{gainfo.Type.GetDescription()},无法分配");

        await _dbContext.InsertAsync(new DevicePermissionManuallyEntity
        {
            DeviceCode = request.DeviceCode,
            UserNo = request.UserNo,
            ValidDateTime = request.ValidDateTime,
        });

        await _dbContext.InsertAsync(new DeviceTaskEntity
        {
            Type = DeviceTaskEnumType.Add,
            DeviceType = device.Type,
            UserId = null,
            UserNo = request.UserNo,
            DeviceUniqueNo = device.UniqueNo,
            Status = DeviceTaskStatusEnumType.Wait,
            Version = 0,
            ResultMessage = null,
            Source = "手动分配额外权限",
            Priority = 0,
            TenantId = device.TenantId
        });
    }

    /// <inheritdoc />
    public async Task DeleteAsync(long id)
    {
        await DeleteAsync(new List<long> { id });
    }

    public async Task DeleteAsync(List<long> ids)
    {
        var data = await _dbContext.Queryable<DevicePermissionManuallyEntity>().Where(x => ids.Contains(x.Id)).ToListAsync();
        await DeleteAsync(data);
    }


    public async Task ClearUserDeviceManuallyPermissionsAsync(string userNo)
    {
        var userInfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == userNo).Select(x => new { x.Id, x.No }).SingleAsync()
                       ?? await _dbContext.Queryable<GainfoLeaveEntity>().Where(x => x.No == userNo).Select(x => new { Id = (long)x.IdentityUserId, x.No }).SingleAsync();
        userInfo.ThrowIfNull($"{userNo}不存在");
        var data = await _dbContext.Queryable<DevicePermissionManuallyEntity>().Where(x => x.UserNo == userInfo.No).ToListAsync();

        if (data.Count > 0)
        {
            await DeleteAsync(data);
        }
    }

    private async Task DeleteAsync(List<DevicePermissionManuallyEntity> data)
    {
        var deviceCodes = data.Select(x => x.DeviceCode).Distinct().ToList();
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => deviceCodes.Contains(x.Code)).ToListAsync();

        foreach (var item in data)
        {
            var userInfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == item.UserNo).Select(x => new { x.Id, x.No }).SingleAsync()
                           ?? await _dbContext.Queryable<GainfoLeaveEntity>().Where(x => x.No == item.UserNo).Select(x => new { Id = (long)x.IdentityUserId, x.No }).SingleAsync();

            if (userInfo != null)
            {
                var device = devices.FirstOrDefault(x => x.Code == item.DeviceCode);
                if (device != null)
                {
                    await _dbContext.InsertAsync(new DeviceTaskEntity
                    {
                        Type = DeviceTaskEnumType.Delete,
                        DeviceType = device.Type,
                        UserId = userInfo.Id,
                        UserNo = userInfo.No,
                        DeviceUniqueNo = device.UniqueNo,
                        Status = DeviceTaskStatusEnumType.Wait,
                        Version = 0,
                        ResultMessage = null,
                        Source = "手动分配额外权限",
                        Priority = 0,
                        TenantId = device.TenantId
                    });
                }
            }

            await _dbContext.DeleteAsync(item);
        }
    }


    /// <inheritdoc />
    public async Task ClearAllDevicePermissions(string factory, string userCode)
    {
        var userInfo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == userCode).Select(x => new { x.Id, x.No }).SingleAsync()
                       ?? await _dbContext.Queryable<GainfoLeaveEntity>().Where(x => x.Code == userCode).Select(x => new { Id = (long)x.IdentityUserId, x.No }).SingleAsync();
        userInfo.ThrowIfNull($"{userCode}不存在");
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.TenantId == factory).ToListAsync();

        var data = devices.Select(x => new DeviceTaskEntity
        {
            Type = DeviceTaskEnumType.Delete,
            DeviceType = x.Type,
            UserId = userInfo.Id,
            UserNo = userInfo.No,
            DeviceUniqueNo = x.UniqueNo,
            Status = DeviceTaskStatusEnumType.Wait,
            Version = 0,
            ResultMessage = null,
            Source = "手动删除处理",
            Priority = 0,
            TenantId = x.TenantId
        }).ToList();

        await _dbContext.InsertAsync(data);
    }
}