using SJZY.Track.Domain.OrderAggregate;
using SJZY.Track.Domain.TrackTemplateAggregate;
using SJZY.Track.Application.Dtos.ProvideServices;
using SJZY.Track.Domain;
using SJZY.Track.Repository.TrackDetails;

namespace SJZY.Track.Application.Services.ProvideServices;

[ApiExplorerSettings(GroupName = "TrackQuery")]
public class TrackQueryService : ApplicationService
{
    private readonly ITrackDetailsRepository _trackDetailsRepository;
    private readonly IOrderRepository _orderRepository;
    private readonly ITrackTemplateRepository _trackTemplateRepository;

    public TrackQueryService(ITrackDetailsRepository trackDetailsRepository, IOrderRepository orderRepository,
        ITrackTemplateRepository trackTemplateRepository)
    {
        _trackDetailsRepository = trackDetailsRepository;
        _orderRepository = orderRepository;
        _trackTemplateRepository = trackTemplateRepository;
    }

    [HttpPost("TrackQuery/GetTrack")]
    public async Task<List<GetTrackOutput>> GetTrackAsync(GetTrackInput input)
    {
        if (input.OrderNos.Count > 500)
        {
            throw new BusinessException(message: "最多只能查询500单");
        }

        var res = new List<GetTrackOutput>();
        var distinctOrderNumbers = input.OrderNos.Distinct().ToList();
        var details = await _trackDetailsRepository.GetListAsync(distinctOrderNumbers);
        var orderTemplates = await _orderRepository.GetOrderTemplatesAsync(distinctOrderNumbers);
        var distinctTemplateIds = orderTemplates.Select(x => x.TrackTemplateId).Distinct().ToList();
        var templateContents = await _trackTemplateRepository.GetTemplateContentsAsync(distinctTemplateIds);

        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,
                Date = x.TrackTime.AddHours(input.TimeZone - x.TraceTimeZone),
                TimeZone = x.TraceTimeZone
            }).ToList();

            TrackDetailSort(item, input.SortMethod);

            res.Add(item);
        }


        return res;
    }

    public async Task CreateOrder()
    {
        using var tran = TransactionHelper.GetReadCommitted();
        await _orderRepository.InsertAsync(new OrderEntity());
        await _orderRepository.CreateOrderTemplateAsync(new OrderTemplateEntity());

        tran.Complete();
    }

    private void TrackDetailSort(GetTrackOutput item, SortMethod sortMethod)
    {
        switch (sortMethod)
        {
            case SortMethod.ByTrackTime:
                // tips：quick-sort 直接修改原list
                item.TrackDetails.Sort((a, b) => a.Date.CompareTo(b.Date));
                break;
            case SortMethod.ByTrackTimeDesc:
                item.TrackDetails.Sort((a, b) => b.Date.CompareTo(a.Date));
                break;
            case SortMethod.ByTemplate:
            default:
                throw new ArgumentOutOfRangeException(nameof(sortMethod), sortMethod, "不支持的排序方式");
        }
    }
}