using DotNetCore.CAP;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Consts;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.EventHandlers;

public class TrackChangeAfterUpdateOrderEventHandler : ITransientDependency, ICapSubscribe
{
    private readonly IOrderRepository _orderRepository;
    private readonly ITrackDetailsRepository _trackDetailsRepository;

    public TrackChangeAfterUpdateOrderEventHandler(IOrderRepository orderRepository,
        ITrackDetailsRepository trackDetailsRepository)
    {
        _orderRepository = orderRepository;
        _trackDetailsRepository = trackDetailsRepository;
    }

    [CapSubscribe(GlobalConst.TrackChangeAfterUpdateOrderSubscribe)]
    public async Task ConsumerAsync(TrackChangeAfterUpdateOrderEvent @event)
    {
        var orders = await _orderRepository.GetListAsync(x => @event.OrderIds.Contains(x.Id),
            x => new OrderEntity
            {
                Id = x.Id,
                IsCompleted = x.IsCompleted,
                LatestTrackContent = x.LatestTrackContent,
                LatestTrackEnContent = x.LatestTrackEnContent,
                LatestTrackPlace = x.LatestTrackPlace,
                LatestTrackTime = x.LatestTrackTime,
                LatestTrackTimeZone = x.LatestTrackTimeZone,
            });

        if (orders.Count == 0) return;

        // todo：delete可能发生回退，直接去es查最新轨迹，但是可能es还没有刷盘，导致回退失效，可以考虑加个定时任务弥补
        if (@event.IsDelete)
        {
            foreach (var order in orders)
            {
                var tracks = await _trackDetailsRepository.GetListAsync(@event.OrderIds);

                var track = tracks.Where(x => x.OrderId == order.Id).MaxBy(x => x.TrackTime);
                // 删除全部轨迹导致的重置行为
                if (track == default)
                {
                    if (order.LatestTrackTime == null) return;

                    // tips：订单是支持从已完成态到未完成态的
                    order.ResetTrackInfo();
                }
                else
                {
                    // 删除引发的回退更新
                    order.IsCompleted = @event.IsCompleted;
                    order.LatestTrackContent = track.TrackContent;
                    order.LatestTrackEnContent = track.TrackEnContent;
                    order.LatestTrackPlace = track.TrackPlace;
                    order.LatestTrackTime = track.TrackTime;
                    order.LatestTrackTimeZone = track.TrackTimeZone;
                }
            }
        }
        else // upsert可以直接计算
        {
            foreach (var order in orders)
            {
                if (order.LatestTrackTime != null &&
                    @event.TrackTime.Subtract(TimeSpan.FromHours(@event.TrackTimeZone)) <
                    order.LatestTrackTime.Value.Subtract(TimeSpan.FromHours(order.LatestTrackTimeZone ?? 0)))
                {
                    continue;
                }

                // upsert引发的更新
                order.IsCompleted = @event.IsCompleted;
                order.LatestTrackContent = @event.TrackContent;
                order.LatestTrackEnContent = @event.TrackEnContent;
                order.LatestTrackPlace = @event.TrackPlace;
                order.LatestTrackTime = @event.TrackTime;
                order.LatestTrackTimeZone = @event.TrackTimeZone;
            }
        }

        await _orderRepository.UpdateRangeAsync(orders, x => new
        {
            x.IsCompleted, x.LatestTrackContent, x.LatestTrackEnContent, x.LatestTrackPlace, x.LatestTrackTime,
            x.LatestTrackTimeZone
        });
    }
}