/***********************************************************************
 *            Project: baifenBinfa
 *        ProjectName: 百分兵法管理系统                               
 *                Web: http://chuanyin.com                     
 *             Author:                                        
 *              Email:                               
 *         CreateTime: 2024/4/17 13:28:20
 *        Description: 暂无
 ***********************************************************************/

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Threading.Tasks;
using System.Xml.Linq;
using CoreCms.Net.Configuration;
using CoreCms.Net.IRepository;
using CoreCms.Net.IRepository.UnitOfWork;
using CoreCms.Net.IServices;
using CoreCms.Net.Model.Entities;
using CoreCms.Net.Model.Entities.Expression;
using CoreCms.Net.Model.Entities.Order;
using CoreCms.Net.Model.ViewModels.Basics;
using CoreCms.Net.Model.ViewModels.UI;
using CoreCms.Net.Utility.Helper;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using SqlSugar;
using static CoreCms.Net.Configuration.GlobalEnumVars;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.CgibinExpressIntracityQueryStoreResponse.Types;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.ProductSPUAddRequest.Types;
using System.Linq;
using CoreCms.Net.Model.Entities.baifenbingfa.apply;
using CoreCms.Net.Model.ViewModels.DTO;
using CoreCms.Net.Model.Entities.baifenbingfa.Promote;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.ScanProductAddV2Request.Types.Product.Types;
using NPOI.SS.Formula.Functions;
using CoreCms.Net.Model.FromBody;
using Essensoft.Paylink.Alipay.Domain;


namespace CoreCms.Net.Services
{
    /// <summary>
    /// 计划订单表 接口实现
    /// </summary>
    public class CoreCmsPlanOrderServices : BaseServices<CoreCmsPlanOrder>, ICoreCmsPlanOrderServices
    {
        private readonly ICoreCmsPlanOrderRepository _dal;
        private readonly IUnitOfWork _unitOfWork;
        private readonly ICoreCmsPlanOrderItemRepository _itemDal;
        private readonly ICoreCmsUserServices _coreCmsUserServices;
        private readonly ICoreCmsUserServices _userServices;

        public CoreCmsPlanOrderServices(IUnitOfWork unitOfWork, ICoreCmsPlanOrderRepository dal
            , ICoreCmsPlanOrderItemRepository itemDal
            , ICoreCmsUserServices coreCmsUserServices
            , ICoreCmsUserServices userServices)
        {
            this._dal = dal;
            base.BaseDal = dal;
            _unitOfWork = unitOfWork;
            _itemDal = itemDal;
            _coreCmsUserServices = coreCmsUserServices;
            _userServices =userServices;
    }

        #region 实现重写增删改查操作==========================================================

        /// <summary>
        /// 重写异步插入方法
        /// </summary>
        /// <param name="entity">实体数据</param>
        /// <returns></returns>
        public async Task<AdminUiCallBack> InsertAsync(CoreCmsPlanOrder entity)
        {
            return await _dal.InsertAsync(entity);
        }

        /// <summary>
        /// 重写异步更新方法方法
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<AdminUiCallBack> UpdateAsync(CoreCmsPlanOrder entity)
        {
            return await _dal.UpdateAsync(entity);
        }

        /// <summary>
        /// 重写异步更新方法方法
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<AdminUiCallBack> UpdateAsync(List<CoreCmsPlanOrder> entity)
        {
            return await _dal.UpdateAsync(entity);
        }

        /// <summary>
        /// 重写删除指定ID的数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<AdminUiCallBack> DeleteByIdAsync(object id,string userName)
        {
            var jm = new AdminUiCallBack() ;
            try
            {
                //开始事务处理
                _unitOfWork.BeginTran();
                var order = await _dal.QueryByIdAsync(id);

                if (order.status == 2)  //&& string.IsNullOrEmpty(houtai)
                {
                    _unitOfWork.RollbackTran();
                    jm.code = 1;
                    jm.msg = "订单已经锁单不能重复锁单";
                    return jm;
                }

                order.upDataBy = userName;
                order.upDataTime = DateTime.Now;







                //order.keYongAmount = order.oldOrderAmount - order.orderAmount;
              

                 
                    order.status = 2;

                //if (order.keYongAmount > 0)
                //{
                //    //修改用户余额

                //    var jmsss = await _coreCmsUserServices.UpdateBalance(order.userId, order.keYongAmount, "用户计划订单" + order.orderId + "款项结余");
                //}



                //}


                //校验后再创建订单
                var jmss = await _dal.UpdateAsync(order);






                _unitOfWork.CommitTran();

                jm.code = 0;
                jm.data = order;
                jm.msg = "锁单成功";
            }
            catch (Exception e)
            {
                _unitOfWork.RollbackTran();
                jm.code = 1;
                jm.msg = e.ToString();
            }
            return jm;
            //return await _dal.DeleteByIdAsync(id);
        }

        /// <summary>
        /// 重写删除指定ID集合的数据(批量删除)
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public async Task<AdminUiCallBack> DeleteByIdsAsync(string[] ids, string userName)
        {
            var jm = new AdminUiCallBack();
            try
            {
                //开始事务处理
                _unitOfWork.BeginTran();
                var orders = await _dal.QueryListByClauseAsync(p => ids.Contains(p.orderId), p => p.orderId, OrderByType.Asc, true);

                foreach (var order in orders)
                {
                    if (order.status != 2)  //&& string.IsNullOrEmpty(houtai)
                    {
                        order.upDataBy = userName;
                        order.upDataTime = DateTime.Now;
                        order.status = 2;
                        //校验后再创建订单
                        var jmss = await _dal.UpdateAsync(order);
                    }

                    






                    //order.keYongAmount = order.oldOrderAmount - order.orderAmount;





                    //if (order.keYongAmount > 0)
                    //{
                    //    //修改用户余额

                    //    var jmsss = await _coreCmsUserServices.UpdateBalance(order.userId, order.keYongAmount, "用户计划订单" + order.orderId + "款项结余");
                    //}



                    //}


                    
                }



               






                _unitOfWork.CommitTran();

                jm.code = 0;
                jm.data = orders;
                jm.msg = "锁单成功";
            }
            catch (Exception e)
            {
                _unitOfWork.RollbackTran();
                jm.code = 1;
                jm.msg = e.ToString();
            }
            return jm;
            //return await _dal.DeleteByIdsAsync(ids);
        }

        #endregion

        #region 获取缓存的所有数据==========================================================

        /// <summary>
        /// 获取缓存的所有数据
        /// </summary>
        /// <returns></returns>
        public async Task<List<CoreCmsPlanOrder>> GetCaChe()
        {
            return await _dal.GetCaChe();
        }

        #endregion

       #region 重写根据条件查询分页数据
        /// <summary>
        ///     重写根据条件查询分页数据
        /// </summary>
        /// <param name="predicate">判断集合</param>
        /// <param name="orderByType">排序方式</param>
        /// <param name="pageIndex">当前页面索引</param>
        /// <param name="pageSize">分布大小</param>
        /// <param name="orderByExpression"></param>
        /// <param name="blUseNoLock">是否使用WITH(NOLOCK)</param>
        /// <returns></returns>
        public async Task<IPageList<CoreCmsPlanOrder>> QueryPageAsync(Expression<Func<CoreCmsPlanOrder, bool>> predicate,
            Expression<Func<CoreCmsPlanOrder, object>> orderByExpression, OrderByType orderByType, int pageIndex = 1,
            int pageSize = 20, bool blUseNoLock = false)
        {
            return await _dal.QueryPageAsync(predicate, orderByExpression, orderByType, pageIndex, pageSize, blUseNoLock);
        }
        #endregion

        #region 获取计划订单列表微信小程序
        /// <summary>
        /// 获取计划订单列表微信小程序
        /// </summary>
        /// <returns></returns>
        public async Task<WebApiCallBack> GetOrderList(int status = -1, int userId = 0, int page = 1, int limit = 5, int money = 0)
        {
            var jm = new WebApiCallBack { status = true };

            var where = PredicateBuilder.True<CoreCmsPlanOrder>();

            if (status > -1)
            {
                where = where.And(p => p.status == status);
            }
            if (userId > 0)
            {
                //var user = await _unitOfWork.GetDbClient().Queryable<CoreCmsUser>().Where(x => x.id == userId).FirstAsync();

                where = where.And(p => p.userId == userId);
            }
            if (money > 0)
            {
                where = where.And(p => p.keYongAmount > p.huaFeiAmount);
            }
            var list = await _dal.QueryPageAsync(where, p => p.createTime, OrderByType.Desc, page, limit);

            if (list!=null && list.Count>0)
            {
                foreach (var order in list)
                {
                    //获取相关状态描述说明转换
                    order.statusText = EnumHelper.GetEnumDescriptionByValue<GlobalEnumVars.PlanOrderTiJiao>(order.status);
                    order.keYongAmount = order.keYongAmount - order.huaFeiAmount;
                }
            }
            jm.data = new
            {
                list,
                count = list.TotalCount,
                page,
                limit,
                status
            };

            return jm;
        }


        #endregion



        /// <summary>
        ///     创建订单
        /// </summary>
        /// <param name="userId">用户序列</param>
        /// <param name="userName">用户昵称</param>
        /// <param name="status">计划订单状态</param>
        /// <param name="itemIds">明细id</param>
        /// <param name="itemNums">明细数量</param>
        /// <param name="houtai">是否后台编辑</param>
        /// <returns></returns>
        public async Task<WebApiCallBack> ToUpdate(string orderId, int userId, string userName, int status, string itemIds, string itemNums, string houtai = "")
        {
            var jm = new WebApiCallBack() { methodDescription = "修改计划订单" };
            try
            {
                //开始事务处理
                _unitOfWork.BeginTran();
                var order  = await _dal.QueryByIdAsync(orderId);

                var oldorderAmount = order.orderAmount;
                if (order.status == 2 && string.IsNullOrEmpty(houtai))   
                {
                    _unitOfWork.RollbackTran();
                    jm.status = false;
                    jm.otherData = "订单已经锁单不能修改";
                    return jm;
                }

                order.upDataBy = userName;
                order.upDataTime = DateTime.Now;

                List<CoreCmsPlanOrderItem> orderItems;
                var ids = CommonHelper.StringToIntArray(itemIds);
                var nums = CommonHelper.StringToStringArray(itemNums);
                orderItems = await _itemDal.QueryListByClauseAsync(x => x.orderId == orderId);
                decimal orderAmount = 0;
                for (int i=0;i< ids.Length; i++)
                {
                    var id = ids[i];
                    int num = 0;
                    int.TryParse(nums[i], out num);

                   var item = orderItems.Where(p => p.id == id).FirstOrDefault();
                    item.nums = num;
                    item.amount = item.price * (decimal)num;
                    var jms = await _itemDal.UpdateAsync(item);
                    orderAmount += item.amount;
                }

                order.orderAmount = orderAmount;
                order.keYongAmount = order.oldOrderAmount - order.orderAmount ;

                if (order.keYongAmount < order.huaFeiAmount)
                {
                    _unitOfWork.RollbackTran();
                    jm.status = false;
                    jm.otherData = "可用余额不足";
                    return jm;
                }

                //var keYongAmount = oldorderAmount - orderAmount;
                //if (order.status == 1)
                //{
                //    keYongAmount = order.oldOrderAmount - order.orderAmount;
                //}

                //if (status == 2)
                //{
                //    order.status = 2;

                //    if (keYongAmount != 0)
                //    {
                //        //修改用户余额

                //        var jmsss = await _coreCmsUserServices.UpdateBalance(order.userId, keYongAmount, "用户计划订单"+ order.orderId + "款项结余");
                //    }
                        
                    
                    
                //}


                //校验后再创建订单
                var jmss = await _dal.UpdateAsync(order);

              
 
 
                   

                _unitOfWork.CommitTran();

                jm.status = true;
                jm.data = order;
                jm.msg = "修改成功";
            }
            catch (Exception e)
            {
                _unitOfWork.RollbackTran();
                jm.status = false;
                jm.otherData = e.ToString();
            }
            return jm;
        }





        /// <summary>
        ///     创建订单
        /// </summary>
        /// <param name="jiHuaOrders">计划订单</param>
        /// <param name="userId">用户序列</param>
        /// <param name="userName">用户昵称</param>
        /// <returns></returns>
        public async Task<AdminUiCallBack> ToAddJiHua(List<JiHuaOrder> jiHuaOrders, int userId, string userName)
        {
            var jm = new AdminUiCallBack() ;
            try
            {
                //开始事务处理
                _unitOfWork.BeginTran();
                CoreCmsPlanOrder order = new CoreCmsPlanOrder();
                order.orderId = CommonHelper.GetSerialNumberType((int)GlobalEnumVars.SerialNumberType.计划订单编号);

                order.status = 1;
                order.shipMobile = jiHuaOrders[0].shipMobile;
                order.shipAddress = jiHuaOrders[0].shipAddress;
                order.shipName = jiHuaOrders[0].shipName;
                order.shouhuoAddress = jiHuaOrders[0].shouhuoAddress;
                if (string.IsNullOrEmpty(order.shipMobile))
                {
                    //找不到用户就注册用户
                    jm.code = 1;
                    jm.msg = order.shipMobile + "联系电话不能为空";
                    return jm;
                }
                var user = await _unitOfWork.GetDbClient().Queryable<CoreCmsUser>().Where(x => x.mobile == order.shipMobile && x.isDelete == false && x.status == 1).FirstAsync();
                if (user != null)
                {
                    order.userId = user.id;
                    user.isplanorder = "是";
                  var users = await _unitOfWork.GetDbClient().Updateable(user).ExecuteCommandAsync();
                }
                else
                {

                    var data = new FMWxAccountCreate
                    {
                        mobile = order.shipMobile,
                        invitecode = 0,
                        sessionAuthId = ""
                    };

                   var jms = await _userServices.SmsLogin(data);
                     user = await _unitOfWork.GetDbClient().Queryable<CoreCmsUser>().Where(x => x.mobile == order.shipMobile && x.isDelete == false && x.status == 1).FirstAsync();
                    if (user != null)
                    {
                        order.userId = user.id;
                        user.isplanorder = "是";
                        var users = await _unitOfWork.GetDbClient().Updateable(user).ExecuteCommandAsync();
                    }
                    else
                    {
                       
                            //找不到用户就注册用户
                            jm.code = 1;
                            jm.msg = order.shipMobile + "联系电话不正确";
                            return jm;
                        
                    }
                  
                }
               
                order.createBy = userName;
                order.createTime = DateTime.Now;
                order.upDataBy = userName;
                order.upDataTime = DateTime.Now;
                order.isdelete = false;


                var shi = await _unitOfWork.GetDbClient().Queryable<CoreCmsArea>().Where(x => x.name == jiHuaOrders[0].shi).FirstAsync();
                if(shi == null)
                {
                    jm.code = 1;
                    jm.msg = order.shipMobile + "没有找到市";
                    return jm;
                }

                var quxian = await _unitOfWork.GetDbClient().Queryable<CoreCmsArea>().Where(x => x.name == jiHuaOrders[0].quxian && x.parentId == shi.id).FirstAsync();
                if (shi == null)
                {
                    jm.code = 1;
                    jm.msg = order.shipMobile + "没有找到区县";
                    return jm;
                }
                order.shengId = 510000;
                order.shi = jiHuaOrders[0].shi;
                order.shiId = shi.id;
                order.quxianId = quxian.id;
                order.quxian = jiHuaOrders[0].quxian;
                order.pianqu = jiHuaOrders[0].pianqu;


                decimal orderAmount = 0;
                for (int i = 0; i < jiHuaOrders.Count; i++)
                {
                    var item = new CoreCmsPlanOrderItem();
                    item.orderId = order.orderId;
                    item.name = jiHuaOrders[i].name;
                    item.specification = jiHuaOrders[i].specification;
                    item.price = jiHuaOrders[i].price; 
                    item.nums = jiHuaOrders[i].nums; ;
                    item.amount = item.price * (decimal)jiHuaOrders[i].nums;
                    item.createBy = userName;
                    item.createTime = DateTime.Now;
                    item.upDataBy = userName;
                    item.upDataTime = DateTime.Now;
                    item.isdelete = false;
                    item.isOld = true;
                    var jms = await _itemDal.InsertAsync(item);
                    orderAmount += item.amount;


                    item.isOld = false;
                    jms = await _itemDal.InsertAsync(item);
                    if (jms.code == 1)
                    {
                         
                        return jms;
                    }
                }

                order.orderAmount = orderAmount;
                order.oldOrderAmount = orderAmount;
                order.keYongAmount = 0;
                order.huaFeiAmount = 0;

                //校验后再创建订单

                var sss =  await _unitOfWork.GetDbClient().Insertable<CoreCmsPlanOrder>(order).ExecuteCommandAsync();

                //var jmss = await _dal.InsertAsync(order);

                //if (jmss.code == 1)
                //{

                //    return jmss;
                //}









                _unitOfWork.CommitTran();

                jm.code = 0;
                jm.data = order;
                jm.msg = "导入成功";
            }
            catch (Exception e)
            {
                _unitOfWork.RollbackTran();
                jm.code = 1;
                jm.otherData = e.ToString();
            }
            return jm;
        }
    }
}