using DynamicQuery.Net.Dto.Input;
using LifePayment.Application.Contracts;
using LifePayment.Domain;
using LifePayment.Domain.Models;
using LifePayment.Domain.Shared;
using MailKit.Search;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Nest;
using Newtonsoft.Json;
using NPOI.OpenXmlFormats.Dml.Chart;
using NPOI.SS.Formula.Functions;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.EventBus.Distributed;
using ZeroD.Util;
using ZeroD.Util.Fadd;
using static LifePayment.Domain.Shared.LifePaymentConstant;
using static IdentityServer4.Models.IdentityResources;

namespace LifePayment.Application;

public class LifePayService : ApplicationService, ILifePayService
{
    private readonly IDistributedEventBus _distributedEventBus;
    private readonly ILogger<LifePayService> _logger;

    private readonly IRepository<LifePayRate, Guid> _lifePayRateRepository;
    private readonly IRepository<LifePayOrder, Guid> _lifePayOrderRepository;
    private readonly IRepository<LifePayUser, Guid> _lifePayUserRepository;

    private readonly IAliPayApi _aliPayApi;
    private readonly IWxPayApi _wxPayApi;
    private readonly WxPayOption _wxPayOptions;

    private readonly IACOOLYManager _aCOOLYManager;

    public LifePayService(IDistributedEventBus distributedEventBus,
                          ILogger<LifePayService> logger,
                          IACOOLYManager aCOOLYManager,
                          IRepository<LifePayRate, Guid> lifePayRateRepository,
                          IRepository<LifePayOrder, Guid> lifePayOrderRepository,
                          IRepository<LifePayUser, Guid> lifePayUserRepository,
                          IAliPayApi aliPayApi,
                          IWxPayApi wxPayApi,
                          IOptions<WxPayOption> wxPayOptions)
    {
        _logger = logger;
        _aCOOLYManager = aCOOLYManager;
        _lifePayRateRepository = lifePayRateRepository;
        _lifePayOrderRepository = lifePayOrderRepository;
        _lifePayUserRepository = lifePayUserRepository;
        _aliPayApi = aliPayApi;
        _wxPayApi = wxPayApi;
        _wxPayOptions = wxPayOptions.Value;
        _distributedEventBus = distributedEventBus;
    }

    #region 查询

    /// <summary>
    /// 获取电费面值
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<ElectricParValueResponse> GetElectricParValue()
    {
        return await _aCOOLYManager.ElectricParValue(new ACOOLYRequestBaseInput());
    }

    /// <summary>
    /// 获取电费充值区域
    /// </summary>
    /// <returns></returns>
    public async Task<ElectricSupportAreaResponse> GetElectricSupportArea()
    {
        return await _aCOOLYManager.GetElectricSupportArea(new ACOOLYRequestBaseInput());
    }

    /// <summary>
    /// 获取话费面值
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<PhoneParValueResponse> GetPhoneParValue()
    {
        return await _aCOOLYManager.PhoneParValue(new ACOOLYRequestBaseInput());
    }

    /// <summary>
    /// 获取折扣
    /// </summary>
    /// <returns></returns>
    public async Task<List<LifePayRateListOutput>> GetRate()
    {
        return await _lifePayRateRepository.Select(x => new LifePayRateListOutput() { Rate = x.Rate, RateType = x.RateType })
                                           .ToListAsync();
    }

    /// <summary>
    /// 获取用户分页数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<PageOutput<UserListOutput>> GetUserPage(PageInput input)
    {
        return await _lifePayUserRepository.Select(x =>
                                                   new UserListOutput()
                                                   {
                                                       Id = x.Id,
                                                       PhoneNumber = x.PhoneNumber,
                                                       CreationTime = x.CreationTime,
                                                       LastLoginTime = x.LastLoginTime
                                                   })
                                           .GetPageResult(input.PageModel);
    }

    /// <summary>
    /// 获取订单分页数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<PageOutput<LifePayOrderListOutput>> GetLifePayOrderPage(QueryLifePayOrderListInput input)
    {
        return await _lifePayOrderRepository.Where(x => x.PayStatus != LifePayStatusEnum.未支付)
                                            .WhereIf(input.BeginFinishTime.HasValue, x => x.FinishTime >= input.BeginFinishTime)
                                            .WhereIf(input.EndFinishTime.HasValue, x => x.FinishTime <= input.EndFinishTime)
                                            .WhereIf(input.BeginPayTime.HasValue, x => x.PayTime >= input.BeginPayTime)
                                            .WhereIf(input.EndPayTime.HasValue, x => x.PayTime <= input.EndPayTime)
                                            .WhereIf(input.LifePayOrderStatus.HasValue, x => x.LifePayOrderStatus == input.LifePayOrderStatus.Value)
                                            .WhereIf(input.PayStatus.HasValue, x => x.PayStatus == input.PayStatus.Value)
                                            .WhereIf(input.LifePayOrderType.HasValue, x => x.LifePayOrderType == input.LifePayOrderType.Value)
                                            .WhereIf(input.UserId.HasValue, x => x.UserId == input.UserId.Value)
                                            .Select(x =>
                                                    new LifePayOrderListOutput
                                                    {
                                                        DiscountAmount = x.DiscountAmount,
                                                        FinishTime = x.FinishTime,
                                                        Id = x.Id,
                                                        LifePayOrderStatus = x.LifePayOrderStatus,
                                                        LifePayOrderType = x.LifePayOrderType,
                                                        LifePayType = x.LifePayType,
                                                        OrderNo = x.OrderNo,
                                                        PayAmount = x.PayAmount,
                                                        PhoneNumber = x.PhoneNumber,
                                                        RechargeAmount = x.RechargeAmount,
                                                        UserId = x.UserId,
                                                        OutOrderNo = x.OutOrderNo,
                                                        PayStatus = x.PayStatus,
                                                        PayTime = x.PayTime,
                                                        RefundCredentialsImgUrl = x.RefundCredentialsImgUrl,
                                                        CreationTime = x.CreationTime
                                                    })
                                            .GetPageResult(input.PageModel);
    }

    /// <summary>
    /// 获取我的订单分页数据
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<PageOutput<UserLifePayOrderOutput>> GetUserLifePayOrderPage(QueryLifePayOrderListInput input)
    {
        if (!input.UserId.HasValue)
        {
            return new PageOutput<UserLifePayOrderOutput>();
        }

        return await _lifePayOrderRepository.Where(x => x.PayStatus != LifePayStatusEnum.未支付)
                                            .WhereIf(input.BeginFinishTime.HasValue, x => x.FinishTime >= input.BeginFinishTime)
                                            .WhereIf(input.EndFinishTime.HasValue, x => x.FinishTime <= input.EndFinishTime)
                                            .WhereIf(input.BeginPayTime.HasValue, x => x.PayTime >= input.BeginPayTime)
                                            .WhereIf(input.EndPayTime.HasValue, x => x.PayTime <= input.EndPayTime)
                                            .WhereIf(input.LifePayOrderStatus.HasValue, x => x.LifePayOrderStatus == input.LifePayOrderStatus.Value)
                                            .WhereIf(input.PayStatus.HasValue, x => x.PayStatus == input.PayStatus.Value)
                                            .WhereIf(input.UserId.HasValue, x => x.UserId == input.UserId.Value)
                                            .WhereIf(input.LifePayOrderType.HasValue, x => x.LifePayOrderType == input.LifePayOrderType)
                                            .Select(x =>
                                                    new UserLifePayOrderOutput
                                                    {
                                                        DiscountAmount = x.DiscountAmount,
                                                        FinishTime = x.FinishTime,
                                                        Id = x.Id,
                                                        LifePayOrderStatus = x.LifePayOrderStatus,
                                                        LifePayOrderType = x.LifePayOrderType,
                                                        LifePayType = x.LifePayType,
                                                        OrderNo = x.OrderNo,
                                                        PayAmount = x.PayAmount,
                                                        RechargeAmount = x.RechargeAmount,
                                                        PayStatus = x.PayStatus,
                                                        PayTime = x.PayTime,
                                                        OrderParamDetailJsonStr = x.OrderParamDetailJsonStr,
                                                        CreationTime = x.CreationTime,
                                                        RefundTime = x.RefundTime
                                                    })
                                            .GetPageResult(input.PageModel);
    }

    /// <summary>
    /// 根据订单号获取支付状态
    /// </summary>
    /// <param name="orderNo"></param>
    /// <returns></returns>
    public async Task<LifePayStatusEnum> GetPayStatusByOrderNo(string orderNo)
    {
        return await _lifePayOrderRepository.Where(x => x.OrderNo == orderNo)
                                            .Select(x => x.PayStatus)
                                            .FirstOrDefaultAsync();
    }

    #endregion

    #region 操作

    /// <summary>
    /// 创建生活缴费话费订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<CreateLifePayOrderOutput> CreateLifePayPhoneOrder(CreateLifePayOrderInput<LifePhoneData> input)
    {
        var user = await _lifePayUserRepository.FirstOrDefaultAsync(x => x.Id == input.UserId);
        CheckExtensions.IfTrueThrowUserFriendlyException(user == null, "用户不存在，请先登录再操作");

        var rate = await GetRate();
        CheckExtensions.IfTrueThrowUserFriendlyException(rate.IsNullOrEmpty(), "未配置折扣");

        var amount = CalculateAmount(input.ProductData.ParValue, rate.FirstOrDefault(x => x.RateType == LifePayRateTypeEnum.默认话费折扣).Rate);

        var orderInput = new CreateLifePayOrderInput
        {
            OrderNo = CreateOrderNo(),
            LifePayOrderStatus = LifePayOrderStatusEnum.待确认,
            LifePayOrderType = LifePayOrderTypeEnum.话费订单,
            //LifePayType = input.LifePayType,
            OrderParamDetailJsonStr = JsonConvert.SerializeObject(input.ProductData),
            UserId = user.Id,
            PayStatus = LifePayStatusEnum.未支付,
            PhoneNumber = user.PhoneNumber,
            PayAmount = amount.PayAmont,
            DiscountAmount = amount.DiscountAmount,
            RechargeAmount = amount.RechargeAmount,
        };

        await CreateLifePayOrder(orderInput);

        var result = new CreateLifePayOrderOutput()
        {
            OrderNo = orderInput.OrderNo,
        };
        return result;
    }

    /// <summary>
    /// 创建生活缴费电费订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<CreateLifePayOrderOutput> CreateLifePayElectricOrder(CreateLifePayOrderInput<LifeElectricData> input)
    {
        var user = await _lifePayUserRepository.FirstOrDefaultAsync(x => x.Id == input.UserId);
        CheckExtensions.IfTrueThrowUserFriendlyException(user == null, "用户不存在，请先登录再操作");

        var rate = await GetRate();
        CheckExtensions.IfTrueThrowUserFriendlyException(rate.IsNullOrEmpty(), "未配置折扣");

        var amount = CalculateAmount(input.ProductData.ParValue, rate.FirstOrDefault(x => x.RateType == LifePayRateTypeEnum.默认电费折扣).Rate);

        var orderInput = new CreateLifePayOrderInput
        {
            OrderNo = CreateOrderNo(),
            LifePayOrderStatus = LifePayOrderStatusEnum.待确认,
            LifePayOrderType = LifePayOrderTypeEnum.电费订单,
            // LifePayType = input.LifePayType,
            OrderParamDetailJsonStr = JsonConvert.SerializeObject(input.ProductData),
            UserId = user.Id,
            PayStatus = LifePayStatusEnum.未支付,
            PhoneNumber = user.PhoneNumber,
            PayAmount = amount.PayAmont,
            DiscountAmount = amount.DiscountAmount,
            RechargeAmount = amount.RechargeAmount,
        };

        await CreateLifePayOrder(orderInput);

        var result = new CreateLifePayOrderOutput()
        {
            OrderNo = orderInput.OrderNo,
        };
        return result;
    }

    /// <summary>
    /// 设置生活缴费支付类型
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<string> SetLifePayOrderPayType(SetLifePayOrderPayTypeInput input, string ip)
    {
        var order = await _lifePayOrderRepository.Where(x => x.OrderNo == input.OrderNo).FirstOrDefaultAsync();
        CheckExtensions.IfTrueThrowUserFriendlyException(order == null, "订单不存在");

        CheckExtensions.IfTrueThrowUserFriendlyException(order.LifePayType.HasValue, "当前订单已选择支付类型");

        order.LifePayType = input.LifePayType;

        await _lifePayOrderRepository.UpdateAsync(order);

        var desc = "生活缴费-";
        switch (order.LifePayOrderType)
        {
            case LifePayOrderTypeEnum.话费订单:
                desc += "话费";
                break;
            case LifePayOrderTypeEnum.电费订单:
                desc += "电费";
                break;
            default:
                break;
        }

#if DEBUG
        //var payUrl = await GetPayQRCode(order.LifePayType.Value, order.OrderNo, desc, 0.01m, ip, input.H5Type);
        var payUrl = await GetPayQRCode(order.LifePayType.Value, order.OrderNo, desc, order.PayAmount, ip, input.H5Type);
#else
      //var payUrl = await GetPayQRCode(order.LifePayType.Value, order.OrderNo, desc, 0.01m, ip, input.H5Type);
        var payUrl = await GetPayQRCode(order.LifePayType.Value, order.OrderNo, desc, order.PayAmount, ip, input.H5Type);
#endif

        return payUrl;
    }

    /// <summary>
    /// 设置生活缴费支付类型
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<ModelPaymentMiniPay> GetPayOrderForJsAPI(GetPayOrderForJsAPIInput input, string ip)
    {
        var order = await _lifePayOrderRepository.Where(x => x.OrderNo == input.OrderNo).FirstOrDefaultAsync();
        CheckExtensions.IfTrueThrowUserFriendlyException(order == null, "订单不存在");

        CheckExtensions.IfTrueThrowUserFriendlyException(order.LifePayType.HasValue, "当前订单已选择支付类型");

        order.LifePayType = input.LifePayType;
        await _lifePayOrderRepository.UpdateAsync(order);

        var desc = "生活缴费-";
        switch (order.LifePayOrderType)
        {
            case LifePayOrderTypeEnum.话费订单:
                desc += "话费";
                break;
            case LifePayOrderTypeEnum.电费订单:
                desc += "电费";
                break;
            default:
                break;
        }


        //var result = await PayTransactionsJsAPI(input.OpenId, input.Attach, 0.01m, input.OrderNo, desc);
        //return result;

        //  var result = await PayTransactionsJsAPI(input.OpenId, input.Attach,  order.PayAmount, input.OrderNo, desc);

        var result = await PayTransactionsJsAPI(input.OpenId, input.Attach, order.PayAmount, input.OrderNo, desc);
        return result;
        //var payUrl = await GetPayQRCode(order.LifePayType.Value, order.OrderNo, desc, 0.01m, ip, input.H5Type);
        //var payUrl = await GetPayQRCode(order.LifePayType.Value, order.OrderNo, desc, order.PayAmount, ip, input.H5Type);



    }

    /// <summary>
    /// 创建生活缴费订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task CreateLifePayOrder(CreateLifePayOrderInput input)
    {
        CheckExtensions.IfTrueThrowUserFriendlyException(input.RechargeAmount < 0.01m || input.PayAmount < 0.01m || input.DiscountAmount < 0, "订单金额错误");

        var entity = ObjectMapper.Map<CreateLifePayOrderInput, LifePayOrder>(input);
        await _lifePayOrderRepository.InsertAsync(entity);
    }

    /// <summary>
    /// 创建ACOOLY话费订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<(string Code, string RequestNo, string ACOOLYOrderNo)> CreateACOOLYPhoneOrder(LifePhoneData input, string orderNo)
    {
        var requestInput = new ConfirmPhoneOrderRequestInput()
        {
            IspCode = input.IspCode,
            ParValue = input.ParValue,
            Phone = input.Phone,
            OutOrderNo = orderNo,
            Name = input.Name
        };
        var result = await _aCOOLYManager.ConfirmPhoneOrder(requestInput);
#if DEBUG

        _logger.LogInformation($"CreateACOOLYPhoneOrder:{JsonConvert.SerializeObject(result)}");

#endif

        CheckExtensions.IfTrueThrowUserFriendlyException(!result.Success || (result.Code != ACOOLYConstant.Code.SUCCESS && result.Code != ACOOLYConstant.Code.PROCESSING),
                                                        "调用ACOOLY接口ConfirmElectricOrder返回错误:" + JsonConvert.SerializeObject(result));

        return (result.Code, requestInput.RequestNo, result.PhoneChargeOrder.BusiOrderNo);
    }

    /// <summary>
    /// 创建ACOOLY电费订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<(string Code, string RequestNo, string ACOOLYOrderNo)> CreateACOOLYElectricOrder(LifeElectricData input, string orderNo)
    {
        var requestInput = new ConfirmElectricOrderRequestInput()
        {
            City = input.City,
            ElectricAccount = input.ElectricAccount,
            ElectricAccountType = input.ElectricAccountType,
            ElectricType = input.ElectricType,
            ParValue = input.ParValue,
            Province = input.Province,
            SixID = input.SixID,
            OutOrderNo = orderNo
        };
        var result = await _aCOOLYManager.ConfirmElectricOrder(requestInput);
#if DEBUG

        _logger.LogInformation($"CreateACOOLYElectricOrder:{JsonConvert.SerializeObject(result)}");

#endif

        CheckExtensions.IfTrueThrowUserFriendlyException(!result.Success || (result.Code != ACOOLYConstant.Code.SUCCESS && result.Code != ACOOLYConstant.Code.PROCESSING),
                                                        "调用ACOOLY接口ConfirmElectricOrder返回错误:" + JsonConvert.SerializeObject(result));

        return (result.Code, requestInput.RequestNo, result.ElectricChargeOrder.BusiOrderNo);
    }

    public async Task<ModelPaymentMiniPay> PayTransactionsJsAPI(string openid, string order_guid, decimal amount, string outTradeNo, string description)
    {
        string time_expire = DateTime.Now.AddMinutes(5).ToString("yyyy-MM-ddTHH:mm:ss") + "+08:00";//订单失效时间
        ModelMiniPayRequest req = new ModelMiniPayRequest
        {

            TimeExpire = time_expire,
            Appid = _wxPayOptions.AppID,
            Mchid = _wxPayOptions.Mchid,
            Attach = order_guid,
            Description = description,
            OutTradeNo = outTradeNo,
            Amount = new Model_MiniPay_Amount
            {
                Total = Convert.ToInt32(100 * amount),
                Currency = "CNY"
            },
            NotifyUrl = $"{_wxPayOptions.NotifyUrl}{LifePaymentConstant.WxRechargeNotifySectionUrl}",
            Payer = new Model_MiniPay_Payer
            {
                OpenId = openid
            }
        };
        var timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
        string nonce = Guid.NewGuid().ToString();

        var res = await _wxPayApi.PayTransactionsJsAPI(req);
        string package = "prepay_id=" + res.PrepayId;
        ModelPaymentMiniPay info = new ModelPaymentMiniPay();
        if (res != null)
        {

            string paytext = BuildSignByPay(_wxPayOptions.AppID, timestamp, nonce, package);
            string paysign = _wxPayApi.GeneratePaySignByKey(paytext);

            info.Timestamp = timestamp.ToString();
            info.NonceStr = nonce;
            info.Package = package;
            info.SignType = "RSA";
            info.PaySign = paysign;
            info.TimeExpire = time_expire;
        }
        return info;
    }

    /// <summary>
    /// 构造签名串
    /// </summary>
    /// <param name="appId">小程序的AppID</param>
    /// <param name="timestamp">时间戳</param>
    /// <param name="nonceStr">随机字符串</param>
    /// <param name="package">package值</param>
    /// <returns>签名串</returns>
    public string BuildSignByPay(string appId, long timestamp, string nonceStr, string package)
    {
        string format = $"{appId}\n{timestamp}\n{nonceStr}\n{package}\n";
        return format;
    }

    /// <summary>
    /// 支付成功回调处理
    /// </summary>
    /// <param name="orderNo"></param>
    /// <param name="outOrderNo"></param>
    /// <returns></returns>
    public async Task LifePaySuccessHandler(string orderNo, string outOrderNo)
    {
        var order = await _lifePayOrderRepository.Where(x => x.OrderNo == orderNo).FirstOrDefaultAsync();
        CheckExtensions.IfTrueThrowUserFriendlyException(order == null, "订单不存在");

        if (order.PayStatus == LifePayStatusEnum.已支付)
        {
            return;
        }

        order.PayStatus = LifePayStatusEnum.已支付;
        order.PayTime = DateTime.Now;
        order.OutOrderNo = outOrderNo;
        try
        {
            var result = (Code: "Fail", RequestNo: "", ACOOLYOrderNo: "");
            switch (order.LifePayOrderType)
            {
                case LifePayOrderTypeEnum.话费订单:
                    result = await CreateACOOLYPhoneOrder(JsonConvert.DeserializeObject<LifePhoneData>(order.OrderParamDetailJsonStr), order.OrderNo);
                    break;
                case LifePayOrderTypeEnum.电费订单:
                    result = await CreateACOOLYElectricOrder(JsonConvert.DeserializeObject<LifeElectricData>(order.OrderParamDetailJsonStr), order.OrderNo);
                    break;
                default:
                    break;
            }

            order.LifePayOrderStatus = LifePayOrderStatusEnum.待确认;
            //SetOrderStatus(order, result.Code);
            order.OutRequestNo = result.RequestNo.IsNullOrEmpty() ? null : result.RequestNo;
            order.ACOOLYOrderNo = result.ACOOLYOrderNo.IsNullOrEmpty() ? null : result.ACOOLYOrderNo;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "处理生活缴费支付成功回调时异常");
            order.LifePayOrderStatus = LifePayOrderStatusEnum.已失败;
            order.PayStatus = LifePayStatusEnum.待退款;
        }
        _logger.LogError("生活缴费订单状态：" + order.LifePayOrderStatus.ToString());
        await _lifePayOrderRepository.UpdateAsync(order);
    }

    /// <summary>
    /// ACOOLYO订单通知处理
    /// </summary>
    /// <param name="orderNo"></param>
    /// <param name="outOrderNo"></param>
    /// <returns></returns>
    public async Task ACOOLYOrderNotifyHandler(string orderNo, string acoolyOrderNo, LifePayOrderStatusEnum status)
    {
        var order = await _lifePayOrderRepository.Where(x => x.OrderNo == orderNo).FirstOrDefaultAsync();
        CheckExtensions.IfTrueThrowUserFriendlyException(order == null, "订单不存在");

        if (order.LifePayOrderStatus == LifePayOrderStatusEnum.已完成)
        {
            return;
        }

        order.LifePayOrderStatus = status;
        if (acoolyOrderNo.IsNotNullOrEmpty())
        {
            order.ACOOLYOrderNo = acoolyOrderNo;
        }

        if (order.LifePayOrderStatus == LifePayOrderStatusEnum.已完成)
        {
            order.FinishTime = DateTime.Now;
        }

        if (order.LifePayOrderStatus == LifePayOrderStatusEnum.已失败 && order.PayStatus != LifePayStatusEnum.已退款)
        {
            order.PayStatus = LifePayStatusEnum.待退款;
        }

        await _lifePayOrderRepository.UpdateAsync(order);
    }

    /// <summary>
    /// 退款生活缴费订单
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task RefundLifePayOrder(RefundLifePayOrderInput input)
    {
        var order = await _lifePayOrderRepository.FirstOrDefaultAsync(x => x.Id == input.Id);
        CheckExtensions.IfTrueThrowUserFriendlyException(order == null, "订单不存在");

        if (order.PayStatus == LifePayStatusEnum.已退款)
        {
            return;
        }

        if (order.LifePayOrderStatus != LifePayOrderStatusEnum.已失败 && order.PayStatus != LifePayStatusEnum.待退款)
        {
            throw new UserFriendlyException("当前订单状态无法退款");
        }

        order.PayStatus = LifePayStatusEnum.已退款;
        order.RefundCredentialsImgUrl = input.RefundCredentialsImgUrl;
        order.RefundTime = DateTime.Now;

        await _lifePayOrderRepository.UpdateAsync(order);

        #region 记录日志

        await PublishLifePayOrderHistoryEvent("退款", "退款", order.Id);

        #endregion

    }

    #endregion

    #region 私有

    private string CreateOrderNo()
    {
        return "JF" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + GlobalRandom.GetRandomNum(4);
    }

    private (decimal PayAmont, decimal DiscountAmount, decimal RechargeAmount) CalculateAmount(decimal amount, decimal rate)
    {
        var payAmount = decimal.Round(amount * rate, 2, MidpointRounding.AwayFromZero);
        CheckExtensions.IfTrueThrowUserFriendlyException(payAmount < 0.01m, "支付金额错误");

        return (payAmount, amount - payAmount, amount);
    }

    private void SetOrderStatus(LifePayOrder order, string code)
    {
        switch (code)
        {
            case ACOOLYConstant.Code.SUCCESS:
                order.LifePayOrderStatus = LifePayOrderStatusEnum.已完成;
                order.FinishTime = DateTime.Now;
                break;
            case ACOOLYConstant.Code.PROCESSING:
                order.LifePayOrderStatus = LifePayOrderStatusEnum.待确认;
                break;
            default:
                break;
        }
    }

    /// <summary>
    /// 记录相关的操作历史
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task PublishLifePayOrderHistoryEvent(string operateContent, string operateName, Guid relationId, int? tableType = TableType.LifePayOrder)
    {
        var recordEto = new RecordOperateHistoryEto
        {
            CreatorName = CurrentUser.Name,
            OperateContent = operateContent,
            OperateName = operateName,
            RelationId = relationId,
            TableType = tableType
        };

        await _distributedEventBus.PublishAsync(recordEto, false);
    }

    /// <summary>
    /// 获取支付二维码
    /// </summary>
    /// <param name="payType"></param>
    /// <param name="outTradeNo"></param>
    /// <param name="description"></param>
    /// <param name="amount"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    public async Task<string> GetPayQRCode(LifePayTypeEnum payType, string outTradeNo, string description, decimal amount, string ip, string h5Type)
    {
        var codeUrl = string.Empty;
        switch (payType)



        {
            case LifePayTypeEnum.AliPay:
                codeUrl = await GetAliPayQRCode(outTradeNo, description, amount);

                break;
            case LifePayTypeEnum.WxPay:
                codeUrl = await GetWxPayQRCode(outTradeNo, description, amount); //native
                                                                                 // codeUrl = await GetWxPayH5Url(outTradeNo, description, amount, ip, h5Type); //h5
                break;
            default:
                throw new UserFriendlyException(string.Format(CustomeErrorMessage.NotImplementedWhenSometing, "获取支付二维码"));
        }

        return codeUrl;
    }

    /// <summary>
    /// 获取微信支付二维码
    /// </summary>
    /// <param name="outTradeNo"></param>
    /// <param name="description"></param>
    /// <param name="amount"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    private async Task<string> GetWxPayQRCode(string outTradeNo, string description, decimal amount)
    {
        CheckExtensions.IfTrueThrowUserFriendlyException(amount <= 0,
                                                         CustomeErrorMessage.SometingMustSometing,
                                                         "获取支付二维码时金额", "大于0");

        var res = await _wxPayApi.PayTransactionsNative(new PayTransactionsNativeInput
        {
            Appid = _wxPayOptions.AppID,
            Mchid = _wxPayOptions.Mchid,
            Description = description,
            OutTradeNo = outTradeNo,
            Amount = new PayAmount
            {
                Total = Convert.ToInt32(100 * amount),
            },
            NotifyUrl = $"{_wxPayOptions.NotifyUrl}{LifePaymentConstant.WxRechargeNotifySectionUrl}",
        });

        if (res == null || res.CodeUrl.IsNullOrEmpty())
        {
            _logger.LogError($"获取微信支付二维码异常:{(res == null ? "返回参数为空" : $"{res.Code} --{res.Message}")}");
            throw new UserFriendlyException(string.Format(CustomeErrorMessage.SometingError, "获取支付二维码时"));
        }

        return res.CodeUrl;
    }

    /// <summary>
    /// 获取微信支付二维码
    /// </summary>
    /// <param name="outTradeNo"></param>
    /// <param name="description"></param>
    /// <param name="amount"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    private async Task<string> GetWxPayH5Url(string outTradeNo, string description, decimal amount, string ip, string h5Type)
    {
        CheckExtensions.IfTrueThrowUserFriendlyException(amount <= 0,
                                                         CustomeErrorMessage.SometingMustSometing,
                                                         "获取支付二维码时金额", "大于0");

        var res = await _wxPayApi.PayTransactionsH5(new PayTransactionsNativeH5
        {
            Appid = _wxPayOptions.AppID,
            Mchid = _wxPayOptions.Mchid,
            Description = description,
            OutTradeNo = outTradeNo,
            Amount = new PayAmount
            {
                Total = Convert.ToInt32(100 * amount),
            },
            NotifyUrl = $"{_wxPayOptions.NotifyUrl}{LifePaymentConstant.WxRechargeNotifySectionUrl}",
            SceneInfo = new H5SceneInfo() { PayerClientIp = ip, H5Info = new H5Info() { Type = h5Type } }
        });

        if (res == null || res.H5Url.IsNullOrEmpty())
        {
            _logger.LogError($"获取微信支付Url异常:{(res == null ? "返回参数为空" : $"{res.Code} --{res.Message}")}");
            throw new UserFriendlyException(string.Format(CustomeErrorMessage.SometingError, "获取支付Url时"));
        }

        return res.H5Url;
    }

    /// <summary>
    /// 获取支付宝二维码
    /// </summary>
    /// <param name="outTradeNo"></param>
    /// <param name="description"></param>
    /// <param name="amount"></param>
    /// <returns></returns>
    /// <exception cref="UserFriendlyException"></exception>
    private async Task<string> GetAliPayQRCode(string outTradeNo, string description, decimal amount)
    {
        CheckExtensions.IfTrueThrowUserFriendlyException(amount < 0.01M,
                                                         CustomeErrorMessage.SometingMustSometing,
                                                         "获取支付二维码时金额", "大于0.01");

        var res = await _aliPayApi.GetAliPayQRCode(new GetPayQrCodeInput
        {
            Subject = description,
            OutTradeNo = outTradeNo,
            TotalAmount = amount,
        });

        if (res == null || res.QrCode.IsNullOrEmpty())
        {
            _logger.LogError($"获取支付宝支付二维码异常:{(res == null ? "返回参数为空" : $"{res.Code} --{res.Msg}")}");
            throw new UserFriendlyException(string.Format(CustomeErrorMessage.SometingError, "获取支付二维码时"));
        }

        return res.QrCode;
    }
    /// <summary>
    /// 构造待签名字符串
    /// </summary>
    /// <param name="method">HTTP请求方法</param>
    /// <param name="uri">API接口的相对路径</param>
    /// <param name="timestamp">时间戳（秒级）</param>
    /// <param name="nonce">随机字符串</param>
    /// <param name="body">请求体的JSON字符串</param>
    /// <returns>待签名字符串</returns>
    public static string BuildSignByUniOrder(string method, string uri, long timestamp, string nonce, string body)
    {
        string message = $"{method}\n{uri}\n{timestamp}\n{nonce}\n{body}\n";
        return message;
    }


    #endregion
}