using System.Linq.Expressions;
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.Utils.Extensions;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using SqlSugar;

namespace Dlhis.ScheduledTask.DeviceUploadLog.Services.Implements;

public class DeviceUploadLogService : IDeviceUploadLogService
{
    private readonly IDbContext _dbContext;

    public DeviceUploadLogService(IDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<Pagination<DeviceUploadLogResponse>> GetPageAsync(DeviceUploadLogPageRequest request)
    {
        var page = await _dbContext.Queryable<DeviceUploadLogEntity>()
            .WhereIF(request.SearchDateTimePeriod?.Start.HasValue == true, deviceUp => deviceUp.RaiseDateTime >= request.SearchDateTimePeriod.Start)
            .WhereIF(request.SearchDateTimePeriod?.End.HasValue == true, deviceUp => deviceUp.RaiseDateTime <= request.SearchDateTimePeriod.End)
            .OrderBy(deviceUp => deviceUp.CreateTime, OrderByType.Desc)
            .Select((deviceUp) => new DeviceUploadLogResponse
            {
                OriginUserUniqueNo = deviceUp.UserUniqueNo,
                DeviceUniqueNo = deviceUp.DeviceUniqueNo,
                Id = deviceUp.Id,
                RaiseDateTime = deviceUp.RaiseDateTime,
                SerialNo = deviceUp.SerialNo,
                //UserNo = ga.No,
                //UserCode = ga.Code,
                //UserName = ga.Name,
            })
            .ToPageListAsync(request);

        var gainfos = await _dbContext.Queryable<GainfoEntity>().ToListAsync();
        page.Data.ForEach(item =>
        {
            _ = int.TryParse(item.OriginUserUniqueNo, out var userId);

            var gainfo = gainfos.FirstOrDefault(x => x.No == item.OriginUserUniqueNo || x.Id == userId || x.Code == item.OriginUserUniqueNo);
            item.UserNo = gainfo?.No;
            item.UserCode = gainfo?.Code;
            item.UserName = gainfo?.Name;
        });

        return page;
    }

    public async Task UploadLogsAsync(List<DeviceUploadLogUploadRequest> requests)
    {
        //判断存在的记录
        Expression<Func<DeviceUploadLogEntity, bool>> where = LinqExpressionExtension.False<DeviceUploadLogEntity>();
        requests.ForEach(p =>
        {
            where = where.Or(x => x.DeviceUniqueNo == p.DeviceUniqueNo && x.SerialNo == p.SerialNo && x.RaiseDateTime == p.RaiseDateTime);
        });

        //处理冗余的请求数据
        var exists = await _dbContext.Queryable<DeviceUploadLogEntity>().Where(where).ToListAsync();
        foreach (var item in exists)
        {
            requests.RemoveAll(x => x.DeviceUniqueNo == item.DeviceUniqueNo && x.SerialNo == item.SerialNo && x.RaiseDateTime == item.RaiseDateTime);
        }

        var nos = requests.Select(x => x.DeviceUniqueNo).ToList();
        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => nos.Contains(x.UniqueNo)).ToListAsync();

        var records = requests.GroupBy(x => x.DeviceUniqueNo).SelectMany(x =>
        {
            var device = devices.FirstOrDefault(item => item.UniqueNo == x.Key);
            if (device != null)
            {
                return x.AsEnumerable().Select(item => new DeviceUploadLogEntity
                {
                    DeviceUniqueNo = x.Key,
                    UserUniqueNo = item.UserUniqueNo,
                    RaiseDateTime = item.RaiseDateTime,
                    SerialNo = item.SerialNo,
                    Type = item.Type,
                    TenantId = device.TenantId,

                }).ToList();
            }

            return null;

        }).Where(x => x != null).ToList();

        await _dbContext.InsertAsync(records);
    }

    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 = new List<DeviceUploadLogEntity>(requests.Count);
        foreach (var request in requests)
        {
            logs.Add(new DeviceUploadLogEntity
            {
                DeviceUniqueNo = request.DeviceUniqueNo,
                Type = DeviceUploadLogTypeEnumType.Raise,
                RaiseDateTime = request.Begin,
                TenantId = tenantId
            });
        }

        await _dbContext.InsertAsync(logs);
    }
}