using SJZY.Track.Domain;
using SJZY.Track.Domain.Aggregates.OrderAggregate;
using SJZY.Track.Domain.Aggregates.TrackDetailsAggregate;
using SJZY.Track.Domain.Aggregates.TrackTemplateAggregate;
using SJZY.Track.Domain.Dtos.Order;
using SJZY.Track.Domain.VEntities;
using SJZY.Track.Repository.VData.Entitys;
using SqlSugar;

namespace SJZY.Track.Repository.Repositories;

public class OrderRepository : BasicRepository<OrderEntity>, IOrderRepository, ITransientDependency
{
    private readonly ITrackDetailsRepository _trackDetailsRepository;

    public OrderRepository(
        ITrackDetailsRepository trackDetailsRepository
    )
    {
        this._trackDetailsRepository = trackDetailsRepository;
    }

    public async Task CreateOrderAsync(OrderEntity order)
    {
        using var tran = TransactionHelper.GetReadCommitted();

        var orderId = await InsertReturnIdentityAsync(order);
        order.OrderTemplates.ForEach(x => x.OrderId = orderId);
        await Context.Insertable(order.OrderTemplates).ExecuteCommandAsync();
        order.OrderFlights.ForEach(x => x.OrderId = orderId);
        await Context.Insertable(order.OrderFlights).ExecuteCommandAsync();

        tran.Complete();
    }

    public async Task UpdateOrderAsync(OrderEntity order)
    {
        using var tran = TransactionHelper.GetReadCommitted();

        // 更新订单主表
        await UpdateAsync(order, x => new { x.CustomId, x.SubSystemId });

        // 更新订单模板
        await Context.Deleteable<OrderTemplateEntity>().Where(x => x.OrderId == order.Id).ExecuteCommandAsync();
        order.OrderTemplates.ForEach(x => x.OrderId = order.Id);
        await Context.Insertable(order.OrderTemplates).ExecuteCommandAsync();

        // 更新订单航班
        await Context.Deleteable<OrderFlightEntity>().Where(x => x.OrderId == order.Id).ExecuteCommandAsync();
        order.OrderFlights.ForEach(x => x.OrderId = order.Id);
        await Context.Insertable(order.OrderFlights).ExecuteCommandAsync();

        tran.Complete();
    }

    public async Task DeleteOrderAsync(int orderId)
    {
        using var tran = TransactionHelper.GetReadCommitted();

        // 软删订单主表
        await SoftDeleteAsync(x => x.Id == orderId);

        // 软删订单模板
        // 软删订单航班
        // 软删订单关联关系

        tran.Complete();
    }

    #region 订单关联

    public async Task<List<LinkedOrderVO>> GetLinkedOrdersAsync(int orderId)
    {
        return await Context.Queryable<OrderLinkEntity>()
            .LeftJoin<OrderEntity>((a, b) => a.LinkOrderId == b.Id)
            .Where(a => a.OrderId == orderId)
            .Select((a, b) => new LinkedOrderVO
            {
                OrderId = b.Id,
                OrderType = b.OrderType,
                OrderNo = b.OrderNo,
                SubSystemId = b.SubSystemId,
                IsPushCompleted = b.IsPushCompleted,
                CustomId = b.CustomId
            })
            .ToListAsync();
    }

    public async Task LinkOrderAsync(List<OrderLinkEntity> orderLinkEntities)
    {
        await Context.Insertable(orderLinkEntities).ExecuteCommandAsync();
    }

    public async Task UnLinkByIdsAsync(List<int> linkIds)
    {
        await Context.Deleteable(linkIds).ExecuteCommandAsync();
    }

    #endregion

    #region 轨迹订单明细

    ///// <summary>
    ///// 根据轨迹订单id获取轨迹明细列表
    ///// </summary>
    ///// <param name="input"></param>
    ///// <returns></returns>
    //public async Task<List<TrackOrderDetailVO>> GetOrderDetails(GetOrderDetailsInputVO input)
    //{
    //    return null;
    //}

    #endregion

    #region 轨迹订单分页

    /// <summary>
    /// 获取分页的轨迹订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<UnifyPageResultDto<TrackOrderVO>> GetPageTrackOrder(GetPageTrackOrderInputVO input)
    {
        List<string> orderNoList = new List<string>();
        List<int> questionTypeIds = new List<int>();
        if (!input.OrderNos.IsNullOrWhiteSpace())
        {
            orderNoList = input.OrderNos.Split(new char[] { ',', '，', ':', '：' }).ToList();
        }
        if (input.TabType==1)
        {
            questionTypeIds= new List<int> { 1, 4 };
        }
        else if (input.TabType==2)
        {
            questionTypeIds= new List<int> { 2, 4 };
        }

        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(!orderNoList.IsNullOrEmpty(), (a, b, c) => orderNoList.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.TabType>0 && (!questionTypeIds.IsNullOrEmpty()), (a, b, c) => questionTypeIds.Contains(a.QuestionType))
            .OrderByDescending((a, b, c) => a.CreateTime)
            .Select((a, b, c) => new TrackOrderVO
            {
                Id = a.Id,
                OrderNumber = a.OrderNo,
                OrderType = a.OrderType,
                OrderTypeName = SqlFunc.IF(a.OrderType == 1).Return("干线提单").ElseIF(a.OrderType == 2).Return("小包运单")
                    .ElseIF(a.OrderType == 3)
                    .Return("箱/袋单").ElseIF(a.OrderType == 4).Return("FBA订单").End(""),
                CustomerShortName = b.Abbreviation,
                CustomerCode = b.Code,
                CustomerId = a.CustomId,
                QuestionType = a.QuestionType,
                QuestionTypeName = SqlFunc.IF(a.QuestionType == 1).Return("异常").ElseIF(a.QuestionType == 2).Return("预警").End(""),
                ProblemDescription = a.ProblemDescription,
                ProblemDescriptionName =SqlFunc.IF(a.ProblemDescription == 1).Return("推送异常").ElseIF(a.ProblemDescription == 2).Return("推送预警").End(""),
                //TrackTemplateNames = SqlFunc.Subqueryable<OrderTemplateEntity>()
                //    .LeftJoin<TrackTemplateEntity>((aa, bb) => aa.TrackTemplateId == bb.Id)
                //    .Where((aa, bb) => a.Id == aa.OrderId).SelectStringJoin((aa, bb) => bb.Name, ","),

                //TrackTemplateIds = SqlFunc.Subqueryable<OrderTemplateEntity>()
                //    .LeftJoin<TrackTemplateEntity>((aa, bb) => aa.TrackTemplateId == bb.Id)
                //    .Where((aa, bb) => a.Id == aa.OrderId).SelectStringJoin((aa, bb) => bb.Id, ","),
                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 { OrderId = a.OrderId, Name = b.Name, TemplateId = b.Id })
                .ToListAsync();
            var esTrackDetails = await _trackDetailsRepository.GetListAsync(orderIds);
            pageList.List.ForEach(a =>
            {
                var esDetails = esTrackDetails?.Where(b => b.OrderId == a.Id).OrderByDescending(b => b.TrackTime);
                var trackDetail = esDetails?.FirstOrDefault();
                if (trackDetail != null)
                {
                    if (trackDetail.TrackContent != a.NewestTrackContent)
                    {
                        a.NewestTrackContent = trackDetail.TrackContent;
                    }

                    if (trackDetail.TrackEnContent != a.NewestTrackEnContent)
                    {
                        a.NewestTrackEnContent = trackDetail.TrackEnContent;
                    }

                    if (trackDetail.TrackPlace != a.NewestTrackPlace)
                    {
                        a.NewestTrackPlace = trackDetail.TrackPlace;
                    }

                    if (trackDetail.TrackTime != a.NewestTrackTime)
                    {
                        a.NewestTrackTime = trackDetail.TrackTime;
                    }
                }

                a.TrackTemplateNames = trackTemplateList.Where(b => b.OrderId == a.Id).Select(a => a.Name)
                    .JoinAsString(",");
                a.TrackTemplateIds = trackTemplateList.Where(b => b.OrderId == a.Id).Where(b => b.TemplateId>0).Select(a => a.TemplateId).ToList();
            });
        }


        #region 暂时注释

        //if (pageList.List.Any())
        //{
        //    var orderIds = pageList.List.Select(a => a.Id);
        //    //查询轨迹模版


        //    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 { OrderId = a.OrderId, Name = b.Name })
        //         .ToListAsync();

        //    pageList.List.ForEach(a =>
        //    {
        //        var templateListOfOrderId = trackTemplateList.Where(b => b.OrderId== a.Id);
        //        a.TrackTemplateNames  = templateListOfOrderId.Select(c => c.Name).JoinAsString(",");
        //    });
        //}

        #endregion

        return pageList;
    }

    #endregion


    public async Task<List<OrderTemplateVO>> GetOrderTemplatesAsync(List<string> orderNos)
    {
        return await Context.Queryable<OrderEntity>()
            .LeftJoin<OrderTemplateEntity>((a, b) => a.Id == b.OrderId)
            .LeftJoin<VServiceProviderEntity>((a, b, c) => b.ServiceProviderId == c.Id)
            .Where(a => orderNos.Contains(a.OrderNo))
            .Select((a, b, c) => new OrderTemplateVO
            {
                OrderNo = a.OrderNo,
                OrderType = a.OrderType,
                TemplateId = b.TrackTemplateId,
                ServiceProviderId = b.ServiceProviderId,
                ServiceProviderCode = c.Code,
                SubSystemId = a.SubSystemId
            })
            .ToListAsync();
    }
}