using SJZY.Track.Application.Contract.Dtos.ProvideServices;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Queries;

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 轨迹查询服务
/// </summary>
[ApiExplorerSettings(GroupName = "提供接口")]
public class TrackQueryService : ApplicationService
{
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly ITrackQueries _trackQueries;

    public TrackQueryService(ITrackDetailsRepository trackDetailsRepository,
        ITrackQueries trackQueries)
    {
        _trackDetailsRepository = trackDetailsRepository;
        _trackQueries = trackQueries;
    }

    /// <summary>
    /// 根据订单号获取轨迹
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="BusinessException"></exception>
    [HttpPost("Track/Query")]
    public async Task<List<GetTrackOutput>> QueryAsync(GetTrackInput input)
    {
        if (input.OrderNos.Count > 500)
        {
            throw new BusinessException(message: "最多只能查询500单");
        }

        var res = new List<GetTrackOutput>();
        input.OrderNos = input.OrderNos.Distinct().ToList(); // 单号去重
        var details = await _trackDetailsRepository.GetListAsync(input.OrderType, input.OrderNos);

        var isTurn = input.TimeZone != 0;
        foreach (var group in details.GroupBy(x => x.OrderId))
        {
            var item = new GetTrackOutput();
            var trackDetails = group.ToList();
            item.OrderNo = trackDetails.First().OrderNo;

            item.TrackDetails = trackDetails.Select(x => new TrackDetail
            {
                Code = x.TrackCode,
                Status = x.TrackStatus,
                Content = x.TrackContent,
                Location = x.TrackPlace,
                Time = isTurn ? x.TrackTime.AddHours(input.TimeZone - x.TraceTimeZone) : x.TrackTime,
                TimeZone = isTurn ? input.TimeZone : x.TraceTimeZone
            }).ToList();

            res.Add(item);
        }

        await TrackDetailSort(res, input);

        return res;
    }

    private async Task TrackDetailSort(List<GetTrackOutput> list, GetTrackInput input)
    {
        switch (input.SortMethod)
        {
            case SortMethod.ByTrackTime:
                // tips：quick-sort 直接修改原list
                list.ForEach(item => item.TrackDetails.Sort((a, b) => a.Time.CompareTo(b.Time)));
                break;
            case SortMethod.ByTrackTimeDesc:
                list.ForEach(item => item.TrackDetails.Sort((a, b) => b.Time.CompareTo(a.Time)));
                break;
            case SortMethod.ByTemplate:
                var orderTemplates = await _trackQueries
                    .GetOrderTemplateLinksAsync(input.OrderType, input.OrderNos);
                var distinctTemplateIds = orderTemplates.Select(x => x.TemplateId).Distinct().ToList();
                var templateContent = await _trackQueries.GetOrderedTrackCodesAsync(distinctTemplateIds);
                list.ForEach(item =>
                {
                    var codes = new List<string>();
                    // 多模板拼接显示
                    foreach (var orderTemplate in orderTemplates.Where(x => x.OrderNo == item.OrderNo))
                    {
                        codes.AddRange(templateContent
                            .Where(t => t.TemplateId == orderTemplate.TemplateId)
                            .Select(t => t.Code));
                    }

                    item.TrackDetails = item.TrackDetails
                        .Where(x => codes.Contains(x.Code)) // 剔除不在模板内容中的元素
                        .OrderBy(x => codes.IndexOf(x.Code)) // 按照在模板内容的位置排序
                        .ToList();
                });
                break;
            default:
                throw new ArgumentOutOfRangeException(nameof(input.SortMethod), input.SortMethod, "不支持的排序方式");
        }
    }
}