-- rawget / rawset : accès BRUT à une table, en contournant toute métaméthode __index/__newindex
-- Indispensable pour éviter une récursion infinie à l'intérieur même d'une métaméthode
local logged = setmetatable({}, {
  __index = function(t, key)
    print("lecture de la clé: " .. tostring(key))
    return rawget(t, key)          -- lecture brute, PAS t[key] (qui redéclencherait __index -> boucle infinie)
  end,
  __newindex = function(t, key, value)
    print("écriture de la clé: " .. tostring(key) .. " = " .. tostring(value))
    rawset(t, key, value)           -- écriture brute, PAS t[key] = value (récursion infinie sinon)
  end,
})

logged.score = 100   -- "écriture de la clé: score = 100"
print(logged.score)   -- "lecture de la clé: score" puis 100

-- __call : rend une table directement "appelable" comme une fonction
local Multiplier = setmetatable({ factor = 3 }, {
  __call = function(self, value)
    return value * self.factor
  end,
})

print(Multiplier(10))   -- 30, la table se comporte comme une fonction

-- Cas d'usage réel : classes instanciables via un appel direct sur le "constructeur"
local Class = setmetatable({}, {
  __call = function(cls, ...)
    local instance = setmetatable({}, cls)
    if instance.init then instance:init(...) end
    return instance
  end,
})

-- Proxy table : intercepter TOUS les accès pour valider/logger/limiter, données réelles stockées à part
local function createValidatedTable(schema)
  local data = {}   -- stockage réel, inaccessible directement de l'extérieur
  return setmetatable({}, {
    __index = data,
    __newindex = function(_, key, value)
      local validator = schema[key]
      if validator and not validator(value) then
        error("valeur invalide pour '" .. key .. "': " .. tostring(value), 2)
      end
      data[key] = value
    end,
  })
end

local player = createValidatedTable({
  hp = function(v) return type(v) == "number" and v >= 0 and v <= 100 end,
})
player.hp = 50    -- accepté
-- player.hp = -10  -- lèverait une erreur : "valeur invalide pour 'hp': -10"

-- Tables faibles combinées à __mode pour un registre d'objets sans fuite mémoire
-- (référence croisée à la leçon "tables avancées", approfondie ici pour un cas expert)
local WeakRegistry = setmetatable({}, { __mode = "k" })   -- clés faibles

local function registerEntity(entity, metadata)
  WeakRegistry[entity] = metadata   -- si "entity" n'est plus référencé ailleurs, l'entrée disparaît du registre
end

-- __tostring combiné à __concat pour une intégration transparente dans des chaînes construites dynamiquement
local Money = {}
Money.__index = Money

function Money.new(cents)
  return setmetatable({ cents = cents }, Money)
end

Money.__tostring = function(m)
  return string.format("%.2f€", m.cents / 100)
end

Money.__concat = function(a, b)
  -- __concat reçoit les deux opérandes dans l'ordre, même si un seul est de type Money
  local left = type(a) == "table" and tostring(a) or a
  local right = type(b) == "table" and tostring(b) or b
  return left .. right
end

local price = Money.new(1999)
print("Prix: " .. price)   -- appelle __concat : "Prix: 19.99€"

-- getmetatable / debug.getmetatable pour inspecter le comportement d'une table (utile en debug)
local mt = getmetatable(price)
print(mt == Money)   -- true

-- Protéger une métatable contre modification externe avec __metatable
local Protected = setmetatable({}, { __metatable = "accès interdit" })
print(getmetatable(Protected))   -- "accès interdit" (la vraie métatable est masquée)
-- setmetatable(Protected, {})    -- lèverait une erreur : "cannot change a protected metatable"