using System.Diagnostics;
using System.Linq.Expressions;
using System.Text;
using BSI.Stack.Rabbit;
using BSI.Stack.Rabbit.Handler;
using DotNetCore.CAP;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using RabbitMQ.Client.Events;
using SJZY.Expand.ABP.Core.PublicMethords;
using SJZY.InterfaceRelay.Application.Contracts;
using SJZY.Track.Application.Contract.Dtos.TrackPull;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Application.Contract.Services;
using SJZY.Track.Application.Helpers;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Enums;
using SJZY.Track.Domain.Queries;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.Rabbit;

public class TrackRefreshEventHandler : ITransientDependency, IRabbitHandler
{
    private readonly ICapPublisher _capPublisher;
    private readonly ILogger<TrackRefreshEventHandler> _logger;
    private readonly IOrderRepository _orderRepository;
    private readonly ITimezoneQueries _timezoneQueries;
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly ITrackPullCacheService _trackPullCacheService;

    public TrackRefreshEventHandler(IOrderRepository orderRepository,
        ICapPublisher capPublisher, ITrackPullCacheService trackPullCacheService,
        ITrackDetailsRepository trackDetailsRepository, ITimezoneQueries timezoneQueries,
        ILogger<TrackRefreshEventHandler> logger)
    {
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _trackPullCacheService = trackPullCacheService;
        _trackDetailsRepository = trackDetailsRepository;
        _timezoneQueries = timezoneQueries;
        _logger = logger;
    }


    public bool Enable(ConsumeOptions options)
    {
        return options.Queue == GlobalConst.TrackRefreshSubscribe;
    }

    public async Task Handle(IServiceProvider sp, BasicDeliverEventArgs args, ConsumeOptions options)
    {
        var msg = Encoding.UTF8.GetString(args.Body.ToArray());
        var @event = System.Text.Json.JsonSerializer.Deserialize<InterfaceRelayForwardReplayEvent>(msg);
        if (@event == null)
        {
            _logger.LogWarning(
                $"rabbit on queue({options.Queue}) received msg can't convert to {nameof(InterfaceRelayForwardReplayEvent)}");
            return;
        }

        await ConsumerAsync(@event);
    }

    public async Task ConsumerAsync(InterfaceRelayForwardReplayEvent @event)
    {
        if (!@event.IsSuccess)
        {
            _logger.LogWarning("请求id: {@RequestId}，轨迹刷新失败", @event.RequestId);
            return;
        }

        var attach = Base64Helper.DeSerialize<TrackRefreshAttach>(@event.Attach);
        if (attach is null || @event.Data == null)
        {
            _logger.LogWarning("请求id: {@RequestId}，轨迹消费失败，attach或data解析为空", @event.RequestId);
            return;
        }

        var config = await _trackPullCacheService.GetPullParamsWithContentAsync(attach.SubSystemId,
            attach.ServiceProviderId);
        if (config == null)
        {
            _logger.LogWarning("请求id: {@RequestId}，轨迹消费失败，找不到拉取配置：{@Attach}", attach.ToJson(), @event.RequestId);
            return;
        }

        var data = JObject.Parse(@event.Data);

        var orderToken = data.SelectToken(config.ParamConfig.OrderPath);
        if (orderToken is JArray orderTokens)
        {
            foreach (var token in orderTokens)
            {
                await HandleOrderAsync(token, config, attach);
            }
        }
        else if (orderToken is JObject)
        {
            await HandleOrderAsync(orderToken, config, attach);
        }
    }

    private async Task HandleOrderAsync(JToken orderToken, TrackPullParamsWithContentDto paramsWithContent,
        TrackRefreshAttach attach)
    {
        var paramConfig = paramsWithContent.ParamConfig;
        var orderNo = orderToken[paramConfig.OrderNoName]?.Value<string>();
        if (orderNo.IsNullOrWhiteSpace()) return;

        var trackToken = orderToken.SelectToken(paramConfig.TrackDetailsPath);
        if (trackToken is null) return;

        var order = await _orderRepository.GetFirstAsync(x =>
                x.OrderType == attach.OrderType && x.OrderNo == orderNo,
            x => new
            {
                x.Id,
                x.LatestPushTrackCode,
                x.CustomId
            });
        if (order == default) return;

        var context = new TrackRefreshContext
        {
            OrderId = order.Id,
            OrderType = attach.OrderType,
            OrderNo = orderNo!,
            ServiceProviderName = attach.ServiceProviderName,
            CustomId = order.CustomId,
            SubSystemId = attach.SubSystemId
        };


        if (trackToken is JArray trackTokens)
        {
            foreach (var item in trackTokens)
            {
                await HandleTrackAsync(item, paramsWithContent, context);
            }
        }
        else if (trackToken is JObject)
        {
            await HandleTrackAsync(trackToken, paramsWithContent, context);
        }
    }

    private async Task HandleTrackAsync(JToken trackToken, TrackPullParamsWithContentDto paramsWithContent,
        TrackRefreshContext context)
    {
        var originTrackDataHash = StringHelper.GetHash(JsonConvert.SerializeObject(trackToken));
        // 如果已经存在一模一样的报文了说明处理过了，直接return
        if (await _trackDetailsRepository.AnyAsync(context.OrderId, originTrackDataHash))
        {
            return;
        }

        var paramConfig = paramsWithContent.ParamConfig;
        var contentConfigs = paramsWithContent.ContentConfigs;
        TrackPullContentConfigDto? matchedContentConfig = null;

        // 1、匹配轨迹代码

        // 2、匹配轨迹状态
        if (!paramConfig.TrackStatusName.IsNullOrWhiteSpace())
        {
            var trackStatus = trackToken[paramConfig.TrackStatusName!]?.Value<string>();
            if (!trackStatus.IsNullOrWhiteSpace())
            {
                matchedContentConfig = contentConfigs.FirstOrDefault(x => x.TrackStatusValue == trackStatus);
            }
        }
        // 3、匹配轨迹内容
        else if (!paramConfig.TrackContentName.IsNullOrWhiteSpace())
        {
            var trackContent = trackToken[paramConfig.TrackContentName!]?.Value<string>();
            if (!trackContent.IsNullOrWhiteSpace())
            {
                Debug.Assert(trackContent != null, nameof(trackContent) + " != null");
                // 3.1 按内容直接匹配

                // 3.2 按关键字分析轨迹内容
                if (matchedContentConfig is null)
                {
                    foreach (var contentConfig in contentConfigs)
                    {
                        foreach (var keyword in contentConfig.TrackKeyword?.Split(',') ?? Enumerable.Empty<string>())
                        {
                            if (trackContent.Contains(keyword, StringComparison.OrdinalIgnoreCase))
                            {
                                matchedContentConfig = contentConfig;
                                break;
                            }
                        }

                        if (matchedContentConfig is null) continue;

                        foreach (var keyword in contentConfig.TrackKeywordReverse?.Split(',') ??
                                                Enumerable.Empty<string>())
                        {
                            if (trackContent.Contains(keyword, StringComparison.OrdinalIgnoreCase))
                            {
                                matchedContentConfig = null;
                                break;
                            }
                        }
                    }
                }
            }
        }

        // 轨迹发生时间
        var trackTime = paramConfig.TrackTimeName == null
            ? null
            : trackToken[paramConfig.TrackTimeName]?.Value<DateTime>();

        // 轨迹时区
        var (trackTimeZone, hasTimezoneBottomLine) =
            await GetTimezone(paramConfig, matchedContentConfig, context, trackToken);

        // 轨迹发生地
        var (trackPlace, hasPlaceBottomLine) =
            await GetTrackPlace(paramConfig, matchedContentConfig, context, trackToken);

        if (matchedContentConfig is null)
        {
            _logger.LogDebug("订单号：{OrderNo}，未匹配到轨迹内容，轨迹报文：{TrackContent}",
                context.OrderNo, trackToken.ToString());
            await InsertNotMappedTrackAsync(trackToken, context, trackPlace, trackTime, trackTimeZone, paramConfig);
            return;
        }

        var deficiencyTagValue = CalcDeficiencyTagValue(hasPlaceBottomLine, hasTimezoneBottomLine, trackToken, context);

        // 新增/更新轨迹
        var trackUpsertEvent = new TrackUpsertEvent
        {
            OrderIdentifiers =
                new[]
                {
                    new OrderIdentifier
                    {
                        OrderId = context.OrderId,
                        OrderNo = context.OrderNo,
                        OrderType = context.OrderType,
                    }
                },
            TrackRefreshData = new TrackRefreshStruct
            {
                ServiceProviderName = context.ServiceProviderName,
                OriginTrackDataHash = originTrackDataHash,
                OriginTrackContent = paramConfig.TrackContentName != null
                    ? trackToken[paramConfig.TrackContentName]?.Value<string>()
                    : GlobalConst.EmptyString
            },
            SubSystemId = context.SubSystemId,
            TrackCode = matchedContentConfig.TrackContentCode,
            TrackPlace = trackPlace ?? GlobalConst.EmptyString,
            TrackTime = trackTime ?? DateTime.Now,
            TrackTimeZone = trackTimeZone ?? GlobalConst.NoneTrackTimeZone,
            DeficiencyTagValue = deficiencyTagValue,
            IsAdd = true,
        };

        await _capPublisher.PublishAsync(GlobalConst.TrackUpsertForRefreshSubscribe, trackUpsertEvent);
    }

    /// <summary>
    /// 触发了兜底，但是没有兜底住，对订单进行标记
    /// 1表示时区，2表示发生地，3表示两种
    /// </summary>
    /// <param name="hasPlaceBottomLine"></param>
    /// <param name="hasTimezoneBottomLine"></param>
    /// <param name="trackToken"></param>
    /// <param name="context"></param>
    /// <returns></returns>
    private int CalcDeficiencyTagValue(bool hasPlaceBottomLine, bool hasTimezoneBottomLine, JToken trackToken,
        TrackRefreshContext context)
    {
        var deficiencyTagValue = 0;

        if (hasTimezoneBottomLine)
        {
            _logger.LogWarning("订单号：{@OrderNo}, 轨迹发生时区无法解析，触发了兜底，但是没有兜底住：{@Data}", context.OrderNo,
                trackToken.ToString());
            deficiencyTagValue += 1;
        }

        if (hasPlaceBottomLine)
        {
            _logger.LogWarning("订单号：{@OrderNo}, 轨迹发生地无法解析，触发了兜底，但是没有兜底住：{@Data}", context.OrderNo,
                trackToken.ToString());
            deficiencyTagValue += 2;
        }

        return deficiencyTagValue;
    }

    private async Task InsertNotMappedTrackAsync(JToken trackToken, TrackRefreshContext context, string? trackPlace,
        DateTime? trackTime, float? trackTimeZone, TrackPullParamConfigDto paramConfig)
    {
        // 新增服务商轨迹到es
        var track = new TrackDetailsIndex
        {
            IndexName = $"{GlobalConst.TrackIndex}-{DateTime.Now:yyyy.MM.dd}",
            SubSystemId = context.SubSystemId,
            OrderId = context.OrderId,
            OrderType = context.OrderType,
            OrderNo = context.OrderNo,
            TrackPlace = trackPlace ?? GlobalConst.EmptyString,
            TrackTime = trackTime ?? DateTime.Now,
            TrackTimeZone = trackTimeZone ?? GlobalConst.NoneTrackTimeZone,
            ServiceProviderName = context.ServiceProviderName,
            OriginTrackDataHash = StringHelper.GetHash(JsonConvert.SerializeObject(trackToken)),
            CreateUser = GlobalConst.SystemUser,
            CreateTime = DateTime.Now
        };
        if (!paramConfig.TrackContentName.IsNullOrWhiteSpace())
        {
            track.OriginTrackContent =
                trackToken[paramConfig.TrackContentName!]?.Value<string>() ?? GlobalConst.EmptyString;
        }

        track.ZeroTrackTime = Math.Abs(track.TrackTimeZone - GlobalConst.NoneTrackTimeZone) < 1
            ? track.TrackTime
            : track.TrackTime.Subtract(TimeSpan.FromHours(track.TrackTimeZone));

        await _trackDetailsRepository.AddAsync(track);
    }

    /// <summary>
    /// 获取轨迹时区
    /// </summary>
    /// <param name="paramConfig">配置信息</param>
    /// <param name="matchedContentConfig">配置信息</param>
    /// <param name="context">订单id</param>
    /// <param name="trackToken"></param>
    /// <returns>时区,是否执行了兜底轨迹时区</returns>
    private async Task<(float? trackTimeZone, bool hasTimezoneBottomLine)> GetTimezone(
        TrackPullParamConfigDto paramConfig, TrackPullContentConfigDto? matchedContentConfig,
        TrackRefreshContext context,
        JToken trackToken)
    {
        // 轨迹发生时区
        var trackTimeZone = paramConfig.TrackTimeZoneName == null
            ? null
            : trackToken[paramConfig.TrackTimeZoneName]?.Value<float>();

        bool hasTimezoneBottomLine = false; //执行了兜底但是没有兜底住，需要记录
        if (!trackTimeZone.HasValue && matchedContentConfig?.TrackZonePlaceValue is not null)
        {
            //兜底没配置的就不需要兜底，拉取的发生地没就没
            var timezone = await GetTimezone(matchedContentConfig, context.OrderId);

            trackTimeZone = timezone;
            hasTimezoneBottomLine = !timezone.HasValue;
        }

        return (trackTimeZone, hasTimezoneBottomLine);
    }

    /// <summary>
    /// 获得轨迹地址
    /// </summary>
    /// <param name="paramConfig">配置信息</param>
    /// <param name="matchedContentConfig">配置信息</param>
    /// <param name="context">订单id</param>
    /// <param name="trackToken"></param>
    /// <returns>时区,是否执行了兜底轨迹时区</returns>
    private async Task<(string? trackPlace, bool hasPlaceBottomLine)> GetTrackPlace(TrackPullParamConfigDto paramConfig,
        TrackPullContentConfigDto? matchedContentConfig, TrackRefreshContext context, JToken trackToken)
    {
        // 轨迹发生地
        var trackPlace = paramConfig.TrackPlaceName == null
            ? null
            : trackToken[paramConfig.TrackPlaceName]?.Value<string>();
        var hasPlaceBottomLine = false; //执行了兜底但是没有兜底住，需要记录
        if (trackPlace.IsNullOrWhiteSpace() && matchedContentConfig?.TrackPlaceValue is not null)
        {
            //兜底没配置的就不需要兜底，拉取的发生地没就没
            trackPlace = await GetPlaceByOrder(matchedContentConfig!.TrackPlaceValue.Value, context.OrderId);
            hasPlaceBottomLine = string.IsNullOrWhiteSpace(trackPlace);
        }

        return (trackPlace, hasPlaceBottomLine);
    }

    /// <summary>
    /// 根据订单id获取兜底位置
    /// </summary>
    /// <param name="trackValue"></param>
    /// <param name="orderId"></param>
    /// <returns></returns>
    private Task<string?> GetPlaceByOrder(int trackValue, int orderId)
    {
        Expression<Func<OrderEntity, string?>> resultExpression =
            (TrackLocationValue) trackValue switch
            {
                TrackLocationValue.ArrivalPort => x => x.ArrivalPort,
                TrackLocationValue.ArriveCity => x => x.ArrivalCity,
                TrackLocationValue.ArrivalCountry => x => x.ArrivalCountry,
                TrackLocationValue.LeavePort => x => x.LeavePort,
                TrackLocationValue.LeaveCity => x => x.LeaveCity,
                TrackLocationValue.LeaveCountry => x => x.LeaveCountry,
                _ => x => x.LeaveCountry
            };
        return _orderRepository.GetFirstAsync(x => x.Id == orderId, resultExpression);
    }

    /// <summary>
    /// 获取时区
    /// </summary>
    /// <param name="matchedContentConfig"></param>
    /// <param name="orderId"></param>
    /// <returns></returns>
    private async Task<float?> GetTimezone(TrackPullContentConfigDto matchedContentConfig, int orderId)
    {
        var placeOrCode = await GetPlaceByOrder(matchedContentConfig!.TrackZonePlaceValue.Value, orderId);
        string timezone = null;
        if (!string.IsNullOrEmpty(placeOrCode))
        {
            if (matchedContentConfig!.TrackZonePlaceValue.Value == (int) TrackLocationValue.ArrivalPort
                || matchedContentConfig!.TrackZonePlaceValue.Value == (int) TrackLocationValue.LeavePort)
            {
                timezone = await _timezoneQueries.GetPortTimezone(placeOrCode);
                return DateTimeHelper.ConvertTimeZoneToFloat(timezone);
            }

            timezone = await _timezoneQueries.GetCityTimezone(placeOrCode);
            return DateTimeHelper.ConvertTimeZoneToFloat(timezone);
        }

        return null;
    }
}