var accountsPublicKeyURL = "/accounts/p/40-10071243359/getPayloadEncryptionPublicKey";
var encWithTimeStamp = Boolean("");
var CurrentTime;
var difference_time;
var encryptData = {
	isValidData : function(instr){
		return instr != null && instr != "" && instr != "null";
	},
	loadFile : function(url){
		var docHead = document.head || document.getElementsByTagName("head" )[0] || document.documentElement; 
		var script = document.createElement("script"); 
		script.src = url;
		docHead.appendChild(script); 
	},
	enabled : Boolean(""),
	encrypt : function(encDataArray,Base64decodeNeed, encryptionvalue){
		return new Promise(function(resolve, reject) {
			var OnlyValidData = [];
			var i=0;
			if(encryptData.isValidData(encDataArray)){
				encDataArray.forEach(function(validData){
					if(encryptData.isValidData(validData)){
						OnlyValidData[i] = validData;
						i++;
					}
				});
			}
			if(!encryptData.enabled || typeof ZASEC  == "undefined" || !encryptData.isValidData(encDataArray) || !encryptData.isValidData(encryptionvalue)){
				resolve(OnlyValidData);
				return (encryptData.isValidData(OnlyValidData.length) ? OnlyValidData : encDataArray);
			}
			var promises = [];
			promises.push(ZASEC.Encryption.encryptData(OnlyValidData,"common",ZASEC.configuration.setCSRF({paramName: "iamcsrcoo",cookieName: "iamcsr"})));
	        checkDefine();
        	Promise.allSettled(promises).then(function(encDataArray){
        		if(encryptData.isValidData(encDataArray[0].value) && Base64decodeNeed){
					encDataArray[0].value.data = window.btoa(encDataArray[0].value.data);
				}
				resolve(encDataArray);
			}).catch(function(error) {
				reject(error);
			});
		});
	}
}
function xhr() {
    var xmlhttp;
    if (window.XMLHttpRequest) {
	xmlhttp=new XMLHttpRequest();
    }
    else if(window.ActiveXObject) {
		try {
		    xmlhttp=new ActiveXObject("Msxml2.XMLHTTP");
		}
		catch(e) {
		    xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
		}
    }
    return xmlhttp;
}
function setValueAtPath(obj, path, newValue) {
    var keys = path.split('.');
    var current = obj;

    for (var i = 0; i < keys.length - 1; i++) {
        if (current[keys[i]] === undefined) {
            current[keys[i]] = {}; // Create an object if it doesn't exist
        }
        current = current[keys[i]];
    }

    // Set the new value at the last key
    current[keys[keys.length - 1]] = newValue;
}
function triggerEncryption(params,encryptionpath,encryptionvalue,URIEncryptionNeeeded){
	return encryptData.encrypt(Array.isArray(encryptionvalue) ? encryptionvalue : [encryptionvalue], URIEncryptionNeeeded, encryptionvalue).then(function(encryptedval) {
		var returndata = {}
		if(!encryptData.enabled || !isValid(encryptionvalue)){
			returndata["data"] = typeof params == "undefined" || params == undefined ? encryptionvalue : params;
			return returndata;
		}
		var validData = typeof encryptedval[0] == 'string' ? encryptedval[0] : encryptedval[0].value;
		returndata["key"] = validData.key;
		var nojson = !isValidJSON(params);
		var noparam = !isValid(params);
		var nopath = !isValid(encryptionpath);
		
		if(URIEncryptionNeeeded){
			returndata["data"] = encryptionpath.path.replace(encryptionpath.value, validData.data);
			return returndata;
		}
		if(nopath){
			returndata["data"] = validData.data;
			return returndata;
		}
		if(!nojson){
			params = JSON.parse(params);
		}
		if(!noparam && !Array.isArray(encryptionpath)){
			setValueAtPath(params, encryptionpath.path ? encryptionpath.path : encryptionpath, validData.data);
		}
		if(Array.isArray(encryptionvalue)){
			validData = Array.isArray(validData.data) ? validData.data : [validData.data];
			validData.forEach(function(data, index){
				setValueAtPath(params, encryptionpath[index].path, data);
			});
		}
		if(!nojson){
			params = JSON.stringify(params);
		}
		returndata["data"] = params;
		return returndata;
	});
}
function isValidJSON(data) {
  try {
    JSON.parse(data);
    return true;
  } catch (e) {
    return false;
  }
}
function isValid(instr) {
	return instr != null && instr != "" && instr != "null";
}
function checkDefine(){
	if (!Promise.allSettled) {
	    Promise.allSettled = function (promises) {
	        return Promise.all(promises.map(function (p) {
	            return p.then(function (value) {
	                return {
	                    status: "fulfilled",
	                    value: value
	                };
	            }).catch(function (reason) {
	                return {
	                    status: "rejected",
	                    reason: reason
	                };
	            });
	        }));
	    };
	}
}
function isValid(instr) {
	return instr != null && instr != "" && instr != "null";
}