using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.ScheduledTask.TaskAssignment.Request;
using Dlhis.ScheduledTask.TaskAssignment.Response;
using Kurisu.AspNetCore.Utils.Extensions;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.Options;
using SqlSugar;
using Newtonsoft.Json.Linq;
using Kurisu.AspNetCore;
using Kurisu.AspNetCore.Utils;
using Dlhis.ScheduledTask.TaskAssignment.Dto;
using Kurisu.AspNetCore.CustomClass;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;

namespace Dlhis.ScheduledTask.TaskAssignment.Services.Implements;

public class AssignmentService : IAssignmentService
{
    private readonly IDbContext _dbContext;
    private readonly IDataProtectionProvider _dataProtectionProvider;
    private readonly FaceUrlOptions _faceUrlOptions;

    public AssignmentService(IDbContext dbContext,
        IDataProtectionProvider dataProtectionProvider,
        IOptions<FaceUrlOptions> options)
    {
        _dbContext = dbContext;
        _dataProtectionProvider = dataProtectionProvider;
        _faceUrlOptions = options.Value;
    }

    public async Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksAsync(DeviceTaskGetRequest request)
    {
        var data = await GetDataAsync(request);
        if (data.IsEmpty()) return new List<DeviceTaskToDeviceByDeviceResponse>();

        var deviceUploadInfos = await GetDeviceUploadRecordInfosAsync(data);

        var timeLimitedDataProtector = _dataProtectionProvider
            .CreateProtector("down:face")
            .ToTimeLimitedDataProtector();

        return data.GroupBy(x => new { x.Brand, x.DeviceUniqueNo, x.DeviceConnectionInfo, x.FuncStr })
            .Select(x =>
            {
                var b = x.Key.Brand;
                var d = x.Key.DeviceUniqueNo;
                var dc = x.Key.DeviceConnectionInfo ?? "{}";
                var func = x.Key.FuncStr ?? "[]";

                var jobj = new JObject
                {
                    { "connectionInfo", JToken.Parse(dc) },
                    { "function", JArray.Parse(func) }
                };

                return new DeviceTaskToDeviceByDeviceResponse
                {
                    Brand = b,
                    DeviceUniqueNo = d,
                    DeviceInfo = jobj,
                    Tasks = x.Select(item =>
                    {
                        var key = $"face:{item.UserCode}";
                        var token = item.Type == DeviceTaskEnumType.Delete
                            ? string.Empty
                            : timeLimitedDataProtector.Protect(key, TimeSpan.FromSeconds(_faceUrlOptions.Limit));

                        var dto = new TaskCombineDto
                        {
                            TaskId = item.TaskId,
                            Type = item.Type,
                        };

                        switch (dto.Type)
                        {
                            case DeviceTaskEnumType.Add:
                            case DeviceTaskEnumType.Delete:
                            case DeviceTaskEnumType.Update:
                            {
                                dto.Info = new UserToDeviceResponse
                                {
                                    UserId = item.UserId.HasValue ? item.UserId.Value : 0,
                                    UserNo = item.UserNo,
                                    UserCode = item.UserCode,
                                    UserName = item.UserName,
                                    DepartmentNo = item.DepartmentNo,
                                    DepartmentName = item.DepartmentName,
                                    CardNo = item.Type == DeviceTaskEnumType.Delete ? string.Empty : item.CardNo,
                                    Face = item.Type == DeviceTaskEnumType.Delete ? string.Empty : _faceUrlOptions.Url + token, //下发才附带照片信息
                                    ValidDatePeriod = new DatePeriod
                                    {
                                        Start = DateOnly.FromDateTime(DateTime.Now.AddDays(-1)),
                                        End = DateOnly.FromDateTime(DateTime.Now.AddYears(20)),
                                    },
                                    TimePeriods = new List<int> { 1 },
                                    Doors = new List<int> { 1 },
                                    Schedule = 1
                                };
                            }
                                break;
                            case DeviceTaskEnumType.TimePeriodAdd:
                            case DeviceTaskEnumType.TimePeriodDelete:
                            {
                                dto.Info = new TimePeriodToDeviceResponse
                                {
                                    Id = 1,
                                    Name = "小白领",
                                    Enable = true,
                                    Sections = new List<TimePeriodWeekDaySection>()
                                    {
                                        new()
                                        {
                                            DayOfWeek = DayOfWeek.Monday,
                                            TimePeriods = new List<TimePeriod>
                                            {
                                                new()
                                                {
                                                    Start = TimeOnly.Parse("08:00:00"),
                                                    End = TimeOnly.Parse("17:30:00"),
                                                },
                                            }
                                        }
                                    }
                                };
                            }
                                break;
                            case DeviceTaskEnumType.ScheduleAdd:
                            case DeviceTaskEnumType.ScheduleDelete:
                            {
                                dto.Info = new ScheduleToDeviceResponse
                                {
                                    Id = 1,
                                    Enable = true,
                                    Name = "计划的一部分",
                                    Schedules = new List<ScheduleDto>
                                    {
                                        new()
                                        {
                                            Name = "国庆节",
                                            DateTimePeriod = new DateTimePeriod
                                            {
                                                Start = new DateTime(2024, 10, 1),
                                                End = new DateTime(2024, 10, 7)
                                            }
                                        }
                                    }
                                };
                            }
                                break;

                            case DeviceTaskEnumType.UploadRecord:
                            {
                                dto.Info = new UploadRecordToDeviceResponse
                                {
                                    DateTimePeriod = new DateTimePeriod
                                    {
                                        Start = deviceUploadInfos.TryGetValue(d, out var dt) ? (dt ?? DateTime.Now) : DateTime.Now,
                                        End = DateTime.Now.AddDays(1)
                                    }
                                };
                            }
                                break;
                        }

                        return dto;
                    }).ToList()
                };
            }).ToList();
    }

    /// <summary>
    /// 获取新token
    /// </summary>
    /// <param name="taskId"></param>
    /// <returns></returns>
    /// <exception cref="NotImplementedException"></exception>
    public async Task<string> RenewFaceUrlAsync(long taskId)
    {
        var task = await _dbContext.Queryable<DeviceTaskEntity>().Where(x => x.Id == taskId).FirstAsync();
        task.ThrowIfNull("该任务不存在");
        (task.Status != DeviceTaskStatusEnumType.Process).ThrowIfTrue($"设备任务下发状态需为{DeviceTaskStatusEnumType.Process.GetDescription()}");

        var faceUrlOptions = App.GetServiceProvider(true).GetService<IOptions<FaceUrlOptions>>().Value;
        var dataProtectionProvider = App.GetServiceProvider(true).GetService<IDataProtectionProvider>();

        var timeLimitedDataProtector = dataProtectionProvider
            .CreateProtector("down:face")
            .ToTimeLimitedDataProtector();

        var userCode = await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == task.UserNo).Select(x => x.Code).SingleAsync();

        var key = $"face:{userCode}";
        var token = timeLimitedDataProtector.Protect(key, TimeSpan.FromSeconds(faceUrlOptions.Limit));

        return faceUrlOptions.Url + token;
    }


    public async Task UpdateDeviceTaskStatusAsync(List<UpdateDeviceTaskStatusRequest> requests)
    {
        var taskIds = requests.Select(x => x.TaskId).ToList();
        var deviceTasks = await _dbContext.Queryable<DeviceTaskEntity>()
            .Where(x => taskIds.Contains(x.Id))
            .Where(x => x.Status == DeviceTaskStatusEnumType.Process)
            .ToListAsync();

        var now = DateTime.Now;

        deviceTasks.ForEach(task =>
        {
            var callbackMessage = requests.First(x => x.TaskId == task.Id);

            task.Status = callbackMessage.IsSuccess ? DeviceTaskStatusEnumType.Success : DeviceTaskStatusEnumType.Error;
            task.ResultMessage = callbackMessage.ResultMessage;
            task.ModifiedTime = now;
        });

        await _dbContext.UpdateAsync(deviceTasks);
    }


    //**************************************************** help method **************************************************

    private async Task<List<TaskDto>> GetDataAsync(DeviceTaskGetRequest request)
    {
        var data = await CommonHelper.RetryAsync(async () =>
        {
            var page = await _dbContext.Queryable<DeviceTaskEntity>()
                .LeftJoin<DeviceEntity>((deviceTask, device) => deviceTask.DeviceUniqueNo == device.UniqueNo)
                .LeftJoin<DeviceTemplateEntity>((deviceTask, device, deviceTemplate) => deviceTemplate.Code == device.TemplateCode)
                .LeftJoin<GainfoEntity>((deviceTask, device, deviceTemplate, ga) => deviceTask.UserNo == ga.No)
                .LeftJoin<GainfoLeaveEntity>((deviceTask, device, deviceTemplate, ga, gaLeave) => deviceTask.UserNo == gaLeave.No)
                .LeftJoin<DepartmentEntity>((deviceTask, device, deviceTemplate, ga, gaLeave, department) => department.No == ga.DepartmentNo)
                .LeftJoin<GainfoExternalEntity>((deviceTask, device, deviceTemplate, ga, gaLeave, department, gainfoEx) => deviceTask.UserNo == gainfoEx.No)
                .LeftJoin<DeviceRegistryEntity>((deviceTask, device, deviceTemplate, ga, gaLeave, department, gainfoEx, deviceRegistry) => deviceRegistry.DeviceUniqueNo == deviceTask.DeviceUniqueNo)
                .Where((deviceTask, device) => device.Enable)
                .WhereIF(!request.IsProcess, deviceTask => deviceTask.Status == DeviceTaskStatusEnumType.Wait)
                .WhereIF(request.IsProcess, deviceTask => deviceTask.Status == DeviceTaskStatusEnumType.Process
                                                          && SqlFunc.DateDiff(DateType.Minute, deviceTask.ModifiedTime, DateTime.Now) > 30)
                .WhereIF(request.DeviceUniqueNo.IsPresent(), (deviceTask, device) => deviceTask.DeviceUniqueNo == request.DeviceUniqueNo)
                .WhereIF(request.Factory.IsPresent(), (deviceTask, device) => deviceTask.TenantId == request.Factory)
                .WhereIF(request.Types.IsPresent(), deviceTask => request.Types.Contains(deviceTask.Type))
                .WhereIF(request.Brand.IsPresent(), (deviceTask, device, deviceTemplate) => deviceTemplate.Brand == request.Brand)
                .Where((deviceTask, device, deviceTemplate, ga, gaLeave, department, gainfoEx, deviceRegistry) =>
                    SqlFunc.DateAdd(deviceRegistry.LastHeartbeatTime, SqlFunc.IIF(device.HeartbeatInterval == 0, 30, 30), DateType.Second) > DateTime.Now)
                .OrderBy(deviceTask => new { Priority = SqlFunc.Desc(deviceTask.Priority), deviceTask.CreateTime })
                .Select((deviceTask, device, deviceTemplate, ga, gaLeave, department, gainfoEx) => new TaskDto
                {
                    UserId = SqlFunc.IsNull(SqlFunc.IsNull(deviceTask.UserId, ga.Id), gaLeave.IdentityUserId),
                    TaskId = deviceTask.Id,
                    Type = deviceTask.Type,
                    DeviceUniqueNo = deviceTask.DeviceUniqueNo,
                    DeviceConnectionInfo = device.ConnectionInfo,
                    Brand = deviceTemplate.Brand,
                    FuncStr = device.Funcs.ToString(),
                    UserNo = deviceTask.UserNo,
                    UserCode = SqlFunc.IsNull(SqlFunc.IsNull(ga.Code, gaLeave.Code), gainfoEx.Code),
                    UserName = SqlFunc.IsNull(SqlFunc.IsNull(ga.Name, gaLeave.Name), gainfoEx.Name),
                    DepartmentNo = ga.DepartmentNo,
                    DepartmentName = department.Name,
                    CardNo = ga.CardNo,
                    Version = deviceTask.Version,
                    Status = deviceTask.Status
                })
                .ToPageListAsync(request);

            if (!page.Data.Any())
            {
                return page.Data;
            }

            var taskIdVs = page.Data.Select(x => new { x.TaskId, x.Version, x.Status }).ToList();
            var where = LinqExpressionExtensions.False<DeviceTaskEntity>();
            taskIdVs.ForEach(p => { where = where.Or(x => x.Id == p.TaskId && x.Version == p.Version && x.Status == p.Status); });

            var effect = await _dbContext.Updateable<DeviceTaskEntity>()
                .SetColumns(x => x.Version == x.Version + 1)
                .SetColumns(x => x.Status == DeviceTaskStatusEnumType.Process)
                .SetColumns(x => x.ModifiedTime == DateTime.Now)
                .Where(where)
                .ExecuteCommandAsync();

            (taskIdVs.Count != effect).ThrowIfTrue("获取任务失败");

            return page.Data;
        }, 5);

        return data;
    }

    private async Task<Dictionary<string, DateTime?>> GetDeviceUploadRecordInfosAsync(List<TaskDto> data)
    {
        if (data.Any(x => x.Type == DeviceTaskEnumType.UploadRecord))
        {
            var deviceNos = data.Select(x => x.DeviceUniqueNo).Distinct().ToList();
            var result = new Dictionary<string, DateTime?>(deviceNos.Count);

            //日志数据最后一条
            var logInfos = await _dbContext.Queryable<DeviceUploadLogEntity>().Select(it => new
                {
                    RowNumber = SqlFunc.RowNumber(SqlFunc.Desc(it.Id), it.DeviceUniqueNo),
                    it.DeviceUniqueNo,
                    it.RaiseDateTime
                })
                .MergeTable()
                .Where(it => it.RowNumber == 1)
                .ToListAsync();

            foreach (var item in deviceNos)
            {
                var logInfo = logInfos.FirstOrDefault(x => x.DeviceUniqueNo == item);
                result.Add(item, logInfo?.RaiseDateTime);
            }

            return result;
        }

        return new Dictionary<string, DateTime?>();
    }
}