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 Dlhis.Sys.Api;
using Dlhis.Sys.Api.Request;
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.TaskAssignment.Services.Implements;

public class DeviceTaskAssignmentService : IDeviceTaskAssignmentService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;
    private readonly IUserApi _userApi;
    private readonly ILogger<DeviceTaskAssignmentService> _logger;

    public DeviceTaskAssignmentService(IDbContext dbContext,
        ITenantApi tenantApi,
        IUserApi userApi,
        ILogger<DeviceTaskAssignmentService> logger)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
        _userApi = userApi;
        _logger = logger;
    }

    public async Task<Pagination<DeviceTaskAssignmentResponse>> GetPageAsync(DeviceTaskAssignmentRequest request)
    {
        var page = await _dbContext.Queryable<DeviceTaskEntity>()
            .LeftJoin<DeviceEntity>((deviceTask, device) => deviceTask.DeviceUniqueNo == device.UniqueNo)
            .LeftJoin<GainfoEntity>((deviceTask, device, ga) => deviceTask.UserNo == ga.No)
            .LeftJoin<GainfoLeaveEntity>((deviceTask, device, ga, gaLeave) => deviceTask.UserNo == gaLeave.No)
            .LeftJoin<DeviceRegistryEntity>((deviceTask, device, ga, gaLeave, deviceRegistry) => deviceRegistry.DeviceUniqueNo == deviceTask.DeviceUniqueNo)
            .WhereIF(request.SearchDateTimePeriod.HasValue(), deviceTask => deviceTask.ModifiedTime >= request.SearchDateTimePeriod.Start
                                                                            && deviceTask.ModifiedTime <= request.SearchDateTimePeriod.End
            )
            .WhereIF(request.UserNo.IsPresent(), deviceTask => deviceTask.UserNo == request.UserNo)
            .Where(deviceTask => deviceTask.TenantId == request.Factory)
            .WhereIF(request.Type.HasValue, deviceTask => deviceTask.DeviceType == request.Type)
            .WhereIF(request.TaskTypes.IsPresent(), deviceTask => request.TaskTypes.Contains(deviceTask.Type))
            .WhereIF(request.Status.IsPresent(), deviceTask => request.Status.Contains(deviceTask.Status))
            .WhereIF(!request.Search.IsEmpty(), (deviceTask, device, ga) =>
                ga.Name == request.Search
                || ga.Code == request.Search
                || deviceTask.DeviceUniqueNo == request.Search
            )
            .WhereIF(request.IsOffline.HasValue && request.IsOffline.Value, (deviceTask, device, ga, gaLeave, deviceRegistry) =>
                device.HeartbeatInterval != 0 && SqlFunc.DateAdd(deviceRegistry.LastHeartbeatTime, device.HeartbeatInterval, DateType.Second) < DateTime.Now)
            .WhereIF(request.IsOffline.HasValue && !request.IsOffline.Value, (deviceTask, device, ga, gaLeave, deviceRegistry) =>
                device.HeartbeatInterval == 0 || SqlFunc.DateAdd(deviceRegistry.LastHeartbeatTime, device.HeartbeatInterval, DateType.Second) >= DateTime.Now)
            .OrderBy(deviceTask => deviceTask.ModifiedTime, OrderByType.Desc)
            .Select((deviceTask, device, ga, gaLeave, deviceRegistry) => new DeviceTaskAssignmentResponse
            {
                Id = deviceTask.Id,
                DeviceUniqueNo = deviceTask.DeviceUniqueNo,
                ResultMessage = deviceTask.ResultMessage,
                RetryCount = deviceTask.Version,
                Status = deviceTask.Status,
                UserNo = deviceTask.UserNo,
                UserName = SqlFunc.IsNull(ga.Name, gaLeave.Name),
                UserCode = SqlFunc.IsNull(ga.Code, gaLeave.Code),
                Type = deviceTask.Type,
                CreateTime = deviceTask.CreateTime,
                LastUpdateTime = deviceTask.ModifiedTime,
                TenantId = deviceTask.TenantId,
                LastHeartbeatTime = deviceRegistry.LastHeartbeatTime,
                HeartbeatInterval = device.HeartbeatInterval,
                DeployPlace = device.DeployPlace,
                CreateBy = deviceTask.CreatedBy,
                Source = deviceTask.Source
            })
            .ToPageListAsync(request);

        try
        {
            var tenants = await _tenantApi.GetTenantsInternalAsync();
            page.Data.ForEach(item => { item.TenantName = tenants.FirstOrDefault(x => x.Code == item.TenantId)?.Name; });
        }
        catch (Exception)
        {
            //ignore
        }

        try
        {
            var userIds = page.Data.Select(x => x.CreateBy).Distinct().ToList();
            var userInfos = await _userApi.GetUserByIdsAsync(new IdsRequest { Ids = userIds });
            page.Data.ForEach(item => item.Creator = userInfos.FirstOrDefault(x => x.Id == item.CreateBy)?.OperatorName);
        }
        catch (Exception e)
        {
            _logger.LogError("获取人员数据失败:{error}", e.Message);
        }

        return page;
    }

    public async Task ResetAsync(DeviceTaskResetRequest request)
    {
        var tasks = await _dbContext.Queryable<DeviceTaskEntity>()
            .Where(x => request.Ids.Contains(x.Id))
            .ToListAsync();

        //判断process任务时间
        if (!request.Force)
        {
            var now = DateTime.Now;
            tasks.Any(x => x.ModifiedTime.AddMinutes(10) < now && x.Status == DeviceTaskStatusEnumType.Process).ThrowIfTrue("请等待任务处理完成");
        }

        tasks.ForEach(x => x.Status = DeviceTaskStatusEnumType.Wait);

        //更新任务状态
        await _dbContext.UpdateAsync(tasks);
    }
}