// Algorithme et configuration constants
const algorithm = "AES-CBC";
const keyLength = 256;

/**
 * Génère une clé AES-256
 */
export async function generateKey(): Promise<CryptoKey> {
  return crypto.subtle.generateKey(
    {
      name: algorithm,
      length: keyLength,
    },
    true, // extractable
    ["encrypt", "decrypt"]
  );
}

/**
 * Exporte une clé AES en format JSON Web Key (JWK)
 */
export async function exportKey(key: CryptoKey): Promise<JsonWebKey> {
  return crypto.subtle.exportKey("jwk", key);
}

/**
 * Importe une clé AES à partir d'un format JSON Web Key (JWK)
 */
export async function importKey(jwk: JsonWebKey): Promise<CryptoKey> {
  return crypto.subtle.importKey(
    "jwk",
    jwk,
    { name: algorithm },
    true, // extractable
    ["encrypt", "decrypt"]
  );
}

/**
 * Encode les données en Base64
 */
function toBase64(buffer: ArrayBuffer): string {
  return btoa(String.fromCharCode(...new Uint8Array(buffer)));
}

/**
 * Décode les données en Base64
 */
function fromBase64(base64: string): ArrayBuffer {
  const binaryString = atob(base64);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes.buffer;
}

/**
 * Chiffre une donnée
 * @param data - Les données à chiffrer
 * @param key - La clé AES
 * @param iv - Le vecteur d'initialisation
 * @returns Une chaîne encodée en Base64
 */
export async function encryptToBase64(
  data: string,
  key: CryptoKey,
  iv: Uint8Array
): Promise<string> {
  const encodedData = new TextEncoder().encode(data);
  const encrypted = await crypto.subtle.encrypt(
    {
      name: algorithm,
      iv: iv.buffer as ArrayBuffer,
    },
    key,
    encodedData
  );
  return toBase64(encrypted);
}

/**
 * Déchiffre une donnée
 * @param base64Data - Les données chiffrées en Base64
 * @param key - La clé AES
 * @param iv - Le vecteur d'initialisation
 * @returns Une chaîne déchiffrée
 */
export async function decryptFromBase64(
  base64Data: string,
  key: CryptoKey,
  iv: Uint8Array
): Promise<string> {
  const encryptedData = fromBase64(base64Data);
  const decrypted = await crypto.subtle.decrypt(
    {
      name: algorithm,
      iv: iv as any,
    },
    key,
    encryptedData
  );
  return new TextDecoder().decode(decrypted);
}

/**
 * USAGE

import { generateKey, encryptToBase64, decryptFromBase64, exportKey, importKey } from './aesCrypto';

(async () => {
    const key = await generateKey();
    const iv = crypto.getRandomValues(new Uint8Array(16)); // Génère un IV aléatoire

    const data = "Ceci est un secret!";

    // Chiffrement
    const encryptedBase64 = await encryptToBase64(data, key, iv);

    // Déchiffrement
    const decrypted = await decryptFromBase64(encryptedBase64, key, iv);

    // Exporter et importer la clé
    const exportedKey = await exportKey(key);

    const importedKey = await importKey(exportedKey);
})();

 */