/***********************************************************************
 *            Project: baifenBinfa
 *        ProjectName: 百分兵法管理系统                               
 *                Web: http://chuanyin.com                     
 *             Author:                                        
 *              Email:                               
 *         CreateTime: 202403/02   
 *        Description: 暂无
 ***********************************************************************/
using System;
using System.Threading.Tasks;
using System.Xml;
using CoreCms.Net.Caching.AutoMate.RedisCache;
using CoreCms.Net.Configuration;
using CoreCms.Net.IServices;
using CoreCms.Net.Loging;
using Essensoft.Paylink.Alipay;
using Essensoft.Paylink.Alipay.Notify;
using Essensoft.Paylink.Alipay.Utility;
using Google.Protobuf.WellKnownTypes;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using NLog;

namespace CoreCms.Net.Web.WebApi.Controllers.PayNotify
{
    /// <summary>
    /// 支付宝异步通知 
    /// </summary>
    [Route("Notify/[controller]/[action]")]
    public class AliPayController : ControllerBase
    {
        private readonly IAlipayNotifyClient _client;
        private readonly IRedisOperationRepository _redisOperationRepository;
        private readonly IAlipayConfigServices _alipayConfigServices;


        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="client"></param>
        /// <param name="redisOperationRepository"></param>
        /// <param name="alipayConfigServices"></param>
        public AliPayController(IAlipayNotifyClient client, IRedisOperationRepository redisOperationRepository, IAlipayConfigServices alipayConfigServices)
        {
            _client = client;
            _redisOperationRepository = redisOperationRepository;
            _alipayConfigServices = alipayConfigServices;
        }

        #region 支付宝统一回调接口
        /// <summary>
        /// APP支付统一下单支付结果通知
        /// https://api.pro.coreshop.cn/Notify/AliPay/Unifiedorder
        /// </summary>
        [HttpPost]
        [Route("m-{appid}")]
        public async Task<IActionResult> Unifiedorder([FromRoute(Name = "appid")] string appid)
        {
            try
            {
                var config = await _alipayConfigServices.QueryByClauseAsync(p => p.isDefault == true && p.isEnable == true && p.appId == appid);
                //构建linkPay请求配置实体
                var payOptions = new AlipayOptions
                {
                    AppId = config.appId,
                    AlipayPublicKey = config.publicKey,
                    AppPrivateKey = config.privateKey,
                    ServerUrl = config.serverUrl,
                    SignType = config.signType,
                    AppPublicCert = config.appPublicCert,
                    AlipayPublicCert = config.alipayPublicCert,
                    AlipayRootCert = config.alipayRootCert
                };

                var notify = await _client.ExecuteAsync<AlipayTradeAppPayNotify>(Request, payOptions);
                if (notify.TradeStatus == AlipayTradeStatus.Success)
                {
                    await _redisOperationRepository.ListLeftPushAsync(RedisMessageQueueKey.AliPayNotice, JsonConvert.SerializeObject(notify));
                    NLogUtil.WriteAll(LogLevel.Trace, LogType.Order, "支付宝支付成功回调", JsonConvert.SerializeObject(notify));
                    return AlipayNotifyResult.Success;
                }
                else
                {
                    NLogUtil.WriteAll(LogLevel.Error, LogType.Order, "支付宝支付成功回调异常", JsonConvert.SerializeObject(notify));

                }
                return NoContent();
            }
            catch (Exception ex)
            {
                NLogUtil.WriteAll(LogLevel.Error, LogType.Order, "支付宝支付成功回调异常", "统一下单支付结果通知", ex);
                return NoContent();
            }
        }

        #endregion

        #region 其他
        /// <summary>
        /// 应用网关
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [Route("m-{appid}")]

        public async Task<IActionResult> Gateway([FromRoute(Name = "appid")] string appid)
        {
            try
            {
                var config = await _alipayConfigServices.QueryByClauseAsync(p => p.isDefault == true && p.isEnable == true && p.appId == appid);
                //构建linkPay请求配置实体
                var payOptions = new AlipayOptions
                {
                    AppId = config.appId,
                    AlipayPublicKey = config.publicKey,
                    AppPrivateKey = config.privateKey,
                    ServerUrl = config.serverUrl,
                    SignType = config.signType,
                    AppPublicCert = config.appPublicCert,
                    AlipayPublicCert = config.alipayPublicCert,
                    AlipayRootCert = config.alipayRootCert
                };


                var service = Request.Form["service"].ToString();
                switch (service)
                {
                    // 激活开发者模式
                    case "alipay.service.check":
                        {
                            var options = payOptions;

                            // 获取参数
                            var parameters = await _client.GetParametersAsync(Request);
                            var sign = parameters["sign"];
                            parameters.Remove("sign");

                            var signContent = AlipaySignature.GetSignContent(parameters);

                            // 验签
                            //var isSuccess = AlipaySignature.RSACheckContent(signContent, sign, options.AlipayPublicKey, options.SignType);
                            // 验签
                            var isSuccess = AlipaySignature.RSACheckContent(signContent, sign, options.AlipayPublicKey, options.SignType);

                            // 组XML响应内容
                            //var response = MakeVerifyGWResponse(isSuccess, options.AlipayPublicKey, options.AppPrivateKey, options.SignType);
                            var response = MakeVerifyGwResponse(isSuccess, options.AlipayPublicKey, options.AppPrivateKey, options.SignType);


                            return Content(response, "text/xml");
                        }
                }

                var msg_method = Request.Form["msg_method"].ToString();
                switch (msg_method)
                {
                    // 资金单据状态变更通知
                    case "alipay.fund.trans.order.changed":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayFundTransOrderChangedNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 第三方应用授权取消消息
                    case "alipay.open.auth.appauth.cancelled":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayOpenAuthAppauthCancelledNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 用户授权取消消息
                    case "alipay.open.auth.userauth.cancelled":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayOpenAuthUserauthCancelledNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 小程序审核通过通知
                    case "alipay.open.mini.version.audit.passed":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayOpenMiniVersionAuditPassedNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 用户授权取消消息
                    case "alipay.open.mini.version.audit.rejected":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayOpenMiniVersionAuditRejectedNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 收单资金结算到银行账户，结算退票的异步通知
                    case "alipay.trade.settle.dishonoured":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayTradeSettleDishonouredNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 收单资金结算到银行账户，结算失败的异步通知
                    case "alipay.trade.settle.fail":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayTradeSettleFailNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                    // 收单资金结算到银行账户，结算成功的异步通知
                    case "alipay.trade.settle.success":
                        {
                            var notify = await _client.CertificateExecuteAsync<AlipayTradeSettleSuccessNotify>(Request, payOptions);
                            return AlipayNotifyResult.Success;
                        }
                }

                return NoContent();
            }
            catch
            {
                return NoContent();
            }
        }

        /// <summary>
        /// 扫码支付异步通知
        /// </summary>
        [HttpPost]
        [Route("m-{appid}")]

        public async Task<IActionResult> Precreate([FromRoute(Name = "appid")] string appid)
        {
            try
            {
                var config = await _alipayConfigServices.QueryByClauseAsync(p => p.isDefault == true && p.isEnable == true && p.appId == appid);
                //构建linkPay请求配置实体
                var payOptions = new AlipayOptions
                {
                    AppId = config.appId,
                    AlipayPublicKey = config.publicKey,
                    AppPrivateKey = config.privateKey,
                    ServerUrl = config.serverUrl,
                    SignType = config.signType,
                    AppPublicCert = config.appPublicCert,
                    AlipayPublicCert = config.alipayPublicCert,
                    AlipayRootCert = config.alipayRootCert
                };


                var notify = await _client.ExecuteAsync<AlipayTradeAppPayNotify>(Request, payOptions);
                if (notify.TradeStatus == AlipayTradeStatus.Success)
                {
                    await _redisOperationRepository.ListLeftPushAsync(RedisMessageQueueKey.AliPayNotice, JsonConvert.SerializeObject(notify));
                    return AlipayNotifyResult.Success;
                }
                NLogUtil.WriteAll(LogLevel.Trace, LogType.Order, "支付宝支付成功回调", JsonConvert.SerializeObject(notify));
                return NoContent();
            }
            catch (Exception ex)
            {
                NLogUtil.WriteAll(LogLevel.Trace, LogType.Order, "支付宝支付成功回调", "统一下单支付结果通知", ex);
                return NoContent();
            }
        }

        /// <summary>
        /// APP支付异步通知
        /// </summary>
        [HttpPost]
        [Route("m-{appid}")]
        public async Task<IActionResult> AppPay([FromRoute(Name = "appid")] string appid)
        {
            try
            {
                var config = await _alipayConfigServices.QueryByClauseAsync(p => p.isDefault == true && p.isEnable == true && p.appId == appid);
                //构建linkPay请求配置实体
                var payOptions = new AlipayOptions
                {
                    AppId = config.appId,
                    AlipayPublicKey = config.publicKey,
                    AppPrivateKey = config.privateKey,
                    ServerUrl = config.serverUrl,
                    SignType = config.signType,
                    AppPublicCert = config.appPublicCert,
                    AlipayPublicCert = config.alipayPublicCert,
                    AlipayRootCert = config.alipayRootCert
                };

                var notify = await _client.CertificateExecuteAsync<AlipayTradeAppPayNotify>(Request, payOptions);
                if (notify.TradeStatus == AlipayTradeStatus.Success)
                {
                    Console.WriteLine("OutTradeNo: " + notify.OutTradeNo);

                    return AlipayNotifyResult.Success;
                }
                return NoContent();
            }
            catch
            {
                return NoContent();
            }
        }

        /// <summary>
        /// 电脑网站支付异步通知
        /// </summary>
        [HttpPost]
        [Route("m-{appid}")]
        public async Task<IActionResult> PagePay([FromRoute(Name = "appid")] string appid)
        {
            try
            {
                var config = await _alipayConfigServices.QueryByClauseAsync(p => p.isDefault == true && p.isEnable == true && p.appId == appid);
                //构建linkPay请求配置实体
                var payOptions = new AlipayOptions
                {
                    AppId = config.appId,
                    AlipayPublicKey = config.publicKey,
                    AppPrivateKey = config.privateKey,
                    ServerUrl = config.serverUrl,
                    SignType = config.signType,
                    AppPublicCert = config.appPublicCert,
                    AlipayPublicCert = config.alipayPublicCert,
                    AlipayRootCert = config.alipayRootCert
                };

                var notify = await _client.CertificateExecuteAsync<AlipayTradePagePayNotify>(Request, payOptions);
                if (notify.TradeStatus == AlipayTradeStatus.Success)
                {
                    Console.WriteLine("OutTradeNo: " + notify.OutTradeNo);

                    return AlipayNotifyResult.Success;
                }
                return NoContent();
            }
            catch
            {
                return NoContent();
            }
        }

        /// <summary>
        /// 手机网站支付异步通知
        /// </summary>
        [HttpPost]
        [Route("m-{appid}")]
        public async Task<IActionResult> WapPay([FromRoute(Name = "appid")] string appid)
        {
            try
            {
                var config = await _alipayConfigServices.QueryByClauseAsync(p => p.isDefault == true && p.isEnable == true && p.appId == appid);
                //构建linkPay请求配置实体
                var payOptions = new AlipayOptions
                {
                    AppId = config.appId,
                    AlipayPublicKey = config.publicKey,
                    AppPrivateKey = config.privateKey,
                    ServerUrl = config.serverUrl,
                    SignType = config.signType,
                    AppPublicCert = config.appPublicCert,
                    AlipayPublicCert = config.alipayPublicCert,
                    AlipayRootCert = config.alipayRootCert
                };

                var notify = await _client.CertificateExecuteAsync<AlipayTradeWapPayNotify>(Request, payOptions);
                if (notify.TradeStatus == AlipayTradeStatus.Success)
                {
                    Console.WriteLine("OutTradeNo: " + notify.OutTradeNo);

                    return AlipayNotifyResult.Success;
                }
                return NoContent();
            }
            catch
            {
                return NoContent();
            }
        }

        private static string MakeVerifyGwResponse(bool isSuccess, string certPublicKey, string appPrivateKey, string signType)
        {
            var xmlDoc = new XmlDocument(); //创建实例
            var xmldecl = xmlDoc.CreateXmlDeclaration("1.0", "GBK", null);
            xmlDoc.AppendChild(xmldecl);

            var xmlElem = xmlDoc.CreateElement("alipay"); //新建元素
            xmlDoc.AppendChild(xmlElem); //添加元素

            var alipay = xmlDoc.SelectSingleNode("alipay");

            var response = xmlDoc.CreateElement("response");
            var success = xmlDoc.CreateElement("success");
            if (isSuccess)
            {
                success.InnerText = "true";//设置文本节点
                response.AppendChild(success);//添加到<Node>节点中
            }
            else
            {
                success.InnerText = "false";//设置文本节点
                response.AppendChild(success);//添加到<Node>节点中
                var err = xmlDoc.CreateElement("error_code");
                err.InnerText = "VERIFY_FAILED";
                response.AppendChild(err);
            }

            var bizContent = xmlDoc.CreateElement("biz_content");
            bizContent.InnerText = certPublicKey;
            response.AppendChild(bizContent);

            alipay.AppendChild(response);

            var sign = xmlDoc.CreateElement("sign");
            //sign.InnerText = AlipaySignature.RSASignContent(response.InnerXml, appPrivateKey, signType);
            sign.InnerText = AlipaySignature.RSASignContent(response.InnerXml, appPrivateKey, signType);

            alipay.AppendChild(sign);

            var sign_type = xmlDoc.CreateElement("sign_type");
            sign_type.InnerText = signType;
            alipay.AppendChild(sign_type);

            return xmlDoc.InnerXml;
        }



        #endregion
    }
}