using MyCode.Project.Domain.Message.Response.BaoDian;
using MyCode.Project.Domain.Model;
using MyCode.Project.Domain.Repositories;
using MyCode.Project.Infrastructure.Common;
using MyCode.Project.Infrastructure.Enumeration;
using MyCode.Project.Infrastructure.Extensions;
using MyCode.Project.Repositories;
using MyCode.Project.Repositories.Common;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyCode.Project.Services.BLL
{
    /// <summary>
    /// 老客销售计划
    /// </summary>
    public class OldMemberPlanCalBLL:CommonPlanCalBLL
    {
        #region 初始化
        private readonly ILxmSheetItemRepository _lxmSheetItemRepository;
        private readonly ILxmProductSalesScheduleRepository _lxmProductSalesScheduleRepository;
        private readonly IBdClerkOldMemberSalesPlanRepository _bdClerkOldMemberSalesPlanRepository;
        public OldMemberPlanCalBLL(IRepository repository,
            ILxmSheetItemRepository lxmSheetItemRepository,
            ILxmProductSalesScheduleRepository lxmProductSalesScheduleRepository,
            IBdClerkOldMemberSalesPlanRepository bdClerkOldMemberSalesPlanRepository
            ) :base(repository)
        {
            _repository = repository;
            _lxmSheetItemRepository = lxmSheetItemRepository;
            _lxmProductSalesScheduleRepository = lxmProductSalesScheduleRepository;
            _bdClerkOldMemberSalesPlanRepository = bdClerkOldMemberSalesPlanRepository;
        }
        #endregion

        #region Run(根据订单id来运算)
        /// <summary>
        ///  根据订单id来运算
        /// </summary>
        /// <param name="objSheetId"></param>
        [TransactionCallHandler]
        public void Run(object objSheetId)
        {
            //初始化
            base.Init(objSheetId.ToString());

            //预转销订单不处理
            var checkResult = base.CheckPassed(PlanType.OldMemberSalesPlan);

            if (!checkResult) { return; }

            //先删掉可以保证该方法不断的被调用计算
            _repository.Delete<BdOrderPlan>(p => p.OrderId == SheetId && p.PlanType == (int)PlanType.OldMemberSalesPlan);

            //得到该订单中的商品明细
            var sheetItems = _repository.Queryable<LxmSheetItem>().Where(p => p.SalesSheetId == SheetId).WithCache(100).ToList();

            //在时间段范围内邀请人来参加活动，里面有某个商品符合就算
            if (Sheet.Direct == 1)
            {
                //查看当月的该用户老客套餐计划
                var oldMemberPlans = _bdClerkOldMemberSalesPlanRepository.GetOldMemberPlanList(Sheet.ShopId, Sheet.MemberId, Sheet.OrderClerkId, VersionTime, Sheet.CreateTime.Value);

                if (oldMemberPlans == null || oldMemberPlans.Count == 0)
                {
                    LogHelper.Info($"[老客运算]订单={SheetId}没有匹配到任何计划");
                    return;
                }

                var planSkus = _lxmProductSalesScheduleRepository.GetPackageProductList(oldMemberPlans.Select(p => p.PackageId).ToList(), 1);

                CalNormalOrder(oldMemberPlans, planSkus, sheetItems);
            }
            else
            {
                CalRefundOrder(sheetItems);
            }
        }
        #endregion


        #region CalRefundOrder(如果是退款单)
        /// <summary>
        /// 如果是退款单
        /// </summary>
        private void CalRefundOrder(List<LxmSheetItem> listNorMalSheetItem)
        {
            if (Sheet.SourceOrderId == null)
            {
                LogHelper.Info($"[老客运算]退款单={Sheet.Id}找不到原始订单");
                return;
            }

            //判断原始销售单是否当月，如果不是当月，则跳出
            var sourceOrderId = Sheet.SourceOrderId;

            //判断原始销售单是否当月，如果不是当月，则跳出
            var sourceOrder = GetSourceSimpleOrder(Sheet.SourceOrderId);

            if (sourceOrder.OrderPreorderId != null) { sourceOrderId = sourceOrder.OrderPreorderId; }

            var sheetOrderMonthFirstDay = Sheet.CreateTime.Value.GetFirstDayOfMonth();

            if (sourceOrder.CreateTime.Value.GetFirstDayOfMonth() != sheetOrderMonthFirstDay)
            {
                LogHelper.Info($"[老客运算]退款单={Sheet.Id}的原始订单={Sheet.SourceOrderId}非当月，老客计划不运算");
                return;
            }

            var sourceItemQty = _repository.Queryable<LxmSheetItem>().Where(p => p.SalesSheetId == sourceOrderId).Select(p => SqlFunc.AggregateSum(p.Qty)).First();

            var sheetTime = Sheet.CreateTime.Value;

            //判断当前是否是全退,如果是全退，则当月的需要写一条反的数据,根据退的商品的数量;
            //先得到当月1号到今天该订单退的情况
            //var refundQty = _lxmSheetItemRepository.GetRefundQty(Sheet.SourceOrderId, sheetOrderMonthFirstDay, Sheet.CreateTime.Value);
            var refundQty = _lxmSheetItemRepository.GetRefundQty(sourceOrderId, sheetOrderMonthFirstDay, Sheet.CreateTime.Value.AddSeconds(1));

            //只是部分退而已
            if (sourceItemQty != refundQty)
            {
                LogHelper.Info($"[老客运算]退款单={Sheet.Id}只是部分退，不用写反向数据");
                return;
            }

            //全退了，写反向的数据
            var orderPlans = _repository.Queryable<BdOrderPlan>()
                .Where(p => p.OrderId == Sheet.SourceOrderId && p.OrderTime >= sheetOrderMonthFirstDay && p.OrderTime <= Sheet.CreateTime.Value && p.PlanType == (int)PlanType.OldMemberSalesPlan)
                .ToList();
            if (orderPlans == null || orderPlans.Count == 0) { return; }

            var insertOrderPlans = new List<BdOrderPlan>();

            foreach (var plan in orderPlans)
            {
                var insertOrderPlan = new BdOrderPlan()
                {
                    Id = IdHelper.GetNewId(),
                    OrderId = SheetId,
                    OrderTime = Sheet.CreateTime.Value,
                    PackageId = plan.PackageId,
                    PackageName = plan.PackageName,
                    PlanId = plan.PlanId,
                    PlanType = plan.PlanType,
                    Qty = -plan.Qty,
                    UpdateTime = DateTime.Now,
                    SourceOrderId = sourceOrderId,
                    SourcePackageId = plan.SourcePackageId,
                    Info = $"原始订单id={Sheet.SourceOrderId}全退导致[老客运算]产生反向流水"
                };

                insertOrderPlans.Add(insertOrderPlan);
            }

            _repository.Add<BdOrderPlan>(insertOrderPlans);
        }
        #endregion

        #region CalNormalOrder(计算正常的订单)
        /// <summary>
        /// 计算正常的订单
        /// </summary>
        /// <param name="listClerkPlan"></param>
        /// <param name="listPackage"></param>
        /// <param name="listSheetItem"></param>
        private void CalNormalOrder(List<OldMemberPlanResp> listClerkPlan,
            List<PackageListResp> listPackage,
            List<LxmSheetItem> listSheetItem)
        {
            //只要满足一个就符合计划,这里当时正向的，就是不是退款的情况的
            foreach (var clerkPlan in listClerkPlan)
            {

                //匹配到的计划配置里面的sku
                var IfMatchPlan = IfMatchPlanProductOrService(listPackage, clerkPlan.PackageId, listSheetItem);

                var orderPlan = new BdOrderPlan()
                {
                    Id = IdHelper.GetNewId(),
                    OrderId = Sheet.Id,
                    OrderTime = Sheet.CreateTime.Value,
                    PackageId = clerkPlan.PackageId,
                    PackageName = clerkPlan.PackageName,
                    PlanId = clerkPlan.PlanId,
                    PlanType = (int)PlanType.OldMemberSalesPlan,
                    Qty = 1,
                    UpdateTime = DateTime.Now,
                    SourcePackageId = clerkPlan.SourcePackageId
                };

                //看看订单明细里面是不是有这个商品
                if (IfMatchPlan)
                {
                    orderPlan.Info = Info;
                    _repository.Add<BdOrderPlan>(orderPlan);
                }

            }
        }
        #endregion

        #region IfMatchPlanProductOrService(是否匹配计划中的商品，需要所有匹配才算)
        /// <summary>
        /// 是否匹配计划中的商品，需要所有匹配才算
        /// </summary>
        /// <param name="orderSkuId"></param>
        /// <param name="listPlanSkuId"></param>
        /// <returns></returns>
        private bool IfMatchPlanProductOrService(List<PackageListResp> listPackage, long packageId, List<LxmSheetItem> listSheetItem)
        {
            //匹配到的计划配置里面的sku
            var matchPlanSkus = listPackage.Where(p => p.Id == packageId).ToList();

            foreach (var planSku in matchPlanSkus)
            {
                if (!listSheetItem.Exists(p => p.ItemId.ToLower() == planSku.ProductOrServiceId.ToLower() && p.Qty >= planSku.Qty))
                {
                    Info = $"[老客运算]sheetid={SheetId}，{planSku.ProductOrServiceName},id={planSku.ProductOrServiceId}在订单明细中不存在或者数量小于套餐的最小数量";
                    return false;
                }
            }

            Info = "符合[老客计划]，所有商品都需要在套餐中存在，且数量要对上";
            return true;

        }
        #endregion
    }
}