function stringToUint8Array(str) {
  const length = str.length;
  const uint8Array = new Uint8Array(length);
  for (let i = 0; i < length; i++) {
    uint8Array[i] = str.charCodeAt(i);
  }
  return uint8Array;
}

async function processAES256(action, plainText, password, iv){
	var enc = new TextEncoder();
	var salt = 'hY0wTq6xwc6ni01G';
	var iterations = 1001;
	var keyLength = 32; // 32 bytes for AES-256 (256 bits)
	var digest = 'SHA-1';
	var resultTxt = '';
	
	iv = enc.encode(iv);
	
	try {
		
	  var derivedKey = await generatePBKDF2(password, salt, iterations, keyLength, digest);
  
      if(action == 'encrypt'){
		  //Encrypt
		  resultTxt = await encryptWithAES256(plainText, derivedKey, iv);
	  }else if(action == 'decrypt'){
		  //Decrypt
		  resultTxt = await decryptWithAES256(plainText, derivedKey, iv);
	  }
	  
	} catch (error) {
		
	  console.error('Error generating PBKDF2 or performing AES-256 encryption/decryption ('+action+'):', error);
	  
	}
	
	return resultTxt;
}

async function generatePBKDF2(password, salt, iterations, keyLength, digest) {
  const encoder = new TextEncoder();
  const importedKey = await crypto.subtle.importKey(
    'raw',
    encoder.encode(password),
    { name: 'PBKDF2' },
    false,
    ['deriveBits']
  );

  const derivedBits = await crypto.subtle.deriveBits(
    {
      name: 'PBKDF2',
      salt: encoder.encode(salt),
      iterations: iterations,
      hash: digest
    },
    importedKey,
    keyLength * 8 // Key length in bits
  );

  return crypto.subtle.importKey(
    'raw',
    derivedBits,
    { name: 'AES-CBC' },
    false,
    ['encrypt', 'decrypt']
  );
}

async function encryptWithAES256(plainText, derivedKey, iv) {

  const encodedText = new TextEncoder().encode(plainText);
  const encryptedData = await crypto.subtle.encrypt(
    { name: 'AES-CBC', iv: iv },
    derivedKey,
    encodedText
  );

  return arrayBufferToBase64(encryptedData);
}

async function decryptWithAES256(encryptedTxt, derivedKey, iv) {
  //var iv = new Uint8Array(iv);
  
  const encryptedData = new Uint8Array(base64ToArrayBuffer(encryptedTxt)); 
  const decryptedData = await crypto.subtle.decrypt(
	{ name: 'AES-CBC', iv: iv },
	derivedKey,
	encryptedData
  );

  const decodedText = new TextDecoder().decode(decryptedData);
  
  return decodedText;
}

function arrayBufferToBase64( buffer ) {
    var binary = '';
    var bytes = new Uint8Array( buffer );
    var len = bytes.byteLength;
    for (var i = 0; i < len; i++) {
        binary += String.fromCharCode( bytes[ i ] );
    }
    return window.btoa( binary );
}

function base64ToArrayBuffer(base64) {
    var binaryString = atob(base64);
    var bytes = new Uint8Array(binaryString.length);
    for (var i = 0; i < binaryString.length; i++) {
        bytes[i] = binaryString.charCodeAt(i);
    }
    return bytes.buffer;
}

async function generateSecureKey() {
  const key = await crypto.subtle.generateKey(
    {
      name: "AES-CBC",
      length: 256
    },
    true, // extractable
    ["encrypt", "decrypt"]
  );

  const keyData = await crypto.subtle.exportKey("raw", key);
  const keyString = arrayBufferToBase64(keyData);

  return keyString;
}

function generateSecureIV() {
  const iv = crypto.getRandomValues(new Uint8Array(16));
  return arrayBufferToBase64(iv);
}