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

namespace Dlhis.ScheduledTask.TaskAssignment.Services.Implements;

public class DeviceTaskAssignmentService : IDeviceTaskAssignmentService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;

    public DeviceTaskAssignmentService(IDbContext dbContext, ITenantApi tenantApi)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
    }

    public async Task<Pagination<DeviceTaskAssignmentResponse>> GetPageAsync(DeviceTaskAssignmentRequest request)
    {
        var page = await _dbContext.Queryable<DeviceTaskEntity>()
            .LeftJoin<GainfoEntity>((deviceTask, ga) => deviceTask.UserNo == ga.No)
            .LeftJoin<DeviceEntity>((deviceTask, ga, device) => deviceTask.DeviceUniqueNo == device.UniqueNo)
            .WhereIF(!request.Search.IsEmpty(), (deviceTask, ga, device) =>
            deviceTask.UserNo == request.Search
            || ga.Name.Contains(request.Search)
            || ga.Code == request.Search
            || deviceTask.DeviceUniqueNo == request.Search
            )
            .WhereIF(request.TaskTypes.IsPresent(), deviceTask => request.TaskTypes.Contains(deviceTask.Type))
            .WhereIF(request.Type.HasValue, (deviceTask, ga, device) => device.Type == request.Type)
            .WhereIF(request.Status.IsPresent(), deviceTask => request.Status.Contains(deviceTask.Status))
            .Where(deviceTask => 1 == 1)
            .OrderBy(deviceTask => deviceTask.CreateTime, OrderByType.Desc)
            .Select((deviceTask, ga, device) => new DeviceTaskAssignmentResponse
            {
                Id = deviceTask.Id,
                DeviceUniqueNo = deviceTask.DeviceUniqueNo,
                ResultMessage = deviceTask.ResultMessage,
                RetryCount = deviceTask.Version,
                Status = deviceTask.Status,
                UserNo = deviceTask.UserNo,
                UserName = ga.Name,
                UserCode = ga.Code,
                Type = deviceTask.Type,
                CreateTime = deviceTask.CreateTime,
                LastUpdateTime = deviceTask.ModifiedTime,
                TenantId = deviceTask.TenantId,
                DeployPlace = device.DeployPlace,
            })
            .ToPageListAsync(request);


        try
        {
            var tenantResult = await _tenantApi.GetTenantsInternalAsync();
            var tenants = tenantResult.Data;

            page.Data.ForEach(item =>
            {
                item.TenantName = tenants.FirstOrDefault(x => x.Code == item.TenantId)?.Name;
            });

        }
        catch (Exception)
        {
        }

        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("请等待任务处理完成");
        }

        //更新任务状态
        await _dbContext.Updateable<DeviceTaskEntity>()
              .SetColumns(x => x.Status == DeviceTaskStatusEnumType.Wait)
              .Where(x => request.Ids.Contains(x.Id))
              .Where(x => x.Status == DeviceTaskStatusEnumType.Process || x.Status == DeviceTaskStatusEnumType.Error)
              .ExecuteCommandAsync();
    }
}