using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.ScheduledTask.DeviceUploadLog.Request;
using Dlhis.ScheduledTask.DeviceUploadLog.Response;
using Kurisu.AspNetCore.CustomClass;
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.ScheduledTask.DeviceUploadLog.Services.Implements;

public class DeviceUploadLogService : IDeviceUploadLogService
{
    private readonly IDbContext _dbContext;
    private readonly ILogger<DeviceUploadLogService> _logger;

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

    public async Task<Pagination<DeviceUploadLogResponse>> GetPageAsync(DeviceUploadLogPageRequest request)
    {
        DeviceUploadLogTypeEnumType? type = request.Type switch
        {
            DeviceTypeEnumType.Attendance => DeviceUploadLogTypeEnumType.Attendance,
            DeviceTypeEnumType.Door => DeviceUploadLogTypeEnumType.Door,
            _ => null
        };

        return await _dbContext.Queryable<DeviceUploadLogEntity>()
            .LeftJoin<DeviceEntity>((deviceUp, device) => deviceUp.DeviceUniqueNo == device.UniqueNo)
            .LeftJoin<GainfoEntity>((deviceUp, device, ga) => deviceUp.UserUniqueNo == ga.Code)
            .WhereIF(type.HasValue, (deviceUp, device) => deviceUp.Type == type)
            .WhereIF(request.Sync.HasValue, deviceUp => deviceUp.Sync == request.Sync)
            .WhereIF(request.SearchDateTimePeriod.HasValue(), deviceUp => deviceUp.RaiseDateTime >= request.SearchDateTimePeriod.Start && deviceUp.RaiseDateTime <= request.SearchDateTimePeriod.End)
            .WhereIF(request.IsOutSource.HasValue && request.IsOutSource.Value, deviceUp => SqlFunc.Subqueryable<OutsourceEntity>().Where(x => x.Code == deviceUp.UserUniqueNo).Any())
            .WhereIF(request.IsOutSource.HasValue && !request.IsOutSource.Value, deviceUp => SqlFunc.Subqueryable<OutsourceEntity>().Where(x => x.Code == deviceUp.UserUniqueNo).NotAny())
            .WhereIF(request.Search.IsPresent(), (deviceUp, device, ga) =>
                ga.Code == request.Search
                || ga.Name == request.Search
                || deviceUp.DeviceUniqueNo == request.Search
            )
            .OrderBy(deviceUp => deviceUp.CreateTime, OrderByType.Desc)
            .Select((deviceUp, device, ga) => new DeviceUploadLogResponse
            {
                OriginUserUniqueNo = deviceUp.UserUniqueNo,
                Supplier = device.Supplier,
                DeviceUniqueNo = deviceUp.DeviceUniqueNo,
                Id = deviceUp.Id,
                RaiseDateTime = deviceUp.RaiseDateTime,
                CreateTime = deviceUp.CreateTime,
                SerialNo = deviceUp.SerialNo,
                UserNo = ga.No,
                UserCode = ga.Code,
                UserName = ga.Name,
                DeployPlace = device.DeployPlace,
                Sync = deviceUp.Sync,
            })
            .ToPageListAsync(request);
    }

    public async Task UploadLogsAsync(List<DeviceUploadLogUploadRequest> requests)
    {
        var deviceUniqueNos = requests.Select(x => x.DeviceUniqueNo).Distinct().ToList();
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => deviceUniqueNos.Contains(x.UniqueNo)).ToListAsync();
        var existsDeviceUniqueNos = devices.Select(x => x.UniqueNo).ToList();

        var inserts = new List<DeviceUploadLogEntity>();
        foreach (var request in requests.Where(x => existsDeviceUniqueNos.Contains(x.DeviceUniqueNo)))
        {
            if (await _dbContext.Queryable<DeviceUploadLogEntity>().Where(x => x.DeviceUniqueNo == request.DeviceUniqueNo
                                                                               && x.SerialNo == request.SerialNo
                                                                               && x.RaiseDateTime == request.RaiseDateTime).AnyAsync())
            {
                continue;
            }

            var device = devices.First(x => x.UniqueNo == request.DeviceUniqueNo);

            inserts.Add(new DeviceUploadLogEntity
            {
                DeviceUniqueNo = request.DeviceUniqueNo,
                UserUniqueNo = request.UserUniqueNo,
                RaiseDateTime = request.RaiseDateTime,
                SerialNo = request.SerialNo,
                Type = device.Type == DeviceTypeEnumType.Attendance
                    ? DeviceUploadLogTypeEnumType.Attendance
                    : device.Type == DeviceTypeEnumType.Door && device.AsAttendance
                        ? DeviceUploadLogTypeEnumType.Attendance
                        : DeviceUploadLogTypeEnumType.Door,

                TenantId = device.TenantId
            });
        }

        await _dbContext.InsertAsync(inserts);
    }

    public async Task SetUploadLogsBeginDateTimeAsync(List<SetUploadLogsBeginDateTimeRequest> requests)
    {
        var uniqueNos = requests.DistinctBy(x => x.DeviceUniqueNo).Select(x => x.DeviceUniqueNo).ToList();
        var devices = await _dbContext.Queryable<DeviceEntity>()
            .Where(x => uniqueNos.Contains(x.UniqueNo))
            .Where(x => x.Type == DeviceTypeEnumType.Attendance || x.Type == DeviceTypeEnumType.Door)
            .ToListAsync();

        (uniqueNos.Count != devices.Count).ThrowIfTrue("存在非考勤和门禁的设备");

        var tenantId = devices.FirstOrDefault().TenantId;
        var logs = requests.Select(request => new DeviceUploadLogEntity
        {
            DeviceUniqueNo = request.DeviceUniqueNo,
            Type = DeviceUploadLogTypeEnumType.Raise,
            RaiseDateTime = request.Begin,
            TenantId = tenantId
        }).ToList();

        await _dbContext.InsertAsync(logs);
    }
}