from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import base64
def decrypt(nonce, ciphertext, associated_data):
    key = "Your32Apiv3Key"
    key_bytes = str.encode(key)
    nonce_bytes = str.encode(nonce)
    ad_bytes = str.encode(associated_data)
    data = base64.b64decode(ciphertext)
    aesgcm = AESGCM(key_bytes)
    return aesgcm.decrypt(nonce_bytes, data, ad_bytes)

{code : 200}

- (void)requestPayment:(TMFMiniAppInfo *)app params:(NSDictionary *)params completionHandler:(MACommonCallback)completionHandler {
    [TUITool makeToast:@"Prepare to pay..."];
    // Request the App backend based on the params parameters passed in by the mini program
    [[TCMPPDemoPayManager sharedInstance] checkPreOrder:params completionHandler:^(NSError * _Nullable err, PayResponseData * _Nullable result) {
        [TUITool hideToastActivity];
        if (!err) {
        // The request succeeded，and the payment native page pops up
            dispatch_async(dispatch_get_main_queue(), ^{
                TCMPPPaymentMethodsController *payMethodVC = [[TCMPPPaymentMethodsController alloc]init];
                payMethodVC.payResponseData = result;
                payMethodVC.app = app;
                [[[TCMPPShareMiniAppModule sharedInstance] topViewController].navigationController pushViewController:payMethodVC animated:NO];
                payMethodVC.completeHandle = ^(NSDictionary * _Nullable result, NSError * _Nullable error) {
                // Complete payment and call back to the mini program
                    completionHandler(result,error);
                };
            });
        } else {
        // The request failed, payment was not completed, and the callback was sent to the mini program
            NSDictionary *retDic = @{@"retmsg":err.localizedDescription};
            if (result.returnCode && result.returnMessage) {
                retDic = @{@"returnCode":result.returnCode,@"returnMessage":result.returnMessage};
            }
            completionHandler(retDic,err);
        }
    }];
}

@ProxyService(proxy = MiniOpenApiProxy.class)
public class MiniOpenApiProxyV2Impl extends MiniOpenApiProxy {
    private static final String TAG = "MiniOpenApiProxy";

    @Override
    public void requestPayment(IMiniAppContext miniAppContext, JSONObject params, AsyncResult result) {
        PaymentManagerV2.g().startPayment(miniAppContext, params, result);
    }
}

public class PaymentManagerV2 {
    private static final String TAG = "PaymentManager";
    private static PaymentManagerV2 instance;
    private final PayApiV2 payApi = new PayApiV2();
    private PaymentRequest paymentRequest;

    public static PaymentManagerV2 g() {
        if (instance == null) {
            instance = new PaymentManagerV2();
        }
        return instance;
    }

    public void startPayment(IMiniAppContext miniAppContext, JSONObject params, AsyncResult result) {
        // do params check
        if (params.has("prepayId")) {
            checkOrder(miniAppContext, params, result);
        } else {
            JSONObject failRet = new JSONObject();
            try {
                failRet.put("success", false);
            } catch (JSONException e) {
            }
            result.onReceiveResult(false, failRet);
        }
    }

    /**
     * STEP 1: check order status
     *
     * @param miniAppContext
     * @param params
     * @param result
     */
    private void checkOrder(IMiniAppContext miniAppContext, JSONObject params, AsyncResult result) {
        String appId = miniAppContext.getMiniAppInfo().appId;
        Activity activity = miniAppContext.getAttachedActivity();
        payApi.checkOrder(appId, params, new PayApiV2.PayCallBack() {
            @Override
            public void onSuccess(JSONObject checkRet) {
                String fee = checkRet.optString("actualAmount");
                double paymentValue = Double.parseDouble(fee) / 10000;
                showPayTypeList(activity, paymentValue, checkRet.toString());
                paymentRequest = new PaymentRequest(miniAppContext, checkRet, result, paymentValue);
                Log.e("TAG", "payment request " + this.hashCode());
            }

            @Override
            public void onFailed(String errCode, String msg) {
                Log.e(TAG, "pay failed " + msg);
                activity.runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(miniAppContext.getContext(), "failed", Toast.LENGTH_SHORT).show();
                    }
                });
                result.onReceiveResult(false, new JSONObject());
            }
        });
    }

    /**
     * STEP 2: show pwd dialog
     *
     * @param activity
     * @param money
     */
    private void showPwdDialog(Activity activity, double money, ICustomPayCallback payCallback, int iconSrc,
            String desc) {
        CustomPayDemo.CustomPayDialog customPayDialog = new CustomPayDemo.CustomPayDialog(activity, money,
                R.style.MyAlertDialog, iconSrc, desc);
        customPayDialog.addPayResultListen(payCallback);
        customPayDialog.show();
    }

    /**
     * STEP 3: confirm pwd input and check pwd
     *
     * @param activity
     * @param pwd
     * @param data
     * @param result
     */
    private void checkPwdAndPay(Activity activity, String pwd, JSONObject data, AsyncResult result, String payModel,
            String payModelId) {
        if (checkPassWord(pwd)) {
            requestPayment(activity, data, result, payModel, payModelId);
        } else {
            JSONObject ret = new JSONObject();
            try {
                ret.put("errMsg", "bad pwd ");
            } catch (JSONException e) {
            }
            result.onReceiveResult(false, ret);
            activity.finish();
        }
    }

    private boolean checkPassWord(String pwd) {
        return "666666".equals(pwd);
    }

    /**
     * STEP 4: request payment
     *
     * @param activity
     * @param data
     * @param asyncResult
     */
    private void requestPayment(Activity activity, JSONObject data, AsyncResult asyncResult, String payModel, String paymdelId) {
        payApi.payOrder(data, new PayApiV2.PayCallBack() {
            @Override
            public void onSuccess(JSONObject result) {wei
                String totalFee = result.optString("paymentAmount");
                showPayResult(true, activity, totalFee);
                JSONObject resultToJs = result.optJSONObject("data");
                asyncResult.onReceiveResult(true, resultToJs);
            }


            @Override
            public void onFailed(String errCode, String msg) {
                JSONObject ret = new JSONObject();
                try {
                    ret.put("errMsg", msg);
                    ret.put("errCode", errCode);
                } catch (JSONException e) {
                }
                asyncResult.onReceiveResult(false, ret);
                activity.finish();
            }
        }, payModel, paymdelId);
    }

    private void showPayResult(boolean success, Activity activity, String total) {
        Intent intent = new Intent(activity, PaymentResultActivity.class);
        intent.putExtra("success", success);
        intent.putExtra("total", total);
        intent.putExtra("isV2", true);
        activity.startActivity(intent);
        activity.finish();
    }

    private void showPayTypeList(Activity activity, double total, String rawData) {
        Intent intent = new Intent(activity, PaymentMethodActivity.class);
        intent.putExtra("totalFee", total);
        intent.putExtra("rawData", rawData);
        activity.startActivity(intent);
    }

    public void showPwdConfirm(Activity activity, int iconSrc, String desc, String model, String modelId) {
        if (null != paymentRequest) {
            AsyncResult result = paymentRequest.result;
            JSONObject checkRet = paymentRequest.params;
            try {
                checkRet.put("appId", paymentRequest.miniAppContext.getMiniAppInfo().appId);
            } catch (JSONException | NullPointerException e) {
            }
            showPwdDialog(activity, paymentRequest.payValue, (retCode, msg, dialogInterface) -> {
                if (retCode == 1) {
                    String pwd = ((CustomPayDemo.CustomPayDialog) dialogInterface).getInputText();
                    Log.e(TAG, "onDismiss isComplete=" + pwd);
                    if (!TextUtils.isEmpty(pwd)) {
                        checkPwdAndPay(activity, pwd, checkRet, result, model, modelId);
                    } else {
                        Log.e(TAG, "empty pwd ~");
                        JSONObject ret = new JSONObject();
                        try {
                            ret.put("errMsg", "empty pws");
                        } catch (JSONException e) {
                        }
                        result.onReceiveResult(false, ret);
                        activity.finish();
                    }
                    paymentRequest = null;
                }
            }, iconSrc, desc);
        }
    }

    public void notifyPaymentCancel() {
        if (null != paymentRequest) {
            JSONObject ret = new JSONObject();
            try {
                ret.put("errMsg", "cancel");
            } catch (JSONException e) {
            }
            paymentRequest.result.onReceiveResult(false, ret);
            paymentRequest = null;
        }
    }

    private static class PaymentRequest {
        public IMiniAppContext miniAppContext;
        public JSONObject params;
        public AsyncResult result;
        public double payValue = 0f;

        public PaymentRequest(IMiniAppContext miniAppContext, JSONObject params, AsyncResult result, double payValue) {
            this.miniAppContext = miniAppContext;
            this.params = params;
            this.result = result;
            this.payValue = payValue;

        }
    }
}