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

namespace SJZY.Track.Application.CAP.EventHandlers;

public class TrackChangeAfterUpdateOrderEventHandler : ITransientDependency, ICapSubscribe
{
    private readonly IOrderRepository _orderRepository;
    private readonly IForewarningNotifyService _forewarningNotifyService;

    public TrackChangeAfterUpdateOrderEventHandler(IOrderRepository orderRepository,
        IForewarningNotifyService forewarningNotifyService)
    {
        _orderRepository = orderRepository;
        _forewarningNotifyService = forewarningNotifyService;
    }

    [CapSubscribe(GlobalConst.TrackChangeAfterUpdateOrderSubscribe)]
    public async Task ConsumerAsync(TrackChangeAfterUpdateOrderEvent @event)
    {
        var orders = await _orderRepository.GetListAsync(x => @event.OrderIds.Contains(x.Id), x => MapOrderSummary(x));

        if (orders.Count == 0) return;

        var updateOrders = 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;
                }
            }

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

            // 触发拉取节点
            if (@event.TriggerPullOrderIds.Contains(order.Id))
            {
                order.IsTriggerPull = 1;
            }

            order.LatestTrackContent = @event.TrackContent;
            order.LatestTrackEnContent = @event.TrackEnContent;
            order.LatestTrackPlace = @event.TrackPlace;
            order.LatestTrackTime = @event.TrackTime;
            order.LatestTrackTimeZone = @event.TrackTimeZone;
            updateOrders.Add(order);
        }

        await _orderRepository.UpdateRangeAsync(updateOrders, x => new
        {
            x.IsCompleted, x.LatestTrackContent, x.LatestTrackEnContent, x.LatestTrackPlace, x.LatestTrackTime,
            x.LatestTrackTimeZone
        });
        
        // 预警计算
        var warningOrders =  orders.Select(order => new ForewarningOrderModel
        {
            Id = order.Id,
            TrackStatusId = @event.TrackStatusId,
            SubSystemId = order.SubSystemId,
            CustomerId = order.CustomId,
            CargoType = order.CargoType,
            Month = order.CreateTime.Month,
            Area = DetermineAreaBasedOnOrderDetails(order),
            IsTransit = order.IsTransit,
            LeavePort = order.LeavePort,
            ProductCode = order.ProductCode
        }).ToList();
        _forewarningNotifyService.WarningCalculateAsync(warningOrders);
    }

    private OrderEntity MapOrderSummary(OrderEntity x)
    {
        return new OrderEntity
        {
            Id = x.Id,
            SubSystemId = x.SubSystemId,
            CustomId = x.CustomId,
            
            // 轨迹
            IsCompleted = x.IsCompleted,
            LatestTrackContent = x.LatestTrackContent,
            LatestTrackEnContent = x.LatestTrackEnContent,
            LatestTrackPlace = x.LatestTrackPlace,
            LatestTrackTime = x.LatestTrackTime,
            LatestTrackTimeZone = x.LatestTrackTimeZone,
                
            // 因素
            CargoType = x.CargoType,
            CreateTime = x.CreateTime,
            ArrivalCountry = x.ArrivalCountry,
            ArrivalProvince = x.ArrivalProvince,
            ArrivalCity = x.ArrivalCity,
            ArrivalPostCode = x.ArrivalPostCode,
            IsTransit = x.IsTransit,
            LeavePort = x.LeavePort,
            ProductCode = x.ProductCode
        };
    }

// Placeholder methods for deriving or converting values. You'll need to implement these based on your specific logic.
    private int DetermineTrackBasedOnOrderDetails(OrderEntity order)
    {
        // Implement logic to determine Track
        return default;
    }

    private int? DetermineMonthBasedOnOrderDetails(OrderEntity order)
    {
        // Implement logic to determine Month
        return default;
    }

    private int? DetermineAreaBasedOnOrderDetails(OrderEntity order)
    {
        // Implement logic to determine Area
        return default;
    }
}