// Rôle : gère les sauvegardes JSON locales via la File System Access API.

export const AUTO_BACKUP_SETTING = "autoBackup";
export const AUTO_BACKUP_FILE_PATTERN = /^sokkog-global-\d{4}-\d{2}-\d{2}\.json$/;
const AUTO_BACKUP_LOCK = "sokkog-auto-backup";

export function isFileSystemAccessSupported(scope = globalThis) {
  return Boolean(scope && "showDirectoryPicker" in scope);
}

export function getLocalDateKey(date = new Date()) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, "0");
  const day = String(date.getDate()).padStart(2, "0");
  return `${year}-${month}-${day}`;
}

export function getBackupFileName(date = new Date()) {
  return `sokkog-global-${getLocalDateKey(date)}.json`;
}

export function normalizeAutoBackupConfig(value) {
  return {
    enabled: value?.enabled === true,
    directoryHandle: value?.directoryHandle || null,
    lastBackup: typeof value?.lastBackup === "string" ? value.lastBackup : ""
  };
}

async function withBackupLock(task) {
  if (globalThis.navigator?.locks?.request) {
    return globalThis.navigator.locks.request(AUTO_BACKUP_LOCK, { mode: "exclusive" }, task);
  }
  return task();
}

async function queryReadWritePermission(directoryHandle) {
  if (!directoryHandle?.queryPermission) return "denied";
  return directoryHandle.queryPermission({ mode: "readwrite" });
}

export async function getDirectoryPermission(directoryHandle) {
  try {
    return await queryReadWritePermission(directoryHandle);
  } catch {
    return "denied";
  }
}

async function listBackupFiles(directoryHandle) {
  const files = [];
  for await (const entry of directoryHandle.values()) {
    if (entry.kind === "file" && AUTO_BACKUP_FILE_PATTERN.test(entry.name)) files.push(entry.name);
  }
  return files;
}

function sortBackupFiles(files) {
  return [...files].sort((left, right) => right.slice(14, 24).localeCompare(left.slice(14, 24)));
}

async function cleanupBackups(directoryHandle) {
  const files = sortBackupFiles(await listBackupFiles(directoryHandle));
  for (const filename of files.slice(10)) await directoryHandle.removeEntry(filename);
}

async function readBackupFile(directoryHandle, filename) {
  const fileHandle = await directoryHandle.getFileHandle(filename);
  const file = await fileHandle.getFile();
  return file.text();
}

function comparableBackupContents(contents) {
  try {
    const payload = JSON.parse(contents);
    if (!payload || typeof payload !== "object" || Array.isArray(payload)) return null;
    const withoutTimestamp = { ...payload };
    delete withoutTimestamp.exportedAt;
    return JSON.stringify(withoutTimestamp);
  } catch {
    return null;
  }
}

export function backupContentsEqual(left, right) {
  const comparableLeft = comparableBackupContents(left);
  const comparableRight = comparableBackupContents(right);
  return comparableLeft !== null && comparableLeft === comparableRight;
}

async function writeBackupFile(directoryHandle, filename, contents, preserveExisting) {
  const fileHandle = await directoryHandle.getFileHandle(filename, { create: true });
  let writable;
  try {
    writable = await fileHandle.createWritable();
    await writable.write(contents);
    await writable.close();
  } catch (error) {
    try { await writable?.abort(); } catch { /* Le fichier peut déjà être fermé. */ }
    if (!preserveExisting) {
      try { await directoryHandle.removeEntry(filename); } catch { /* Le fichier peut ne pas avoir été créé. */ }
    }
    throw error;
  }
}

export async function saveBackup({ directoryHandle, generateJson, date = new Date(), force = false }) {
  if (!directoryHandle) return { ok: false, reason: "missing-directory" };
  const permission = await getDirectoryPermission(directoryHandle);
  if (permission !== "granted") return { ok: false, reason: "permission", permission };
  const filename = getBackupFileName(date);

  return withBackupLock(async () => {
    try {
      const existing = await listBackupFiles(directoryHandle);
      if (!force && existing.includes(filename)) return { ok: true, created: false, filename };
      const contents = await generateJson();
      if (!force && existing.length) {
        const latestFilename = sortBackupFiles(existing)[0];
        try {
          if (backupContentsEqual(contents, await readBackupFile(directoryHandle, latestFilename))) {
            return { ok: true, created: false, unchanged: true, filename, comparedTo: latestFilename };
          }
        } catch {
          // Une lecture impossible ne doit pas empêcher la création d'une nouvelle version.
        }
      }
      await writeBackupFile(directoryHandle, filename, contents, existing.includes(filename));
      let cleanupError = "";
      try {
        await cleanupBackups(directoryHandle);
      } catch (error) {
        cleanupError = error?.message || "Erreur de nettoyage des anciennes sauvegardes.";
      }
      return { ok: true, created: true, filename, cleanupError };
    } catch (error) {
      return { ok: false, reason: "backup", error };
    }
  });
}