using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Alipay.AopSdk.Core;
using Alipay.AopSdk.Core.Request;
using Alipay.AopSdk.Core.Response;
using AlipaySDKNet.OpenAPI.Api;
using AlipaySDKNet.OpenAPI.Client;
using AlipaySDKNet.OpenAPI.Model;
using AlipaySDKNet.OpenAPI.Util;
using AlipaySDKNet.OpenAPI.Util.Model;
using Google.Protobuf.WellKnownTypes;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NCC.Common.Configuration;
using NCC.Common.Core.Manager;
using NCC.Common.Extension;
using NCC.Common.Helper;
using NCC.Dependency;
using NCC.DynamicApiController;
using NCC.Extend.Entitys;
using NCC.Extend.Interfaces.AliPay;
using NCC.System.Entitys.Permission;
using NCC.System.Entitys.System;
using Newtonsoft.Json.Linq;
using SqlSugar;
using NCC.DataEncryption;
using NCC.Common.Const;
using Microsoft.AspNetCore.Http;
using Yitter.IdGenerator;
using NCC.Common.Extensions;
using Aop.Api.Util;
using Microsoft.AspNetCore.Components.Forms;
using Serilog;
using NCC.Localization;
using NCC.Extend.Entitys.Dto.UavFeeRule;
using Mapster;
using NCC.Code.QrCode;
using System.IO;
using QRCoder;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.PixelFormats;
using System.Net.Http;
using NCC.Extend.Entitys.Enums;

namespace NCC.Extend.AliPay
{
    /// <summary>
    /// 支付宝支付服务
    /// </summary>
    [ApiDescriptionSettings(Tag = "支付宝支付服务", Name = "AliPay", Order = 200)]
    [Route("api/Extend/[controller]")]
    public class AliPayService : IAliPayService, IDynamicApiController, ITransient
    {
        private readonly SqlSugarScope _db;
        private readonly IUserManager _userManager;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private static readonly HttpClient httpClient = new HttpClient();
        private static AlipayOptions _AlipayOptions;

        /// <summary>
        /// 初始化一个<see cref="AliPayService"/>类型的新实例
        /// </summary>
        public AliPayService(ISqlSugarClient db, IUserManager userManager, IHttpContextAccessor httpContextAccessor)
        {
            _db = (SqlSugarScope)db;
            _userManager = userManager;
            _httpContextAccessor = httpContextAccessor;
        }

        #region 支付宝基本信息
        [NonAction]
        private static AlipayConfig GetAlipayConfig()
        {
            return new AlipayConfig
            {
                ServerUrl = "https://openapi.alipay.com",
                // AppId = "2021005150691832",
                AppId = App.Configuration["PaymentSettings:AlipayConfig:APPLETE_APPID"],
                PrivateKey = App.Configuration["PaymentSettings:AlipayConfig:ALIPay_RSA_PRIVATEKEY"],
                AlipayPublicKey = App.Configuration["PaymentSettings:AlipayConfig:ALIPay_RSA_ALI_PUBLICKEY"],
            };
        }
        [NonAction]
        private static Aop.Api.AlipayConfig GetAlipayConfig_V2()
        {
            Aop.Api.AlipayConfig alipayConfig = new Aop.Api.AlipayConfig();
            alipayConfig.ServerUrl = "https://openapi.alipay.com/gateway.do";
            alipayConfig.AppId = App.Configuration["PaymentSettings:AlipayConfig:APPLETE_APPID"];
            alipayConfig.PrivateKey = App.Configuration["PaymentSettings:AlipayConfig:ALIPay_RSA_PRIVATEKEY"];
            alipayConfig.Format = "json";
            alipayConfig.AlipayPublicKey = App.Configuration["PaymentSettings:AlipayConfig:ALIPay_RSA_ALI_PUBLICKEY"];
            alipayConfig.Charset = "UTF-8";
            alipayConfig.SignType = "RSA2";
            return alipayConfig;
        }
        #endregion

        #region 生成支付宝小程序的二维码
        /// <summary>
        /// 生成支付宝小程序的二维码
        /// </summary>
        /// <param name="queryParams"></param>
        /// <returns></returns>
        [HttpPost("CreateQrCode")]
        [AllowAnonymous]
        public async Task<dynamic> CreateQrCode(string queryParams)
        {
            //alipayqr://platformapi/startapp?appId=2021005150691832&page=pages/projectClockin/projectClockin&query=deviceCode=Sa123784932
            queryParams = queryParams.Replace("id=", "");
            string serverUrl = "https://openapi.alipay.com/gateway.do";
            string appId = GetAlipayConfig().AppId;
            string privateKey = GetAlipayConfig().PrivateKey;
            string alipayPublicKey = GetAlipayConfig().AlipayPublicKey;
            IAopClient client = new DefaultAopClient(serverUrl, appId, privateKey, "json", "1.0", "RSA2", alipayPublicKey, "UTF-8", false);
            var request = new AlipayOpenAppQrcodeCreateRequest();
            request.BizContent = $@"{{
                ""url_param"": ""pages/projectClockin/projectClockin"",
                ""query_param"": ""{queryParams}"",
                ""describe"": ""跳转首页"",
                ""page"": ""pages/projectClockin/projectClockin""
            }}";
            AlipayOpenAppQrcodeCreateResponse response = client.Execute(request);
            if (response.IsError)
                return (false, "", response.Msg);

            var content = await ReadQrCodeAsync(response.QrCodeUrl, queryParams);
            var QrCodeUrl = GenerateQrCodeToFile($"{content}?deviceCode={queryParams}", "DeviceQrCode");
            return (true, QrCodeUrl, "success", content);
            // return (true, response.QrCodeUrl, "success");
        }
        /// <summary>
        /// 创建二维码
        /// </summary>
        /// <param name="content"></param>
        /// <param name="dir"></param>
        /// <returns></returns>
        /// <exception cref="ArgumentNullException"></exception>
        [NonAction]
        public static string GenerateQrCodeToFile(string content, string dir)
        {
            if (string.IsNullOrWhiteSpace(content))
                throw new ArgumentNullException(nameof(content));
            if (string.IsNullOrWhiteSpace(dir))
                throw new ArgumentNullException(nameof(dir));
            string fileName = Guid.NewGuid().ToString("N") + ".png";
            // 拼接跨平台路径
            string basePath = Path.Combine(AppContext.BaseDirectory, "wwwroot", "image", "qr", dir);
            if (!Directory.Exists(basePath))
                Directory.CreateDirectory(basePath);
            string fullPath = Path.Combine(basePath, fileName);
            try
            {
                // 创建二维码
                using (QRCodeGenerator qrGenerator = new QRCodeGenerator())
                using (QRCodeData qrCodeData = qrGenerator.CreateQrCode(content, QRCodeGenerator.ECCLevel.Q))
                using (PngByteQRCode qrCode = new PngByteQRCode(qrCodeData))
                {
                    byte[] qrCodeAsPng = qrCode.GetGraphic(20);
                    File.WriteAllBytes(fullPath, qrCodeAsPng);
                }
                // 返回相对路径
                return $"/image/qr/{dir}/{fileName}";
            }
            catch (Exception ex)
            {
                Console.WriteLine($"二维码生成失败: {ex.Message}");
                return null;
            }
        }
        [NonAction]
        public static async Task<string> ReadQrCodeAsync(string pathOrUrl, string queryParams)
        {
            try
            {
                using Image<Rgba32> image = await DownloadImageAsync(pathOrUrl, queryParams);
                var reader = new ZXing.ImageSharp.BarcodeReader<Rgba32>
                {
                    AutoRotate = true,
                    TryInverted = true
                };

                var result = reader.Decode(image);
                return result?.Text ?? "未识别出二维码内容";
            }
            catch (Exception ex)
            {
                return $"识别失败：{ex.Message}";
            }
        }
        public static async Task<Image<Rgba32>> DownloadImageAsync(string url, string queryParams)
        {
            try
            {
                var savePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "/wwwroot/image/qr/DeviceQrCode", $"{queryParams}.png");
                var directory = Path.GetDirectoryName(savePath);
                if (!Directory.Exists(directory))
                {
                    Directory.CreateDirectory(directory);
                }

                var response = await httpClient.GetAsync(url);
                response.EnsureSuccessStatusCode();

                await using var stream = await response.Content.ReadAsStreamAsync();
                await using var fileStream = new FileStream(savePath, FileMode.Create, FileAccess.Write);
                await stream.CopyToAsync(fileStream);
                return await SixLabors.ImageSharp.Image.LoadAsync<Rgba32>(savePath);
            }
            catch (Exception ex)
            {
                Console.WriteLine("下载图片失败: " + ex.Message);
                return null;
            }
        }
        #endregion

        #region 创建普通支付订单
        /// <summary>
        /// 创建支付订单
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("CreatePay")]
        [AllowAnonymous]
        public async Task<dynamic> CreatePay(AliPayEntity input)
        {
            // return input.ToJson();
            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            // 构造请求参数以调用接口
            AlipayTradeApi instance = new AlipayTradeApi();
            instance.Client.SetAlipayConfigUtil(alipayConfigUtil);

            AlipayTradeCreateModel data = new AlipayTradeCreateModel();
            // 设置商户订单号
            data.OutTradeNo = input.OutTradeNo;
            // 设置产品码
            data.ProductCode = "JSAPI_PAY";
            // 设置小程序支付中
            data.OpAppId = alipayConfigUtil.AppId;
            // 设置订单总金额
            data.TotalAmount = input.TotalAmount.ToString();
            // 设置业务扩展参数
            // ExtendParams extendParams = new ExtendParams();
            // extendParams.TradeComponentOrderId = "2023060801502300000008810000005657";
            // data.ExtendParams = extendParams;
            // 设置可打折金额
            data.DiscountableAmount = input.DiscountableAmount.ToString();
            // 设置订单标题
            data.Subject = input.Subject;
            // 设置订单附加信息
            data.Body = input.Body;
            // uid参数未来计划废弃，存量商户可继续使用，新商户请使用openid。请根据应用-开发配置-openid配置选择支持的字段。
            // data.BuyerId = "2088102146225135";
            // 设置买家支付宝用户唯一标识
            data.BuyerOpenId = input.BuyerOpenId;
            // 设置商户门店编号(暂时不用)
            // data.StoreId = "NJ_001";
            // 第三方代调用模式下请设置app_auth_token
            CustomizedParams customizedParams = new CustomizedParams();
            // customizedParams.AppAuthToken = "<-- 请填写应用授权令牌 -->";
            try
            {
                var response = instance.Create(data, 0, customizedParams);
                return response;
            }
            catch (Exception e)
            {
                // AlipayTradeCreateDefaultResponse errorObject = (AlipayTradeCreateDefaultResponse)e.ErrorObject;
                // Console.WriteLine("调用失败:" + errorObject);
                return e.ToJson();
            }
        }

        #endregion

        #region 线上资金授权冻结接口
        /// <summary>
        /// 线上资金授权冻结接口
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("Appfreeze")]
        public async Task<dynamic> Appfreeze(AliPayAppFreezeEntity input)
        {
            //获取订单的基本信息
            var orderinfo = _db.Queryable<UavOrderEntity>().Where(x => x.OrderNo == input.OutOrderNo).First();
            //从订单中获取计费规则的快照
            UavFeeRuleEntity uavFee = orderinfo.FeeRuleSnapshot.ToObject<UavFeeRuleCrInput>().Adapt<UavFeeRuleEntity>();//获取快照中的费用规则
            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            GenericExecuteApi api = new GenericExecuteApi();
            api.Client.SetAlipayConfigUtil(alipayConfigUtil);
            // 构造请求参数以调用接口
            Dictionary<string, Object> bizParams = new Dictionary<string, object>();
            Dictionary<string, Object> bizContent = new Dictionary<string, Object>();
            //通过扣费规则表去找到冻结金额
            //-----------------
            input.Amount = uavFee.TotalCap;
            //-----------------
            // 设置订单标题
            // bizContent.Add("order_title", input.OrderTitle);
            bizContent.Add("order_title", "无人机租借");
            // 设置商户授权资金订单号
            bizContent.Add("out_order_no", input.OutOrderNo);
            // 设置商户本次资金操作的请求流水号
            bizContent.Add("out_request_no", input.OutRequestNo);
            // 设置需要冻结的金额
            bizContent.Add("amount", input.Amount);
            // 设置预授权订单相对超时时间
            bizContent.Add("timeout_express", input.TimeoutExpress);
            // 设置销售产品码
            bizContent.Add("product_code", input.ProductCode);

            List<AliPostPayments> AliPostPaymentslist = new List<AliPostPayments>();
            var unit = uavFee.PackageType switch
            {
                "minute" => "分钟",
                "hour" => "小时",
                _ => "单位" // fallback
            };
            AliPostPaymentslist.Add(new AliPostPayments
            {
                name = uavFee.RuleName,
                description = $"{uavFee.OvertimePrice}元/{unit}，{uavFee.TotalCap}元封顶"
            });
            // 设置无特殊需要请勿传入
            // bizContent.Add("enable_pay_channels", "[{\"payChannelType\":\"MONEY_FUND\"}]");
            bizContent.Add("post_payments", AliPostPaymentslist.ToJson());
            // 设置业务扩展参数
            // bizContent.Add("extra_param", input.aliExtraParam.ToJson());
            bizContent.Add("extra_param", "{\"category\":\"CREDIT_RENT_OFFLINE\",\"serviceId\":\"2025061600000000000104406000\"}");
            // 设置免押受理台模式
            bizContent.Add("deposit_product_mode", input.DepositProductMode);
            bizParams.Add("notify_url", App.Configuration["PaymentSettings:AlipayConfig:ALIPay_NotifyURL_V2"]);
            bizParams.Add("biz_content", bizContent);
            Log.Information("线上资金授权冻结接口传入信息：" + bizParams.ToJson());
            try
            {
                // 如果是第三方代调用模式，请设置app_auth_token（应用授权令牌）
                string orderStr = api.SdkExecute("alipay.fund.auth.order.app.freeze", bizParams, null, null);
                return orderStr;
            }
            catch (ApiException e)
            {
                Console.WriteLine("调用失败");
                return e.ToString();
            }
        }
        #endregion

        #region 线上资金扣款操作
        /// <summary>
        /// 线上资金扣款操作
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("TradePay")]
        public async Task<dynamic> TradePay(AliPayTradePayEntity input)
        {
            Log.Information($"[扣款操作]线上资金扣款操作:{input.ToJson()}");
            //查询订单信息
            var orderinfo = _db.Queryable<UavOrderEntity>().Where(x => x.OrderNo == input.OutTradeNo).First();
            Log.Information($"[扣款操作]{input.OutTradeNo}订单信息", orderinfo.ToJson());
            if (orderinfo == null)
            {
                return new
                {
                    code = 500,
                    message = "订单不存在"
                };
            }

            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            // 构造请求参数以调用接口
            AlipayTradeApi instance = new AlipayTradeApi();
            instance.Client.SetAlipayConfigUtil(alipayConfigUtil);
            AlipayTradePayModel data = new AlipayTradePayModel();
            data.NotifyUrl = App.Configuration["PaymentSettings:AlipayConfig:ALIPay_NotifyURL"];
            // 设置商户订单号
            data.OutTradeNo = input.OutTradeNo;
            // 设置订单总金额
            data.TotalAmount = input.TotalAmount.ToString();
            // 设置订单标题
            data.Subject = input.Subject;
            // 设置产品码
            data.ProductCode = "PREAUTH_PAY";
            // 设置资金预授权单号
            data.AuthNo = orderinfo.AliAuthNo;
            // 设置预授权确认模式
            // data.AuthConfirmMode = input.AuthConfirmMode;
            data.AuthConfirmMode = "COMPLETE";
            // 设置买家支付宝用户唯一标识
            // data.BuyerOpenId = input.BuyerOpenId;
            // 设置订单附加信息
            // data.Body = "Iphone6 16G";
            // 设置支付模式类型
            // data.AdvancePaymentType = "ENJOY_PAY_V2";
            // 设置是否异步支付
            data.IsAsyncPay = false;
            // 设置不可打折金额
            data.UndiscountableAmount = input.TotalAmount.ToString();
            // 设置返回参数选项
            List<string> queryOptions = new List<string>();
            queryOptions.Add("voucher_detail_list");
            data.QueryOptions = queryOptions;
            try
            {
                var response = instance.Pay(data, 0, null);
                return response;
            }
            catch (ApiException e)
            {
                AlipayTradePayDefaultResponse errorObject = (AlipayTradePayDefaultResponse)e.ErrorObject;
                Console.WriteLine("调用失败:" + errorObject);
                Log.Information($"线上资金扣款操作--调用失败:{errorObject}");
                return errorObject;
            }
        }
        #endregion

        #region 取消免押订单
        /// <summary>
        /// 取消免押订单
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("liPayOperationCance")]
        public async Task<dynamic> liPayOperationCance(AliPayOperationCancelEntity input)
        {
            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            // 构造请求参数以调用接口
            AlipayFundAuthOperationApi instance = new AlipayFundAuthOperationApi();
            instance.Client.SetAlipayConfigUtil(alipayConfigUtil);
            AlipayFundAuthOperationCancelModel data = new AlipayFundAuthOperationCancelModel();
            // 设置商户的授权资金订单号
            data.OutOrderNo = input.OutOrderNo;
            // 设置商户的授权资金操作流水号
            data.OutRequestNo = input.OutRequestNo;
            // 设置商户对本次撤销操作的附言描述
            data.Remark = input.Remark;
            data.NotifyUrl = App.Configuration["PaymentSettings:AlipayConfig:ALIPay_NotifyURL_Cancel"];
            try
            {
                var response = instance.Cancel(data, 0, null);
                return response;
            }
            catch (ApiException e)
            {
                AlipayFundAuthOperationCancelDefaultResponse errorObject = (AlipayFundAuthOperationCancelDefaultResponse)e.ErrorObject;
                Console.WriteLine("调用失败:" + errorObject);
                return errorObject;
            }
        }
        #endregion

        #region 支付宝小程序登录
        /// <summary>
        /// 支付宝小程序登录
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        [HttpPost("AlipayLogin")]
        [AllowAnonymous]
        public async Task<dynamic> AlipayLogin([FromBody] AliLoginInput req)
        {
            // 第一步：通过 authCode 换取 user_id
            var client = new DefaultAopClient("https://openapi.alipay.com/gateway.do",
                GetAlipayConfig().AppId,
                GetAlipayConfig().PrivateKey,
                "json",
                "1.0",
                "RSA2",
                GetAlipayConfig().AlipayPublicKey,
                "utf-8",
                false);
            var tokenReq = new AlipaySystemOauthTokenRequest
            {
                GrantType = "authorization_code",
                Code = req.authCode
            };
            var tokenResp = await client.ExecuteAsync(tokenReq);
            var userId = tokenResp.UserId;
            // 第二步：解密手机号
            var phone = DecryptPhoneNumber(req.response, GetAlipayConfig().PrivateKey);
            // 这里开始是用户登录的逻辑
            var info = await _db.Queryable<UserEntity>().Where(o => o.Account == phone && o.ExtensionStr == "支付宝用户" && o.EnabledMark != 0 && o.DeleteMark == null).FirstAsync();
            if (info.IsNullOrEmpty())
            {
                //如果用户信息是空，就注册创建用户
                info = new UserEntity
                {
                    Id = YitIdHelper.NextId().ToString(),
                    Account = phone,
                    MobilePhone = phone,
                    HeadIcon = req.headicon,
                    RealName = req.realName ?? phone,
                    NickName = req.realName,
                    EnabledMark = 1,
                    OpenId = userId,
                    Password = MD5Encryption.Encrypt(userId),
                    ExtensionStr = "支付宝用户"
                };
                await _db.Insertable<UserEntity>(info).ExecuteCommandAsync();
            }
            string tenantDbName = App.Configuration["ConnectionStrings:DBName"];
            var accessToken = string.Empty;
            string tenantId = App.Configuration["ConnectionStrings:ConfigId"];
            var tokenTimeout = _db.Queryable<SysConfigEntity>().Where(s => s.Category == "SysConfig" && s.Key == "tokentimeout").First();
            // 生成Token令牌
            if (KeyVariable.MultiTenancy)
            {
                accessToken = JWTEncryption.Encrypt(new Dictionary<string, object>
                    {
                        { ClaimConst.CLAINM_USERID, info.Id },
                        { ClaimConst.CLAINM_ACCOUNT, info.Account },
                        { ClaimConst.TENANT_ID, tenantId },
                        { ClaimConst.TENANT_DB_NAME, tenantDbName }
                    }, long.Parse(tokenTimeout.Value));
            }
            else
            {
                accessToken = JWTEncryption.Encrypt(new Dictionary<string, object>
                    {
                        { ClaimConst.CLAINM_USERID, info.Id },
                        { ClaimConst.CLAINM_ACCOUNT, info.Account },
                        { ClaimConst.TENANT_ID, tenantId },
                        { ClaimConst.TENANT_DB_NAME, tenantDbName }
                    }, long.Parse(tokenTimeout.Value));
            }
            var httpContext = _httpContextAccessor.HttpContext;
            // 设置Swagger自动登录
            httpContext.SigninToSwagger(accessToken);
            // 生成刷新Token令牌
            var refreshToken = JWTEncryption.GenerateRefreshToken(accessToken, 30);
            // 设置刷新Token令牌
            httpContext.Response.Headers["x-access-token"] = refreshToken;
            var ip = httpContext.GetRemoteIpAddressToIPv4();
            return new
            {
                //theme = input.Theme == null ? "classic" : input.Theme,
                token = "Bearer " + accessToken,
                user = info
            };
        }
        [NonAction]
        public static string DecryptPhoneNumber(string response, string privateKey)
        {
            try
            {
                var plainData = AlipayEncrypt.AesDencrypt("o49tr1UchK+7s/bBvgxSQA==", response, "UTF-8");
                var json = JObject.Parse(plainData);
                return json["mobile"]?.ToString();
            }
            catch (Exception ex)
            {
                // 可记录日志 ex.Message
                throw new Exception("手机号解密失败，请检查私钥或支付宝返回内容", ex);
            }
        }
        #endregion

        #region 线上资金退款操作
        /// <summary>
        /// 线上资金退款操作
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("RefundPay")]
        public async Task<dynamic> RefundPay(AliPayOperationCancelEntity input)
        {
            var orderinfo = _db.Queryable<UavOrderEntity>().Where(x => x.OrderNo == input.OutOrderNo).First();
            Log.Information($"[退款操作]{input.OutOrderNo}订单信息{orderinfo.ToJson()}");
            if (orderinfo == null)
            {
                return new
                {
                    code = 500,
                    message = "订单不存在"
                };
            }
            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            // 构造请求参数以调用接口
            AlipayTradeApi instance = new AlipayTradeApi();
            instance.Client.SetAlipayConfigUtil(alipayConfigUtil);
            AlipayTradeRefundModel data = new AlipayTradeRefundModel();
            // 设置商户订单号
            data.OutTradeNo = input.OutOrderNo;
            // 设置支付宝交易号
            //data.TradeNo = orderinfo.AliAuthNo;
            // 设置退款金额
            data.RefundAmount = orderinfo.ActualAmount.ToString();
            // 设置退款原因说明
            data.RefundReason = "正常退款";
            // 设置退款请求号
            // data.OutRequestNo = "HZ01RF001";
            // 设置查询选项
            List<string> queryOptions = new List<string>();
            queryOptions.Add("refund_detail_item_list");
            data.QueryOptions = queryOptions;
            // 设置针对账期交易
            // data.RelatedSettleConfirmNo = "2024041122001495000530302869";
            try
            {

                var response = instance.Refund(data, 0, null);
                Log.Information($"[支付宝退款响应]Response: {response.ToJson()}");
                if (response.FundChange == "Y")
                {
                    // 退款成功
                    orderinfo.Status = UavOrderStatusEnum.已退款.GetHashCode();
                    orderinfo.UpdateTime = DateTime.Now;
                    await _db.Updateable(orderinfo).ExecuteCommandAsync();
                    //通过订单id去找到流水信息
                    var orderflow = await _db.Queryable<UavWalletFlowEntity>().Where(x => x.RelatedId == orderinfo.OrderNo).ToListAsync();
                    foreach (var item in orderflow)
                    {
                        UavWalletFlowEntity flowEntity = new UavWalletFlowEntity
                        {
                            Id = YitIdHelper.NextId().ToString(),
                            UserId = item.UserId,
                            FlowDirection = item.FlowDirection,
                            Amount = -item.Amount,
                            RelatedId = item.RelatedId,
                            RelatedType = item.RelatedType,
                            Description = "订单退款",
                            CreateTime = DateTime.Now,
                            CreateUser = _userManager.UserId
                        };
                        await _db.Insertable(flowEntity).ExecuteCommandAsync();
                    }
                    //去找到退款记录修改状态
                    var refundEntity = await _db.Queryable<UavRefundApplicationEntity>().Where(x => x.OrderNo == orderinfo.OrderNo).FirstAsync();
                    if (refundEntity != null)
                    {
                        refundEntity.RefundStatus = RefundStatusEnum.已退款.GetHashCode();
                        refundEntity.HandleTime = DateTime.Now;
                        refundEntity.HandleUser = _userManager.UserId;
                        refundEntity.HandleResult = input.HandleResult;
                        await _db.Updateable(refundEntity).ExecuteCommandAsync();
                    }
                    Log.Information($"[退款操作]订单{input.OutOrderNo}退款成功，更新订单状态为已退款");
                    // 返回成功信息
                    return "退款成功";
                }
                else
                {
                    return "退款失败";
                }
            }
            catch (ApiException e)
            {
                AlipayTradeRefundDefaultResponse errorObject = (AlipayTradeRefundDefaultResponse)e.ErrorObject;
                Console.WriteLine("调用失败1:" + e);
                return "fill";
            }
        }
        #endregion

        #region 完结免押订单
        /// <summary>
        /// 完结免押订单
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("TradeFinish")]
        public async Task<dynamic> TradeFinish(AliPayOperationCancelEntity input)
        {
            var orderinfo = _db.Queryable<UavOrderEntity>().Where(x => x.OrderNo == input.OutOrderNo).First();
            //从订单中获取计费规则的快照
            UavFeeRuleEntity uavFee = orderinfo.FeeRuleSnapshot.ToObject<UavFeeRuleCrInput>().Adapt<UavFeeRuleEntity>();//获取快照中的费用规则
            Log.Information($"[退款操作]{input.OutOrderNo}订单信息{orderinfo.ToJson()}");
            if (orderinfo == null)
            {
                return new
                {
                    code = 500,
                    message = "订单不存在"
                };
            }
            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());

            // 构造请求参数以调用接口
            AlipayFundAuthOrderApi instance = new AlipayFundAuthOrderApi();
            instance.Client.SetAlipayConfigUtil(alipayConfigUtil);
            AlipayFundAuthOrderUnfreezeModel data = new AlipayFundAuthOrderUnfreezeModel();

            // 设置支付宝资金授权订单号
            data.AuthNo = orderinfo.AliAuthNo;

            // 设置解冻请求流水号
            data.OutRequestNo = "End_" + orderinfo.OrderNo;

            // 设置本次操作解冻的金额
            data.Amount = uavFee.TotalCap.ToString();

            // 设置商户对本次解冻操作的附言描述
            data.Remark = "订单已完成";

            // 设置解冻扩展信息
            // data.ExtraParam = "{\"unfreezeBizInfo\": \"{\"bizComplete\":\"true\"}\"}";


            // 第三方代调用模式下请设置app_auth_token
            // CustomizedParams customizedParams = new CustomizedParams();
            // customizedParams.AppAuthToken = "<-- 请填写应用授权令牌 -->";

            try
            {
                var response = instance.Unfreeze(data, 0, null);
                Log.Information($"[完结订单]：{response.ToJson()}");
                return "success";
            }
            catch (ApiException e)
            {
                AlipayFundAuthOrderUnfreezeDefaultResponse errorObject = (AlipayFundAuthOrderUnfreezeDefaultResponse)e.ErrorObject;
                Console.WriteLine("调用失败:" + errorObject);
                return errorObject;
            }
        }
        #endregion

        #region 统一收到交易支付接口
        /// <summary>
        /// 统一收到交易支付接口
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("Pay")]
        public async Task<dynamic> Pay(AliPayOperationCancelEntity input)
        {
            var orderinfo = _db.Queryable<UavOrderEntity>().Where(x => x.OrderNo == input.OutOrderNo).First();
            Log.Information($"[统一收单交易接口]{input.OutOrderNo}订单信息{orderinfo.ToJson()}");
            if (orderinfo == null)
            {
                return new
                {
                    code = 500,
                    message = "订单不存在"
                };
            }
            // 初始化SDK
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            GenericExecuteApi api = new GenericExecuteApi();
            api.Client.SetAlipayConfigUtil(alipayConfigUtil);
            // 构造请求参数以调用接口
            Dictionary<string, Object> bizParams = new Dictionary<string, object>();
            Dictionary<string, Object> bizContent = new Dictionary<string, Object>();
            bizContent.Add("out_trade_no", orderinfo.OrderNo);
            bizContent.Add("total_amount", orderinfo.ActualAmount.ToString("1.00"));
            // 设置订单标题
            bizContent.Add("subject", "无人机租金");
            // 设置产品码
            bizContent.Add("product_code", "PREAUTH_PAY");
            // 设置预授权单号
            bizContent.Add("auth_no", orderinfo.AliAuthNo);
            // 设置预授权确认模式
            bizContent.Add("auth_confirm_mode", "COMPLETE");
            bizContent.Add("enable_pay_channels", "balance");
            bizParams.Add("notify_url", App.Configuration["PaymentSettings:AlipayConfig:ALIPay_NotifyURL"]);
            bizParams.Add("biz_content", bizContent);
            Log.Information("统一收单交易接口传入信息：" + bizParams.ToJson());
            try
            {
                // 如果是第三方代调用模式，请设置app_auth_token（应用授权令牌）
                string orderStr = api.SdkExecute("alipay.trade.pay", bizParams, null, null);
                return orderStr;
            }
            catch (ApiException e)
            {
                Console.WriteLine("调用失败");
                return e.ToString();
            }

            // // 初始化SDK
            // AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            // // 构造请求参数以调用接口
            // AlipayTradeApi instance = new AlipayTradeApi();
            // instance.Client.SetAlipayConfigUtil(alipayConfigUtil);
            // AlipayTradePayModel data = new AlipayTradePayModel();
            // // 设置商户订单号
            // data.OutTradeNo = orderinfo.OrderNo;
            // // 设置订单总金额
            // data.TotalAmount = "10";
            // // 设置订单标题
            // data.Subject = "无人机租金";
            // // 设置产品码
            // data.ProductCode = "PREAUTH_PAY";
            // // 设置资金预授权单号
            // data.AuthNo = orderinfo.AliAuthNo;
            // // 设置预授权确认模式
            // data.AuthConfirmMode = "COMPLETE";
            // try
            // {
            //     var response = instance.Pay(data, 0, null);
            //     return response;
            // }
            // catch (ApiException e)
            // {
            //     AlipayTradePayDefaultResponse errorObject = (AlipayTradePayDefaultResponse)e.ErrorObject;
            //     Console.WriteLine("调用失败:" + errorObject);
            //     return "fill";
            // }
        }
        #endregion

        #region 统一收单交易关闭接口
        /// <summary>
        /// 统一收单交易关闭接口
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("ClosePay")]
        public async Task<dynamic> ClosePay(AliPayOperationCancelEntity input)
        {
            var orderinfo = _db.Queryable<UavOrderEntity>().Where(x => x.OrderNo == input.OutOrderNo).First();
            Log.Information($"[统一收单交易关闭接口]{input.OutOrderNo}订单信息{orderinfo.ToJson()}");
            if (orderinfo == null)
            {
                return new
                {
                    code = 500,
                    message = "订单不存在"
                };
            }
            AlipayConfigUtil alipayConfigUtil = new AlipayConfigUtil(GetAlipayConfig());
            // 构造请求参数以调用接口
            AlipayTradeApi instance = new AlipayTradeApi();
            instance.Client.SetAlipayConfigUtil(alipayConfigUtil);
            AlipayTradeCloseModel data = new AlipayTradeCloseModel();
            // 设置该交易在支付宝系统中的交易流水号
            // data.TradeNo = "2013112611001004680073956707";
            // 设置订单支付时传入的商户订单号
            data.OutTradeNo = orderinfo.OrderNo;
            // 设置商家操作员编号 id
            // data.OperatorId = "YX01";
            Log.Information($"[统一收单交易关闭接口]传入参数：{data.ToJson()}");
            try
            {
                var response = instance.Close(data, 0, null);
                return response;
            }
            catch (ApiException e)
            {
                AlipayTradeCloseDefaultResponse errorObject = (AlipayTradeCloseDefaultResponse)e.ErrorObject;
                Log.Information($"[统一收单交易关闭接口]失败{errorObject}");
                return "fill";
            }
        }
        #endregion
    }
}