message

--[[

    Minecraft Intranet

    Message class

--]]

mcnet = mcnet or {}
local message = mcnet.message or {}
mcnet.message = message
local address = mcnet.address or {}
mcnet.address = address

local Class = {}

function Class:new(o)
    o = o or {}
    setmetatable(o, self)
    self.__index = self
    return o
end

local Message = Class:new{
    from = nil,
    to = nil,
    type = "",
    data = nil
}

local Address = Class:new{
    localPart = nil,
    domainPart = nil
}

function message.new(o)
    return Message:new(o)
end

function message.pack(msg)
    assert(type(msg) == "table", "invalid message object")

    if (type(msg.from) == "table") then
        msg.from = address.format(msg.from)
    end

    if (type(msg.to) == "table") then
        msg.to = address.format(msg.to)
    end

    return textutils.serialize(msg)
end

function message.unpack(serialMsg)
    assert(type(serialMsg) == "string", "invalid message string")

    local msg = textutils.unserialize(serialMsg)

    if (msg.from ~= nil) then
        msg.from = address.parse(msg.from)
    end

    if (msg.to ~= nil) then
        msg.to = address.parse(msg.to)
    end

    return message.new(msg)
end

function address.new(o)
    return Address:new(o)
end

function address.parse(addr)
    assert(type(addr) == "string", "invalid address string")

    local i, j, localPart, domainPart = string.find(addr, "^([^@]+)@(.+)$")
    assert(i ~= nil, "invalid address format")

    return address.new{
        localPart = localPart,
        domainPart = domainPart
    }
end

function address.format(addr)
    assert(type(addr) == "table", "invalid address object")

    return string.format("%s@%s", addr.localPart, addr.domainPart)
end

function message.send(receiverId, msg, bWaitUntilPortOpen)
    if(type(msg) ~= "string") then
        msg = message.pack(msg)
    end

    return rednet.send(receiverId, msg, bWaitUntilPortOpen)
end

function message.broadcast(msg, bWaitUntilPortOpen)
    return message.send(nil, msg, bWaitUntilPortOpen)
end

local listeners = {}

function message.receive(senderId, msg, distance)
    if (senderId == nil) then
        return false
    end

    assert(type(senderId) == "number", "invalid sender ID")
    assert(type(msg) == "string", "invalid message string")

    msg = message.unpack(msg)
    for k,listener in pairs(listeners) do
        listener(senderId, msg)
    end

    return true
end

function message.bind(listener)
    assert(type(listener) == "function", "invalid listener function")
    table.insert(listeners, listener)
end