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

namespace SJZY.Track.Application.Services.ProvideServices;

/// <summary>
/// 轨迹查询服务
/// </summary>
public partial class TrackService
{
    private readonly ITrackDetailsRepository _trackDetailsRepository;

    /// <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.Where(x => !x.IsNullOrWhiteSpace()).Distinct().ToList(); // 单号去重、去空
        var details = await _trackDetailsRepository.GetListAsync(input.OrderType, input.OrderNos);

        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 = x.TrackTime.AddHours(input.TimeZone ?? 8 - x.TrackTimeZone),
                TimeZone = input.TimeZone ?? 8
            }).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 _provideQueries
                    .GetOrderTemplateLinksAsync(input.OrderType, input.OrderNos);
                var distinctTemplateIds = orderTemplates.Select(x => x.TemplateId).Distinct().ToList();
                var templateContent = await _provideQueries.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) // 按模板
                            .Where(t => t.IsExternal) // 过滤不对外的
                            .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, "不支持的排序方式");
        }
    }
}