Tables, Metatables & OOP

-- A table is Lua's ONLY data structure. It is both an
-- array (numbered list) AND a dictionary (key -> value) at once.

-- ARRAY part: a list. Lua arrays start at index 1, NOT 0.
local fruits = { "apple", "banana", "cherry" }
print(fruits[1])        -- prints: apple   (first item is [1])
print(fruits[3])        -- prints: cherry
print(#fruits)          -- prints: 3       (# is the length operator)

-- table.insert adds to the end; table.remove takes from the end.
table.insert(fruits, "date")
print(#fruits)          -- prints: 4
table.remove(fruits, 1) -- remove index 1 ("apple"); rest shift down
print(fruits[1])        -- prints: banana

-- DICTIONARY part: string keys instead of numbers.
local player = { name = "Hero", level = 5, alive = true }
print(player.name)      -- prints: Hero    (dot syntax)
print(player["level"])  -- prints: 5       (bracket syntax — same thing)

-- One table can hold BOTH parts at the same time.
local mixed = { "first", "second", color = "red" }
print(mixed[1])         -- prints: first   (array part)
print(mixed.color)      -- prints: red     (hash part)

-- 🎯 YOUR TURN — replace each ___, then run this on onecompiler.com.

local scores = { 10, 20, 30 }

-- 1) Print the FIRST score (remember: Lua arrays start at 1)
print(scores[___])      -- 👉 the index of the first item
-- ✅ Expected output: 10

-- 2) Add 40 to the end of the list
table.insert(scores, ___)   -- 👉 the number to add

-- 3) Print how many scores there are now
print(___scores)        -- 👉 the length operator goes before the table
-- ✅ Expected output: 4

-- A metatable is a table that customises how ANOTHER table behaves.
-- setmetatable(t, mt) attaches the metatable mt to the table t.

-- __index supplies DEFAULTS: when a key is missing on the table,
-- Lua looks it up in __index instead of returning nil.
local defaults = { color = "red", speed = 10, health = 100 }
local player = setmetatable({ name = "Hero", speed = 25 }, { __index = defaults })
print(player.name)    -- prints: Hero   (own field)
print(player.speed)   -- prints: 25     (own field wins over the default)
print(player.color)   -- prints: red    (missing -> falls back via __index)
print(player.health)  -- prints: 100    (from defaults)

-- __newindex intercepts SETTING a new key. Here we block writes
-- to a "read-only" config by raising an error.
local config = setmetatable({}, {
  __newindex = function(t, key, value)
    error("config is read-only: cannot set " .. key)
  end
})
-- config.volume = 11  -- would raise: config is read-only: cannot set volume

-- __add overloads +, __eq overloads ==, __tostring customises printing.
local Vector = {}
Vector.__index = Vector
Vector.__add = function(a, b)
  return setmetatable({ x = a.x + b.x, y = a.y + b.y }, Vector)
end
Vector.__eq = function(a, b)
  return a.x == b.x and a.y == b.y
end
Vector.__tostring = function(v)
  return "(" .. v.x .. ", " .. v.y .. ")"
end

local v1 = setmetatable({ x = 3, y = 4 }, Vector)
local v2 = setmetatable({ x = 1, y = 2 }, Vector)
print(tostring(v1 + v2))      -- prints: (4, 6)   (uses __add then __tostring)
print(v1 == v1)               -- prints: true     (uses __eq)
print(v1 == v2)               -- prints: false

-- 🎯 YOUR TURN — finish the Money type so + adds amounts.

local Money = {}
Money.__index = Money

-- 1) __add should return a new Money whose amount is the sum
Money.__add = function(a, b)
  return setmetatable({ amount = a.amount ___ b.amount }, Money)
  -- 👉 the arithmetic operator that adds two numbers
end

-- 2) __tostring should print the amount with a £ sign in front
Money.__tostring = function(m)
  return "£" .. ___           -- 👉 the field that holds the number
end

local wallet  = setmetatable({ amount = 30 }, Money)
local payment = setmetatable({ amount = 12 }, Money)
print(tostring(wallet + payment))   -- ✅ Expected output: £42

-- Lua has no 'class' keyword. You build classes from
-- tables + metatables. Setting Class.__index = Class makes
-- instances look up missing keys (their methods) on the class.

local Animal = {}
Animal.__index = Animal          -- methods live on Animal; instances inherit them

-- A constructor is just a function that returns a table whose
-- metatable is the class. 'new' is a convention, not a keyword.
function Animal.new(name, sound)
  return setmetatable({ name = name, sound = sound }, Animal)
end

-- 'function Animal:speak()' is sugar for 'function Animal.speak(self)'.
-- The colon ':' silently adds a first parameter called 'self'.
function Animal:speak()
  return self.name .. " says " .. self.sound .. "!"
end

local cat = Animal.new("Cat", "Meow")
print(cat:speak())     -- prints: Cat says Meow!   (cat:speak() passes cat as self)

-- INHERITANCE: make Dog fall back to Animal via __index.
local Dog = setmetatable({}, { __index = Animal })  -- Dog inherits Animal's methods
Dog.__index = Dog                                   -- Dog instances look up on Dog

function Dog.new(name)
  local obj = Animal.new(name, "Woof")  -- reuse the parent constructor
  obj.tricks = {}
  return setmetatable(obj, Dog)
end

function Dog:learnTrick(trick)
  table.insert(self.tricks, trick)      -- 'self' is the Dog instance
end

local rex = Dog.new("Rex")
print(rex:speak())     -- prints: Rex says Woof!   (inherited from Animal)
rex:learnTrick("sit")
rex:learnTrick("roll")
print(#rex.tricks)     -- prints: 2