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;

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>();
        if (!input.OrderNos.IsNullOrWhiteSpace())
        {
            orderNoList = input.OrderNos.Split(new char[] { ',', '，', ':', '：' }).ToList();
        }

        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)
            .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,
                TrackTemplateNames = SqlFunc.Subqueryable<OrderTemplateEntity>()
                    .LeftJoin<TrackTemplateEntity>((aa, bb) => aa.TrackTemplateId == bb.Id)
                    .Where((aa, bb) => a.Id == aa.OrderId).SelectStringJoin((aa, bb) => bb.Name, ","),
                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 esTrackDetails = await _trackDetailsRepository.GetListAsync(orderIds);
            if (!esTrackDetails.IsNullOrEmpty())
            {
                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;
                        }
                    }
                });
            }
        }




        #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)
            .Where(a => orderNos.Contains(a.OrderNo))
            .Select((a, b) => new OrderTemplateVO
            {
                OrderNo = a.OrderNo,
                OrderType = a.OrderType,
                TemplateId = b.TrackTemplateId,
                ServiceProviderId = b.ServiceProviderId
            })
            .ToListAsync();
    }
}