/***********************************************************************
 *            Project: baifenBinfa
 *        ProjectName: 百分兵法管理系统                               
 *                Web: http://chuanyin.com                     
 *             Author:                                        
 *              Email:                               
 *         CreateTime: 202403/02   
 *        Description: 暂无
 ***********************************************************************/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using CoreCms.Net.Auth.HttpContextUser;
using CoreCms.Net.Configuration;
using CoreCms.Net.IRepository;
using CoreCms.Net.IRepository.UnitOfWork;
using CoreCms.Net.IServices;
using CoreCms.Net.IServices.baifenbingfa;
using CoreCms.Net.Loging;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Model.Entities.Expression;
using CoreCms.Net.Model.ViewModels.DTO;
using CoreCms.Net.Model.ViewModels.UI;
using CoreCms.Net.Utility.Extensions;
using CoreCms.Net.Utility.Helper;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SqlSugar;


namespace CoreCms.Net.Services
{
    /// <summary>
    /// 购物车表 接口实现
    /// </summary>
    public class CoreCmsCartServices : BaseServices<CoreCmsCart>, ICoreCmsCartServices
    {
        private readonly ICoreCmsCartRepository _dal;

        private readonly ICoreCmsGoodsCollectionServices _goodsCollectionServices;
        private readonly ICoreCmsPinTuanRuleServices _pinTuanRuleServices;
        private readonly ICoreCmsShipServices _shipServices;
        private readonly ICoreCmsPromotionServices _promotionServices;
        private readonly ICoreCmsPromotionConditionServices _promotionConditionServices;
        private readonly ICoreCmsPromotionResultServices _promotionResultServices;
        private readonly ICoreCmsCouponServices _couponServices;
        private readonly ICoreCmsUserServices _userServices;
        private readonly ICoreCmsSettingServices _settingServices;
        private readonly IServiceProvider _serviceProvider;
        private readonly ICoreCmsProductsServices _productsServices;
        private readonly ICoreCmsPinTuanGoodsServices _pinTuanGoodsServices;
        private readonly ICoreCmsPinTuanRecordServices _pinTuanRecordServices;
        private readonly ICoreCmsGoodsServices _goodsServices;
        private readonly ICoreCmsGoodsCategoryServices _goodsCategoryServices;
        private readonly ICoreCmsSolitaireServices _solitaireServices;
        private readonly ICoreCmsUserShipServices _userShipServices;
        private readonly ICoreCmsStoreServices _storeServices;
        private readonly IBfbfComAPIService  _bfbfComAPIService;
        private readonly IHttpContextUser _user;

        public CoreCmsCartServices(
            ICoreCmsCartRepository dal
            , IServiceProvider serviceProvider
            , ICoreCmsGoodsCollectionServices goodsCollectionServices
            , ICoreCmsPinTuanRuleServices pinTuanRuleServices
            , ICoreCmsShipServices shipServices
            , ICoreCmsPromotionServices promotionServices
            , ICoreCmsCouponServices couponServices
            , ICoreCmsUserServices userServices
            , ICoreCmsSettingServices settingServices
            , ICoreCmsProductsServices productsServices
            , ICoreCmsPinTuanGoodsServices pinTuanGoodsServices
            , IBfbfComAPIService bfbfComAPIService
            ,ICoreCmsPromotionConditionServices promotionConditionServices
            , ICoreCmsGoodsServices goodsServices
            , ICoreCmsGoodsCategoryServices goodsCategoryServices
            , ICoreCmsPromotionResultServices promotionResultServices
            , ICoreCmsPinTuanRecordServices pinTuanRecordServices
            , ICoreCmsSolitaireServices solitaireServices
            , ICoreCmsUserShipServices userShipServices
            , ICoreCmsStoreServices storeServices
            ,IHttpContextUser user)
        {
            this._dal = dal;
            base.BaseDal = dal;

            _serviceProvider = serviceProvider;
            _goodsCollectionServices = goodsCollectionServices;
            _pinTuanRuleServices = pinTuanRuleServices;
            _shipServices = shipServices;
            _promotionServices = promotionServices;
            _couponServices = couponServices;
            _userServices = userServices;
            _settingServices = settingServices;
            _productsServices = productsServices;
            _pinTuanGoodsServices = pinTuanGoodsServices;
            _promotionConditionServices = promotionConditionServices;
            _goodsServices = goodsServices;
            _goodsCategoryServices = goodsCategoryServices;
            _promotionResultServices = promotionResultServices;
            _pinTuanRecordServices = pinTuanRecordServices;
            _solitaireServices = solitaireServices;
            _userShipServices = userShipServices;
            _storeServices = storeServices;
            _bfbfComAPIService = bfbfComAPIService;
            _user   = user;
        }

        #region 设置购物车商品数量====================================================

        /// <summary>
        /// 设置购物车商品数量
        /// </summary>
        /// <param name="id"></param>
        /// <param name="nums"></param>
        /// <param name="userId"></param>
        /// <param name="numType"></param>
        /// <param name="type"></param>
        ///  <param name="isCustomizable"></param>
        /// <returns></returns>
        public async Task<WebApiCallBack> SetCartNum(int id, int nums, int userId, int numType, int type = 1)
        {
            var jm = new WebApiCallBack();
            if (nums <= 0)
            {
                jm.msg = "商品数量必须为正整数";
                return jm;
            }
            if (userId == 0)
            {
                jm.msg = "用户信息获取失败";
                return jm;
            }
            if (id == 0)
            {
                jm.msg = "请提交要设置的信息";
                return jm;
            }
            var cartModel = await _dal.QueryByClauseAsync(p => p.userId == userId && p.productId == id);
            if (cartModel == null)
            {
                jm.msg = "获取购物车数据失败";
                return jm;
            }
            var outData = await Add(userId, cartModel.productId, nums, numType, type,isCustomizable:cartModel.isCustomizable);
            jm.status = outData.status;
            jm.msg = jm.status ? GlobalConstVars.SetDataSuccess : GlobalConstVars.SetDataFailure;
            jm.otherData = outData;

            return jm;
        }


        #endregion

        #region  重写删除指定ID集合的数据(批量删除)
        /// <summary>
        /// 重写删除指定ID集合的数据(批量删除)
        /// </summary>
        /// <param name="ids"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public async Task<WebApiCallBack> DeleteByIdsAsync(int id, int userId)
        {
            var jm = new WebApiCallBack();

            if (userId == 0)
            {
                jm.msg = "用户信息获取失败";
                return jm;
            }
            if (id <= 0)
            {
                jm.msg = "请提交要删除的货品";
                return jm;
            }
            jm.status = await _dal.DeleteAsync(p => p.id == id && p.userId == userId);
            jm.msg = jm.status ? "删除成功" : "删除失败";

            return jm;
        }
        #endregion

        #region 添加单个货品到购物车

        /// <summary>
        /// 添加单个货品到购物车
        /// </summary>
        /// <param name="userId">用户id</param>
        /// <param name="productId">货品序号</param>
        /// <param name="nums">数量</param>
        /// <param name="numType">数量类型/1是直接增加/2是赋值</param>
        /// <param name="cartTypes">1普通购物还是2团购秒杀3团购模式4秒杀模式6砍价模式7赠品</param>
        /// <param name="objectId">关联对象类型</param>
        /// <param name="isCustomizable">关联对象类型</param>
        /// <returns></returns>
        public async Task<WebApiCallBack> Add(int userId, int productId, int nums, int numType, int cartTypes = 1, int objectId = 0,bool isCustomizable = false)
        {
            var jm = new WebApiCallBack();

            using var container = _serviceProvider.CreateScope();

            var orderServices = container.ServiceProvider.GetService<ICoreCmsOrderServices>();
            var productsServices = container.ServiceProvider.GetService<ICoreCmsProductsServices>();
            var goodsServices = container.ServiceProvider.GetService<ICoreCmsGoodsServices>();

            //获取数据 
            if (nums <= 0)
            {
                jm.msg = "请选择货品数量";
                return jm;
            }
            if (productId <= 0)
            {
                jm.msg = "请选择货品";
                return jm;
            }
            //获取货品信息
            var products = await productsServices.GetProductInfo(productId, false, userId); //第二个参数是不算促销信息,否则促销信息就算重复了
            if (products == null)
            {
                jm.msg = "获取货品信息失败";
                return jm;
            }
            if(isCustomizable==true&&products.isCustomizable!=true)
            {
                jm.msg = "该货物不支持定制";
                return jm;
            }
            //判断是否下架
            var isMarketable = await productsServices.GetShelfStatus(productId);
            if (isMarketable == false)
            {
                jm.msg = "货品已下架";
                return jm;
            }
            //剩余库存可购判定
            var canBuyNum = products.stock;
            //获取是否存在记录
            var catInfo = await _dal.QueryByClauseAsync(p => p.userId == userId && p.productId == productId && p.objectId == objectId);

            //根据购物车存储类型匹配数据
            switch (cartTypes)
            {
                case (int)GlobalEnumVars.OrderType.Common:

                    break;
                case (int)GlobalEnumVars.OrderType.PinTuan:
                    numType = (int)GlobalEnumVars.OrderType.PinTuan;
                    //拼团模式去判断是否开启拼团，是否存在
                    var callBack = await AddCartHavePinTuan(products.id, userId, nums, objectId);
                    if (callBack.status == false)
                    {
                        return callBack;
                    }
                    //此人的购物车中的所有购物车拼团商品都删掉，因为立即购买也是要加入购物车的，所以需要清空之前历史的加入过购物车的商品
                    await _dal.DeleteAsync(p => p.type == (int)GlobalEnumVars.OrderType.PinTuan && p.userId == userId);
                    catInfo = null;
                    break;
                case (int)GlobalEnumVars.OrderType.Group or (int)GlobalEnumVars.OrderType.Seckill:
                    //标准模式不需要做什么判断
                    //判断商品是否做团购秒杀
                    if (goodsServices.IsInGroup((int)products.goodsId, out var promotionsModel, objectId) == true)
                    {
                        jm.msg = "进入判断商品是否做团购秒杀";

                        var typeIds = new int[] { (int)GlobalEnumVars.OrderType.Group, (int)GlobalEnumVars.OrderType.Seckill };
                        //此人的购物车中的所有购物车拼团商品都删掉，因为立即购买也是要加入购物车的，所以需要清空之前历史的加入过购物车的商品
                        await _dal.DeleteAsync(p => typeIds.Contains(p.type) && p.productId == products.id && p.userId == userId);
                        catInfo = null;

                        var checkOrder = orderServices.FindLimitOrderByGoodId(products.goodsId, userId, promotionsModel.startTime, promotionsModel.endTime, cartTypes);
                        if (promotionsModel.maxGoodsNums > 0)
                        {
                            if (checkOrder.TotalOrders + nums > promotionsModel.maxGoodsNums)
                            {
                                jm.data = 15610;
                                jm.msg = GlobalErrorCodeVars.Code15610;
                                return jm;
                            }
                        }
                        if (promotionsModel.maxNums > 0)
                        {
                            if (checkOrder.TotalUserOrders + nums > promotionsModel.maxNums)
                            {
                                jm.data = 15611; ;
                                jm.msg = GlobalErrorCodeVars.Code15611;
                                return jm;
                            }
                        }

                    }
                    break;
                case (int)GlobalEnumVars.OrderType.Bargain:

                    break;

                case (int)GlobalEnumVars.OrderType.Solitaire:

                    break;
                default:
                    jm.data = 10000;
                    return jm;
            }

            if (catInfo == null)
            {
                if (nums > canBuyNum)
                {
                    jm.msg = "库存不足";
                    return jm;
                }

                catInfo = new CoreCmsCart
                {
                    userId = userId,
                    productId = productId,
                    nums = nums,
                    type = cartTypes,
                    objectId = objectId,
                    //支持定制
                    isCustomizable= isCustomizable,
                };
                var outId = await _dal.InsertAsync(catInfo);
                jm.status = outId > 0;
                jm.data = outId;
            }
            else
            {
                if (numType == 1)
                {
                    catInfo.nums = nums + catInfo.nums;
                    if (catInfo.nums > canBuyNum)
                    {
                        jm.msg = "库存不足";
                        return jm;
                    }
                }
                else
                {
                    catInfo.nums = nums;
                }
                jm.status = await _dal.UpdateAsync(catInfo);
                jm.data = catInfo.id;
            }
            jm.msg = jm.status ? "添加成功" : "添加失败";

            return jm;
        }

        #endregion

        #region 在加入购物车的时候，判断是否有参加拼团的商品

        /// <summary>
        /// 在加入购物车的时候，判断是否有参加拼团的商品
        /// </summary>
        /// <param name="productId"></param>
        /// <param name="userId">用户序列</param>
        /// <param name="nums">加入购物车数量</param>
        /// <param name="ruleId">规则序列</param>
        ///  <param name="ruleId">货品是否定制</param>
        public async Task<WebApiCallBack> AddCartHavePinTuan(int productId, int userId = 0, int nums = 1, int ruleId = 0)
        {
            var jm = new WebApiCallBack();
            var products = await _productsServices.QueryByIdAsync(productId);
            if (products == null)
            {
                jm.data = 10000;
                jm.msg = GlobalErrorCodeVars.Code10000;
                return jm;
            }
            var pinTuanGoods = await _pinTuanGoodsServices.QueryByClauseAsync(p => p.goodsId == products.goodsId && p.ruleId == ruleId);
            if (pinTuanGoods == null)
            {
                jm.data = 10000;
                jm.msg = GlobalErrorCodeVars.Code10000;
                return jm;
            }
            var pinTuanRule = await _pinTuanRuleServices.QueryByClauseAsync(p => p.id == pinTuanGoods.ruleId && p.isStatusOpen == true);
            if (pinTuanRule == null)
            {
                jm.data = 10000;
                jm.msg = GlobalErrorCodeVars.Code10000;
                return jm;
            }

            if (pinTuanRule.startTime > DateTime.Now)
            {
                jm.data = 15601;
                jm.msg = GlobalErrorCodeVars.Code15601;
                return jm;
            }
            if (pinTuanRule.endTime < DateTime.Now)
            {
                jm.data = 15602;
                jm.msg = GlobalErrorCodeVars.Code15602;
                return jm;
            }
            //查询是否存在已经开团，并且自己是队长的拼团
            var havaGroup = await _pinTuanRecordServices.ExistsAsync(p =>
                p.userId == userId
                && p.goodsId == products.goodsId
                && p.status == (int)GlobalEnumVars.PinTuanRecordStatus.InProgress);
            if (havaGroup)
            {
                jm.data = 15613;
                //jm.msg = GlobalErrorCodeVars.Code15613;
                jm.msg = "您存在已开启的拼团";
                return jm;
            }

            using var container = _serviceProvider.CreateScope();
            var orderRepository = container.ServiceProvider.GetService<ICoreCmsOrderRepository>();
            var checkOrder = orderRepository.FindLimitOrder(products.id, userId, pinTuanRule.startTime, pinTuanRule.endTime, (int)GlobalEnumVars.OrderType.PinTuan);
            if (pinTuanRule.maxGoodsNums > 0)
            {
                if (checkOrder.TotalOrders + nums > pinTuanRule.maxGoodsNums)
                {
                    jm.data = 15610;
                    jm.msg = GlobalErrorCodeVars.Code15610;
                    return jm;
                }
            }
            if (pinTuanRule.maxNums > 0)
            {
                if (checkOrder.TotalUserOrders > pinTuanRule.maxNums)
                {
                    jm.data = 15611;
                    jm.msg = GlobalErrorCodeVars.Code15611;
                    return jm;
                }
            }

            jm.status = true;
            return jm;
        }


        #endregion

        #region 获取购物车原始列表(未核算)

        /// <summary>
        /// 获取购物车原始列表(未核算)
        /// </summary>
        /// <param name="userId">用户序号</param>
        /// <param name="ids">已选择货号</param>
        /// <param name="type">购物车类型/同订单类型</param>
        /// <param name="objectId">关联非订单类型数据序列</param>
        /// <param name="goodsId">goodsId</param>
        /// <returns></returns>
        public async Task<WebApiCallBack> GetCartDtoData(int userId, int[] ids = null, int type = 1, int objectId = 0, int goodsId = 0)
        {
            var jm = new WebApiCallBack() { methodDescription = "获取购物车原始列表(未核算)" };

            //强制过滤一遍，防止出现可以造假数据
            await _dal.DeleteAsync(p => p.userId == userId && p.nums <= 0);

            using var container = _serviceProvider.CreateScope();
            var productsService = container.ServiceProvider.GetService<ICoreCmsProductsServices>();
            var goodsServices = container.ServiceProvider.GetService<ICoreCmsGoodsServices>();

            List<CoreCmsCart> carts;
            if (ids != null && ids.Any())
            {
                carts = await _dal.QueryListByClauseAsync(p => p.userId == userId && p.type == type && ids.Contains(p.id), p => p.id, OrderByType.Asc);
            }
            else
            {
                carts = await _dal.QueryListByClauseAsync(p => p.userId == userId && p.type == type, p => p.id, OrderByType.Asc);
            }

            if (goodsId>0)
            {
                var products = await  _productsServices.GetProducts(goodsId);
                int[] ss =  products.Select(x => x.id).ToArray();

                carts = carts.Where(p => ss.Contains(p.productId)).ToList();

            }


            var cartDto = new CartDto { userId = userId, type = type };

            foreach (var item in carts)
            {
                var cartProducts = new CartProducts();
                //如果没有此商品，就在购物车里删掉
                var productInfo = await productsService.GetProductInfo(item.productId, false, userId);
                if (productInfo == null)
                {
                    await _dal.DeleteAsync(item);
                    continue;
                }
                //商品下架，就从购物车里面删除
                var ps = await productsService.GetShelfStatus(item.productId);
                if (ps == false)
                {
                    await _dal.DeleteAsync(item);
                    continue;
                }
                //商品金额设置为0，就从购物车里面删除
                if (productInfo.price <= 0)
                {
                    await _dal.DeleteAsync(item);
                    continue;
                }

                //获取重量
                var goodsWeight = await goodsServices.GetWeight(item.productId);

                //开始赋值
                cartProducts.id = item.id;
                cartProducts.userId = userId;
                cartProducts.productId = item.productId;
                cartProducts.nums = item.nums;
                cartProducts.type = item.type;
                cartProducts.weight = goodsWeight;
                cartProducts.products = productInfo;
                cartProducts.isCustomizable = item.isCustomizable;
                //如果传过来了购物车数据，就算指定的购物车的数据，否则，就算全部购物车的数据
                if (ids != null && ids.Any() && ids.Contains(item.id))
                {
                    cartProducts.isSelect = true;
                }
                else
                {
                    cartProducts.isSelect = false;
                }
                //判断商品是否已收藏
                cartProducts.isCollection = await _goodsCollectionServices.Check(userId, cartProducts.products.goodsId);

                cartDto.list.Add(cartProducts);
            }
            //如果不同的购物车类型，可能会做一些不同的操作。
            switch (type)
            {
                case (int)GlobalEnumVars.OrderType.Common:
                    //标准模式不需要修改订单数据和商品数据
                    {
                        if(await _bfbfComAPIService.IsDictionary(_user.ID))
                        {
                            foreach (var item in cartDto.list)
                            {
                                item.products.price=item.products.distributionPrice;

                            }
                        }
                    }
                    break;
                case (int)GlobalEnumVars.OrderType.PinTuan:
                    //拼团模式走拼团价，去修改商品价格
                    var result = _pinTuanRuleServices.PinTuanInfo(cartDto.list, objectId);
                    if (result.status)
                    {
                        cartDto.list = result.data as List<CartProducts>;
                    }
                    else
                    {
                        return result;
                    }
                    break;
                case (int)GlobalEnumVars.OrderType.Group:
                    //团购模式不需要修改订单数据和商品数据
                    break;
                case (int)GlobalEnumVars.OrderType.Seckill:
                    //秒杀模式不需要修改订单数据和商品数据
                    break;
                case (int)GlobalEnumVars.OrderType.Bargain:
                    //砍价模式

                    break;
                case (int)GlobalEnumVars.OrderType.Solitaire:
                    //接龙模式，去获取接龙商品价格。
                    var solitaireInfo = await _solitaireServices.SolitaireInfo(objectId, cartDto.list);
                    if (solitaireInfo.status)
                    {
                        cartDto.list = solitaireInfo.data as List<CartProducts>;
                    }
                    else
                    {
                        return solitaireInfo;
                    }
                    break;

                default:
                    jm.msg = GlobalErrorCodeVars.Code10000;
                    return jm;
            }

            jm.status = true;
            jm.data = cartDto;
            jm.msg = GlobalConstVars.GetDataSuccess;

            return jm;
        }

        #endregion

        #region 获取处理后的购物车信息

        /// <summary>
        /// 获取处理后的购物车信息
        /// </summary>
        /// <param name="userId">用户序列</param>
        /// <param name="ids">选中的购物车商品</param>
        /// <param name="orderType">订单类型</param>
        /// <param name="areaId">收货地址id</param>
        /// <param name="point">消费的积分</param>
        /// <param name="couponCode">优惠券码</param>
        /// <param name="deliveryType">关联上面的是否免运费/1=快递配送（要去算运费）生成订单记录快递方式  2=门店自提（不需要计算运费）生成订单记录门店自提信息</param>
        /// <param name="userShipId">用户收货地址</param>
        /// <param name="objectId">关联非普通订单营销类型序列</param>
        /// <returns></returns>
        public async Task<WebApiCallBack> GetCartInfos(int userId, int[] ids, int orderType, int areaId, int point, string couponCode, int deliveryType = (int)GlobalEnumVars.OrderReceiptType.Logistics, int userShipId = 0, int objectId = 0,  int goodsId = 0)
        {
            var jm = new WebApiCallBack() { methodDescription = "获取处理后的购物车信息" };
            var cartDto = new CartDto(); //必须初始化
            var cartDtoData = await GetCartDtoData(userId, ids, orderType, objectId, goodsId);
            if (!cartDtoData.status)
            {
                jm.msg = "1";
                return cartDtoData;
            }
            cartDto = cartDtoData.data as CartDto;

            jm.msg = "2";

            //算订单总金额
            foreach (var item in cartDto.list)
            {
                jm.msg = "3";
                //库存不足不计算金额不可以选择
                if (item.nums > item.products.stock)
                {
                    item.isSelect = false;
                }
                //单条商品总价
                item.products.amount = Math.Round(item.nums * (decimal)item.products.price, 2);
                //定制商品添加定制价格
                if (item.isCustomizable)
                //是定制商品
                {
                    item.products.amount += _bfbfComAPIService.CommandCustomizable(item.nums);
                    item.CustomizableMoney = _bfbfComAPIService.CommandCustomizable(item.nums);
                }

                if (item.isSelect)
                {
                    //算订单总商品价格
                    cartDto.goodsAmount = Math.Round(cartDto.goodsAmount + item.products.amount, 2);
                    //算订单总价格
                    cartDto.amount = Math.Round(cartDto.amount + item.products.amount, 2);
                    //计算总重量
                    cartDto.weight = Math.Round(cartDto.weight + Math.Round(item.weight * item.nums, 2), 2);
                }
            }

            //门店订单，强制无运费
            if (deliveryType == (int)GlobalEnumVars.OrderReceiptType.SelfDelivery)
            {
                cartDto.costFreight = 0;
            }
            else if (deliveryType == (int)GlobalEnumVars.OrderReceiptType.Logistics)
            {
                // 运费判断
                var blFreight = await CartFreight(cartDto, areaId);
                if (blFreight == false)
                {
                    jm.data = cartDto;
                    jm.msg = "运费判断";
                    return jm;
                }
            }
            else if (deliveryType == (int)GlobalEnumVars.OrderReceiptType.IntraCityService)
            {
                await CartFreightByIntraCityService(cartDto, userShipId);
            }


            //接下来算订单促销金额,有些模式不需要计算促销信息，这里就增加判断
            if (orderType == (int)GlobalEnumVars.OrderType.Common)
            {
                jm.data = await _promotionServices.ToPromotion(cartDto);
                jm.msg = "订单促销金额计算";
            }
            else if ((orderType == (int)GlobalEnumVars.OrderType.Group || orderType == (int)GlobalEnumVars.OrderType.Seckill) && objectId > 0)
            {
                //团购秒杀默认时间过期后，不可以下单
                var dt = DateTime.Now;
                var promotionInfo = await _promotionServices.QueryByClauseAsync(p => p.startTime < dt && p.endTime > dt && p.id == objectId);

                var checkRes = await _promotionServices.SetPromotion(promotionInfo, cartDto);
                if (checkRes == false)
                {
                    jm.msg = GlobalErrorCodeVars.Code15600;
                    return jm;
                }
            }
            else if (orderType == (int)GlobalEnumVars.OrderType.PinTuan)
            {
                jm.data = await _promotionServices.ToPromotion(cartDto);
                jm.msg = "拼团也计算促销信息";
            }
            //使用优惠券，判断优惠券是否可用
            var bl = await CartCoupon(cartDto, couponCode);
            if (bl == false)
            {
                jm.status = false;
                jm.data = cartDto.error.data;
                jm.msg = cartDto.error.msg;
                return jm;
            }
            //使用积分
            var pointDto = await CartPoint(cartDto, userId, point);
            if (pointDto.status == false)
            {
                jm.status = false;
                jm.msg = pointDto.msg;
                return jm;
            }

            //判断最终价格
            if (cartDto.amount < 0)
            {
                cartDto.amount = 0;
            }

            jm.status = true;
            jm.data = cartDto;
            jm.msg = "4";

            return jm;
        }

        #endregion

        #region 算运费

        /// <summary>
        /// 算运费
        /// </summary>
        /// <param name="cartDto">购物车信息</param>
        /// <param name="areaId">收货地址id</param>
        /// <returns></returns>
        public async Task<bool> CartFreight(CartDto cartDto, int areaId)
        {
            if (areaId > 0)
            {
                cartDto.costFreight = await _shipServices.GetShipCost(areaId, cartDto.weight, cartDto.goodsAmount);
                cartDto.amount = Math.Round(cartDto.amount + cartDto.costFreight, 2);
            }
            return true;
        }

        #endregion

        #region 根据经纬度算运费

        /// <summary>
        /// 根据经纬度算运费
        /// </summary>
        /// <param name="cartDto">购物车信息</param>
        /// <param name="userShipId">用户地址信息</param>
        /// <returns></returns>
        public async Task<bool> CartFreightByIntraCityService(CartDto cartDto, int userShipId)
        {
            if (userShipId > 0)
            {
                var userShip = await _userShipServices.QueryByClauseAsync(p => p.id == userShipId);
                if (userShip == null)
                {
                    return true;
                }
                var store = await _storeServices.QueryByClauseAsync(p => p.isDefault == true);
                if (store == null)
                {
                    return true;
                }

                if (string.IsNullOrEmpty(userShip.longitude) || string.IsNullOrEmpty(userShip.latitude) || string.IsNullOrEmpty(store.longitude) || string.IsNullOrEmpty(store.latitude))
                {
                    return true;
                }

                //第一种调用方法
                var result = MapHelper.GetDistance(Convert.ToDouble(userShip.latitude.Trim()), Convert.ToDouble(userShip.longitude.Trim()), Convert.ToDouble(store.latitude.Trim()), Convert.ToDouble(store.longitude.Trim()));

                var allConfigs = await _settingServices.GetConfigDictionaries();
                var intraCityServiceBy2Km = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceBy2KM).ObjectToDecimal(0);
                var intraCityServiceBy5Km = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceBy5KM).ObjectToDecimal(0);
                var intraCityServiceBy10Km = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceBy10KM).ObjectToDecimal(0);
                var intraCityServiceBy15Km = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceBy15KM).ObjectToDecimal(0);
                var intraCityServiceBy20Km = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceBy20KM).ObjectToDecimal(0);
                var intraCityServiceByExceed20Km = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceByExceed20KM).ObjectToDecimal(0);

                if (result is >= 0 and <= 2)
                    cartDto.costFreight = intraCityServiceBy2Km;
                else if (result is > 2 and <= 5)
                    cartDto.costFreight = intraCityServiceBy5Km;
                else if (result is > 5 and <= 10)
                    cartDto.costFreight = intraCityServiceBy10Km;
                else if (result is > 10 and <= 15)
                    cartDto.costFreight = intraCityServiceBy15Km;
                else if (result is > 15 and <= 20)
                    cartDto.costFreight = intraCityServiceBy20Km;
                else if (result > 20)
                    cartDto.costFreight = Math.Round(intraCityServiceByExceed20Km * (decimal)result).ObjectToDecimal();
                else if (result < 0)
                    cartDto.costFreight = intraCityServiceBy2Km;
                else
                    cartDto.costFreight = cartDto.costFreight;

                var intraCityServiceFreeCredit = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.IntraCityServiceFreeCredit).ObjectToDecimal(0);
                if (intraCityServiceFreeCredit > 0 && cartDto.amount > intraCityServiceFreeCredit)
                {
                    cartDto.costFreight = 0;
                }
                cartDto.amount = Math.Round(cartDto.amount + cartDto.costFreight, 2);
            }
            return true;
        }

        #endregion

        #region 购物车中使用优惠券

        /// <summary>
        /// 购物车中使用优惠券
        /// </summary>
        /// <param name="cartDto"></param>
        /// <param name="couponCode"></param>
        /// <returns></returns>
        public async Task<bool> CartCoupon(CartDto cartDto, string couponCode)
        {
            if (!string.IsNullOrEmpty(couponCode))
            {
                var arr = couponCode.Split(",");
                //判断优惠券是否可用
                var couponInfo = await _couponServices.CodeToInfo(arr, true);
                if (couponInfo.status == false)
                {
                    cartDto.error = couponInfo;
                    return false;
                }
                //判断优惠券是否符合规格
                var res = await _promotionServices.ToCoupon(cartDto, couponInfo.data as List<CoreCmsPromotion>);
                if (res.status == false)
                {
                    cartDto.error = res;
                    return false;
                }
            }
            return true;
        }

        #endregion

        #region 购物车中使用积分

        /// <summary>
        /// 购物车中使用积分
        /// </summary>
        /// <param name="cartDto"></param>
        /// <param name="userId"></param>
        /// <param name="point"></param>
        /// <returns></returns>
        public async Task<WebApiCallBack> CartPoint(CartDto cartDto, int userId, int point)
        {
            var jm = new WebApiCallBack() { status = true };
            if (point > 0)
            {
                var user = await _userServices.QueryByClauseAsync(p => p.id == userId);
                if (user.point < point)
                {
                    jm.status = false;
                    jm.msg = "积分不足，无法使用积分";
                    return jm;
                }
                //判断积分值多少钱
                //计算可用积分
                var allConfigs = await _settingServices.GetConfigDictionaries();

                //判断是全局模式还是单品模式
                var pointExchangeModel = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.PointExchangeModel).ObjectToInt();
                if (pointExchangeModel == 1)
                {
                    //计算可用积分//订单积分使用比例
                    var ordersPointProportion = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.OrdersPointProportion).ObjectToDecimal(10);
                    var proportion = Math.Round(ordersPointProportion / 100, 4);

                    //最多可以抵扣的金额
                    var maxPointDeductedMoney = Math.Round(cartDto.amount * proportion, 4);

                    //订单积分折现比例(多少积分可以折现1块钱)
                    var pointDiscountedProportion = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.PointDiscountedProportion).ObjectToDecimal(100); //积分兑换比例
                    var pointDeductedMoney = Math.Round(Convert.ToDecimal(point) / pointDiscountedProportion, 4); ; //积分可以抵扣的钱

                    if (maxPointDeductedMoney < pointDeductedMoney)
                    {
                        jm.status = false;
                        jm.msg = "积分超过订单可使用的积分数量";
                        return jm;
                    }
                    cartDto.point = point;
                    cartDto.pointExchangeMoney = pointDeductedMoney;
                    cartDto.amount -= pointDeductedMoney;
                }
                else
                {
                    //可抵扣金额
                    decimal money = 0;

                    foreach (var item in cartDto.list)
                    {
                        money += item.nums * item.products.pointsDeduction;
                    }
                    //计算抵扣这么多金额需要多少积分。
                    //订单积分折现比例(多少积分可以折现1块钱)
                    var pointDiscountedProportion = CommonHelper.GetConfigDictionary(allConfigs, SystemSettingConstVars.PointDiscountedProportion).ObjectToInt(100);
                    //计算需要多少积分
                    var needsPoint = money * pointDiscountedProportion;

                    cartDto.point = point;
                    cartDto.pointExchangeMoney = money;
                    cartDto.amount -= money;
                }
            }
            jm.data = cartDto;
            return jm;
        }

        #endregion

        #region 获取购物车用户数据总数
        /// <summary>
        ///     获取购物车用户数据总数
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetCountAsync(int userId)
        {
            return await _dal.GetCountAsync(userId);
        }

        #endregion

        #region 获取购物车商品总价格
        /// <summary>
        ///     获取购物车商品总价格
        /// </summary>
        /// <returns></returns>
        public async Task<decimal> GetMoneyAsync(int userId)
        {
            return await _dal.GetMoneyAsync(userId);
        }

        #endregion

        #region 根据提交的数据判断哪些购物券可以使用
        /// <summary>
        /// 根据提交的数据判断哪些购物券可以使用
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="ids"></param>
        /// <returns></returns>
        public async Task<WebApiCallBack> GetCartAvailableCoupon(int userId, int[] ids = null)
        {
            var jm = new WebApiCallBack();
            var dt = DateTime.Now;
            var resultData = new List<CoreCmsCoupon>();

            //取用户数据，如果用户没登录，都没意义。
            var user = await _userServices.QueryByClauseAsync(p => p.id == userId);
            if (user == null)
            {
                return jm;
            }
            //先取购物车数据，如果购物车都没存购货品数据，优惠券就没意义
            //获取货品数据
            var carts = await _dal.QueryListByClauseAsync(p => p.userId == userId && p.type == (int)GlobalEnumVars.OrderType.Common);
            if (!carts.Any())
            {
                return jm;
            }
            var productIds = carts.Select(p => p.productId).ToList();
            var products = await _productsServices.QueryListByClauseAsync(p => productIds.Contains(p.id));
            if (!products.Any())
            {
                return jm;
            }
            var cartProducts = new List<CartProducts>();
            var goodIds = new List<int>();
            foreach (var item in carts)
            {
                var cp = new CartProducts { products = products.Find(p => p.id == item.productId) };
                if (cp.products == null)
                {
                    continue;
                }
                //开始赋值
                cp.id = item.id;
                cp.userId = userId;
                cp.productId = item.productId;
                cp.nums = item.nums;
                cp.type = item.type;
                //如果传过来了购物车数据，就算指定的购物车的数据，否则，就算全部购物车的数据
                if (ids != null && ids.Any())
                {
                    if (ids.Contains(item.id))
                    {
                        goodIds.Add(cp.products.goodsId);
                        cartProducts.Add(cp);
                    }
                    continue;
                }
                goodIds.Add(cp.products.goodsId);
                cartProducts.Add(cp);
            }
            //如果获取赛选后没了，就返回无
            if (!cartProducts.Any()) return jm;
            //获取商品数据
            var goods = await _goodsServices.QueryListByClauseAsync(p => goodIds.Contains(p.id));
            //如果商品都被已下架或者删除，也没了。
            if (!goods.Any()) return jm;

            cartProducts.ForEach(p =>
            {
                p.good = goods.Find(g => g.id == p.products.goodsId);
            });


            //获取我的可用优惠券
            var wherec = PredicateBuilder.True<CoreCmsCoupon>();
            wherec = wherec.And(p => p.userId == userId);
            wherec = wherec.And(p => p.isUsed == false);
            wherec = wherec.And(p => p.endTime > dt);
            var userCoupon = await _couponServices.QueryPageMapperAsync(wherec, p => p.createTime, OrderByType.Desc, false);
            if (!userCoupon.Any())
            {
                return jm;
            }

            //获取所有商品分类
            var goodsCategories = await _goodsCategoryServices.GetCaChe();

            foreach (var coupon in userCoupon)
            {
                if (coupon.promotion == null)
                {
                    continue;
                }

                //先判断优惠券是否可以使用
                //判断规则是否开启
                if (coupon.promotion.isEnable == false) continue;
                //判断优惠券规则是否到达开始时间
                if (coupon.startTime > dt) continue;
                //判断优惠券规则是否已经到结束时间了，也就是是否过期了
                if (coupon.endTime < dt) continue;

                //再来判断是否符合规格
                //判断是哪个规则，并且确认是否符合|只要有一个规则不满足，就失效。
                var type = 0;
                foreach (var pc in coupon.conditions)
                {
                    type = 0;
                    JObject parameters = (JObject)JsonConvert.DeserializeObject(pc.parameters);
                    if (parameters == null) break;
                    var objNums = 0;
                    switch (pc.code)
                    {
                        case "GOODS_ALL":
                            //只要购物车有商品就支持，因为是购物车付款调用接口，所以不存在无商品情况
                            type = 2;
                            break;
                        case "GOODS_IDS":
                            //指定某些商品满足条件
                            if (!parameters.ContainsKey("goodsId") || !parameters.ContainsKey("nums")) break;
                            objNums = parameters["nums"].ObjectToInt(0);
                            var goodsIds = CommonHelper.StringToIntArray(parameters["goodsId"].ObjectToString());
                            //只要有一个商品支持，此优惠券就可以使用。
                            if (goodsIds.Any())
                            {
                                foreach (var p in cartProducts)
                                {
                                    if (!goodsIds.Contains(p.products.goodsId))
                                    {
                                        continue;
                                    }
                                    if (p.nums >= objNums)
                                    {
                                        type = 2;
                                        break;
                                    }
                                }
                            }
                            break;
                        case "GOODS_CATS":
                            //指定商品是否满足分类
                            if (!parameters.ContainsKey("catId") || !parameters.ContainsKey("nums")) break;
                            var objCatId = parameters["catId"].ObjectToInt(0);
                            objNums = parameters["nums"].ObjectToInt(0);

                            foreach (var product in cartProducts)
                            {
                                type = _goodsCategoryServices.IsHave(goodsCategories, objCatId, product.good.goodsCategoryId) ? product.nums >= objNums ? 2 : 1
                                    : 0;
                                if (type == 2)
                                {
                                    break;
                                }
                            }
                            break;
                        case "GOODS_BRANDS":
                            //指定商品品牌满足条件
                            if (!parameters.ContainsKey("brandId") || !parameters.ContainsKey("nums")) break;
                            var objBrandId = parameters["brandId"].ObjectToInt(0);
                            objNums = parameters["nums"].ObjectToInt(0);

                            foreach (var product in cartProducts)
                            {
                                type = product.good.brandId == objBrandId ? product.nums >= objNums ? 2 : 1 : 0;
                                if (type == 2)
                                {
                                    break;
                                }
                            }
                            break;
                        case "ORDER_FULL":
                            //订单满XX金额满足条件
                            if (!parameters.ContainsKey("money")) break;
                            var objMoney = parameters["money"].ObjectToDecimal();
                            //算订单总商品价格
                            decimal goodsAmount = 0;
                            foreach (var product in cartProducts)
                            {
                                var money = product.products.price * product.nums;
                                goodsAmount = Math.Round(goodsAmount + money, 2);
                            }
                            if (goodsAmount >= objMoney)
                            {
                                type = 2;
                            }
                            break;
                        case "USER_GRADE":
                            //用户符合指定等级
                            if (!parameters.ContainsKey("grades")) break;
                            var arr = CommonHelper.StringToIntArray(parameters["grades"].ObjectToString());
                            if (arr.Contains(user.grade))
                            {
                                type = 2;
                            }
                            break;
                        default:
                            break;
                    }
                    //不满足条件，直接跳过
                    if (type != 2)
                    {
                        break;
                    }
                }

                if (type == 2)
                {
                    resultData.Add(coupon);
                }
            }

            //结果集拼装
            var resutlList = new List<GetMyCouponResultDto>();
            if (resultData != null && resultData.Any())
            {
                foreach (var item in resultData)
                {
                    var expression1 = string.Empty;
                    var expression2 = string.Empty;

                    foreach (var condition in item.conditions)
                    {
                        expression1 += PromotionHelper.GetConditionMsg(condition.code, condition.parameters);
                    }
                    foreach (var result in item.results)
                    {
                        expression2 += PromotionHelper.GetResultMsg(result.code, result.parameters);
                    }

                    var dto = new GetMyCouponResultDto
                    {
                        couponCode = item.couponCode,
                        promotionId = item.promotionId,
                        isUsed = item.isUsed,
                        userId = item.userId,
                        usedId = item.usedId,
                        createTime = item.createTime,
                        updateTime = item.updateTime,
                        couponName = item.promotion.name,
                        expression1 = expression1,
                        expression2 = expression2,
                        isExpire = item.endTime > dt,
                        startTime = item.startTime,
                        endTime = item.endTime,
                        stime = item.startTime.ToString("yyyy-MM-dd"),
                        etime = item.endTime.ToString("yyyy-MM-dd")
                    };

                    resutlList.Add(dto);
                }
            }
            jm.status = true;
            jm.data = new
            {
                list = resutlList,
                changeData = resultData,
                cartProducts,
                user
            };
            //jm.otherData = userCoupon;
            return jm;
        }

        #endregion

    }
}