using DotNetCore.CAP;
using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Application.Contract.Events;
using SJZY.Track.Application.Contract.Services;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackContentAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.UserCenter.HttpApi.Services;
using Volo.Abp.Http.Client.DynamicProxying;

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 轨迹服务
/// </summary>
[ApiExplorerSettings(GroupName = "提供接口")]
[Route("/ProviderService")]
public partial class TrackService : ApplicationService, ITrackService
{
    private readonly ICapPublisher _capPublisher;
    private readonly IOrderRepository _orderRepository;
    private readonly IHttpClientProxy<IRequestCurrentUserService> _requestCurrentUserService;
    private readonly ITrackContentRepository _trackContentRepository;

    public TrackService(IOrderRepository orderRepository, ICapPublisher capPublisher,
        ITrackDetailsEsRepository trackDetailsEsRepository, ITrackContentRepository trackContentRepository,
        IHttpClientProxy<IRequestCurrentUserService> requestCurrentUserService)
    {
        _orderRepository = orderRepository;
        _capPublisher = capPublisher;
        _trackContentRepository = trackContentRepository;
        _requestCurrentUserService = requestCurrentUserService;
        _trackDetailsEsRepository = trackDetailsEsRepository;
    }

    /// <summary>
    /// 新增、更新轨迹（存在就更新）
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Track/Upsert")]
    public async Task<UnifyResultDto> UpsertTrackAsync(UpsertTrackInput input)
    {
        var order = await _orderRepository.GetFirstAsync(x =>
                x.SubSystemId == input.SubSystemId && x.OrderType == input.OrderType && x.OrderNo == input.OrderNo,
            x => new
            {
                x.Id,
                x.CustomId
            });
        if (order == default)
        {
            throw new BusinessException(message: $"订单：{input.OrderNo}不存在");
        }

        var userInfo = await _requestCurrentUserService.Service.GetCurrentUserBasicInfoAsync();
        if (userInfo.Code != GlobalConst.SuccessCode || userInfo.Data is null)
        {
            //TODO: log || ex
            throw new BusinessException(message: $"调用用户中心，获取用户信息失败:{userInfo.Msg}");
        }

        var name = userInfo.Data.UserName;

        // 新增/更新轨迹
        var @event = ObjectMapper.Map<UpsertTrackInput, TrackUpsertEvent>(input);
        @event.SubSystemId = input.SubSystemId;
        @event.CustomId = order.CustomId;
        @event.OrderIdentifiers = new[]
        {
            new OrderIdentifier
            {
                OrderId = order.Id,
                OrderNo = input.OrderNo,
                OrderType = input.OrderType,
            }
        };
        @event.OperationMan = name;
        await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, @event);
        return new UnifyResultDto(true, true);
    }

    /// <summary>
    /// 删除轨迹
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Track/Delete")]
    public async Task<UnifyResultDto> DeleteTrackAsync(DeleteTrackInput input)
    {
        var orderId = await _orderRepository.GetFirstAsync(
            x => x.SubSystemId == input.SubSystemId && x.OrderType == input.OrderType && x.OrderNo == input.OrderNo,
            x => x.Id);
        if (orderId == default)
        {
            throw new BusinessException(message: $"订单：{input.OrderNo}不存在");
        }

        var userInfo = await _requestCurrentUserService.Service.GetCurrentUserBasicInfoAsync();
        if (userInfo.Code != GlobalConst.SuccessCode || userInfo.Data is null)
        {
            //TODO: log || ex
            throw new BusinessException(message: $"调用用户中心，获取用户信息失败:{userInfo.Msg}");
        }

        var name = userInfo.Data.UserName;

        // 删除轨迹
        var @event = new TrackDeleteEvent
        {
            OrderIds = new[] { orderId },
            TrackCodes = input.TrackCodes,
            SubSystemId = input.SubSystemId,
            OperationMan = name
        };
        await _capPublisher.PublishAsync(GlobalConst.TrackDeleteSubscribe, @event);

        return new UnifyResultDto(true, true);
    }

    /// <summary>
    /// 批量删除轨迹
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Track/BatchDelete")]
    public async Task<UnifyResultDto> BatchDeleteTrackAsync(BatchDeleteTrackInput input)
    {
        input.OrderNos = input.OrderNos.Where(x => !x.IsNullOrWhiteSpace()).Distinct().ToList(); // 单号去重、去空
        var orderIds = await _orderRepository.GetListAsync(x =>
                x.SubSystemId == input.SubSystemId && x.OrderType == input.OrderType &&
                input.OrderNos.Contains(x.OrderNo)
            , x => x.Id);

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

        // 获取用户name
        var userInfo = await _requestCurrentUserService.Service.GetCurrentUserBasicInfoAsync();
        if (userInfo.Code != GlobalConst.SuccessCode || userInfo.Data is null)
        {
            throw new BusinessException(message: $"调用用户中心，获取用户信息失败:{userInfo.Msg}");
        }

        // 删除轨迹
        var @event = new TrackDeleteEvent
        {
            OrderIds = orderIds.ToArray(),
            TrackCodes = input.TrackCodes,
            SubSystemId = input.SubSystemId,
            OperationMan = userInfo.Data.UserName
        };
        await _capPublisher.PublishAsync(GlobalConst.TrackDeleteSubscribe, @event);

        return new UnifyResultDto(true, true);
    }

    /// <summary>
    /// 批量新增、更新轨迹
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Track/BatchUpsert")]
    public async Task<UnifyResultDto> BatchUpsertTrackAsync(BatchUpsertTrackInput input)
    {
        input.OrderNos = input.OrderNos.Where(x => !x.IsNullOrWhiteSpace()).Distinct().ToList(); // 单号去重、去空
        var orders = await _orderRepository.GetListAsync(x =>
                x.SubSystemId == input.SubSystemId && x.OrderType == input.OrderType &&
                input.OrderNos.Contains(x.OrderNo),
            x => new
            {
                x.Id,
                x.OrderNo,
                x.CustomId
            });

        if (orders.Count == 0)
        {
            throw new BusinessException(message: "订单一个都不存在");
        }

        // 获取用户name
        var userInfo = await _requestCurrentUserService.Service.GetCurrentUserBasicInfoAsync();
        if (userInfo.Code != GlobalConst.SuccessCode || userInfo.Data is null)
        {
            throw new BusinessException(message: $"调用用户中心，获取用户信息失败:{userInfo.Msg}");
        }

        // 按客户新增/更新轨迹（为了推送轨迹时方便）
        foreach (var group in orders.GroupBy(x => x.CustomId))
        {
            var @event = new TrackUpsertEvent
            {
                SubSystemId = input.SubSystemId,
                CustomId = group.Key,
                OrderIdentifiers = group.Select(order => new OrderIdentifier
                {
                    OrderId = order.Id,
                    OrderNo = order.OrderNo,
                    OrderType = input.OrderType,
                }).ToArray(),
                IsAdd = input.IsAdd,
                TrackCode = input.TrackCode,
                TrackPlace = input.TrackPlace,
                TrackTime = input.TrackTime,
                TrackTimeZone = input.TrackTimeZone,
                OperationMan = userInfo.Data.UserName
            };
            await _capPublisher.PublishAsync(GlobalConst.TrackUpsertSubscribe, @event);
        }

        return new UnifyResultDto(true, true);
    }
}