using Infrastructure.Attribute;
using Microsoft.AspNetCore.Http;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Infrastructure;
using ARW.Model;
using ARW.Repository;
using ARW.Repository.Business.OrderManage.Orders;
using ARW.Service.Business.IBusinessService.OrderManage.Orders;
using ARW.Model.Dto.Business.OrderManage.Orders;
using ARW.Model.Models.Business.OrderManage.Orders;
using ARW.Model.Vo.Business.OrderManage.Orders;
using ARW.Repository.Business.GoodsManager.Goodss;
using ARW.Repository.Business.GoodsManager.GoodsSpecs.GoodsSkus;
using ARW.Service.Business.IBusinessService.GoodsManager.GoodsSpecs.GoodsSkus;
using ARW.Model.Models.Business.Custom.Customers;
using ARW.Repository.Business.OrderManage.OrderGoodss;
using ARW.Model.Models.Business.GoodsManager.Goodss;
using ARW.Model.Dto.Api.OrderManage.Orders;
using ARW.Model.Vo.Api.OrderManage.Orders;
using Aliyun.OSS;
using Senparc.Weixin.WxOpen.AdvancedAPIs.WxApp.WxAppJson;
using ARW.Common;
using Org.BouncyCastle.Crypto.Prng;
using Senparc.CO2NET.Extensions;
using ARW.Repository.Business.OrderManage.OrderCustomerAddreses;
using ARW.Service.Business.IBusinessService.Custom.Regions;

namespace ARW.Service.Business.BusinessService.OrderManage.Orders
{
    /// <summary>
    /// 订单接口实现类
    ///
    /// @author lwh
    /// @date 2023-08-29
    /// </summary>
    [AppService(ServiceType = typeof(IOrderService), ServiceLifetime = LifeTime.Transient)]
    public class OrderServiceImpl : BaseService<Order>, IOrderService
    {
        private readonly OrderRepository _OrderRepository;
        private readonly OrderGoodsRepository _OrderGoodsRepository;
        private readonly OrderCustomerAddressRepository _OrderCustomerAddressRepository;
        private readonly GoodsRepository _GoodsRepository;
        private readonly IGoodsSkuService _GoodsSkuService;
        private readonly IRegionService _RegionService;

        public OrderServiceImpl(OrderRepository OrderRepository, GoodsRepository goodsRepository, IGoodsSkuService goodsSkuService, OrderGoodsRepository orderGoodsRepository, OrderCustomerAddressRepository orderCustomerAddressRepository, IRegionService regionService)
        {
            this._OrderRepository = OrderRepository;
            _GoodsRepository = goodsRepository;
            _GoodsSkuService = goodsSkuService;
            _OrderGoodsRepository = orderGoodsRepository;
            _OrderCustomerAddressRepository = orderCustomerAddressRepository;
            _RegionService = regionService;
        }

        #region 业务逻辑代码


        /// <summary>
        /// 查询订单分页列表
        /// </summary>
        public async Task<PagedInfo<OrderVo>> GetOrderList(OrderQueryDto parm)
        {
            //开始拼装查询条件d
            var predicate = Expressionable.Create<Order>();

            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.OrderNumber), s => s.OrderNumber.Contains(parm.OrderNumber));
            predicate = predicate.AndIF(parm.PayType != null, s => s.PayType == parm.PayType);
            predicate = predicate.AndIF(parm.PayStatus != null, s => s.PayStatus == parm.PayStatus);
            predicate = predicate.AndIF(parm.DeliveryType != null, s => s.DeliveryType == parm.DeliveryType);
            predicate = predicate.AndIF(!string.IsNullOrEmpty(parm.LogisticsTrackingNumber), s => s.LogisticsTrackingNumber.Contains(parm.LogisticsTrackingNumber));
            predicate = predicate.AndIF(parm.DeliveryStatus != null, s => s.DeliveryStatus == parm.DeliveryStatus);
            predicate = predicate.AndIF(parm.ReceiptStatus != null, s => s.ReceiptStatus == parm.ReceiptStatus);
            predicate = predicate.AndIF(parm.OrderStatus != null, s => s.OrderStatus == parm.OrderStatus);
            predicate = predicate.AndIF(parm.BeginTime != DateTime.MinValue, s => s.Create_time >= parm.BeginTime);
            predicate = predicate.AndIF(parm.EndTime != DateTime.MinValue, s => s.Create_time <= parm.EndTime);
            var query = _OrderRepository
                .Queryable()
                .LeftJoin<Customer>((s, c) => s.CustomerGuid == c.CustomerGuid)
                .Where(predicate.ToExpression())
                .WhereIF(!string.IsNullOrEmpty(parm.CustomerNickNme), (s, c) => c.CustomerNickname.Contains(parm.CustomerNickNme) )
                .WhereIF(!string.IsNullOrEmpty(parm.CustomerPhome), (s, c) => c.CustomerMobilePhoneNumber.Contains(parm.CustomerPhome))
                .OrderBy(s => s.Create_time, OrderByType.Desc)
                .Select((s, c) => new OrderVo
                {
                    OrderId = s.OrderId,
                    OrderGuid = s.OrderGuid,
                    CustomerGuid = s.CustomerGuid,
                    CustomerNickName = c.CustomerNickname,
                    CustomerMobilePhoneNumber = c.CustomerMobilePhoneNumber,
                    CustomerAvatar = c.CustomerAvatar,
                    OrderNumber = s.OrderNumber,
                    OrderAmount = s.OrderAmount,
                    PayPrice = s.PayPrice,
                    PayType = s.PayType,
                    PayStatus = s.PayStatus,
                    DeliveryType = s.DeliveryType,
                    ExpressPrice = s.ExpressPrice,
                    DeliveryStatus = s.DeliveryStatus,
                    ReceiptStatus = s.ReceiptStatus,
                    OrderStatus = s.OrderStatus,
                    CreateTime = s.Create_time
                });

            var list = await query.ToPageAsync(parm);

            foreach (var item in list.Result)
            {
                // 获取订单商品信息
                item.GoodsInfoList = await GetOrderGoodsList(item.OrderGuid);

            }

            return list;
        }


        /// <summary>
        /// 查询订单详情
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<string> GetOrderDetails(OrderDetailDto parm)
        {

            var query = _OrderRepository
                .Queryable()
                .LeftJoin<Customer>((s, c) => s.CustomerGuid == c.CustomerGuid)
                .Where(s => s.OrderId == parm.OrderId)
                .Select((s, c) => new OrderDetailsVo
                {
                    OrderId = s.OrderId,
                    OrderGuid = s.OrderGuid,
                    CustomerPhone = c.CustomerMobilePhoneNumber,
                    OrderNumber = s.OrderNumber,
                    GoodsTotalAmoun = s.GoodsTotalAmoun,
                    OrderAmount = s.OrderAmount,
                    CouponGuid = s.CouponGuid,
                    CouponMoney = s.CouponMoney,
                    PointsMoney = s.PointsMoney,
                    PointsNum = s.PointsNum,
                    PayPrice = s.PayPrice,
                    UpdatePrice = s.UpdatePrice,
                    OrderRemark = s.OrderRemark,
                    PayType = s.PayType,
                    PayStatus = s.PayStatus,
                    PayTime = s.PayTime,
                    DeliveryType = s.DeliveryType,
                    ExpressPrice = s.ExpressPrice,
                    LogisticsCompanyGuid = s.LogisticsCompanyGuid,
                    LogisticsCompany = s.LogisticsCompany,
                    LogisticsTrackingNumber = s.LogisticsTrackingNumber,
                    DeliveryStatus = s.DeliveryStatus,
                    DeliveryTime = s.DeliveryTime,
                    ReceiptStatus = s.ReceiptStatus,
                    ReceiptTime = s.ReceiptTime,
                    OrderStatus = s.OrderStatus,
                    PointsBonus = s.PointsBonus,
                    IsSettled = s.IsSettled,
                    TransactionId = s.TransactionId,
                    IsComment = s.IsComment,
                    OrderSource = s.OrderSource,
                    CreateTime = s.Create_time
                }).Take(1);

            var json = await query.ToJsonAsync();
            if (json != "[]")
            {
                var data = Tools.JsonToVo<OrderDetailsVo>(json);
                data.GoodsInfoList = await GetOrderGoodsList(data.OrderGuid);
                data.OrderReceive = await GetOrderReceive(data.OrderGuid);

                json = data.ToJson();
            }

            return json;
        }



        /// <summary>
        /// 发货
        /// </summary>
        /// <returns></returns>
        public async Task<string> Deliver(OrderDeliverDto parm)
        {
            var isUpdate = await _OrderRepository.UpdateAsync(s => new Order
            {
                LogisticsCompanyGuid = parm.LogisticsCompanyGuid,
                LogisticsCompany = parm.LogisticsCompany,
                LogisticsTrackingNumber = parm.LogisticsTrackingNumber,
                DeliveryStatus = 2,
                DeliveryTime = DateTime.Now,
                Update_time = DateTime.Now
            }, f => f.OrderGuid == parm.OrderGuid);

            if (isUpdate)
                return "发货成功";
            else
                throw new CustomException("发货失败");

        }


        /// <summary>
        /// 订单改价
        /// </summary>
        /// <returns></returns>
        public async Task<string> ChangePrice(OrderChangePriceDto parm)
        {
            var isUpdate = await _OrderRepository.UpdateAsync(s => new Order
            {
                UpdatePrice = parm.ExpressPrice + parm.OrderAmount,
                Update_time = DateTime.Now
            }, f => f.OrderGuid == parm.OrderGuid);

            if (isUpdate)
                return "改价成功";
            else
                throw new CustomException("改价失败");

        }


        /// <summary>
        /// 审核取消订单
        /// </summary>
        /// <returns></returns>
        public async Task<string> CancelOrder(OrderCancelOrderDto parm)
        {
            if (parm.IsAgree)
            {
                var isUpdate = await _OrderRepository.UpdateAsync(s => new Order
                {
                    OrderStatus = 2,
                    Update_time = DateTime.Now
                }, f => f.OrderGuid == parm.OrderGuid);

                if (isUpdate)
                    return "通过申请成功";
                else
                    throw new CustomException("通过申请失败");
            }
            else
            {
                var isUpdate = await _OrderRepository.UpdateAsync(s => new Order
                {
                    OrderStatus = 1,
                    Update_time = DateTime.Now
                }, f => f.OrderGuid == parm.OrderGuid);

                if (isUpdate)
                    return "拒绝申请成功";
                else
                    throw new CustomException("拒绝申请失败");
            }

        }


        /// <summary>
        ///  添加或修改订单
        /// </summary>
        public async Task<string> AddOrUpdateOrder(Order model)
        {
            if (model.OrderId != 0)
            {
                var response = await _OrderRepository.UpdateAsync(model);
                return "修改成功！";
            }
            else
            {

                var response = await _OrderRepository.InsertReturnSnowflakeIdAsync(model);
                return "添加成功！";
            }
        }

        #region Excel处理


        /// <summary>
        /// Excel数据导出处理
        /// </summary>
        public async Task<List<OrderVo>> HandleExportData(List<OrderVo> data)
        {
            return data;
        }

        #endregion


        #region 封装方法

        /// <summary>
        /// 获取商品订单列表
        /// </summary>
        /// <param name="orderGuid">订单guid</param>
        /// <returns></returns>
        /// <exception cref="CustomException"></exception>
        public async Task<List<OrderGoodsVo>> GetOrderGoodsList(long orderGuid)
        {
            var goodsInfoList = new List<OrderGoodsVo>();

            var orderGoodsList = await _OrderGoodsRepository.GetListAsync(s => s.OrderGuid == orderGuid);
            if (orderGoodsList.Count <= 0) throw new CustomException("订单商品不存在");
            foreach (var orderGoods in orderGoodsList)
            {
                var goods = await _GoodsRepository.GetFirstAsync(s => s.GoodsGuid == orderGoods.GoodsGuid) ?? throw new CustomException("商品不存在");
                var orderGoodsInfo = new OrderGoodsVo();
                orderGoodsInfo.GoodsName = goods.GoodsName;
                orderGoodsInfo.GoodsPicture = goods.GoodsPicture;
                orderGoodsInfo.GoodsTotalNum = orderGoods.GoodsTotalNum;
                orderGoodsInfo.GoodsTotalNum = orderGoods.GoodsTotalNum;
                if (orderGoods.GoodsSkuId != null)
                {
                    var specName = await _GoodsSkuService.GetSpecValueFullName(orderGoods.GoodsSkuId);
                    var sku = await _GoodsSkuService.GetByIdAsync(orderGoods.GoodsSkuId);
                    orderGoodsInfo.GoodsSpecName = specName;
                    orderGoodsInfo.GoodsPrice = sku.GoodsSkuPrice;
                    orderGoodsInfo.GoodsCoding = goods.GoodsCoding;
                }
                else
                {
                    orderGoodsInfo.GoodsPrice = goods.GoodsPriceHighest;
                    orderGoodsInfo.GoodsWeight = goods.GoodsWeight;
                }
                orderGoodsInfo.GoodsTotalPrice = orderGoodsInfo.GoodsPrice * orderGoodsInfo.GoodsTotalNum;

                goodsInfoList.Add(orderGoodsInfo);
            }

            return goodsInfoList;
        }


        /// <summary>
        /// 获取收货信息
        /// </summary>
        /// <param name="orderGuid"></param>
        /// <returns></returns>
        public async Task<OrderReceiveVo> GetOrderReceive(long orderGuid)
        {
            var orderReceive = new OrderReceiveVo();
            var receive = await _OrderCustomerAddressRepository.GetFirstAsync(s => s.OrderGuid == orderGuid);
            if (receive != null)
            {
                orderReceive.ConsigneeName = receive.ConsigneeName;
                orderReceive.Phone = receive.Phont;
                orderReceive.Detail = receive.Detail;

                // 获取地区名称
                orderReceive.Region = await _RegionService.GetRegionFullName(receive.ProvinceId, receive.CityId, receive.RegionId);
            }

            return orderReceive;
        }

        #endregion

        #endregion

    }
}