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 ARW.Model;
using ARW.Repository;
using ARW.Repository.Business.OrderManage.OrderRefunds;
using ARW.Service.Api.IBusinessService.OrderManage.OrderRefunds;
using ARW.Model.Dto.Api.OrderManage.OrderRefunds;
using ARW.Model.Models.Business.OrderManage.OrderRefunds;
using ARW.Model.Vo.Api.OrderManage.OrderRefunds;
using System.Reflection.Metadata;
using ARW.Model.Models.Business.ShopManager.Shops;
using ARW.Model.Vo.Api.OrderManage.Orders;
using ARW.Repository.Business.OrderManage.Orders;
using ARW.Repository.Business.OrderManage.OrderGoodss;
using ARW.Repository.Business.GoodsManager.Goodss;
using ARW.Repository.Business.GoodsManager.GoodsSpecs.GoodsSkus;
using ARW.Model.Models.Business.GoodsManager.GoodsSpecs.GoodsSkus;
using ARW.Model.Models.Business.GoodsManager.GoodsSpecs.SpecValues;
using ARW.Repository.Business.GoodsManager.GoodsSpecs.SpecValues;
using ARW.Service.Api.IBusinessService.OrderManage.Orders;
using OfficeOpenXml;
using Newtonsoft.Json;
using ARW.Repository.Business.OrderManage.OrderCustomerAddreses;
using ARW.Service.Business.IBusinessService.Custom.Regions;
using Senparc.Weixin.WxOpen.AdvancedAPIs.WxApp.WxAppJson;
using ARW.Repository.Business.ShopManager.ShopAddresss;
using ARW.Service.Api.IBusinessService.Custom.Regions;
using ARW.Model.Models.Business.OrderManage.Orders;
using ARW.Service.System.IService;
using Senparc.CO2NET.Extensions;
using ARW.Model.Models.Business.LogisticsManage.LogisticsCompanys;
using ARW.Repository.Business.LogisticsManage.LogisticsCompanys;

namespace ARW.Service.Api.BusinessService.OrderManage.OrderRefunds
{
    /// <summary>
    /// 售后单记录表接口实现类Api
    ///
    /// @author lwh
    /// @date 2023-10-16
    /// </summary>
    [AppService(ServiceType = typeof(IOrderRefundServiceApi), ServiceLifetime = LifeTime.Transient)]
    public class OrderRefundServiceImplApi : BaseService<OrderRefund>, IOrderRefundServiceApi
    {
        private readonly OrderRefundRepository _OrderRefundRepository;
        private readonly OrderRepository _OrderRepository;
        private readonly OrderGoodsRepository _OrderGoodsRepository;
        private readonly GoodsRepository _GoodsRepository;
        private readonly ShopAddressRepository _ShopAddressRepository;
        private readonly LogisticsCompanyRepository _LogisticsCompanyRepository;
        private readonly IOrderServiceApi _OrderServiceApi;
        private readonly IRegionService _RegionService;
        private readonly ISysDictDataService _SysDictDataService;
        private readonly GoodsSkuRepository _GoodsSkuRepository;


        public OrderRefundServiceImplApi(OrderRefundRepository OrderRefundRepository, OrderRepository orderRepository, OrderGoodsRepository orderGoodsRepository, GoodsRepository goodsRepository, IOrderServiceApi orderServiceApi, ShopAddressRepository shopAddressRepository, IRegionService regionService, ISysDictDataService sysDictDataService, LogisticsCompanyRepository logisticsCompanyRepository, GoodsSkuRepository goodsSkuRepository)
        {
            this._OrderRefundRepository = OrderRefundRepository;
            _OrderRepository = orderRepository;
            _OrderGoodsRepository = orderGoodsRepository;
            _GoodsRepository = goodsRepository;
            _OrderServiceApi = orderServiceApi;
            _ShopAddressRepository = shopAddressRepository;
            _RegionService = regionService;
            _SysDictDataService = sysDictDataService;
            _LogisticsCompanyRepository = logisticsCompanyRepository;
            _GoodsSkuRepository = goodsSkuRepository;
        }

        #region Api接口代码


        /// <summary>
        /// 查询售后单记录表列表(Api)
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<PagedInfo<OrderRefundVoApi>> GetOrderRefundListApi(OrderRefundQueryDtoApi parm)
        {
            //开始拼装查询条件d
            var predicate = Expressionable.Create<OrderRefund>();

            predicate = predicate.AndIF(parm.CustomerGuid != 0, s => s.CustomerGuid == parm.CustomerGuid);
            predicate = predicate.AndIF(parm.RefundType != null, s => s.RefundType == parm.RefundType);
            predicate = predicate.AndIF(parm.RefundReason != null, s => s.RefundReason == parm.RefundReason);
            predicate = predicate.AndIF(parm.GoodsReceiveStatus != null, s => s.GoodsReceiveStatus == parm.GoodsReceiveStatus);
            predicate = predicate.AndIF(parm.MerchantAuditStatus != null, s => s.MerchantAuditStatus == parm.MerchantAuditStatus);
            predicate = predicate.AndIF(parm.IsCustomerSend != null, s => s.IsCustomerSend == parm.IsCustomerSend);
            predicate = predicate.AndIF(parm.OrderRefundStatus != null, s => s.OrderRefundStatus == parm.OrderRefundStatus);
            var query = _OrderRefundRepository
                .Queryable()
                .Where(predicate.ToExpression())
                .LeftJoin<Shop>((s, c) => s.ShopGuid == c.ShopGuid)
                .OrderBy(s => s.Create_time, OrderByType.Desc)
                .Select((s, c) => new OrderRefundVoApi
                {
                    OrderRefundId = s.OrderRefundId,
                    OrderRefundGuid = s.OrderRefundGuid,
                    ShopGuid = s.ShopGuid,
                    StoreName = c.ShopName,
                    OrderGuid = s.OrderGuid,
                    RefundType = s.RefundType,
                    MerchantAuditStatus = s.MerchantAuditStatus,
                    RefundMoney = s.RefundMoney,
                    IsCustomerSend = s.IsCustomerSend,
                    OrderRefundStatus = s.OrderRefundStatus,
                });


            var list = await query.ToPageAsync(parm);

            foreach (var item in list.Result)
            {
                item.OrderRefundGoodList = await GetOrderGoodsList(item.OrderGuid);


                /* 处理售后订单状态描述 */
                // 待审核
                if (item.MerchantAuditStatus == 1 && item.OrderRefundStatus == 1)
                {
                    item.Status = 1;
                    item.EserRightsStatusDesc = "商家将尽快确认您的退款申请";
                    var buttonVoList = new List<ButtonVO>();
                    var buttonVo = new ButtonVO()
                    {
                        Name = "撤销申请",
                        Type = 2
                    };
                    buttonVoList.Add(buttonVo);
                    item.ButtonVOs = buttonVoList;
                }
                // 已审核
                if (item.MerchantAuditStatus == 2 && item.OrderRefundStatus == 1 && item.RefundType == 1 && item.IsCustomerSend == 1)
                {
                    item.Status = 2;
                    item.EserRightsStatusDesc = "商家已审核确认，预计1小时内发起退款";
                    if(item.RefundType != 2)
                    {
                        var buttonVoList = new List<ButtonVO>();
                        var buttonVo = new ButtonVO()
                        {
                            Name = "填写运单号",
                            Type = 3
                        };
                        buttonVoList.Add(buttonVo);
                        item.ButtonVOs = buttonVoList;
                    }
                }
                // 已发货
                if (item.IsCustomerSend == 2 && item.OrderRefundStatus == 1)
                {
                    item.Status = 3;
                    item.EserRightsStatusDesc = "买家已发货，等待商家收货";
                    //var buttonVoList = new List<ButtonVO>();
                    //var buttonVo = new ButtonVO()
                    //{
                    //    Name = "查看物流",
                    //    Type = 5
                    //};
                    //buttonVoList.Add(buttonVo);
                    //item.ButtonVOs = buttonVoList;
                }
                if (item.OrderRefundStatus == 3)
                {
                    item.Status = 4;
                    item.EserRightsStatusDesc = "退款/售后己完成，商家已退款，退回资金将原路三个工作日内返回您的账户";
                }
                if (item.OrderRefundStatus == 4)
                {
                    item.Status = 5;
                    item.EserRightsStatusDesc = "退款/售后己取消";
                }

            }

            return list;
        }



        /// <summary>
        ///  添加售后单记录表
        /// </summary>
        public async Task<long> AddOrderRefund(OrderRefund model)
        {
            model.GoodsReceiveStatus = 1;
            model.MerchantAuditStatus = 1;
            model.IsCustomerSend = 1;
            model.OrderRefundStatus = 1;
            model.IsMerchantReceive = 1;

            var response = await _OrderRefundRepository.InsertReturnSnowflakeIdAsync(model);
            return response;
        }


        /// <summary>
        ///  撤销申请
        /// </summary>
        public async Task<string> RepealOrderRefund(AddOrderRefundApiDto parm)
        {
            var response = await _OrderRefundRepository.UpdateAsync(f => new OrderRefund
            {
                OrderRefundStatus = 4
            }, s => s.OrderRefundGuid == parm.OrderRefundGuid);
            return "撤销成功！";
        }


        /// <summary>
        ///  买家发货(填写运单号)
        /// </summary>
        public async Task<string> BuyerDelivery(BuyerDeliveryApiDto parm)
        {
            var response = await _OrderRefundRepository.UpdateAsync(f => new OrderRefund
            {
                LogisticsCompanyGuid = parm.LogisticsCompanyGuid,
                ExpressNo = parm.ExpressNo,
                CustomerWaybillRemark = parm.CustomerWaybillRemark,
                IsCustomerSend = 2,
                CustomerSendTime = DateTime.Now,
            }, s => s.OrderRefundGuid == parm.OrderRefundGuid);
            return "发货成功！";
        }



        /// <summary>
        /// 查询售后单记录表详情(Api)
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public async Task<string> GetOrderRefundDetails(OrderRefundDtoApi parm)
        {

            var query = _OrderRefundRepository
                .Queryable()
                .Where(s => s.OrderRefundGuid == parm.OrderRefundGuid)
                .LeftJoin<Shop>((s, c) => s.ShopGuid == c.ShopGuid)
                .LeftJoin<Order>((s, c, d) => s.OrderGuid == d.OrderGuid)
                .Select((s, c, d) => new OrderRefundApiDetailsVo
                {
                    OrderRefundId = s.OrderRefundId,
                    OrderRefundGuid = s.OrderRefundGuid,
                    OrderNo = d.OrderNumber,
                    StoreName = c.ShopName,
                    OrderGuid = s.OrderGuid,
                    RefundType = s.RefundType,
                    MerchantAuditStatus = s.MerchantAuditStatus,
                    RefundMoney = s.RefundMoney,
                    IsCustomerSend = s.IsCustomerSend,
                    OrderRefundStatus = s.OrderRefundStatus,
                    ShopAddressGuid = s.ShopRefundAddressGuid,
                    RefundReason = s.RefundReason,
                    CustomerRefundDesc = s.CustomerRefundDesc,
                    CustomerRefundImg = s.CustomerRefundImg,
                    LogisticsCompanyGuid = s.LogisticsCompanyGuid,
                    ExpressNo = s.ExpressNo,
                    CreateTime = s.Create_time
                }).Take(1);


            var json = await query.ToJsonAsync();


            if (json != "[]")
            {
                json = json.Remove(0, 1);
                json = json.Substring(0, json.Length - 1);
                var data = JsonConvert.DeserializeObject<OrderRefundApiDetailsVo>(json);

                // 获取订单商品列表
                data.OrderRefundGoodList = await GetOrderGoodsList(data.OrderGuid);

                // 处理退款原因
                var dictList = _SysDictDataService.SelectDictDataByType("refund_reason");
                foreach (var item in dictList)
                {
                    if (Convert.ToInt32(item.DictValue) == data.RefundReason)
                    {
                        data.Reason = item.DictLabel;
                    }
                }


                // 处理快递状态
                if (data.LogisticsCompanyGuid != null)
                {
                    data.TrajectoryVos = new TrajectoryVo();
                    var company = await _LogisticsCompanyRepository.GetFirstAsync(s => s.LogisticsCompanyGuid == data.LogisticsCompanyGuid);
                    data.TrajectoryVos.LogisticsCompanyCode = data.ExpressNo;
                    data.TrajectoryVos.LogisticsCompanyName = company.LogisticsCompanyName;
                }


                /* 处理售后订单状态描述 */
                // 待审核
                if (data.MerchantAuditStatus == 1 && data.OrderRefundStatus == 1)
                {
                    data.Status = 1;
                    data.StatusName = "待审核";
                    data.EserRightsStatusDesc = "商家将尽快确认您的退款申请";
                }
                // 已审核
                if (data.MerchantAuditStatus == 2 && data.OrderRefundStatus == 1)
                {
                    data.Status = 2;
                    data.StatusName = "已审核";
                    data.EserRightsStatusDesc = "商家已审核确认，预计1小时内发起退款";
                }
                // 已发货
                if (data.IsCustomerSend == 2 && data.OrderRefundStatus == 1)
                {
                    data.Status = 3;
                    data.StatusName = "已发货";
                    data.EserRightsStatusDesc = "买家已发货，等待商家收货";
                }
                // 已完成
                if (data.OrderRefundStatus == 3)
                {
                    data.Status = 4;
                    data.StatusName = "已完成";
                    data.EserRightsStatusDesc = "退款/售后己完成，商家已退款，退回资金将原路三个工作日内返回您的账户";
                }
                if (data.OrderRefundStatus == 4)
                {
                    data.Status = 5;
                    data.StatusName = "已取消";
                    data.EserRightsStatusDesc = "退款/售后己取消";
                }

                // 商家地址
                var shopAddress = await _ShopAddressRepository.GetFirstAsync(s => s.ShopAddressGuid == data.ShopAddressGuid);
                if (shopAddress != null)
                {
                    var logistics = new Logistics
                    {
                        ReceiverAddressId = shopAddress.ShopAddressGuid,
                        ReceiverName = shopAddress.ShopAddressContactName,
                        ReceiverPhone = shopAddress.ShopAddressContactNumber,
                        ReceiverProvince = await _RegionService.GetRegionName(shopAddress.ProvinceId),
                        ReceiverCity = await _RegionService.GetRegionName(shopAddress.CityId),
                        receiverCountry = await _RegionService.GetRegionName(shopAddress.DistrictId),
                        ReceiverAddress = shopAddress.ShopAddressDetailedAddress
                    };
                    data.LogisticsVO = logistics;
                }

                json = data.ToJson();
            }



            return json;
        }



        #region 业务方法调用


        /// <summary>
        /// 获取售后订单商品列表
        /// </summary>
        /// <param name="orderGuid"></param>
        /// <returns></returns>
        public async Task<List<OrderGoodsApiVo>> GetOrderGoodsList(long orderGuid)
        {
            var orderRefundGoodList = new List<OrderGoodsApiVo>();
            var orderGoodsList = await _OrderGoodsRepository.GetListAsync(s => s.OrderGuid == orderGuid);
            foreach (var _item in orderGoodsList)
            {
                var good = await _GoodsRepository.GetFirstAsync(s => s.GoodsGuid == _item.GoodsGuid);
                var orderGood = new OrderGoodsApiVo
                {
                    GoodsGuId = good.GoodsGuid,
                    Thumb = good.GoodsPicture.Split(',').First(),
                    Title = good.GoodsName,
                    SkuId = _item.GoodsSkuId,
                    Price = _item.GoodsPrice,
                    BuyQuantity = _item.GoodsTotalNum
                };
                if (_item.GoodsSkuId != 0)
                {
                    var sku = await _GoodsSkuRepository.GetFirstAsync(s => s.GoodsSkuId == _item.GoodsSkuId);
                    if (!string.IsNullOrEmpty(sku.GoodsSkuImg))
                    {
                        orderGood.Thumb = sku.GoodsSkuImg;
                    }
                    orderGood.Specifications = await _OrderServiceApi.GetGoodsSpecList(_item.GoodsSkuId);
                }

                orderRefundGoodList.Add(orderGood);
            }
            return orderRefundGoodList;
        }


        /// <summary>
        /// 处理物流状态
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        //public OrderRefundApiDetailsVo GetTrajectory(Order order, OrderRefundApiDetailsVo data)
        //{
        //    data.TrajectoryVos = new TrajectoryVo();
        //    var trajectoryList = new List<Trajectory>();

        //    // 已下单(待发货)
        //    if (order.OrderStatus == 1)
        //    {
        //        var trajectoryNodeList1 = new List<TrajectoryNode> { GetTrajectoryNode("订单已提交", order.Create_time) };
        //        var trajectory1 = GetTrajectory("", "", trajectoryNodeList1, 3);
        //        trajectoryList.Add(trajectory1);

        //        var trajectoryNodeList2 = new List<TrajectoryNode> { GetTrajectoryNode("订单已经支付成功，支付方式为：微信支付", order.PayTime) };
        //        var trajectory2 = GetTrajectory("已下单", "https://cdn-we-retail.ym.tencent.com/web/trajectoryIcons/ordered.svg", trajectoryNodeList2, 2);
        //        trajectoryList.Add(trajectory2);

        //        // 运输中(已发货，待收货)
        //        if (order.DeliveryStatus == 2 && order.ReceiptStatus == 1 && order.PayStatus == 2 && order.OrderStatus == 1)
        //        {
        //            data.TrajectoryVos.LogisticsCompanyCode = order.LogisticsTrackingNumber;
        //            data.TrajectoryVos.LogisticsCompanyName = order.LogisticsCompany;

        //            var trajectoryNodeList3 = new List<TrajectoryNode> { GetTrajectoryNode($"商家已发货，物流承运商：{order.LogisticsCompany}", order.DeliveryTime) };

        //            // 对接快递100接口
        //            //var company = _LogisticsCompanyRepository.GetFirst(s => s.LogisticsCompanyGuid == order.LogisticsCompanyGuid);
        //            //var trackRes = Kuaidi100.GetQueryTrack(company.LogisticsCompanyCode, order.LogisticsTrackingNumber);

        //            var trajectory3 = GetTrajectory("已发货", "deliver", trajectoryNodeList3, 1);
        //            trajectoryList.Add(trajectory3);
        //        }
        //    }

        //    //foreach (var item in trajectoryList)
        //    //{
        //    //    item.Nodes = item.Nodes.OrderBy(s => s.Sort).ToList();
        //    //}
        //    trajectoryList = trajectoryList.OrderBy(s => s.Sort).ToList();
        //    data.TrajectoryVos.Trajectorys = trajectoryList;
        //    return data;
        //}


        //public Trajectory GetTrajectory(string title, string icon, List<TrajectoryNode> trajectoryNodeList, int sort)
        //{
        //    var trajectory = new Trajectory();
        //    trajectory.Title = title;
        //    trajectory.Icon = icon;
        //    trajectory.Nodes = trajectoryNodeList;
        //    trajectory.Sort = sort;

        //    return trajectory;
        //}


        //public TrajectoryNode GetTrajectoryNode(string status, DateTime? time)
        //{
        //    var trajectoryNode = new TrajectoryNode();
        //    trajectoryNode.Status = status;
        //    trajectoryNode.Timestamp = time;
        //    return trajectoryNode;
        //}


        #endregion


        #endregion

    }
}