using DotNetCore.CAP;
using Microsoft.AspNetCore.Authorization;
using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Aggregates.TrackPushAggregate;
using SJZY.Track.Domain.Consts;
using SJZY.UserCenter.HttpApi.Services;

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 轨迹推送服务
/// </summary>
[ApiExplorerSettings(GroupName = "提供接口")]
[Route("/ProviderService")]
public class TrackPushService : ApplicationService
{
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly IOrderRepository _orderRepository;
    private readonly ICapPublisher _capPublisher;
    private readonly ITrackPushRecordsRepository _trackPushRecordsRepository;

    public TrackPushService(ITrackDetailsRepository trackDetailsRepository
        , IOrderRepository orderRepository
        , ICapPublisher capPublisher
        , ITrackPushRecordsRepository trackPushRecordsRepository)
    {
        _trackDetailsRepository = trackDetailsRepository;
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _trackPushRecordsRepository = trackPushRecordsRepository;
    }

    /// <summary>
    /// 手工推送轨迹
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost("Track/Push")]
    public async Task<string> PushTrackAsync(PushTrackInput input)
    {
        input.OrderNos = input.OrderNos.Where(x => !x.IsNullOrWhiteSpace()).Distinct().ToList(); // 单号去重、去空

        var orderIds = await _orderRepository.GetArrayAsync(x =>
            x.OrderType == input.OrderType && input.OrderNos.Contains(x.OrderNo), x => x.Id);

        if (!orderIds.Any())
        {
            throw new BusinessException(message: "一个订单都不存在");
        }

        var tracks = await _trackDetailsRepository.GetListAsync(orderIds, input.TrackCode);
        tracks = tracks.DistinctBy(x => x.OrderId).ToList();

        if (tracks.Count == 0)
        {
            throw new BusinessException(message: "一个能推的轨迹都不存在");
        }

        var res = 0;

        foreach (var track in tracks)
        {
            var trackPushEvent = new TrackPushEvent
            {
                OptionType = OptionType.新增,
                OrderId = track.OrderId,
                OrderNo = track.OrderNo,
                TrackStatus = track.TrackStatus,
                TrackCode = track.TrackCode,
                TrackContent = track.TrackContent,
                TrackPlace = track.TrackPlace,
                TrackTime = track.TrackTime,
                TrackTimeZone = track.TrackTimeZone,
                OperationMan = CurrentUserRequest.CurrentUser.Name,
            };

            await _capPublisher.PublishAsync(GlobalConst.TrackPushSubscribe, trackPushEvent);

            res++;
        }

        return $"即将推送轨迹代码{input.TrackCode}给{res}个订单";
    }


    /// <summary>
    /// 定时任务推送预警（》12小时没有推送的）
    /// </summary>
    /// <returns></returns>
    [AllowAnonymous]
    [HttpPost("Track/PushWarnForTask")]
    public async Task<string> PushWarnForTaskAsync()
    {
        // todo：订单数据上来后一次性update是否会引发长时间X独占？
        var count = await _orderRepository.PushWarnOrdersAsync();
        return $"本次预警扫描了：{count}个订单";
    }

    /// <summary>
    /// 获取轨迹推送记录
    /// </summary>
    /// <returns></returns>
    /// <param name="input"></param>
    [HttpGet("Track/GetTrackPushRecords")]
    public async Task<List<TrackPushRecordIndex>> GetTrackPushRecordsAsync(OrderNoInfo input)
    {
        var orderId = await _orderRepository.GetFirstAsync(x =>
            x.OrderType == input.OrderType && input.OrderNo == x.OrderNo, x => x.Id);
        if (orderId == default)
        {
            throw new BusinessException(message: "订单不存在");
        }

        return await _trackPushRecordsRepository.GetTrackPushRecordsAsync(orderId);
    }
}