using DotNetCore.CAP;
using SJZY.Expand.ABP.Core.Logger;
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)
    {
        if (@event.Visited.Contains(@event.OrderId))
        {
            LogHelper.Error($"删除轨迹订单时，发现循环依赖：{@event.Visited.JoinAsString(",")}");
            return;
        }

        @event.Visited.Add(@event.OrderId);

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

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

            @event.TrackCodes = mapCodes;
        }

        await DeleteTrackAsync(@event);
    }

    private async Task DeleteTrackAsync(TrackDeleteEvent @event)
    {
        // 删除轨迹
        var isOk = await _trackDetailsRepository.DeleteTrackAsync(@event.OrderId, @event.TrackCodes);

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

        // 根据订单关联关系异步向下刷
        var linkedOrders = await _orderRepository.GetLinkedOrdersAsync(@event.OrderId);
        foreach (var linkedOrder in linkedOrders)
        {
            var nextEvent = new TrackDeleteEvent
            {
                OrderId = linkedOrder.OrderId,
                TrackCodes = @event.TrackCodes,
                SubSystemId = linkedOrder.SubSystemId,
                UpSubSystemId = @event.SubSystemId
            };

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