from appservices.common.util import *

def generate_iv():
    iv_length = 16
    iv = os.urandom(iv_length)
    return iv

def idfc_encrypt(data_to_encrypt, secret_hex_key):
    final_encrypted_payload_base64 = ""
    try:
        raw_data_to_encrypt = json.dumps(data_to_encrypt)
        final_encrypted_payload = b''
        secret_key_hex_bytes = unhexlify(secret_hex_key)
        iv = generate_iv()
        print("Dynamic IV: ", hexlify(iv).decode())
        cipher = AES.new(secret_key_hex_bytes, AES.MODE_CBC, iv=iv)
        encrypted_bytes = cipher.encrypt(pad(raw_data_to_encrypt.encode('utf-8'), AES.block_size))
        final_encrypted_payload = iv + encrypted_bytes
        final_encrypted_payload_base64 = base64.b64encode(final_encrypted_payload).decode()
        return final_encrypted_payload_base64
    except Exception as e:
        print(traceback.format_exc())
        return final_encrypted_payload_base64

def idfc_decrypt(encrypted, secret_key):
    decrypted_text = ''
    try:
        secret_key_hex_bytes = unhexlify(secret_key)
        encrypted_combined_bytes = base64.b64decode(encrypted)
        iv = encrypted_combined_bytes[:16]
        encrypted_payload = encrypted_combined_bytes[16:]
        cipher = AES.new(secret_key_hex_bytes, AES.MODE_CBC, iv=iv)
        decrypted_bytes = unpad(cipher.decrypt(encrypted_payload), AES.block_size)
        decrypted_text = decrypted_bytes.decode()
        return decrypted_text
    except Exception as e:
        print(traceback.format_exc())
        return decrypted_text
#old code    
# def jwt_encryption_token(kid,aud_url,client_code):
#     encrypted_jwt_string = ""
#     pem_file_path = os.path.join(app.config["SITE_ROOT"], "static/assets", "graampay.pem")
#     private_key = open(pem_file_path, 'rb').read()
#     currentDate = datetime.datetime.now() + datetime.timedelta(hours=1)
#     currentdatetimestamp=int(currentDate.timestamp())
#     try:
#         jwt_headers = {
#             "alg": "RS256",
#             "typ": "JWT",
#             "kid": kid
#         }
        
#         # print(jwt_headers,"(((((((((((JWT HEADERS)))))))))))")
#         jwt_payload = {
#             "jti": str(random_digit_generate(14)),
#             "sub": client_code,
#             "iss": client_code,
#             "aud": aud_url,
#             "exp": currentdatetimestamp
#         }
#         # print(jwt_payload,"(((((((((((JWT PAYLOAD)))))))))))")
#         encrypted_jwt = jwt.encode(jwt_payload, private_key, algorithm='RS256', headers=jwt_headers)
#         encrypted_jwt_string=encrypted_jwt.decode('utf-8')
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#     return encrypted_jwt_string


def jwt_encryption_token(kid, aud_url, client_code):
    encrypted_jwt_string = ""
    pem_file_path = os.path.join(app.config["SITE_ROOT"], "static/assets", "graampay.pem")
    private_key = open(pem_file_path, 'rb').read()
    currentDate = datetime.datetime.now() + datetime.timedelta(hours=1)
    currentdatetimestamp = int(currentDate.timestamp())
    try:
        jwt_headers = {
            "alg": "RS256",
            "typ": "JWT",
            "kid": kid
        }
        
        jwt_payload = {
            "jti": str(random_digit_generate(14)),
            "sub": client_code,
            "iss": client_code,
            "aud": aud_url,
            "exp": currentdatetimestamp
        }
        
        # Directly assign the encoded JWT
        encrypted_jwt_string = jwt.encode(jwt_payload, private_key, algorithm='RS256', headers=jwt_headers)
    except Exception as e:
        app.logger.error(traceback.format_exc())
    
    return encrypted_jwt_string


def generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion):
    authorizationToken=""
    try:
        token_headers = {'Content-Type': 'application/x-www-form-urlencoded','Accept':'application/json'}
        token_payload = "grant_type="+grant_type+"&scope="+scope+"&client_id="+client_id+"&client_assertion_type="+client_assertion_type+"&client_assertion="+client_assertion

        token_response = requests.post(auth_url, data=token_payload, headers=token_headers)
        tokenResponseJsonData = json.loads(token_response.text)
        authorizationToken = tokenResponseJsonData.get("access_token")
        return authorizationToken
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return authorizationToken


###################################################### Idfc Payout API #########################################################################
def idfc_payout_fundtransfer(client_id,secretKey,kid,get_base_url,aud_url,auth_url,grant_type,scope,source,client_assertion_type,debitAcountNumber,remitterName,number,amount,transferMode,accountNo,ifscCode,beneficiaryName,address,clientOrderId,userId,payOutPaymentGatewayId,client_ip,apiType,comment,emailId):
    paymentgatewayresponseDict = {}
    try:
        requestData = {
            "initiateAuthGenericFundTransferAPIReq": {
                "tellerBranch": "",
                "tellerID": "",
                "transactionID":clientOrderId,
                "debitAccountNumber":debitAcountNumber,
                "creditAccountNumber":accountNo,
                "remitterName":remitterName,
                "amount":amount,
                "currency":"INR",
                "transactionType":transferMode,
                "paymentDescription":comment,
                "beneficiaryIFSC":ifscCode,
                "beneficiaryName":beneficiaryName,
                "beneficiaryAddress": address,
                "emailId": emailId,
                "mobileNo":number
                }
                }
        # print(requestData,"requestData")
        requestDataList=[requestData]
        save_wowpe_link_api_log_table = save_api_logs_data(userId,"payout","fund_transfer",get_base_url,payOutPaymentGatewayId,requestDataList,client_ip,apiType)
        client_assertion =jwt_encryption_token(kid,aud_url,client_id)
        # print(client_assertion,"client_assertion")
        authorizationToken=generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion)
        # print(authorizationToken,"authorizationToken")
        responseEncrypt = idfc_encrypt(requestData,secretKey)
        # print(authorizationToken,"authorizationToken")
        # print(responseEncrypt,"responseEncrypt")

        ft_headers = {
        "content-type": "application/octet-stream",
        "source": source,
        "correlationId":str(random_digit_generate(15)),
        "Authorization": "Bearer "+str(authorizationToken)
        }
        idfcRequestData=[
        {
        "requestData":requestData,
        "headers":ft_headers,
        "client_assertion":client_assertion,
        "authorizationToken":authorizationToken,
        "responseEncrypt":responseEncrypt
        }
        ]
        try:
            transactionData=[]
            ft_url = get_base_url+"paymenttxns/v1/fundTransfer"
            ftResponse = requests.post(ft_url,data=responseEncrypt, headers=ft_headers)
            print(type(ftResponse.text),"ftResponse.text")
            transactionstatus=2
            bank_reference_number=''
            transaction_id=clientOrderId
            messages=""
            transactionDate=""
            status="PROCESSING"
            if isinstance(ftResponse.text, str):
                checkdictvalue=0
                try:
                    jsonResponse = json.loads(ftResponse.text)
                    if isinstance(jsonResponse, dict):
                        checkdictvalue=1
                except Exception as e:
                    pass
                
                if checkdictvalue==0:
                    decrypted_text = idfc_decrypt(ftResponse.text, secretKey)
                    print(decrypted_text,"(((((((((((((decrypted_text)))))))))))))")
                    jsondecryptResponse = json.loads(decrypted_text)
                    print(jsondecryptResponse,"(((((((((((((jsondecryptResponse)))))))))))))")
                    transactionData=[jsondecryptResponse]
                    if jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("status") == "SUCCESS":
                        if jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("resourceData").get("status") == "ACPT":
                            transaction_id=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("resourceData").get("transactionID")
                            bank_reference_number=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("resourceData").get("transactionReferenceNo")
                            messages=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("message")
                            transactionDate=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("time")
                            transactionstatus=1
                            status="SUCCESS"
                        else:
                            transactionstatus=2
                            messages=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("message")
                            transactionDate=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("time")
                            status="PROCESSING"
                    else:
                        transactionstatus=2
                        messages=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("message")
                        transactionDate=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("time")
                        status="PROCESSING"
                else:
                    jsonResponse = json.loads(ftResponse.text)
                    transactionData=[jsonResponse]
                    transactionstatus=2
                    messages=jsonResponse.get('details')
                    status="PROCESSING"
            else:
                jsonResponse = json.loads(ftResponse.text)
                transactionData=[jsonResponse]
                transactionstatus=2
                messages=jsonResponse.get('details')
                status="PROCESSING"
            save_wowpe_link_api_log_table.update(responseData=transactionData,responseDate=datetime.datetime.now())
            paymentgatewayresponseDict={
            "responseStatus":1,
            'transactionstatus':transactionstatus,
            'status':status,
            "messages":messages,
            "bank_reference_number":bank_reference_number,
            "transaction_id":transaction_id,
            "transactionData":transactionData,
            "transactionDate":transactionDate,
            "requestData":idfcRequestData
            }
            return paymentgatewayresponseDict
        except Exception as e:
            app.logger.error(traceback.format_exc())
            paymentgatewayresponseDict["responseStatus"]=0
            paymentgatewayresponseDict['result']="Our banking partner server is down please try after sometime!!"
            return paymentgatewayresponseDict
    except Exception as e:
        app.logger.error(traceback.format_exc())
        paymentgatewayresponseDict["responseStatus"]=0
        paymentgatewayresponseDict['result']="Our banking partner server is down please try after sometime!!"
        return paymentgatewayresponseDict

###################################################### Idfc Payout Status API #########################################################################
def idfc_payout_fundtransfer_status(source,kid,aud_url,auth_url,grant_type,scope,client_id,client_assertion_type,fund_transfer_queryset,secretKey,get_base_url):
    paymentgatewayResponseStatusDict = {}
    responseBody = {}
    transactionDate = fund_transfer_queryset.createdOn
    # Parse the string into a datetime object
    # dt_object = datetime.datetime.strptime(transactionDate, "%Y-%m-%dT%H:%M:%S.%fZ")
    # Convert to a timestamp and then to an integer
    # intdatetimestamp = int(dt_object.timestamp())

    # print(intdatetimestamp,"intdatetimestamp")

    # Format the datetime object to only get day, month, and year
    # print(dt_object,"((((((((((((((dt_object))))))))))))))")
    date_str = transactionDate.strftime("%d%m%Y")

    print(date_str,"DATE STRING")  # Output will be '21092024'
    try:
        transactionReferenceNumber=""
        paymentReferenceNumber=""
        if fund_transfer_queryset.paymentMode=="IMPS":
            transactionReferenceNumber=fund_transfer_queryset.transactionUniqueId
            paymentReferenceNumber=""
        else:
            transactionReferenceNumber=fund_transfer_queryset.transactionUniqueId
            paymentReferenceNumber=fund_transfer_queryset.bankReferenceNumber

        requestBody = {
        "paymentTransactionStatusReq":{
        "tellerBranch":"",
        "tellerID":"",
        "transactionType":fund_transfer_queryset.paymentMode,
        "transactionReferenceNumber":transactionReferenceNumber,
        "paymentReferenceNumber":paymentReferenceNumber,
        "transactionDate":str(date_str)
        }
        }
        client_assertion =jwt_encryption_token(kid,aud_url,client_id)
        # print(client_assertion,"client_assertion")
        authorizationToken=generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion)
        # print(authorizationToken,"authorizationToken")
        responseEncrypt = idfc_encrypt(requestBody,secretKey)
        # print(authorizationToken,"authorizationToken")
        headers = {
            "content-type": "application/octet-stream",
            "source":source,
            "correlationId":fund_transfer_queryset.requestData[0].get('headers').get('correlationId'),
            "Authorization": "Bearer "+str(authorizationToken)
        }
        url = get_base_url+"paymentenqs/v1/paymentTransactionStatus"
        print(requestBody,"((((((((((((((((requestBody))))))))))))))))")
        print(headers,"((((((((((((((((headers))))))))))))))))")
        print(url,"((((((((((((((((url))))))))))))))))")
        try:
            ftResponse = requests.post(url, data=responseEncrypt,headers=headers)
            print(ftResponse.text,"((((((((((RESPONSE TEXT))))))))))")
            if not isinstance(ftResponse.text, str):
                transactionData = [ftResponse.text]
                paymentgatewayResponseStatusDict = {
                "responseStatus":2,
                "result":"No Update!!",
                "transaction_id":fund_transfer_queryset.transactionUniqueId
                }
                return paymentgatewayResponseStatusDict
            else:
                checkdictvalue=0
                try:
                    jsonResponse = json.loads(ftResponse.text)
                    if isinstance(jsonResponse, dict):
                        checkdictvalue=1
                except Exception as e:
                    pass
                if  checkdictvalue==0:
                    bankReferenceNumber=""
                    transactionUniqueId=""
                    transactionstatus=2
                    textStatus="PROCESSING"
                    decrypted_text = idfc_decrypt(ftResponse.text, secretKey)
                    print(decrypted_text,"(((((((((((((decrypted_text)))))))))))))")
                    jsondecryptResponse = json.loads(decrypted_text)
                    print(jsondecryptResponse,"(((((((((((((jsondecryptResponse)))))))))))))")
                    transactionData = [jsondecryptResponse]

                    if jsondecryptResponse.get("paymentTransactionStatusResp").get("metaData").get("status") == "SUCCESS":
                        transactionUniqueId=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData").get("transactionReferenceNumber")
                        bankReferenceNumber=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData").get("paymentReferenceNumber")
                        transactionType=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData").get("transactionType")
                        # messages=jsondecryptResponse.get("paymentTransactionStatusResp").get("metaData").get("message")
                        if transactionType=="IMPS":
                            respStatus=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData").get("status")
                            respCode=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData").get("respCode")
                            messages=respStatus
                            if respCode == "A":
                                transactionstatus=1
                                textStatus="SUCCESS"
                            elif respCode == "F" or respCode=="D":
                                transactionstatus=0
                                textStatus="FAILED"
                            elif respCode == "S" or respCode=="T":
                                if respStatus=="RET" or respStatus=="Failed":
                                    transactionstatus=0
                                    textStatus="FAILED"
                                elif respStatus=="Refunded":
                                    transactionstatus=4
                                    textStatus="REVERSAL"
                                else:
                                    transactionstatus=1
                                    textStatus="SUCCESS"
                            elif respCode=="V" or respCode=="R":
                                paymentgatewayResponseStatusDict = {
                                "responseStatus":2,
                                "result":"No Update!!",
                                "transaction_id":fund_transfer_queryset.transactionUniqueId
                                }
                                return paymentgatewayResponseStatusDict
                            else:
                                paymentgatewayResponseStatusDict = {
                                "responseStatus":2,
                                "result":"No Update!!",
                                "transaction_id":fund_transfer_queryset.transactionUniqueId
                                }
                                return paymentgatewayResponseStatusDict
                        else:
                            resourceData=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData")
                            if "utrNumber" in resourceData:
                                errorID=resourceData.get('errorID')
                                if errorID=="0":
                                    transactionstatus=1
                                    textStatus="SUCCESS"
                                    messages="Success"
                                else:
                                    transactionstatus=0
                                    textStatus="FAILED"
                                    messages=resourceData.get('errorMessage')
                            else:
                                status1=jsondecryptResponse.get("paymentTransactionStatusResp").get("resourceData").get("status1")
                                messages=status1
                                if status1=="ACKNOWLEDGED":
                                    transactionstatus=1
                                    textStatus="SUCCESS"
                                elif status1=="RETURNED/UNPAID" or status1=="REVERSED":
                                    transactionstatus=4
                                    textStatus="REVERSAL"
                                else:
                                    paymentgatewayResponseStatusDict = {
                                    "responseStatus":2,
                                    "result":"No Update!!",
                                    "transaction_id":fund_transfer_queryset.transactionUniqueId
                                    }
                                    return paymentgatewayResponseStatusDict
                    else:
                        errorCode=jsondecryptResponse.get("paymentTransactionStatusResp").get("metaData").get("code")
                        if errorCode=="CBS:188" or errorCode=="EXP_400":
                            transactionData = [jsondecryptResponse]
                            paymentgatewayResponseStatusDict = {
                            "responseStatus":2,
                            "result":"No Update!!",
                            "transaction_id":fund_transfer_queryset.transactionUniqueId
                            }
                            return paymentgatewayResponseStatusDict
                        else:
                            transactionstatus=0
                            textStatus="FAILED"
                            transactionUniqueId=fund_transfer_queryset.transactionUniqueId
                            bankReferenceNumber=fund_transfer_queryset.bankReferenceNumber
                            messages=jsondecryptResponse.get("paymentTransactionStatusResp").get("metaData").get("message") 
                    paymentgatewayResponseStatusDict ={
                    "responseStatus":1,
                    "transactionStatus":transactionstatus,
                    "bankReferenceNumber":bankReferenceNumber,
                    "textStatus":textStatus,
                    "error_message":messages,
                    "transaction_id":transactionUniqueId,
                    "transactionData":transactionData
                    }
                    return paymentgatewayResponseStatusDict
                else:
                    transactionData = [ftResponse.text]
                    paymentgatewayResponseStatusDict = {
                    "responseStatus":2,
                    "result":"No Update!!",
                    "transaction_id":fund_transfer_queryset.transactionUniqueId
                    }
                    return paymentgatewayResponseStatusDict
        except Exception as e:
            app.logger.error(traceback.format_exc())
            paymentgatewayResponseStatusDict["responseStatus"]=0
            paymentgatewayResponseStatusDict["result"]="Our banking partner server is down please try after sometime!!"
            return paymentgatewayResponseStatusDict
    except Exception as e:
        app.logger.error(traceback.format_exc())
        paymentgatewayResponseStatusDict["responseStatus"]=0
        paymentgatewayResponseStatusDict["result"]="Our banking partner server is down please try after sometime!!"
        return paymentgatewayResponseStatusDict    


def idfc_get_payout_account_balance(debitAcountNumber,source,kid,aud_url,client_id,auth_url,grant_type,scope,client_assertion_type,secretKey):
    currentBalanceDict = {"responseStatus":0,"result":""}
    try:
        requestBody ={
            "prefetchAccountReq": {
                "CBSTellerBranch": "",
                "CBSTellerID": "",
                "accountNumber":str(debitAcountNumber)
                }
            }
        client_assertion =jwt_encryption_token(kid,aud_url,client_id)
        authorizationToken=generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion)
        responseEncrypt = idfc_encrypt(requestBody,secretKey)

        headers = {
            "content-type": "application/octet-stream",
            "source":source,
            "correlationId":str(random_digit_generate(15)),
            "Authorization": "Bearer "+str(authorizationToken)
        }

        url = "https://apiext.liab.idfcfirstbank.com/acctenq/v2/prefetchAccount"
        ftResponse = requests.post(url, data=responseEncrypt,headers=headers)
        print(ftResponse.text,"((((((((((RESPONSE TEXT))))))))))")

        checkdictvalue=0
        try:
            jsonResponse = json.loads(ftResponse.text)
            if isinstance(jsonResponse, dict):
                checkdictvalue=1
        except Exception as e:
            pass
        if  checkdictvalue==0:
            decrypted_text = idfc_decrypt(ftResponse.text, secretKey)
            print(decrypted_text,"(((((((((((((decrypted_text)))))))))))))")
            jsondecryptResponse = json.loads(decrypted_text)
            print(jsondecryptResponse,"(((((((((((((jsondecryptResponse)))))))))))))")

            if jsondecryptResponse.get("prefetchAccountResp").get("metaData").get("status") == "SUCCESS":
                accountNumber = jsondecryptResponse.get("prefetchAccountResp").get("resourceData").get("accountNumber")
                availableBalance = jsondecryptResponse.get("prefetchAccountResp").get("resourceData").get("availableBalance")

                currentBalanceDict["responseStatus"]=1
                currentBalanceDict["accountNumber"]=accountNumber
                currentBalanceDict["availableBalance"]=availableBalance
                return currentBalanceDict
            else:
                currentBalanceDict["status"]=jsondecryptResponse.get("prefetchAccountResp").get("metaData").get("status")
                currentBalanceDict["message"]=jsondecryptResponse.get("prefetchAccountResp").get("metaData").get("message")
                return currentBalanceDict
    except Exception as e:
        app.logger.error(traceback.format_exc())
        currentBalanceDict["result"]="Our banking partner server is down please try after sometime!!"
        return currentBalanceDict

def idfc_benivalidation(source,kid,aud_url,client_id,auth_url,grant_type,scope,client_assertion_type,secretKey,ifscCode,accountNo,debitAcountNumber,remitterName,remitter_mobile_number,comment,transactionId):
    benivalidationDict = {"responseStatus":0,"result":""}
    try:
        requestBody ={
            "beneValidationReq": {
                "remitterName": remitterName,
                "remitterMobileNumber": str(remitter_mobile_number),
                "debtorAccountId": str(debitAcountNumber),
                "accountType": "00",
                "creditorAccountId": str(accountNo),
                "ifscCode": str(ifscCode),
                "paymentDescription": comment,
                "transactionReferenceNumber": transactionId,
                "merchantCode": "4814",
                "identifier": "IMPS2.0"
            }
        }
        client_assertion =jwt_encryption_token(kid,aud_url,client_id)
        authorizationToken=generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion)
        responseEncrypt = idfc_encrypt(requestBody,secretKey)
        print(client_assertion,"client_assertion")
        print(authorizationToken,"authorizationToken")
        print(authorizationToken,"authorizationToken")
        print(responseEncrypt,"RESPONSE ENCRYPT")
        headers = {
            "content-type": "application/octet-stream",
            "source":source,
            "correlationId":str(random_digit_generate(15)),
            "Authorization": "Bearer "+str(authorizationToken)
        }
        url = "https://apiext.payments.idfcfirstbank.com/paymentenqs/v1/beneValidation"
        ftResponse = requests.post(url, data=responseEncrypt,headers=headers)
        print(ftResponse,"((((((((((BENIVALIDATION RESPONSE))))))))))")
        print(ftResponse.text,"((((((((((BENIVALIDATION RESPONSE TEXT))))))))))")
        beniValidationData = [ftResponse.text]
        checkdictvalue=0
        try:
            jsonResponse = json.loads(ftResponse.text)
            if isinstance(jsonResponse, dict):
                checkdictvalue=1
        except Exception as e:
            pass
        if  checkdictvalue==0:
            decrypted_text = idfc_decrypt(ftResponse.text, secretKey)
            jsondecryptResponse = json.loads(decrypted_text)
            print(jsondecryptResponse,"(((((((((((((BENIVALIDATION jsondecryptResponse)))))))))))))")
            beniValidationData = [jsondecryptResponse]

            if jsondecryptResponse.get("beneValidationResp").get("metaData").get("status") == "SUCCESS":
                creditorAccountId = jsondecryptResponse.get("beneValidationResp").get("resourceData").get("creditorAccountId")
                creditorName = jsondecryptResponse.get("beneValidationResp").get("resourceData").get("creditorName")
                transactionReferenceNumber = jsondecryptResponse.get("beneValidationResp").get("resourceData").get("transactionReferenceNumber")
                
                benivalidationDict["responseStatus"]=1
                benivalidationDict["beniValidationData"]=beniValidationData
                benivalidationDict["creditorAccountId"]=creditorAccountId
                benivalidationDict["creditorName"]=creditorName
                benivalidationDict["transactionReferenceNumber"]=transactionReferenceNumber
                return benivalidationDict
            else:
                benivalidationDict["status"]=jsondecryptResponse.get("beneValidationResp").get("metaData").get("status")
                benivalidationDict["message"]=jsondecryptResponse.get("beneValidationResp").get("metaData").get("message")
                benivalidationDict["beniValidationData"]=beniValidationData
                return benivalidationDict
    except Exception as e:
        app.logger.error(traceback.format_exc())
        benivalidationDict["result"]="Our banking partner server is down please try after sometime!!"
        return benivalidationDict

def idfc_beni_creation(source,kid,aud_url,client_id,auth_url,grant_type,scope,client_assertion_type,secretKey,ifscCode,accountNo):
    beniCreationDict = {"responseStatus":0,"result":""}
    try:
        requestBody ={
            "createBeneficiaryReq": {
                "msgHdr": {
                    "msgId":str(random_digit_generate(15)),
                    "cnvId":str(random_digit_generate(15)),
                    "extRefId":"GIGA BENEFITS_PymntTrnsctn",
                    "bizObjId":str(random_digit_generate(15)),
                    "appId":str(random_digit_generate(15)),
                    "timestamp":datetime.datetime.now()
                },
                "msgBdy":{
                    "beneficiaryAddReq":{
                        "beneId":"BENI"+str(random_digit_generate(15)),
                        "clientCd":"CL"+str(random_digit_generate(15)),
                        "IFSC":ifscCode,
                        "crAcctNo":accountNo,
                        "beneAcctType":"",
                        "beneNm":"",
                        "beneMobileNo":"",
                        "beneEmailAdd":"",
                        "addr1":"",
                        "addr2":"",
                        "addr3":"",
                        "limitPerDay":"",
                        "limitPerTxn":"",
                        "limitPerMnth":"",
                        "expiryPeriod":"",
                        "strtDt":"",
                        "endDt":""
                    }
                }
            }
        }
        client_assertion =jwt_encryption_token(kid,aud_url,client_id)
        authorizationToken=generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion)
        responseEncrypt = idfc_encrypt(requestBody,secretKey)

        headers = {
            "content-type": "application/octet-stream",
            "source":source,
            "correlationId":str(random_digit_generate(15)),
            "Authorization": "Bearer "+str(authorizationToken),
            "msgId":str(random_digit_generate(15)),
            "cnvId":str(random_digit_generate(15)),
            "extRefId":"GIGA BENEFITS_PymntTrnsctn",
            "bizObjId":str(random_digit_generate(6)),
            "appId":str(random_digit_generate(6)),
            "Timestamp":datetime.datetime.now()
        }

        url = "https://api.idfcbank.com/SWINKPAY/beneficairyregistration"
        ftResponse = requests.post(url, data=responseEncrypt,headers=headers)
        print(ftResponse.text,"((((((((((RESPONSE TEXT))))))))))")
        transactionData = [ftResponse.text]
        checkdictvalue=0
        try:
            jsonResponse = json.loads(ftResponse.text)
            if isinstance(jsonResponse, dict):
                checkdictvalue=1
        except Exception as e:
            pass
        if  checkdictvalue==0:
            decrypted_text = idfc_decrypt(ftResponse.text, secretKey)
            print(decrypted_text,"(((((((((((((decrypted_text)))))))))))))")
            jsondecryptResponse = json.loads(decrypted_text)
            print(jsondecryptResponse,"(((((((((((((jsondecryptResponse)))))))))))))")
            transactionData = [jsondecryptResponse]

            if jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("errorCd") == "BEN000":
                beneId = jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("beneId")
                clientCd = jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("clientCd")
                beneNm = jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("beneNm")
                stsDesc = jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("stsDesc")
                
                beniCreationDict["responseStatus"]=1
                beniCreationDict["beneId"]=beneId
                beniCreationDict["clientCd"]=clientCd
                beniCreationDict["beneNm"]=beneNm
                beniCreationDict["stsDesc"]=stsDesc
                return beniCreationDict
            else:
                beniCreationDict["status"]=jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("errorCd")
                beniCreationDict["message"]=jsondecryptResponse.get("createBeneficiaryResp").get("msgBdy").get("beneficiaryAddResp").get("stsDesc")
                return beniCreationDict
    except Exception as e:
        app.logger.error(traceback.format_exc())
        beniCreationDict["result"]="Our banking partner server is down please try after sometime!!"
        return beniCreationDict


def idfc_bulk_payout_fundtransfer(client_id,secretKey,kid,get_base_url,aud_url,auth_url,grant_type,scope,source,client_assertion_type,debitAcountNumber,remitterName,prepareBulkfundtransferList,bulk_transactionId):
    paymentgatewayresponseDict = {}
    try:
        for each_idfc_record in prepareBulkfundtransferList:
            req_amount=each_idfc_record.get("amount")
            req_bene_code = each_idfc_record.get("beneCode")
            req_account_number = each_idfc_record.get("account_number")
            req_account_name = each_idfc_record.get("account_name")
            req_ifsc_code = each_idfc_record.get("ifsc_code")
            req_transfer_type = each_idfc_record.get("txnPaymode")
            req_bank_name = each_idfc_record.get("bank_name","")
            req_customer_email = each_idfc_record.get("customer_email","")
            req_customer_phone = each_idfc_record.get("customer_phone","")
            req_remark = each_idfc_record.get("req_remark","")
            clientOrderId = each_idfc_record.get("custUniqRef")

            requestData = {
                "initiateAuthGenericFundTransferAPIReq": {
                    "tellerBranch": "",
                    "tellerID": "",
                    "transactionID":clientOrderId,
                    "debitAccountNumber":debitAcountNumber,
                    "creditAccountNumber":req_account_number,
                    "remitterName":remitterName,
                    "amount":req_amount,
                    "currency":"INR",
                    "transactionType":req_transfer_type,
                    "paymentDescription":req_remark,
                    "beneficiaryIFSC":req_ifsc_code,
                    "beneficiaryName":req_account_name,
                    "beneficiaryAddress": "",
                    "emailId": req_customer_email,
                    "mobileNo":req_account_number
                    }
                    }
            # print(requestData,"requestData")
            # requestDataList=[requestData]
            # save_wowpe_link_api_log_table = save_api_logs_data(userId,"payout","fund_transfer",get_base_url,payOutPaymentGatewayId,requestDataList,client_ip,apiType)
            client_assertion =jwt_encryption_token(kid,aud_url,client_id)
            # print(client_assertion,"client_assertion")
            authorizationToken=generate_auth_token(auth_url,grant_type,scope,client_id,client_assertion_type,client_assertion)
            # print(authorizationToken,"authorizationToken")
            responseEncrypt = idfc_encrypt(requestData,secretKey)
            # print(authorizationToken,"authorizationToken")
            # print(responseEncrypt,"responseEncrypt")

            ft_headers = {
            "content-type": "application/octet-stream",
            "source": source,
            "correlationId":str(random_digit_generate(15)),
            "Authorization": "Bearer "+str(authorizationToken)
            }
            idfcRequestData=[
            {
            "requestData":requestData,
            "headers":ft_headers,
            "client_assertion":client_assertion,
            "authorizationToken":authorizationToken,
            "responseEncrypt":responseEncrypt
            }
            ]
            try:
                transactionData=[]
                ft_url = get_base_url+"paymenttxns/v1/fundTransfer"
                ftResponse = requests.post(ft_url,data=responseEncrypt, headers=ft_headers)
                print(type(ftResponse.text),"ftResponse.text")
                transactionstatus=2
                bank_reference_number=''
                transaction_id=clientOrderId
                messages=""
                transactionDate=""
                status="PROCESSING"
                if isinstance(ftResponse.text, str):
                    checkdictvalue=0
                    try:
                        jsonResponse = json.loads(ftResponse.text)
                        if isinstance(jsonResponse, dict):
                            checkdictvalue=1
                    except Exception as e:
                        pass
                    
                    if checkdictvalue==0:
                        decrypted_text = idfc_decrypt(ftResponse.text, secretKey)
                        print(decrypted_text,"(((((((((((((decrypted_text)))))))))))))")
                        jsondecryptResponse = json.loads(decrypted_text)
                        print(jsondecryptResponse,"(((((((((((((jsondecryptResponse)))))))))))))")
                        transactionData=[jsondecryptResponse]
                        if jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("status") == "SUCCESS":
                            if jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("resourceData").get("status") == "ACPT":
                                transaction_id=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("resourceData").get("transactionID")
                                bank_reference_number=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("resourceData").get("transactionReferenceNo")
                                messages=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("message")
                                transactionDate=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("time")
                                transactionstatus=1
                                status="SUCCESS"
                            else:
                                transactionstatus=2
                                messages=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("message")
                                transactionDate=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("time")
                                status="PROCESSING"
                        else:
                            transactionstatus=2
                            messages=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("message")
                            transactionDate=jsondecryptResponse.get("initiateAuthGenericFundTransferAPIResp").get("metaData").get("time")
                            status="PROCESSING"
                    else:
                        jsonResponse = json.loads(ftResponse.text)
                        transactionData=[jsonResponse]
                        transactionstatus=2
                        messages=jsonResponse.get('details')
                        status="PROCESSING"
                else:
                    jsonResponse = json.loads(ftResponse.text)
                    transactionData=[jsonResponse]
                    transactionstatus=2
                    messages=jsonResponse.get('details')
                    status="PROCESSING"
                # save_wowpe_link_api_log_table.update(responseData=transactionData,responseDate=datetime.datetime.now())

                paymentgatewayresponseDict={
                "responseStatus":1,
                'transactionstatus':transactionstatus,
                'status':status,
                "messages":messages,
                "bank_reference_number":bank_reference_number,
                "transaction_id":transaction_id,
                "transactionData":transactionData,
                "transactionDate":transactionDate,
                "requestData":idfcRequestData
                }
                return paymentgatewayresponseDict
            except Exception as e:
                app.logger.error(traceback.format_exc())
                paymentgatewayresponseDict["responseStatus"]=0
                paymentgatewayresponseDict['result']="Our banking partner server is down please try after sometime!!"
                return paymentgatewayresponseDict
    except Exception as e:
        app.logger.error(traceback.format_exc())
        paymentgatewayresponseDict["responseStatus"]=0
        paymentgatewayresponseDict['result']="Our banking partner server is down please try after sometime!!"
        return paymentgatewayresponseDict