local bright = string.char(27).."[1m"
local dim = string.char(27).."[2m"
local underscore = string.char(27).."[4m"
local red = string.char(27).."[31m"
local green = string.char(27).."[32m"
local reset = string.char(27).."[0m"
print(bright..underscore.."\nTesting with ".._VERSION..":"..reset)
repr = function(t)
    local buff = tostring(t)
    if type(t) == 'table' then
        buff = "{"..buff.." "
        for k, v in pairs(t) do
            buff = buff..("%s = %s, "):format(k,v)
        end
        buff = buff.."}"
    end
    return buff
end

local num_errors = 0
local test_number = 0
local function test(description, fn)
    test_number = test_number + 1
    description = (bright.."% 3d. "..reset.."%s"):format(test_number, description)
    io.write(description)
    io.write(red)
    local ok, err = pcall(fn)
    if not ok then
        io.write(reset..dim.."\r..................................")
        io.write(reset.."["..bright..red.."FAILED"..reset.."]\r")
        io.write("\r"..description.."\n"..reset)
        print(reset..red..(err or "")..reset)
        num_errors = num_errors + 1
    else
        io.write(reset..dim.."\r..................................")
        io.write(reset.."["..green.."PASSED"..reset.."]\r")
        io.write(description.."\n")
    end
end

test("Loading module", function()
    immutable = require"immutable"
end)

test("Creating class", function()
    Vec = immutable({"x","y"}, {
        len2=function(self)
            return self.x*self.x + self.y*self.y
        end,
        __add=function(self, other)
            local cls = getmetatable(self)
            return cls(self.x+other.x, self.y+other.y)
        end,
        __tostring=function(self)
            return "Vec("..tostring(self.x)..", "..tostring(self.y)..")"
        end,
    })
end)

test("Instantiating class", function()
    v = assert(Vec(1,3))
end)

test("Testing # operator", function()
    assert(#v == 2)
end)

test("Testing method", function()
    assert(v:len2() == 10)
end)

test("Testing tostring", function()
    assert(tostring(v) == "Vec(1, 3)")
end)

test("Testing from_table", function()
    assert(Vec:from_table(setmetatable({y=3}, {__index={x=1}})) == v)
    assert(Vec:from_table({x=1}) == Vec(1, nil))
end)

test("Testing equality", function()
    also_v = Vec(1,3)
    assert(v == also_v)
    assert(tostring(v) == tostring(also_v))
    -- Hash collision in the current implementation
    not_v = Vec(true,3)
    assert(v ~= not_v)
    assert(tostring(not_v) == "Vec(true, 3)")
    also_not_v = Vec(true,3)
    assert(not_v == also_not_v)
end)

test("Testing singletons", function()
    local T1 = immutable()
    local T2 = immutable()
    assert(T1() == T1())
    assert(T1() ~= T2())
end)

test("Testing __add metamethod", function()
    assert(v + Vec(5,6) == Vec(6,9))
end)
collectgarbage()
test("Testing string members", function()
    Vec("hello", "world")
end)
test("Testing table members", function()
    Vec({}, {})
end)
test("Testing function members", function()
    Vec(function() end, function() end)
end)
test("Testing immutable members", function()
    Vec(v, v)
end)
collectgarbage()
collectgarbage()

test("Testing garbage collection", function()
    local collected = false
    local GCSnooper = immutable({}, {
        __gc=function(self)
            collected = true
        end,
    })
    local g = GCSnooper()
    collectgarbage()
    collectgarbage()
    assert(not collected)
    g = nil
    collectgarbage()
    collectgarbage()
    assert(collected)
end)

test("Testing stupid metamethods", function()
    local Five = immutable({"x"}, {__index=function() return 5 end, derp = 99})
    local f = Five(99)
    assert(f.x == 5 and f.asdf == 5 and f.derp == 5)
end)

test("Testing similar class", function()
    FooVec = immutable({"x","y"}, {
        len2=function(self)
            return self.x*self.x + self.y*self.y
        end,
        __add=function(self, other)
            local cls = getmetatable(self)
            return cls(self.x+other.x, self.y+other.y)
        end,
        __tostring=function(self)
            return "Vec("..tostring(self.x)..", "..tostring(self.y)..")"
        end,
    })
    assert(FooVec(1,1) ~= Vec(1,1))
end)

test("Testing is_instance", function()
    fv = FooVec(1,2)
    assert(FooVec:is_instance(fv))
    assert(not FooVec:is_instance(v))
    assert(not FooVec:is_instance("asdf"))
    assert(not FooVec:is_instance({}))
    assert(not FooVec:is_instance(5))
end)

test("Testing spoofing", function()
    local t = {99,100}
    setmetatable(t, Vec)
    assert(not pcall(function() return t.x end))
    assert(not pcall(function() return Vec(88) end))
    assert(not pcall(function() return Vec.__tostring(t) end))
end)

test("Testing unpacking", function()
    if table.unpack then
        local a, b = table.unpack(Vec(5,6))
        assert(a == 5 and b == 6)
    end
end)

if num_errors == 0 then
    print(green.."All tests passed!"..reset)
else
    print(bright..red.."*** "..tostring(num_errors).." test"..(num_errors > 1 and "s" or "").." failed! ***"..reset)
    io.write(reset)
    os.exit(false, true)
end