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.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;
                nextEvent.OrderIds = group.Select(x => x.OrderId).ToArray();

                // 不同子系统需要做内容映射
                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: "订单跨子系统，未配置内容映射，请联系管理员");
                        return;
                    }

                    nextEvent.TrackCodes = mapCodes;
                }

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

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

        if (isOk)
        {
            // 触发订单主表更新事件
            await _capPublisher.PublishDelayAsync(TimeSpan.FromSeconds(3),
                GlobalConst.TrackChangeAfterUpdateOrderSubscribe,
                new TrackChangeAfterUpdateOrderEvent
                {
                    OrderIds = @event.OrderIds,
                    IsDelete = true
                });
        }
    }
}