using Nest;
using SJZY.Expand.ElasticSearch.Services;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Dtos.TrackDetails;

namespace SJZY.Track.Infrastructure.Repositories;

internal class TrackDetailsRepository : ElasticSearchContextAbstract<TrackDetailsIndex>, ITrackDetailsRepository,
    ITransientDependency
{
    public string IndexName => $"{TrackDetailsIndex.IndexName}-{DateTime.Now:yyyy.MM.dd}";

    public TrackDetailsRepository(ConnectionFactory connectionFactory) : base(connectionFactory)
    {
    }

    public async Task<TrackDetailsIndex?> GetFirstOrDefaultAsync(int orderId, string trackCode)
    {
        var r = await Context.SearchAsync<TrackDetailsIndex>(s => s
            .Index($"{TrackDetailsIndex.IndexName}-{DateTime.Now:yyyy.MM.dd}")
            .Query(q =>
                q.Term(t => t.Field(f => f.OrderId).Value(orderId))
                && q.Term(t => t.Field(f => f.TrackCode).Value(trackCode))
            )
        );

        if (r.IsValid)
        {
            return r.Documents.FirstOrDefault();
        }

        return default;
    }

    public async Task UpdateAsync(TrackDetailsIndex index)
    {
        var response = await Context.UpdateAsync<TrackDetailsIndex>(index.Id, u => u
                .Index(IndexName)
                .Doc(index)
        //.Refresh(Refresh.True) // 可选：立即刷新索引使更改立即可见
        );
        if (!response.IsValid)
            throw new Exception($"数据修改失败，原因：{response.DebugInformation}");
    }

    public async Task CreateAsync(TrackDetailsIndex index)
    {
        var response = await Context.IndexAsync(index, request => request.Index(IndexName));
        if (!response.IsValid)
            throw new Exception($"数据添加失败，原因：{response.DebugInformation}");
    }

    public async Task<List<TrackDetailsIndex>> GetListAsync(int orderType, List<string> orderNos)
    {
        if (orderNos.Count < 1) return new List<TrackDetailsIndex>();

        var data = await Context.SearchAsync<TrackDetailsIndex>(x => x
            .Source(s => s.Includes(fd => fd
                .Field(f => f.TrackStatus)
                .Field(f => f.TrackCode)
                .Field(f => f.TrackContent)
                .Field(f => f.TrackPlace)
                .Field(f => f.TrackTime)
                .Field(f => f.TraceTimeZone)
            ))
            .Query(q =>
                q.Terms(t => t
                    .Field(f => f.OrderNo)
                    .Terms(orderNos))
                && q.Term(f => f.OrderType, orderType))
        );

        return data.Documents.ToList();
    }

    public async Task<List<TrackDetailsIndex>> GetListAsync(int orderId)
    {
        var data = await Context.SearchAsync<TrackDetailsIndex>(x => x
             .Source(s => s.Includes(fd => fd
                 .Field(f => f.TrackStatus)
                 .Field(f => f.TrackCode)
                 .Field(f => f.TrackContent)
                 .Field(f => f.TrackPlace)
                 .Field(f => f.TrackTime)
                 .Field(f => f.TraceTimeZone)
             )).Query(q => q.Terms(t => t.Field(f => f.OrderId).Terms(orderId))));

        return data?.Documents?.ToList();
    }

    public async Task<(List<TrackDetailsIndex> list, long total)> GetListAsync(TrackDetailsQueryInput input)
    {
        if (input.OrderNos.Count < 1) return default;

        var distinctOrderNumbers = input.OrderNos.Distinct();
        var finalSize = input.PageSize > 500 ? 500 : input.PageSize;

        var data = await Context.SearchAsync<TrackDetailsIndex>(x => x
                .Query(q => q.Terms(t => t
                    .Field(f => f.OrderNo)
                    .Terms(distinctOrderNumbers)))
                .Sort(s => s.Field(f => f.CreateTime, SortOrder.Descending))
                .From((input.PageIndex - 1) * input.PageSize)
                .Size(finalSize)
                .TrackTotalHits() // todo: 聚合获取匹配查询条件的文档总数，而不受"index.max_result_window"的限制
        );

        return (data.Documents.ToList(), data.Total);
    }
}