using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.Enums;
using SJZY.Track.Domain.Queries;
using SJZY.Track.Domain.VEntities;
using SJZY.Track.Repository.VData.Entitys;

namespace SJZY.Track.Repository.Queries;

public class TrackOrderQueries : ISugarRepository, ITrackOrderQueries,
    ITransientDependency
{
    public ISqlSugarClient Context { get; set; }

    public TrackOrderQueries()
    {
        Context = SqlsugarScopeBasic.GetContextSafely("default");
    }

    /// <summary>
    /// 获取分页的轨迹订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<UnifyPageResultDto<TrackOrderVO>> GetPageTrackOrder(GetPageTrackOrderInputVO input)
    {
        var pageList = await Context.Queryable<OrderEntity>()
            .LeftJoin<VExternalSubjectEntity>((a, b) => a.CustomId == b.Id && b.IsDeleted == false)
            .LeftJoin<VSystemEntity>((a, b, c) => a.SubSystemId == c.Id && c.IsDeleted == false)
            .WhereIF(input.SubSystemId > 0, (a, b, c) => a.SubSystemId == input.SubSystemId)
            .WhereIF(!input.OrderNos.IsNullOrEmpty(), (a, b, c) => input.OrderNos!.Contains(a.OrderNo))
            .WhereIF(input.CreateTimeStart.HasValue && input.CreateTimeEnd.HasValue,
                (a, b, c) => a.CreateTime >= input.CreateTimeStart && a.CreateTime <= input.CreateTimeEnd)
            .WhereIF(input.CreateTimeStart.HasValue && (!input.CreateTimeEnd.HasValue),
                (a, b, c) => a.CreateTime >= input.CreateTimeStart)
            .WhereIF((!input.CreateTimeStart.HasValue) && input.CreateTimeEnd.HasValue,
                (a, b, c) => a.CreateTime <= input.CreateTimeEnd)
            .WhereIF(input.CustomerId > 0, (a, b, c) => a.CustomId == input.CustomerId)
            .WhereIF(input.TrackOrderType > 0, (a, b, c) => a.OrderType == input.TrackOrderType)
            .WhereIF(input.TabType > 0, (a, b, c) => a.QuestionType == input.TabType)
            .WhereIF(input.TabType == (int)TrackProblemType.Warn, (a, b, c) => !a.IsCompleted)
            .OrderByDescending((a, b, c) => a.CreateTime)
            .Select((a, b, c) => new TrackOrderVO
            {
                Id = a.Id,
                OrderNumber = a.OrderNo,
                OrderType = a.OrderType,
                QuestionType = a.QuestionType,
                CustomerShortName = b.Abbreviation,
                CustomerCode = b.Code,
                CustomerId = a.CustomId,
                NewestTrackContent = a.LatestTrackContent,
                NewestTrackEnContent = a.LatestTrackEnContent,
                NewestTrackPlace = a.LatestTrackPlace,
                NewestTrackTime = a.LatestTrackTime,
                IsFinish = a.IsCompleted,
                CreateTime = a.CreateTime,
                SubSystem = c.CnName,
                SubSystemId = c.Id
            })
            .ToPagedListAsync(input.PageIndex, input.PageSize);

        if (pageList.List.Any())
        {
            //查询也需要最新的轨迹
            var orderIds = pageList.List.Select(a => a.Id).ToList();
            //查询轨迹模版
            var trackTemplateList = await Context.Queryable<OrderTemplateEntity>()
                .LeftJoin<TrackTemplateEntity>((a, b) => a.TrackTemplateId == b.Id)
                .Where((a, b) => orderIds.Contains(a.OrderId))
                .Select((a, b) => new { a.OrderId, b.Name, TemplateId = b.Id })
                .ToListAsync();
            pageList.List.ForEach(a =>
            {
                a.TrackTemplateNames = trackTemplateList.Where(b => b.OrderId == a.Id).Select(x => x.Name)
                    .JoinAsString(",");
                a.TrackTemplateIds = trackTemplateList.Where(b => b.OrderId == a.Id).Where(b => b.TemplateId > 0)
                    .Select(x => x.TemplateId).ToList();
            });
        }

        return pageList;
    }

    public async Task<List<GetTrackCounterVO>> GetTrackProblemCountsAsync()
    {
        return await Context.Queryable<OrderEntity>()
            .GroupBy(x => x.QuestionType)
            .Select(x => new GetTrackCounterVO
            {
                ProblemType = x.QuestionType,
                Count = SqlFunc.AggregateCount(1)
            })
            .ToListAsync();
    }
}