-- Localiser les fonctions globales fréquemment utilisées : l'accès à une locale est plus rapide
-- que l'accès à une globale (résolution différente dans la VM Lua)
local sqrt = math.sqrt        -- capture locale, résolue une seule fois
local insert = table.insert

local function distance(x1, y1, x2, y2)
  return sqrt((x2 - x1) ^ 2 + (y2 - y1) ^ 2)   -- utilise la locale "sqrt", pas math.sqrt à chaque appel
end

-- Éviter la concaténation répétée de chaînes en boucle : O(n²) car chaque ".." crée une nouvelle chaîne
-- MAUVAIS
local function buildStringBad(items)
  local result = ""
  for _, item in ipairs(items) do
    result = result .. item .. ","   -- réallocation complète à CHAQUE itération
  end
  return result
end

-- BON : accumuler dans une table, joindre une seule fois à la fin avec table.concat (O(n))
local function buildStringGood(items)
  local parts = {}
  for i, item in ipairs(items) do
    parts[i] = item
  end
  return table.concat(parts, ",")
end

-- Pré-allouer une table quand la taille finale est connue évite les réallocations internes successives
-- table.create n'existe pas en Lua standard, mais on peut au moins éviter les insert() répétés
local function generateGrid(n)
  local grid = {}
  for i = 1, n do
    grid[i] = 0   -- assignation directe par index, plus rapide que table.insert dans une boucle chaude
  end
  return grid
end

-- Éviter la création d'objets/tables/closures dans les boucles "chaudes" (hot path, exécuté chaque frame)
-- MAUVAIS : crée une nouvelle table à chaque appel, pression constante sur le garbage collector
local function updateBad(entities)
  for _, entity in ipairs(entities) do
    local delta = { x = entity.vx * 0.016, y = entity.vy * 0.016 }   -- allocation inutile à chaque frame
    entity.x = entity.x + delta.x
    entity.y = entity.y + delta.y
  end
end

-- BON : pas d'allocation, calcul direct
local function updateGood(entities)
  for _, entity in ipairs(entities) do
    entity.x = entity.x + entity.vx * 0.016
    entity.y = entity.y + entity.vy * 0.016
  end
end

-- Mesurer le temps d'exécution avec os.clock() (temps CPU) pour identifier les vrais points chauds
local function benchmark(fn, iterations, ...)
  local start = os.clock()
  for _ = 1, iterations do
    fn(...)
  end
  local elapsed = os.clock() - start
  print(string.format("%d itérations en %.4fs (%.6fs/itération)", iterations, elapsed, elapsed / iterations))
end

benchmark(buildStringGood, 10000, {"a", "b", "c", "d", "e"})

-- Garbage collector : ajuster son comportement pour un jeu temps réel (éviter les pauses (stutter) perceptibles)
collectgarbage("collect")           -- collecte complète immédiate (ex: à un point de chargement, pas en jeu)
print(collectgarbage("count"))       -- mémoire utilisée en Ko, utile pour surveiller les fuites

-- Mode incrémental réglable : ajuster le pas de collecte pour lisser la charge sur plusieurs frames
collectgarbage("incremental", 200, 100, 12)
-- (pause, stepmul, stepsize) : paramètres avancés à ajuster selon le profil du jeu, à mesurer empiriquement

-- Éviter les métatables __index de type fonction dans les hot paths : plus lent qu'un __index de type table
-- __index fonction = appel de fonction à CHAQUE accès manquant ; __index table = simple lookup, bien plus rapide
local SlowClass = setmetatable({}, {
  __index = function(t, k) return rawget(SlowClass, k) end,   -- indirection inutile et coûteuse
})

local FastClass = {}
FastClass.__index = FastClass   -- lookup direct dans la table, le pattern standard vu en leçon POO

-- Checklist de performance Lua avant optimisation "prématurée"
1. Toujours PROFILER avant d'optimiser (os.clock(), ou un profiler du moteur hôte) - l'intuition trompe souvent
2. Localiser les fonctions globales appelées fréquemment (math.*, string.*, table.*)
3. Éviter les allocations de table/closure dans les boucles exécutées chaque frame
4. Préférer table.concat à la concaténation répétée en boucle
5. Utiliser __index de type table plutôt que fonction quand c'est possible (accès direct plus rapide)