using System.Diagnostics;
using System.Linq.Expressions;
using DotNetCore.CAP;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
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.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Enums;
using Volo.Abp.DependencyInjection;

namespace SJZY.Track.Application.EventHandlers;

public class TrackRefreshEventHandler : ITransientDependency, ICapSubscribe
{
    private readonly IOrderRepository _orderRepository;
    private readonly ICapPublisher _capPublisher;
    private readonly ITrackPullCacheService _trackPullCacheService;

    public TrackRefreshEventHandler(IOrderRepository orderRepository,
        ICapPublisher capPublisher, ITrackPullCacheService trackPullCacheService)
    {
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _trackPullCacheService = trackPullCacheService;
    }

    [CapSubscribe(GlobalConst.TrackRefreshSubscribe)]
    public async Task ConsumerAsync(InterfaceRelayForwardReplayEvent @event)
    {
        // tips：attach返回的是服务商id，必有
        var attach = JsonConvert.DeserializeObject<TrackRefreshAttach>(@event.Attach);
        if (attach is null) return;
        var config =
            await _trackPullCacheService.GetPullParamWithContentConfigAsync(attach.SubSystemId,
                attach.ServiceProviderId);

        var data = JObject.Parse(@event.Data.ToString()!);
        var orderToken = data[config.ParamConfig.OrderPath];
        if (orderToken is JArray orderTokens)
        {
            foreach (var token in orderTokens)
            {
                await HandleOrderAsync(token, config, attach.OrderType);
            }
        }
        else if (orderToken is JObject)
        {
            await HandleOrderAsync(orderToken, config, attach.OrderType);
        }
    }

    private async Task HandleOrderAsync(JToken orderToken, TrackPullParamWithContentConfigDto paramWithContentConfig,
        int orderType)
    {
        var paramConfig = paramWithContentConfig.ParamConfig;
        var orderNo = orderToken[paramConfig.OrderNoName]?.Value<string>();
        if (orderNo.IsNullOrWhiteSpace()) return;

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

        var trackToken = orderToken[paramConfig.TrackDetailsPath];
        if (trackToken is null) return;
        var trackUpsertEvent = new TrackUpsertEvent
        {
            OrderId = order.Id,
            SubSystemId = order.SubSystemId,
            LatestPushTrackContentId = order.LatestPushTrackContentId,
            CustomId = order.CustomId,
            OrderType = orderType,
            OrderNo = orderNo!,
        };

        if (trackToken is JArray trackTokens)
        {
            foreach (var item in trackTokens)
            {
                await HandleTrackAsync(item, paramWithContentConfig, trackUpsertEvent);
            }
        }
        else if (orderToken is JObject)
        {
            await HandleTrackAsync(orderToken, paramWithContentConfig, trackUpsertEvent);
        }
    }

    private async Task HandleTrackAsync(JToken trackToken, TrackPullParamWithContentConfigDto paramWithContentConfig,
        TrackUpsertEvent @event)
    {
        var trackUpsertEvent = @event.DeepCopy();
        var paramConfig = paramWithContentConfig.ParamConfig;
        var contentConfigs = paramWithContentConfig.ContentConfigs;
        TrackPullContentConfigDto? matchedContentConfig = null;

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

                // 按关键字分析轨迹内容
                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;
                            }
                        }
                    }
                }
            }
        }

        if (matchedContentConfig is null) return;

        // 轨迹发生地
        var trackPlace = paramConfig.TrackPlaceName == null
            ? null
            : trackToken[paramConfig.TrackPlaceName]?.Value<string>();
        if (trackPlace.IsNullOrWhiteSpace())
        {
            Expression<Func<OrderEntity, string?>> resultExpression =
                (TrackLocationValue?)matchedContentConfig.TrackPlaceValue 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
                };
            trackPlace = await _orderRepository.GetFirstAsync(x =>
                x.Id == trackUpsertEvent.OrderId, resultExpression);
        }

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

        // 新增/更新轨迹
        trackUpsertEvent.TrackCode = matchedContentConfig.TrackContentCode;
        trackUpsertEvent.TrackPlace = trackPlace ?? "CN";
        trackUpsertEvent.TrackTime = trackTime ?? DateTime.Now;
        trackUpsertEvent.TrackTimeZone = trackTimeZone ?? matchedContentConfig.TrackTimeZoneValue ?? 8;
        await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, trackUpsertEvent);
    }
}