-- Métatable minimale : intercepte les opérations sur une table via des "métaméthodes"
local t = setmetatable({}, {
  __index = function(table, key)
    return "clé inconnue: " .. key    -- appelé quand une clé absente est lue
  end,
})
print(t.foo)   -- "clé inconnue: foo"

-- __index avec une TABLE (pas une fonction) : pattern le plus courant pour l'héritage/POO
local Animal = {}
Animal.__index = Animal    -- Animal sert de "classe" ET de métatable pour ses instances

function Animal.new(name, sound)
  local self = setmetatable({}, Animal)
  self.name = name
  self.sound = sound
  return self
end

function Animal:makeSound()      -- "self" implicite via la syntaxe ":"
  print(self.name .. " fait " .. self.sound)
end

local dog = Animal.new("Rex", "Wouf")
dog:makeSound()   -- "Rex fait Wouf"
-- Fonctionnement : dog n'a pas de méthode makeSound, Lua cherche dans sa métatable (__index = Animal)

-- Sucre syntaxique ":" équivalent à passer "self" explicitement en premier argument
function Animal:makeSound() ... end
-- est strictement équivalent à :
function Animal.makeSound(self) ... end

dog:makeSound()          -- équivalent à :
Animal.makeSound(dog)     -- appel explicite avec self passé manuellement

-- Héritage : chaîner les métatables (Dog hérite de Animal)
local Dog = setmetatable({}, { __index = Animal })   -- Dog délègue à Animal si non trouvé
Dog.__index = Dog

function Dog.new(name)
  local self = Animal.new(name, "Wouf")   -- réutilise le constructeur parent
  return setmetatable(self, Dog)           -- réassigne la métatable à Dog (pas Animal)
end

function Dog:fetch()                        -- méthode spécifique à Dog, absente de Animal
  print(self.name .. " rapporte la balle")
end

local rex = Dog.new("Rex")
rex:makeSound()   -- hérité d'Animal : "Rex fait Wouf"
rex:fetch()         -- propre à Dog : "Rex rapporte la balle"

-- Métaméthodes arithmétiques : surcharge d'opérateurs pour des types custom (ex: vecteurs 2D)
local Vector2 = {}
Vector2.__index = Vector2

function Vector2.new(x, y)
  return setmetatable({ x = x, y = y }, Vector2)
end

Vector2.__add = function(a, b)
  return Vector2.new(a.x + b.x, a.y + b.y)
end

Vector2.__tostring = function(v)
  return string.format("Vector2(%g, %g)", v.x, v.y)
end

Vector2.__eq = function(a, b)
  return a.x == b.x and a.y == b.y
end

local v1 = Vector2.new(1, 2)
local v2 = Vector2.new(3, 4)
local v3 = v1 + v2               -- appelle __add
print(tostring(v3))               -- appelle __tostring : "Vector2(4, 6)"
print(v1 == Vector2.new(1, 2))     -- appelle __eq : true

-- __newindex : intercepte l'ÉCRITURE sur une clé absente (utile pour des tables en lecture seule ou validées)
local function readOnlyTable(t)
  return setmetatable({}, {
    __index = t,
    __newindex = function(table, key, value)
      error("Tentative de modification d'une table en lecture seule: " .. tostring(key), 2)
    end,
  })
end

local CONFIG = readOnlyTable({ maxPlayers = 4, difficulty = "hard" })
print(CONFIG.maxPlayers)   -- 4, lecture OK via __index
-- CONFIG.maxPlayers = 8   -- lèverait une erreur via __newindex

-- Tableau récapitulatif des métaméthodes les plus utilisées
-- __index      : lecture d'une clé absente
-- __newindex   : écriture d'une clé absente
-- __add/__sub/__mul/__div : opérateurs arithmétiques
-- __eq/__lt/__le : comparaisons
-- __tostring   : conversion en chaîne (utilisée par print/tostring)
-- __call       : rend une table "appelable" comme une fonction
-- __len        : personnalise le résultat de l'opérateur "#"