using DotNetCore.CAP;
using Fake.UnitOfWork;
using TrackCenter.Application.Events;
using TrackCenter.Application.Services.Warning.Handlers;
using TrackCenter.Domain.Aggregates.OrderAggregate;

namespace TrackCenter.Application.CAP.EventHandlers;

public class TrackChangeAfterUpdateOrderEventHandler(IOrderRepository orderRepository, IServiceProvider serviceProvider)
    : ITransientDependency, ICapSubscribe
{
    [UnitOfWork]
    [CapSubscribe(GlobalConst.TrackChangeAfterUpdateOrderSubscribe)]
    public virtual async Task ConsumerAsync(TrackChangeAfterUpdateOrderEvent @event)
    {
        var orders = await GetOrdersAsync(@event.OrderIds);

        if (orders.Count == 0)
        {
            Log.Warning($"没有找到订单信息：{@event.OrderIds.JoinAsString(",")}，无法更新轨迹信息");
            return;
        }

        var updateOrders = new List<OrderEntity>();
        var warningCalcOrders = new List<OrderEntity>();
        foreach (var order in orders)
        {
            if (order.LatestTrackContent != @event.TrackContent)
            {
                if (order.LatestTrackTime != null &&
                    @event.TrackTime.Subtract(TimeSpan.FromHours(@event.TrackTimeZone)) <
                    order.LatestTrackTime.Value.Subtract(TimeSpan.FromHours(order.LatestTrackTimeZone ?? 0)))
                {
                    continue;
                }
            }

            // 执行轨迹兜底时 时区缺失和发生地缺失标记，1表示时区，2表示发生地，3表示两种
            if (@event.DeficiencyTagValue is > 0 and <= 3)
            {
                order.DeficiencyTag = @event.DeficiencyTagValue;
            }

            if (!order.IsCompleted)
            {
                order.IsCompleted = @event.IsCompleted;

                // 当订单由未完结变为完结时，进行预警计算
                if (order.IsCompleted)
                    warningCalcOrders.Add(order);
            }

            // 当轨迹发生时间大于订单上的最新的轨迹发生时间时，才更新订单冗余的轨迹信息
            if (order.LatestTrackTime == null ||
                (@event.TrackTime.Subtract(TimeSpan.FromHours(@event.TrackTimeZone)) >
                 order.LatestTrackTime.Value.Subtract(TimeSpan.FromHours(order.LatestTrackTimeZone ?? 0)))
               )
            {
                order.LatestTrackStatus = @event.TrackStatus;
                order.LatestTrackContent = @event.TrackContent;
                order.LatestTrackEnContent = @event.TrackEnContent;
                order.LatestTrackPlace = @event.TrackPlace;
                order.LatestTrackTime = @event.TrackTime;
                order.LatestTrackTimeZone = @event.TrackTimeZone;
                //当【预计签收时间】【签收地时区】同时存在时则更新主表
                if (@event.EstimatedDeliveryDate.HasValue && @event.DestinationTimeZone.HasValue)
                {
                    order.EstimatedDeliveryDate = @event.EstimatedDeliveryDate.Value;
                    order.DestinationTimeZone = @event.DestinationTimeZone.Value;
                }
            }

            updateOrders.Add(order);
        }

        await orderRepository.UpdateRangeAsync(updateOrders, x => new
            {
                x.IsCompleted,
                x.LatestTrackStatus,
                x.LatestTrackContent,
                x.LatestTrackEnContent,
                x.LatestTrackPlace,
                x.LatestTrackTime,
                x.LatestTrackTimeZone,
                x.DeficiencyTag,
                x.EstimatedDeliveryDate,
                x.DestinationTimeZone
            }
        );

        // 引发预警计算
        if (warningCalcOrders.Count > 0)
            WarningCalc_OrderDeletedOrCompleted(warningCalcOrders);
    }

    private async Task<List<OrderEntity>> GetOrdersAsync(int[] orderIds)
    {
        return await orderRepository.GetListAsync(order => orderIds.Contains(order.Id), order => new OrderEntity
        {
            Id = order.Id,
            // 轨迹
            IsCompleted = order.IsCompleted,
            LatestTrackStatus = order.LatestTrackStatus,
            LatestTrackContent = order.LatestTrackContent,
            LatestTrackEnContent = order.LatestTrackEnContent,
            LatestTrackPlace = order.LatestTrackPlace,
            LatestTrackTime = order.LatestTrackTime,
            LatestTrackTimeZone = order.LatestTrackTimeZone,
            DestinationTimeZone = order.DestinationTimeZone,
            EstimatedDeliveryDate = order.EstimatedDeliveryDate,
        });
    }

    private void WarningCalc_OrderDeletedOrCompleted(List<OrderEntity> order)
    {
        _ = Task.Run(async () =>
        {
            var scope = serviceProvider.CreateScope();
            try
            {
                var handler = scope.ServiceProvider.GetRequiredService<IOrderWarningHandler>();
                await handler.HandleOrderDeletedOrCompletedAsync(order);
            }
            catch (Exception ex)
            {
                Log.Error(ex.ToString());
            }
            finally
            {
                scope.Dispose();
            }
        });
    }
}