using BBWYB.Common.Extensions;
using BBWYB.Common.Http;
using BBWYB.Common.Log;
using BBWYB.Common.Models;
using BBWYB.Server.Business.Extensions;
using BBWYB.Server.Model;
using BBWYB.Server.Model.Db;
using BBWYB.Server.Model.Dto;
using FreeSql;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using SDKAdapter;
using SDKAdapter.OperationPlatform.Client;
using SDKAdapter.OperationPlatform.Models;
using System.Collections.Concurrent;
using System.Linq.Expressions;
using System.Security.Cryptography;
using Yitter.IdGenerator;

namespace BBWYB.Server.Business
{
    public class OrderBusiness : BaseBusiness, IDenpendency
    {

        private IList<Enums.PackConfigState?> waitConfigStateList;

        private Lazy<QiKuManager> qikuManagerLazy;
        private Lazy<OP_PlatformClientFactory> opPlatformClientFactoryLazy;
        private Lazy<RestApiService> restApiServiceLazy;

        private OP_PlatformClientFactory opPlatformClientFactory => opPlatformClientFactoryLazy.Value;
        private RestApiService restApiService => restApiServiceLazy.Value;
        private QiKuManager qikuManager => qikuManagerLazy.Value;

        private List<Enums.TimeLimitTaskType?> hgzTaskTypeList;

        public OrderBusiness(IFreeSql fsql, NLogManager nLogManager, IIdGenerator idGenerator, IServiceProvider serviceProvider) : base(fsql, nLogManager, idGenerator)
        {
            qikuManagerLazy = new Lazy<QiKuManager>(() => serviceProvider.GetService<QiKuManager>());
            opPlatformClientFactoryLazy = new Lazy<OP_PlatformClientFactory>(() => serviceProvider.GetService<OP_PlatformClientFactory>());
            restApiServiceLazy = new Lazy<RestApiService>(() => serviceProvider.GetService<RestApiService>());

            waitConfigStateList = new List<Enums.PackConfigState?>() { Enums.PackConfigState.待配置, Enums.PackConfigState.需修改 };

            hgzTaskTypeList = new List<Enums.TimeLimitTaskType?>()
            {
                Enums.TimeLimitTaskType.合格证拟定任务,
                Enums.TimeLimitTaskType.合格证补充任务
            };
        }

        private ISelect<Order, OrderConsignee, OrderCost> GetOrderListQueryConditions(QueryOrderRequest request)
        {
            var select = fsql.Select<Order, OrderConsignee, OrderCost>()
                             .LeftJoin((o, ocs, oct) => o.Id == ocs.OrderId)
                             .LeftJoin((o, ocs, oct) => o.Id == oct.OrderId);
            if (!string.IsNullOrEmpty(request.OrderId))
                select = select.Where((o, ocs, oct) => o.Id == request.OrderId);
            else if (!string.IsNullOrEmpty(request.OrderSn))
                select = select.Where((o, ocs, oct) => o.OrderSn == request.OrderSn);
            else
            {
                if (!string.IsNullOrEmpty(request.Sku) ||
                    !string.IsNullOrEmpty(request.SourceSku) ||
                    !string.IsNullOrEmpty(request.ProductId) ||
                    request.IsWaitConfig)
                {
                    var childSelect = fsql.Select<OrderSku>().As("osku")
                                          .WhereIf(!string.IsNullOrEmpty(request.Sku), osku => osku.SkuId == request.Sku)
                                          .WhereIf(!string.IsNullOrEmpty(request.SourceSku), osku => osku.BelongSkuId == request.SourceSku)
                                          .WhereIf(!string.IsNullOrEmpty(request.ProductId), osku => osku.ProductId == request.ProductId)
                                          .WhereIf(request.IsWaitConfig && request.IsOnlyDisplayPackConfigEditState != 1, osku => waitConfigStateList.Contains(osku.PackConfigState) || osku.PackConfigState == null)
                                          .WhereIf(request.IsWaitConfig && request.IsOnlyDisplayPackConfigEditState == 1, osku => osku.PackConfigState == Enums.PackConfigState.需修改);
                    select = select.WhereIf(request.IsWaitConfig, (o, ocs, oct) => o.OrderState != Enums.OrderState.已取消)
                                   .WhereIf(request.IsWaitConfig, (o, ocs, oct) => o.IntoStoreType == Enums.IntoStoreType.发回齐越)
                                   .WhereIf(request.IsWaitConfig, (o, ocs, oct) => o.IsPurchased == true)
                                   .Where((o, ocs, oct) => childSelect.Where(osku => osku.OrderId == o.Id).Any());

                    if (request.IsWaitConfig && request.IsOnlyDisplayCerConfigTimeOut == 1)
                    {
                        var configTimeOutChildSelect = fsql.Select<TimeLimitTask>().As("t")
                                                           .Where(t => t.ShopId == request.ShopId)
                                                           .Where(t => hgzTaskTypeList.Contains(t.TaskType))
                                                           .Where(t => t.IsTimely == false);
                        select = select.Where((o, ocs, oct) => configTimeOutChildSelect.Where(t => t.OrderId == o.Id).Any());
                    }
                }

                if (request.IsOnlyDisplayPurchaseTimeOut == 1 && (request.OrderState == Enums.OrderState.等待采购 || request.OrderState == Enums.OrderState.部分采购))
                {
                    var childSelect = fsql.Select<TimeLimitTask>().As("t")
                                          .Where(t => t.ShopId == request.ShopId)
                                          .Where(t => t.TaskType == Enums.TimeLimitTaskType.采购任务)
                                          .Where(t => t.IsTimely == false);
                    select = select.Where((o, ocs, oct) => childSelect.Where(t => t.OrderId == o.Id).Any());
                }

                if (request.IsOnlyDisplayCheckComputationTimeOut == 1 && request.OrderState == Enums.OrderState.待核算)
                {
                    var childSelect = fsql.Select<TimeLimitTask>().As("t")
                                          .Where(t => t.ShopId == request.ShopId)
                                          .Where(t => t.TaskType == Enums.TimeLimitTaskType.待核算任务)
                                          .Where(t => t.IsTimely == false);
                    select = select.Where((o, ocs, oct) => childSelect.Where(t => t.OrderId == o.Id).Any());
                }

                var isDeliveryTimeout = request.IsOnlyDisplayDeliveryTimeout == 1 && (request.OrderState == Enums.OrderState.待发货 || request.OrderState == Enums.OrderState.部分发货);
                if (isDeliveryTimeout || !string.IsNullOrEmpty(request.PurchaseOrderId))
                {
                    var childSelect = fsql.Select<OrderPurchaseInfo>().As("opi");
                    if (isDeliveryTimeout)
                    {
                        var before24hTime = DateTime.Now.AddHours(-24);
                        childSelect = childSelect.Where(opi => opi.ShopId == request.ShopId &&
                                                               (opi.OrderState == Enums.PurchaseOrderState.待发货 || opi.OrderState == Enums.PurchaseOrderState.部分发货) &&
                                                               opi.CreateTime < before24hTime);
                    }
                    if (!string.IsNullOrEmpty(request.PurchaseOrderId))
                    {
                        childSelect = childSelect.Where(opi => opi.PurchaseOrderId == request.PurchaseOrderId);
                    }
                    select = select.Where((o, ocs, oct) => childSelect.Where(opi => opi.OrderId == o.Id).Any());
                }

                select = select.WhereIf(request.OrderState == Enums.OrderState.待付款 ||
                                        request.OrderState == Enums.OrderState.待验收 ||
                                        request.OrderState == Enums.OrderState.待核算 ||
                                        request.OrderState == Enums.OrderState.已完成 ||
                                        request.OrderState == Enums.OrderState.已取消,
                                        (o, ocs, oct) => o.OrderState == request.OrderState)
                               .WhereIf(request.OrderState == Enums.OrderState.等待采购, (o, ocs, oct) => o.OrderState == Enums.OrderState.等待采购 ||
                                                                                                          o.OrderState == Enums.OrderState.部分采购)
                               .WhereIf(request.OrderState == Enums.OrderState.待发货, (o, ocs, oct) => o.OrderState == Enums.OrderState.待发货 ||
                                                                                                        o.OrderState == Enums.OrderState.部分发货)
                               .WhereIf(request.OrderState == Enums.OrderState.待收货, (o, ocs, oct) => o.OrderState == Enums.OrderState.待收货 ||
                                                                                                         o.OrderState == Enums.OrderState.部分收货)
                               .WhereIf(request.StartDate != null, (o, ocs, oct) => o.StartTime >= request.StartDate)
                               .WhereIf(request.EndDate != null, (o, ocs, oct) => o.StartTime <= request.EndDate)
                               .WhereIf(!string.IsNullOrEmpty(request.ClientOrderId), (o, ocs, oct) => o.ClientOrderId == request.ClientOrderId)
                               .WhereIf(!string.IsNullOrEmpty(request.SourceShopName), (o, ocs, oct) => o.SourceShopName == request.SourceShopName)
                               .WhereIf(request.IsOnlyDisplaySpecialOrder == 1, (o, ocs, oct) => o.IsSpecialOrder == 1)
                               .WhereIf(request.IsOnlyDisplaySendQiYue == 1, (o, ocs, oct) => o.IntoStoreType == Enums.IntoStoreType.发回齐越)
                               .WhereIf(request.IsOnlyDisplayPurchaserSendInStore == 1, (o, ocs, oct) => o.IntoStoreType == Enums.IntoStoreType.厂商代发入仓);
            }

            select = select.WhereIf(request.ShopId != null, (o, ocs, oct) => o.ShopId == request.ShopId);

            //select = select.Where((o, ocs, oct) => o.ShopId == searchOrderRequest.ShopId);

            return select;
        }

        private Expression<Func<Order, OrderConsignee, OrderCost, Order>> GetOrderListField()
        {
            return (o, ocs, oct) => new Order()
            {
                Id = o.Id,
                OrderSn = o.OrderSn,
                EndTime = o.EndTime,
                FreightPrice = o.FreightPrice,
                ModifyTime = o.ModifyTime,
                OrderPayment = o.OrderPayment,
                OrderSellerPrice = o.OrderSellerPrice,
                OrderState = o.OrderState,
                OrderTotalPrice = o.OrderTotalPrice,
                OrderType = o.OrderType,
                PayType = o.PayType,
                Platform = o.Platform,
                ShopId = o.ShopId,
                StartTime = o.StartTime,
                VenderRemark = o.VenderRemark,
                PurchaseRemark = o.PurchaseRemark,
                BuyerRemark = o.BuyerRemark,
                //WaybillNo = o.WaybillNo,
                SellerPreferentialAmount = o.SellerPreferentialAmount,
                PreferentialAmount = o.PreferentialAmount,
                ClientOrderId = o.ClientOrderId,
                SourceShopName = o.SourceShopName,
                //SourceSku = o.SourceSku,
                //ExpressName = o.ExpressName,
                IsPurchased = o.IsPurchased,
                BuyerAccount = o.BuyerAccount,
                InPackAmount = o.InPackAmount,
                IsWaitPack = o.IsWaitPack,
                IntoStoreType = o.IntoStoreType,
                PayTime = o.PayTime,
                IsSpecialOrder = o.IsSpecialOrder,

                ContactName = ocs.ContactName,
                Address = ocs.Address,
                Province = ocs.Province,
                County = ocs.County,
                Town = ocs.Town,
                City = ocs.City,
                Mobile = ocs.Mobile,
                TelePhone = ocs.TelePhone,

                DeliveryExpressFreight = oct.DeliveryExpressFreight,
                PlatformCommissionAmount = oct.PlatformCommissionAmount,
                PlatformCommissionRatio = oct.PlatformCommissionRatio,
                Profit = oct.Profit,
                PurchaseAmount = oct.PurchaseAmount,
                IsManualEdited = oct.IsManualEdited,
                PackConfigState = o.PackConfigState,
                SkuAmount = oct.SkuAmount,
                PurchaseFreight = oct.PurchaseFreight
            };
        }

        public OrderListResponse GetOrderList(QueryOrderRequest request)
        {
            if (request.EndDate != null)
                request.EndDate = request.EndDate.Value.Date.AddDays(1).AddSeconds(-1);

            var select = GetOrderListQueryConditions(request).OrderByDescending((o, ocs, oct) => o.StartTime)
                                                             .Count(out var total)
                                                             .Page(request.PageIndex, request.PageSize);

            var orderSourceList = select.ToList(GetOrderListField());
            var orderList = orderSourceList.Map<IList<OrderResponse>>();
            var orderIdList = orderList.Select(o => o.Id).ToList();

            if (orderList.Count() > 0)
            {
                #region 查询关联信息 
                var orderPurchaseRelationInfoList = fsql.Select<OrderPurchaseRelationInfo>().Where(ori => orderIdList.Contains(ori.OrderId)).ToList();
                #endregion

                #region 查询快递单信息
                var purchaseExpressOrderList = fsql.Select<ExpressOrderRelationInfo, PurchaseExpressOrder>()
                                                   .InnerJoin((eori, peo) => eori.WayBillNo == peo.WaybillNo)
                                                   .Where((eori, peo) => orderIdList.Contains(eori.OrderId)).ToList((eori, peo) => new PurchaseExpressOrderResponse
                                                   {
                                                       CreateTime = peo.CreateTime,
                                                       ExpressContent = peo.ExpressContent,
                                                       ExpressChangedTime = peo.ExpressChangedTime,
                                                       ExpressState = peo.ExpressState,
                                                       IsSubscribeKD100 = peo.IsSubscribeKD100,
                                                       OrderId = eori.OrderId,
                                                       PurchaseOrderId = eori.PurchaseOrderId,
                                                       ShopId = eori.ShopId.Value,
                                                       SourceExpressId = peo.SourceExpressId,
                                                       SourceExpressName = peo.SourceExpressName,
                                                       TargetExpressId = peo.TargetExpressId,
                                                       TargetExpressName = peo.TargetExpressName,
                                                       WaybillNo = peo.WaybillNo
                                                   });
                #endregion

                #region 查询入仓采购单信息
                var inStoreRelationList = fsql.Select<InStorePurchaseOrdeRrelationInfo>().Where(i => orderIdList.Contains(i.OrderId)).ToList();
                if (inStoreRelationList.Count() > 0)
                {
                    foreach (var purchaseExpressOrder in purchaseExpressOrderList)
                    {
                        purchaseExpressOrder.InStorePurchaseOrderIdList = inStoreRelationList.Where(i => i.OrderId == purchaseExpressOrder.OrderId &&
                                                                                                         i.PurchaseOrderId == purchaseExpressOrder.PurchaseOrderId &&
                                                                                                         i.WaybillNo == purchaseExpressOrder.WaybillNo)
                                                                                             .Select(i => i.InStorePurchaseOrderId)
                                                                                             .ToList();
                    }
                }
                #endregion

                #region 查询订单留言
                var orderMessageList = fsql.Select<OrderMessage>().Where(om => orderIdList.Contains(om.OrderId)).ToList<OrderMessageResponse>();
                foreach (var order in orderList)
                    order.OrderMessageList = orderMessageList.Where(om => om.OrderId == order.Id).ToList();
                #endregion

                #region 处理订单成本明细
                var orderCostDetailList = fsql.Select<OrderCostDetail>().Where(ocd => orderIdList.Contains(ocd.OrderId) && ocd.IsEnabled == true).ToList<OrderCostDetailResponse>();
                foreach (var order in orderList)
                    order.OrderCostDetailList = orderCostDetailList.Where(ocd => ocd.OrderId == order.Id).ToList();
                #endregion

                #region 处理订单Sku成本
                var orderSkuCostList = fsql.Select<OrderSkuCost>().Where(osc => orderIdList.Contains(osc.OrderId)).ToList<OrderSkuCostResponse>();
                foreach (var order in orderList)
                {
                    if (order.OrderCost == null)
                        continue;
                    order.OrderCost.OrderSkuCostList = orderSkuCostList.Where(osc => osc.OrderId == order.Id).ToList();
                    foreach (var orderSkuCost in order.OrderCost.OrderSkuCostList)
                    {
                        orderSkuCost.OrderCostDetailList = orderCostDetailList.Where(ocd => ocd.OrderId == order.Id && ocd.SkuId == orderSkuCost.SkuId).ToList();
                    }
                }
                #endregion

                #region 处理采购信息
                var orderPurchaseInfoList = fsql.Select<OrderPurchaseInfo>().Where(op => orderIdList.Contains(op.OrderId) && op.IsEnabled == true).ToList<OrderPurchaseInfoResponse>();
                var purchaserIdList = orderPurchaseInfoList.Where(opi => !string.IsNullOrEmpty(opi.PurchaserId)).Select(opi => opi.PurchaserId).Distinct().ToList();
                var orderPurchaseSkuInfoList = fsql.Select<OrderPurchaseSkuInfo>().Where(o => orderIdList.Contains(o.OrderId)).ToList<OrderPurchaseSkuInfoResponse>();
                foreach (var order in orderList)
                {
                    order.OrderPurchaseInfoList = orderPurchaseInfoList.Where(op => op.OrderId == order.Id).ToList();
                    foreach (var orderPurchaseInfo in order.OrderPurchaseInfoList)
                    {
                        orderPurchaseInfo.OrderPurchaseSkuInfoList = orderPurchaseSkuInfoList.Where(opsi => opsi.PurchaseOrderId == orderPurchaseInfo.PurchaseOrderId).ToList();
                        orderPurchaseInfo.PurchaseExpressOrderList = purchaseExpressOrderList.Where(peo => peo.PurchaseOrderId == orderPurchaseInfo.PurchaseOrderId).ToList();
                    }

                    if (order.OrderPurchaseInfoList != null && order.OrderPurchaseInfoList.Count() > 0)
                    {
                        if (order.OrderState == Enums.OrderState.部分采购 &&
                            order.OrderPurchaseInfoList.Any(opi => opi.IsAutoEditOrderPrice == Enums.AutoEditOrderPriceType.已平价))
                        {
                            order.IsAutoEditOrderPrice = Enums.AutoEditOrderPriceType.部分平价;
                            continue;
                        }

                        var opiCount = order.OrderPurchaseInfoList.Count();
                        var pjCount = order.OrderPurchaseInfoList.Count(opi => opi.IsAutoEditOrderPrice == Enums.AutoEditOrderPriceType.已平价);
                        if (pjCount == 0)
                            order.IsAutoEditOrderPrice = Enums.AutoEditOrderPriceType.未平价;
                        if (opiCount == pjCount)
                            order.IsAutoEditOrderPrice = Enums.AutoEditOrderPriceType.已平价;
                        else if (opiCount > pjCount)
                            order.IsAutoEditOrderPrice = Enums.AutoEditOrderPriceType.部分平价;
                    }
                }
                #endregion

                #region 处理采购单商家信息
                if (purchaserIdList.Count() > 0)
                {
                    var purchaserList = fsql.Select<Purchaser>(purchaserIdList).ToList();
                    foreach (var purchaseOrder in orderPurchaseInfoList)
                    {
                        purchaseOrder.Purchaser = purchaserList.FirstOrDefault(p => p.Id == purchaseOrder.PurchaserId);
                    }
                }
                #endregion

                #region 处理SKU
                var orderSkuList = fsql.Select<OrderSku>().Where(osku => orderIdList.Contains(osku.OrderId)).ToList<OrderSkuResponse>();
                foreach (var order in orderList)
                {
                    order.ItemList = orderSkuList.Where(osku => osku.OrderId == order.Id).ToList();
                }
                #endregion

                #region 处理SKU的快递单
                foreach (var purchaseExpressOrder in purchaseExpressOrderList)
                {
                    var order = orderList.FirstOrDefault(o => o.Id == purchaseExpressOrder.OrderId);
                    if (order == null)
                        continue;
                    purchaseExpressOrder.CalculationBelongOrderSku(order.IntoStoreType, orderPurchaseInfoList, orderPurchaseRelationInfoList, orderPurchaseSkuInfoList);
                    var currentOrderSkuList = orderSkuList.Where(osku => !string.IsNullOrEmpty(purchaseExpressOrder.BelongSkuIds) &&
                                                                         osku.OrderId == purchaseExpressOrder.OrderId &&
                                                                         purchaseExpressOrder.BelongSkuIds.Contains(osku.SkuId)).ToList();
                    foreach (var osku in currentOrderSkuList)
                    {
                        if (osku.PurchaseExpressOrderList.Any(peo => peo.WaybillNo == purchaseExpressOrder.WaybillNo))
                            continue;
                        osku.PurchaseExpressOrderList.Add(purchaseExpressOrder);
                    }
                }
                #endregion

                #region 限时任务
                var orderTimeLimitTaskList = fsql.Select<TimeLimitTask>().Where(t => orderIdList.Contains(t.OrderId))
                                                                         .ToList<TimeLimitTaskResponse>();

                foreach (var order in orderList)
                {
                    foreach (var orderSku in order.ItemList)
                    {
                        #region 采购限时任务
                        orderSku.PurchaseTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
                                                                                                    t.SkuId == orderSku.SkuId &&
                                                                                                    t.TaskType == Enums.TimeLimitTaskType.采购任务);
                        #endregion

                        #region 合格证拟定任务
                        orderSku.CerConfigTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
                                                                                                     t.SkuId == orderSku.SkuId &&
                                                                                                     t.TaskType == Enums.TimeLimitTaskType.合格证拟定任务);
                        #endregion

                        #region 合格证补充任务
                        orderSku.CerEditTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
                                                                                                   t.SkuId == orderSku.SkuId &&
                                                                                                   t.TaskType == Enums.TimeLimitTaskType.合格证补充任务);
                        #endregion

                        #region 待核算任务
                        orderSku.CheckComputationTimeLimitTask = orderTimeLimitTaskList.FirstOrDefault(t => t.OrderId == order.Id &&
                                                                                                            t.TaskType == Enums.TimeLimitTaskType.待核算任务);
                        #endregion

                        #region 判断sku的发货状态
                        var purchaseOrder = order.OrderPurchaseInfoList.FirstOrDefault(opi => opi.OrderId == order.Id && opi.BelongSkuIds.Contains(orderSku.SkuId));
                        if (purchaseOrder != null)
                        {
                            if (purchaseOrder.PurchasePlatform == Enums.Platform.阿里巴巴 && order.IntoStoreType != Enums.IntoStoreType.厂商代发入仓)
                            {
                                //验证采购关系
                                var currentSku_PurchaseSkuIdList = orderPurchaseRelationInfoList.Where(opri => opri.OrderId == order.Id &&
                                                                                                               opri.PurchaseOrderId == purchaseOrder.PurchaseOrderId &&
                                                                                                               opri.BelongSkuId == orderSku.SkuId)
                                                                                                   .Select(x => x.PurchaseSkuId)
                                                                                                   .Distinct()
                                                                                                   .ToList();
                                if (currentSku_PurchaseSkuIdList.Count() > 0)
                                {
                                    var currentSku_PurchaseSkuList = purchaseOrder.OrderPurchaseSkuInfoList?.Where(posku => currentSku_PurchaseSkuIdList.Contains(posku.PurchaseSkuId))
                                                                                                           ?.ToList();
                                    if (currentSku_PurchaseSkuList != null && currentSku_PurchaseSkuList.Count() > 0)
                                    {
                                        var totalCount = currentSku_PurchaseSkuList.Count();
                                        var shipCount = currentSku_PurchaseSkuList.Count(posku => !string.IsNullOrEmpty(posku.WaybillNo));
                                        if (totalCount == shipCount)
                                            orderSku.ShipState = 1;
                                        if (shipCount == 0)
                                            orderSku.ShipState = 0;
                                        if (totalCount > shipCount)
                                            orderSku.ShipState = 2;
                                    }
                                }
                            }
                            else
                            {
                                orderSku.ShipState = purchaseOrder.PurchaseExpressOrderList != null &&
                                                     purchaseOrder.PurchaseExpressOrderList.Count() > 0 ? 1 : 0;
                            }
                        }
                        #endregion
                    }
                }

                #endregion


            }
            return new OrderListResponse()
            {
                Count = total,
                Items = orderList
            };
        }

        public IList<PurchaseExpressOrderResponse> GetPurchaseExpressOrderList(QueryExpressOrderRequest request)
        {
            var purchaseExpressOrderList = fsql.Select<ExpressOrderRelationInfo, PurchaseExpressOrder>()
                                                 .InnerJoin((eori, peo) => eori.WayBillNo == peo.WaybillNo)
                                                 .Where((eori, peo) => eori.OrderId == request.OrderId).ToList((eori, peo) => new PurchaseExpressOrderResponse
                                                 {
                                                     CreateTime = peo.CreateTime,
                                                     ExpressContent = peo.ExpressContent,
                                                     ExpressChangedTime = peo.ExpressChangedTime,
                                                     ExpressState = peo.ExpressState,
                                                     IsSubscribeKD100 = peo.IsSubscribeKD100,
                                                     OrderId = eori.OrderId,
                                                     PurchaseOrderId = eori.PurchaseOrderId,
                                                     ShopId = eori.ShopId.Value,
                                                     SourceExpressId = peo.SourceExpressId,
                                                     SourceExpressName = peo.SourceExpressName,
                                                     TargetExpressId = peo.TargetExpressId,
                                                     TargetExpressName = peo.TargetExpressName,
                                                     WaybillNo = peo.WaybillNo
                                                 });
            var order = fsql.Select<Order>(request.OrderId).ToOne();
            var orderPurchaseInfoList = fsql.Select<OrderPurchaseInfo>().Where(op => op.OrderId == request.OrderId && op.IsEnabled == true).ToList<OrderPurchaseInfoResponse>();
            var orderPurchaseRelationList = fsql.Select<OrderPurchaseRelationInfo>().Where(opri => opri.OrderId == request.OrderId && opri.SourceSkuId == request.SourceSkuId).ToList();
            var orderPurchaseSkuList = fsql.Select<OrderPurchaseSkuInfo>().Where(posku => posku.OrderId == request.OrderId).ToList<OrderPurchaseSkuInfoResponse>();
            var orderSku = fsql.Select<OrderSku>().Where(osku => osku.OrderId == request.OrderId && osku.BelongSkuId == request.SourceSkuId).ToOne();

            IList<PurchaseExpressOrderResponse> list = new List<PurchaseExpressOrderResponse>();
            #region 处理SKU的快递单
            foreach (var purchaseExpressOrder in purchaseExpressOrderList)
            {
                purchaseExpressOrder.CalculationBelongOrderSku(order.IntoStoreType, orderPurchaseInfoList, orderPurchaseRelationList, orderPurchaseSkuList);
                if (!string.IsNullOrEmpty(purchaseExpressOrder.BelongSkuIds))
                {
                    if (purchaseExpressOrder.BelongSkuIds.Contains(orderSku.SkuId))
                    {
                        if (!list.Any(x => x.WaybillNo == purchaseExpressOrder.WaybillNo))
                            list.Add(purchaseExpressOrder);
                    }
                }
            }
            #endregion
            return list;
        }

        public IList<PurchaseExpressOrderResponse> GetPurchaseExpressOrderList(IList<string> orderIds)
        {
            var purchaseExpressOrderList = fsql.Select<ExpressOrderRelationInfo, PurchaseExpressOrder>()
                                                .InnerJoin((eori, peo) => eori.WayBillNo == peo.WaybillNo)
                                                .Where((eori, peo) => orderIds.Contains(eori.OrderId)).ToList((eori, peo) => new PurchaseExpressOrderResponse
                                                {
                                                    CreateTime = peo.CreateTime,
                                                    ExpressContent = peo.ExpressContent,
                                                    ExpressChangedTime = peo.ExpressChangedTime,
                                                    ExpressState = peo.ExpressState,
                                                    IsSubscribeKD100 = peo.IsSubscribeKD100,
                                                    OrderId = eori.OrderId,
                                                    PurchaseOrderId = eori.PurchaseOrderId,
                                                    ShopId = eori.ShopId.Value,
                                                    SourceExpressId = peo.SourceExpressId,
                                                    SourceExpressName = peo.SourceExpressName,
                                                    TargetExpressId = peo.TargetExpressId,
                                                    TargetExpressName = peo.TargetExpressName,
                                                    WaybillNo = peo.WaybillNo
                                                });
            var orderList = fsql.Select<Order>(orderIds).ToList();
            var orderPurchaseInfoList = fsql.Select<OrderPurchaseInfo>().Where(op => orderIds.Contains(op.OrderId) && op.IsEnabled == true).ToList<OrderPurchaseInfoResponse>();
            var orderPurchaseRelationList = fsql.Select<OrderPurchaseRelationInfo>().Where(opri => orderIds.Contains(opri.OrderId)).ToList();
            var orderPurchaseSkuList = fsql.Select<OrderPurchaseSkuInfo>().Where(posku => orderIds.Contains(posku.OrderId)).ToList<OrderPurchaseSkuInfoResponse>();

            #region 处理SKU的快递单
            foreach (var purchaseExpressOrder in purchaseExpressOrderList)
            {
                var order = orderList.FirstOrDefault(o => o.Id == purchaseExpressOrder.OrderId);
                if (order == null)
                    continue;
                purchaseExpressOrder.CalculationBelongOrderSku(order.IntoStoreType, orderPurchaseInfoList, orderPurchaseRelationList, orderPurchaseSkuList);
            }
            #endregion
            return purchaseExpressOrderList;
        }

        public void CancelOrder(CancelOrderRequest request, string mdsToken)
        {
            try
            {
                opPlatformClientFactory.GetClient((AdapterEnums.PlatformType)request.Platform).CancelOrder(new OP_CancelOrderRequest()
                {
                    AppKey = request.AppKey,
                    AppSecret = request.AppSecret,
                    AppToken = request.AppToken,
                    OrderId = request.OrderId,
                    Platform = (AdapterEnums.PlatformType)request.Platform,
                    Remark = request.Remark
                });
            }
            catch (Exception ex)
            {
                if (!ex.Message.Contains("订单已删除"))
                    throw new BusinessException(ex.Message);
            }

            fsql.Transaction(() =>
            {
                fsql.Update<Order>(request.OrderId).Set(o => o.OrderState, Enums.OrderState.已取消).ExecuteAffrows();
                fsql.Delete<TimeLimitTask>().Where(t => t.OrderId == request.OrderId).ExecuteAffrows();
            });

            try
            {
                restApiService.SendRequest("https://bbwy.qiyue666.com", "api/BatchPurchase/UpdatePurchaseOrderState", new
                {
                    OrderId = request.OrderId,
                    PurchaseOrderState = Enums.OrderState.已取消
                }, null, HttpMethod.Post);
            }
            catch
            {

            }

            //var sql = $"update purchaseorderv2 set OrderState=6 where Id='{request.OrderId}'";
            ////取消C端采购单
            //restApiService.SendRequest("https://bbwy.qiyue666.com",
            //                           "/Api/Sql/ExecuteNonQuery",
            //                           new { sql = sql.AESEncrypt() },
            //                           new Dictionary<string, string>() { { "Authorization", $"Bearer {mdsToken}" } },
            //                           HttpMethod.Post);

            try
            {
                //取消齐库的任务
                var qikuResponse = restApiService.SendRequest("http://qiku.qiyue666.com/",
                                                              $"/api/PackPurchaseTask/CancelOrderPackTask?orderId={request.OrderId}",
                                                              null,
                                                              null,
                                                              HttpMethod.Post);
                if (qikuResponse.StatusCode != System.Net.HttpStatusCode.OK)
                    throw new Exception(qikuResponse.Content);
            }
            catch (Exception ex)
            {
                nLogManager.GetLogger($"取消打包任务-{request.OrderId}").Error(ex, JsonConvert.SerializeObject(request));
            }
        }

        public void EditPrice(OP_EditPriceRequest request)
        {
            var client = opPlatformClientFactory.GetClient(request.Platform);
            client.EditPrice(new OP_EditPriceRequest()
            {
                AppKey = request.AppKey,
                AppSecret = request.AppSecret,
                AppToken = request.AppToken,
                OrderId = request.OrderId,
                EditItems = request.EditItems
            });

            var orderListResponse = client.GetOrderList(new OP_QueryOrderRequest()
            {
                AppKey = request.AppKey,
                AppSecret = request.AppSecret,
                AppToken = request.AppToken,
                OrderId = request.OrderId,
                PageIndex = 1,
                PageSize = 1,
                SortTimeField = AdapterEnums.SortTimeField.Modify,
                SortType = AdapterEnums.SortType.Desc
            });

            var order = orderListResponse.Items.FirstOrDefault();
            var orderCost = fsql.Select<OrderCost>(request.OrderId).ToOne();
            var orderSkuCostList = fsql.Select<OrderSkuCost>().Where(osc => osc.OrderId == request.OrderId).ToList();
            var orderCostDetailList = fsql.Select<OrderCostDetail>().Where(ocd => ocd.OrderId == request.OrderId && ocd.IsEnabled == true).ToList();

            IList<IUpdate<OrderSku>> updates_orderSku = new List<IUpdate<OrderSku>>();
            IUpdate<OrderCost> updateOrderCost = null;
            IList<IUpdate<OrderSkuCost>> updateOrderSkuCostList = new List<IUpdate<OrderSkuCost>>();
            IList<IUpdate<OrderCostDetail>> updateOrderCostDetailList = new List<IUpdate<OrderCostDetail>>();


            foreach (var orderSku in order.OrderSkuList)
            {
                updates_orderSku.Add(fsql.Update<OrderSku>(orderSku.Id).Set(osku => osku.Price, orderSku.SkuPrice)
                                                                       .Set(osku => osku.BuyerPayFreight, orderSku.FreightAmount)
                                                                       .Set(osku => osku.InPackAmount, orderSku.PackAmount));

                var ocdList = orderCostDetailList.Where(ocd => ocd.SkuId == orderSku.SkuId).ToList();
                if (ocdList != null && ocdList.Count() > 0)
                {
                    foreach (var orderCostDetail in ocdList)
                    {
                        orderCostDetail.CalculationOrderCostDetailCostAndProfit(orderCostDetail.SkuAmount ?? 0M,
                                                                                orderCostDetail.PurchaseFreight ?? 0M,
                                                                                orderCostDetail.OutPackAmount ?? 0M,
                                                                                orderCostDetail.DeliveryExpressFreight ?? 0M);
                        updateOrderCostDetailList.Add(fsql.Update<OrderCostDetail>(orderCostDetail.Id).Set(ocd => ocd.Profit, orderCostDetail.Profit));
                    }
                }

                var orderSkuCost = orderSkuCostList.FirstOrDefault(osc => osc.SkuId == orderSku.SkuId);
                if (orderSkuCost != null)
                {
                    orderSkuCost.CalculationOrderSkuCostAndProfit(orderSku.SkuPrice * orderSku.Quantity,
                                                                  orderSku.FreightAmount,
                                                                  orderSku.PackAmount,
                                                                  ocdList);
                    updateOrderSkuCostList.Add(fsql.Update<OrderSkuCost>(orderSkuCost.Id).Set(osc => osc.Profit, orderSkuCost.Profit));
                }
            }

            if (orderCost != null)
            {
                orderCost.CalculationOrderCostAndProfit(order.OrderTotalAmount,
                                                        orderCost.SkuAmount ?? 0M,
                                                        orderCost.PurchaseFreight ?? 0M,
                                                        orderCost.OutPackAmount ?? 0M,
                                                        orderCost.DeliveryExpressFreight ?? 0M);
                updateOrderCost = fsql.Update<OrderCost>().SetSource(orderCost);
            }


            fsql.Transaction(() =>
            {
                fsql.Update<Order>(request.OrderId).Set(o => o.OrderTotalPrice, order.OrderTotalAmount)
                                                   .Set(o => o.OrderSellerPrice, order.OrderProductAmount)
                                                   .Set(o => o.FreightPrice, order.FreightAmount)
                                                   .Set(o => o.InPackAmount, order.PackAmount)
                                                   .ExecuteAffrows();
                updateOrderCost?.ExecuteAffrows();

                if (updates_orderSku.Count() > 0)
                {
                    foreach (var update in updates_orderSku)
                        update.ExecuteAffrows();
                }
                if (updateOrderCostDetailList.Count() > 0)
                {
                    foreach (var update in updateOrderCostDetailList)
                        update.ExecuteAffrows();
                }
                if (updateOrderSkuCostList.Count() > 0)
                    foreach (var update in updateOrderSkuCostList)
                        update.ExecuteAffrows();
            });

            #region 通知C端
            restApiService.SendRequest("https://bbwy.qiyue666.com",
                                      "/Api/PurchaseOrder/QuanTanEditPriceCallback",
                                      new { orderId = request.OrderId },
                                      null,
                                      HttpMethod.Post);
            #endregion
        }

        public void EditVenderRemark(EditVenderRemarkRequest request)
        {
            fsql.Update<Order>(request.OrderId).Set(o => o.VenderRemark, request.VenderRemark).ExecuteAffrows();
        }

        public void EditOrderSkuRemark(EditOrderSkuRemarkRequest request)
        {
            fsql.Update<OrderSku>().Set(osku => osku.Remark, request.Remark)
                                   .Where(osku => osku.OrderId == request.OrderId)
                                   .Where(osku => osku.SkuId == request.SkuId)
                                   .ExecuteAffrows();
        }

        public void QiKuPublishPackAmount(QiKuPublishPackAmountRequest request)
        {

        }

        public void CheckSku(CheckSkuRequest request)
        {
            var dbOrder = fsql.Select<Order>(request.OrderId).ToOne();
            if (dbOrder == null)
                throw new BusinessException($"订单{request.OrderId}不存在");
            var orderSkuList = fsql.Select<OrderSku>().Where(osku => osku.OrderId == request.OrderId).ToList();
            var orderSku = orderSkuList.FirstOrDefault(osku => osku.BelongSkuId == request.SourceSkuId);
            if (orderSku == null)
                throw new BusinessException($"订单{request.OrderId}的归属sku中不存在{request.SourceSkuId}");

            if (orderSku.IsCheck == true)
                throw new BusinessException("已验收,无需重复验收");


            IUpdate<Order> updateOrder = null;
            IUpdate<OrderSku> updateOrderSku = null;

            orderSku.IsCheck = true;
            updateOrderSku = fsql.Update<OrderSku>(orderSku.Id).Set(osku => osku.IsCheck, true);

            var oldOrderState = dbOrder.OrderState;
            dbOrder.CalculationOrderState(fsql, orderSkuList);
            if (oldOrderState != dbOrder.OrderState)
                updateOrder = fsql.Update<Order>(dbOrder.Id).Set(o => o.OrderState, dbOrder.OrderState);

            fsql.Transaction(() =>
            {
                updateOrderSku?.ExecuteAffrows();
                updateOrder?.ExecuteAffrows();
            });
        }

        public void CheckComputationOrder(string orderId)
        {
            var order = fsql.Select<Order>(orderId).ToOne();
            if (order == null)
                throw new BusinessException("未查询到订单");
            if (order.OrderState != Enums.OrderState.待核算)
                throw new BusinessException("订单状态不正确,只有待核算的订单才允许核算");
            //var orderCost = fsql.Select<OrderCost>(orderId).ToOne();
            //if (orderCost == null)
            //    throw new BusinessException("未查询到订单成本");
            //if (Math.Abs(orderCost.Profit ?? 0) > 1M)
            //    throw new BusinessException("订单利润绝对值不能大于1");

            var orderSkuCostList = fsql.Select<OrderSkuCost>().Where(o => o.OrderId == orderId).ToList();
            if (orderSkuCostList.Count() == 0)
                throw new BusinessException("未查询到订单sku成本");
            if (orderSkuCostList.Any(osc => Math.Abs(osc.Profit ?? 0) > 1))
                throw new BusinessException("订单sku利润绝对值不能大于1");

            fsql.Transaction(() =>
                {
                    fsql.Update<Order>(orderId).Set(o => o.OrderState, Enums.OrderState.已完成).ExecuteAffrows();
                    fsql.Update<TimeLimitTask>().Set(t => t.CompletionTime, DateTime.Now)
                                                .Set(t => t.IsTimely == (DateTime.Now < t.ExpirationTime ? true : false))
                                                .Where(t => t.OrderId == orderId)
                                                .Where(t => t.CompletionTime == null)
                                                .Where(t => t.TaskType == Enums.TimeLimitTaskType.待核算任务).ExecuteAffrows();
                });

            SendPurchaseOrderStateToC(orderId, Enums.OrderState.已完成);
        }

        private void SendPurchaseOrderStateToC(string orderId, Enums.OrderState orderState)
        {
            try
            {
#if DEBUG
                var url = "https://bbwy.qiyue666.com";
#else
                var url = "http://172.16.54.105:8090";
#endif

                restApiService.SendRequest(url, "api/BatchPurchase/UpdatePurchaseOrderState", new
                {
                    OrderId = orderId,
                    PurchaseOrderState = orderState
                }, null, HttpMethod.Post);
            }
            catch (Exception ex)
            {
                nLogManager.Default().Error(ex, $"OrderId-{orderId}推送C订单状态[{orderState}]失败");
            }
        }

        public OrderCountByStateResponse StatisticsOrderCountByOrderState(long shopId)
        {
            var noOrderStateList = new List<Enums.OrderState>()
            {
                Enums.OrderState.已取消,
                Enums.OrderState.已完成
            };
            var orderCountGroup = fsql.Select<Order>().Where(o => o.ShopId == shopId)
                                                      .Where(o => !noOrderStateList.Contains(o.OrderState.Value))
                                                      .GroupBy(o => o.OrderState)
                                                      .ToList(g => new
                                                      {
                                                          OrderState = g.Key,
                                                          OrderCount = g.Count()
                                                      });

            var childSelect = fsql.Select<OrderSku>().As("osku").Where(osku => waitConfigStateList.Contains(osku.PackConfigState) || osku.PackConfigState == null);
            var waitConfigCount = fsql.Select<Order>().Where(o => o.ShopId == shopId)
                                                      .Where(o => !noOrderStateList.Contains(o.OrderState.Value))
                                                      .Where(o => o.IntoStoreType == Enums.IntoStoreType.发回齐越)
                                                      .Where(o => o.IsPurchased == true)
                                                      .Where(o => childSelect.Where(osku => osku.OrderId == o.Id).Any())
                                                      .Count();

            return new OrderCountByStateResponse()
            {
                WaitPayCount = orderCountGroup.FirstOrDefault(o => o.OrderState == Enums.OrderState.待付款)?.OrderCount ?? 0,
                WaitPurchaseCount = orderCountGroup.FirstOrDefault(o => o.OrderState == Enums.OrderState.等待采购 ||
                                                                        o.OrderState == Enums.OrderState.部分采购)?.OrderCount ?? 0,
                WaitShipmentCount = orderCountGroup.FirstOrDefault(o => o.OrderState == Enums.OrderState.待发货 ||
                                                                        o.OrderState == Enums.OrderState.部分发货)?.OrderCount ?? 0,
                WaitReceiveCount = orderCountGroup.FirstOrDefault(o => o.OrderState == Enums.OrderState.待收货 ||
                                                                       o.OrderState == Enums.OrderState.部分收货)?.OrderCount ?? 0,
                WaitCheckCount = orderCountGroup.FirstOrDefault(o => o.OrderState == Enums.OrderState.待验收)?.OrderCount ?? 0,
                WaitComputationCount = orderCountGroup.FirstOrDefault(o => o.OrderState == Enums.OrderState.待核算)?.OrderCount ?? 0,
                WaitConfigCount = waitConfigCount,
            };
        }

        /// <summary>
        /// 齐库推送sku配置状态
        /// </summary>
        /// <param name="request"></param>
        public void QikuPublishOrderSkuPackConfigState(QikuPublishOrderSkuPackConfigStateRequest request)
        {
            qikuManager.QikuPublishOrderSkuPackConfigState(request);
        }

        public void SetSpecialOrder(SetSpecialOrderRequest request)
        {
            fsql.Update<Order>(request.OrderId).Set(o => o.IsSpecialOrder, request.IsSpecialOrder).ExecuteAffrows();
        }
    }
}