--[[
This file defines the table types and functions that can run
on those tables for two types of town - a growth town and a
stable town. Unlike Java, you can define multiple types in
the same file, and you would logically do so if they are always
going to be used in the same appliaction and maintained by the
same person / team.

In both table types in this file, we have provided functions
of the same name, meaning that our main code can simply ask
for (example) the growth factor for a town, and know that the
program itself will know WHICH growth factor algorithm to use
for that particular town - known in OO as "polymorphism"
]]

growth = growth or {}
stable = stable or {}
local meta_g = {}
local meta_s = {}

-- Define a new growth town

function growth.new(place,pop,tph, houseprice)
        -- save the data
        local town = {}
        town["place"] = place
        town["pop"] = pop
        town["tph"] = tph
        town["houseprice"] = houseprice

        -- The following add functionallity to a growth town
        -- Some of these routines are specific to a growth town
        -- but others are shared with a static town
        town["getfact"] = growth.getfactor
        town["addpeeps"] = addpeeps
        town["wastage"] = wastage
        town["change_house_prices"] = growth.change_house_prices
        -- As these are just references being copied, we do
        -- NOT have an efficiency problem!

        -- Also set the metatable so that our application can
        -- pick up underlying code to define other non-standard
        -- functionallity, such as how to add (merge) two towns
        -- as the grow into each other, and how to format them
        -- as a string when they are printed out
        setmetatable(town,meta_g)
        return town
        end

function stable.new(place,pop,tph, houseprice)
        -- A lot of common code with growth.new ...
        -- So perhaps a case for an internal shared function?
        local town = {}
        town["place"] = place
        town["pop"] = pop
        town["tph"] = tph
        town["houseprice"] = houseprice
        town["getfact"] = stable.getfactor
        town["addpeeps"] = addpeeps
        town["wastage"] = wastage
        town["change_house_prices"] = stable.change_house_prices
        setmetatable(town,meta_s)
        return town
        end

-- Differing algorithms defined

function growth.getfactor(self)
        return self.pop / self.houseprice / self.houseprice * (6 + self.tph)
        end

function stable.getfactor(self)
        return self.pop / self.houseprice / self.houseprice * (3 + self.tph)
        end

function growth.print(self)
        return string.format("%12s - %6d - %6s - %7d",
                self.place, self.pop, "FAST", self.houseprice);
        end

function stable.print(self)
        return string.format("%12s - %6d - %6s - %7d",
                self.place, self.pop, "STABLE", self.houseprice);
        end

function stable.change_house_prices(self,inc,out)
        factor = (out/inc) * (out/inc) + 0.02
        self.houseprice = self.houseprice * factor
        end

function growth.change_house_prices(self,inc,out)
        factor = out/inc - 0.01
        self.houseprice = self.houseprice * factor
        end

-- Shared algorithms defined
-- (but these should really be in a table of their own to avoid
-- namespace clutter!)

function addpeeps(self,extra)
        self.pop = self.pop + extra
        end

function wastage(self)
        self.pop = self.pop * 0.99
        end

-- Defining operations in the metatables - saying what to
-- run when we 'print' a town.

meta_g.__tostring = growth.print
meta_s.__tostring = stable.print