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.Authentication.Abstractions;
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 ICurrentUser _currentUser;

    public DeviceUploadLogService(IDbContext dbContext, ICurrentUser currentUser)
    {
        _dbContext = dbContext;
        _currentUser = currentUser;
    }

    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;
            }

            if (request.CardNo.IsPresent() && request.UserUniqueNo != request.CardNo)
            {
                //UserUniqueNo为老系统档案号(自动生成),CardNo为工号
                if (await _dbContext.Queryable<OldDeviceGainfoEntity>()
                        .Where(x => x.DeviceUniqueNo == request.DeviceUniqueNo)
                        .Where(x => x.No == request.UserUniqueNo && x.Code == request.CardNo)
                        .Select(x => x.Code)
                        .AnyAsync())
                {
                    request.UserUniqueNo = request.CardNo;
                }
            }

            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,
                Status = request.Status ?? true,
                CreatedBy = 1,
                ModifiedBy = 1,
            });
        }

        await _dbContext.InsertAsync(inserts);
    }


    public async Task<List<DeviceUploadLogResponse>> GetMyRecordsAsync(DeviceUploadLogMyRecordRequest request)
    {
        var jinkoCode = _currentUser.GetUserClaim("jinko-code") ?? string.Empty;

        return await _dbContext.Queryable<DeviceUploadLogEntity>()
            .LeftJoin<DeviceEntity>((log, d) => log.DeviceUniqueNo == d.UniqueNo)
            .Where(log => log.UserUniqueNo == jinkoCode)
            .Where(log => log.Status)
            .WhereIF(request.DateTimePeriod.HasValue(), log => log.RaiseDateTime >= request.DateTimePeriod.Start && log.RaiseDateTime <= request.DateTimePeriod.End)
            .Where((log, d) => d.Type == DeviceTypeEnumType.Attendance || (d.Type == DeviceTypeEnumType.Door && d.AsAttendance))
            .OrderBy(log => log.RaiseDateTime)
            .Select((log, d) => new DeviceUploadLogResponse
            {
                OriginUserUniqueNo = log.UserUniqueNo,
                DeviceUniqueNo = log.DeviceUniqueNo,
                Id = log.Id,
                RaiseDateTime = log.RaiseDateTime,
                CreateTime = log.CreateTime,
                SerialNo = log.SerialNo,
                DeployPlace = d.DeployPlace,
                Sync = log.Sync,
                Status = log.Status
            })
            .ToListAsync();
    }

    public async Task QiaoqiaoGaoshiqingAsync(DeviceUploadLogSecretAddRequest request)
    {
        var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.UniqueNo == request.DeviceUniqueNo).SingleAsync();

        await _dbContext.InsertAsync(new DeviceUploadLogEntity
        {
            DeviceUniqueNo = device.UniqueNo,
            UserUniqueNo = request.UserCode,
            RaiseDateTime = request.RaiseDateTime,
            SerialNo = string.Empty,
            Type = device.Type == DeviceTypeEnumType.Attendance
                ? DeviceUploadLogTypeEnumType.Attendance
                : device.Type == DeviceTypeEnumType.Door && device.AsAttendance
                    ? DeviceUploadLogTypeEnumType.Attendance
                    : DeviceUploadLogTypeEnumType.Door,

            TenantId = device.TenantId,
            Status = true,
            CreatedBy = 1,
            ModifiedBy = 1,
        });
    }

    public async Task<DateTimePeriod> GetDeviceUploadRecordSettingAsync(string deviceNo)
    {
        var start = await _dbContext.Queryable<DeviceUploadLogEntity>()
            .Where(x => x.DeviceUniqueNo == deviceNo)
            .Select(x => SqlFunc.AggregateMax(x.RaiseDateTime))
            .SingleAsync();

        //0001-01-01 00:00:00
        return new DateTimePeriod
        {
            Start = start,
            End = DateTime.Now.AddDays(1)
        };
    }

    public async Task<Pagination<DeviceUploadLogResponse>> GetPageAsync(DeviceUploadLogPageRequest request)
    {
        DeviceUploadLogTypeEnumType? type = request.Type switch
        {
            DeviceTypeEnumType.Attendance => DeviceUploadLogTypeEnumType.Attendance,
            DeviceTypeEnumType.Door => DeviceUploadLogTypeEnumType.Door,
            _ => throw new UserFriendlyException("不支持当前设备类型")
        };

        if (request.IsOutsource.HasValue && request.IsOutsource.Value)
        {
            var r = await _dbContext.Queryable<OutsourceEntity>()
                .LeftJoin<DeviceUploadLogEntity>((os, x) => os.Code == x.UserUniqueNo)
                .LeftJoin<DeviceEntity>((os, x, device) => x.DeviceUniqueNo == device.UniqueNo)
                .LeftJoin<GainfoEntity>((os, x, device, ga) => os.Code == ga.Code)
                .LeftJoin<GainfoEntity>((os, x, device, ga, gaSap) => gaSap.Code == os.SapCode)
                .WhereIF(request.SearchDateTimePeriod.HasValue(), (os, x) => x.RaiseDateTime >= request.SearchDateTimePeriod.Start
                                                                             && x.RaiseDateTime <= request.SearchDateTimePeriod.End)
                .Where((os, x) => x.Type == type)
                .WhereIF(request.Search.IsPresent(), (os, x, device, ga, gaSap) =>
                    x.UserUniqueNo == request.Search
                    || x.DeviceUniqueNo == request.Search
                    || os.Supplier == request.Search
                    || os.SapCode == request.Search
                ).OrderBy((os, x, device, ga, gaSap) => x.ModifiedTime, OrderByType.Desc)
                .Select((os, x, device, ga, gaSap) => new DeviceUploadLogResponse
                {
                    Id = x.Id,
                    OriginUserUniqueNo = x.UserUniqueNo,
                    OutsourceSupplier = os.Supplier,
                    SapUserCode = os.SapCode,
                    SapUserName = gaSap.Name,
                    DeviceUniqueNo = x.DeviceUniqueNo,
                    RaiseDateTime = x.RaiseDateTime,
                    CreateTime = x.CreateTime,
                    SerialNo = x.SerialNo,
                    UserNo = ga.No,
                    UserCode = ga.Code,
                    UserName = ga.Name,
                    DeployPlace = device.DeployPlace,
                    Sync = x.Sync,
                    Status = x.Status,
                }).ToPageListAsync(request.PageIndex, request.PageSize);

            return new Pagination<DeviceUploadLogResponse>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Total = 0,
                Data = r
            };
        }
        else
        {
            var r = await _dbContext.Queryable<DeviceUploadLogEntity>()
                .LeftJoin<DeviceEntity>((x, device) => x.DeviceUniqueNo == device.UniqueNo)
                .LeftJoin<GainfoEntity>((x, device, ga) => x.UserUniqueNo == ga.Code)
                .LeftJoin<OutsourceEntity>((x, device, ga, os) => x.UserUniqueNo == os.Code)
                .LeftJoin<GainfoEntity>((x, device, ga, os, gasap) => gasap.Code == os.SapCode)
                .WhereIF(request.SearchDateTimePeriod.HasValue(), x => x.RaiseDateTime >= request.SearchDateTimePeriod.Start
                                                                       && x.RaiseDateTime <= request.SearchDateTimePeriod.End)
                .Where((x, device) => x.Type == type && !SqlFunc.IsNullOrEmpty(x.UserUniqueNo))
                .WhereIF(request.Sync.HasValue, x => x.Sync == request.Sync)
                .WhereIF(request.IsOutsource.HasValue && request.IsOutsource.Value,
                    x => SqlFunc.Subqueryable<OutsourceEntity>().Where(p => p.Code == x.UserUniqueNo).Any())
                .WhereIF(request.IsOutsource.HasValue && !request.IsOutsource.Value,
                    x => SqlFunc.Subqueryable<OutsourceEntity>().Where(p => p.Code == x.UserUniqueNo).NotAny())
                .WhereIF(request.Search.IsPresent(), (x, device, ga, os) =>
                    x.UserUniqueNo == request.Search || x.DeviceUniqueNo == request.Search
                )
                .OrderBy(x => x.ModifiedTime, OrderByType.Desc)
                .Select((x, device, ga, os, gasap) => new DeviceUploadLogResponse
                {
                    Id = x.Id,
                    OriginUserUniqueNo = x.UserUniqueNo,
                    OutsourceSupplier = os.Supplier,
                    SapUserCode = os.SapCode,
                    SapUserName = gasap.Name,
                    DeviceUniqueNo = x.DeviceUniqueNo,
                    RaiseDateTime = x.RaiseDateTime,
                    CreateTime = x.CreateTime,
                    SerialNo = x.SerialNo,
                    UserNo = ga.No,
                    UserCode = ga.Code,
                    UserName = ga.Name,
                    DeployPlace = device.DeployPlace,
                    Sync = x.Sync,
                    Status = x.Status,
                }).ToPageListAsync(request.PageIndex, request.PageSize);

            return new Pagination<DeviceUploadLogResponse>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Total = 0,
                Data = r
            };
        }
    }
}