-- error() lève une erreur, interrompt l'exécution normale de la fonction courante
local function divide(a, b)
  if b == 0 then
    error("division par zéro")   -- interrompt immédiatement divide(), remonte l'appelant
  end
  return a / b
end

-- Sans protection : un appel direct planterait tout le programme
-- print(divide(10, 0))   -- crash: "chemin:ligne: division par zéro"

-- pcall (protected call) : exécute une fonction en capturant toute erreur, ne plante jamais l'appelant
local ok, result = pcall(divide, 10, 0)
print(ok, result)   -- false   "chemin:ligne: division par zéro"

local ok2, result2 = pcall(divide, 10, 2)
print(ok2, result2)   -- true   5.0

-- Pattern idiomatique de gestion
local ok, resultOrError = pcall(divide, 10, 0)
if ok then
  print("Résultat: " .. resultOrError)
else
  print("Erreur capturée: " .. resultOrError)
end

-- error() avec un niveau de traçage (2ème argument) pour pointer l'erreur vers l'APPELANT, pas la fonction elle-même
local function validateAge(age)
  if age < 0 then
    error("l'âge ne peut pas être négatif", 2)   -- niveau 2 : le message pointera vers la ligne d'appel de validateAge
  end
end

-- error() peut aussi lever une TABLE (pas juste une string), utile pour des erreurs structurées
local function fetchResource(id)
  if id < 1 then
    error({ code = "INVALID_ID", message = "id doit être positif", id = id })
  end
end

local ok, err = pcall(fetchResource, -5)
if not ok and type(err) == "table" then
  print("Code d'erreur: " .. err.code .. " (id=" .. err.id .. ")")
end

-- xpcall : comme pcall, mais avec un "message handler" appelé AU MOMENT de l'erreur
-- (utile pour capturer une stack trace, avant que la pile ne soit dépilée)
local function riskyOperation()
  error("problème pendant l'opération")
end

local function errorHandler(err)
  return debug.traceback(err, 2)   -- enrichit le message avec la pile d'appels complète
end

local ok, traceback = xpcall(riskyOperation, errorHandler)
if not ok then
  print(traceback)   -- affiche le message ET la trace complète des appels de fonctions
end

-- Pattern "assert" : raccourci pour vérifier une condition et lever une erreur si elle échoue
local function loadConfig(path)
  local file = io.open(path, "r")
  assert(file, "impossible d'ouvrir le fichier de configuration: " .. path)   -- lève une erreur si file est nil
  local content = file:read("*a")
  file:close()
  return content
end

-- assert() retourne ses arguments tels quels si la condition est truthy, pratique pour chaîner
local config = assert(loadConfig("config.lua"))

-- Pattern robuste : wrapper générique pour exécuter une opération avec logging systématique des erreurs
local function safeCall(fn, ...)
  local results = { pcall(fn, ...) }
  local ok = table.remove(results, 1)
  if not ok then
    local err = results[1]
    print("[ERREUR] " .. tostring(err))
    -- ici : envoyer à un système de monitoring/logging externe en production
    return nil
  end
  return table.unpack(results)   -- ré-étale les valeurs de retour multiples de fn
end

local value = safeCall(divide, 10, 0)   -- ne plante pas, log l'erreur, retourne nil