using DotNetCore.CAP;
using SJZY.Expand.ABP.Core.Logger;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Consts;
using SJZY.Track.Domain.Queries;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.CAP.EventHandlers;

public class TrackDeleteEventHandler : ITransientDependency, ICapSubscribe
{
    private readonly IOrderRepository _orderRepository;
    private readonly IProvideQueries _provideQueries;
    private readonly ICapPublisher _capPublisher;
    private readonly ITrackDetailsRepository _trackDetailsRepository;

    public TrackDeleteEventHandler(IProvideQueries provideQueries,
        IOrderRepository orderRepository, ICapPublisher capPublisher, ITrackDetailsRepository trackDetailsRepository)
    {
        _provideQueries = provideQueries;
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _trackDetailsRepository = trackDetailsRepository;
    }

    [CapSubscribe(GlobalConst.TrackDeleteSubscribe, Group = GlobalConst.TrackDeleteSubscribe)]
    public async Task ConsumerAsync(TrackDeleteEvent @event)
    {
        var dup = @event.Visited.Intersect(@event.OrderIds).ToArray();
        if (dup.Any())
        {
            LogHelper.Error($"删除轨迹时，发现循环依赖：{dup.JoinAsString(",")}");
            return;
        }

        await DeleteTrackAsync(@event);

        // 根据订单关联关系异步向下刷（异步）
        var linkedOrders = await _orderRepository.GetLinkedOrdersAsync(@event.OrderIds);
        foreach (var orderId in @event.OrderIds)
        {
            foreach (var group in linkedOrders.Where(x => x.OwnerOrderId == orderId)
                         .GroupBy(x => x.SubSystemId))
            {
                var nextEvent = @event.DeepCopy();
                nextEvent.Visited.AddRange(@event.OrderIds);
                nextEvent.TrackCodes = @event.TrackCodes;
                nextEvent.SubSystemId = group.Key;

                // 不同子系统需要做内容映射
                if (@event.SubSystemId != nextEvent.SubSystemId)
                {
                    var mapCodes = await _provideQueries
                        .MapTrackCodesAsync(@event.SubSystemId, nextEvent.SubSystemId, @event.TrackCodes.ToArray());

                    if (mapCodes.Count == 0)
                    {
                        //throw new BusinessException(message: "订单跨子系统，未配置内容映射，请联系管理员");
                        continue;
                    }

                    nextEvent.TrackCodes = mapCodes;
                }

                var identifiers = group.Select(x => x.OrderId).ToList();
                var idx = 0;
                while (idx < identifiers.Count)
                {
                    var subEvent = nextEvent.DeepCopy();
                    var cnt = idx + GlobalConst.ChunkSize > identifiers.Count
                        ? identifiers.Count - idx
                        : GlobalConst.ChunkSize;
                    subEvent.OrderIds = identifiers.GetRange(idx, cnt).ToArray();
                    idx += GlobalConst.ChunkSize;

                    await _capPublisher.PublishAsync(GlobalConst.TrackDeleteSubscribe, subEvent);
                }
            }
        }
    }

    private async Task DeleteTrackAsync(TrackDeleteEvent @event)
    {
        // 删除轨迹（删的是同子系统下的单，所以code是统一的）
        var tracks = await _trackDetailsRepository.GetLatestListAsync(@event.OrderIds, @event.TrackCodes);

        await _trackDetailsRepository.DeleteTrackAsync(@event.OrderIds, @event.TrackCodes);

        var orders = await _orderRepository.GetListAsync(x => @event.OrderIds.Contains(x.Id),
            x => new OrderEntity
            {
                Id = x.Id,
                LatestTrackContent = x.LatestTrackContent,
                LatestTrackEnContent = x.LatestTrackEnContent,
                LatestTrackPlace = x.LatestTrackPlace,
                LatestTrackTime = x.LatestTrackTime,
                LatestTrackTimeZone = x.LatestTrackTimeZone,
            });

        if (orders.Count == 0) return;

        foreach (var order in orders)
        {
            var track = tracks.FirstOrDefault(x => x.OrderId == order.Id);

            // 删除全部轨迹导致的重置行为
            if (track == default)
            {
                if (order.LatestTrackTime == null) continue;

                // tips：订单是支持从已完成态到未完成态的
                order.ResetTrackInfo();
            }
            else
            {
                if (order.LatestTrackContent == track.TrackContent) continue;
                // 删除引发的回退更新
                order.LatestTrackContent = track.TrackContent;
                order.LatestTrackEnContent = track.TrackEnContent;
                order.LatestTrackPlace = track.TrackPlace;
                order.LatestTrackTime = track.TrackTime;
                order.LatestTrackTimeZone = track.TrackTimeZone;
            }
        }

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