RIFT event handling

setfenv(1, (...).data);

MulticastDelegate = nil;
do
    local methods = { };

    local metatable = {
        __add = function(self, value)
            self:bind(value);

            return self;
        end,

        __sub = function(self, value)
            self:unbind(value);

            return self;
        end,

        __call = function(self, ...)
            for _, v in ipairs(self) do
                v(...);
            end
        end,

        __index = methods,

        _bind = dummy,

        _unbind = dummy,
    };

    -- public members
    methods.bind = function(self, delegate)
        assert(type(delegate) == "function", "MulticastDelegate.bind requires 'delegate' (function) parameter");

        getmetatable(self)._bind(self, delegate);
        tinsert(self, delegate);
    end

    methods.unbind = function(self, delegate)
        assert(type(delegate) == "function", "MulticastDelegate.unbind requires 'delegate' (function) parameter");

        getmetatable(self)._unbind(self, delegate);
        tremovevalue(self, delegate);
    end

    -- constructor
    MulticastDelegate = function()
        local self = {};

        setmetatable(self, metatable);

        return self;
    end
end

EventTable = nil;
do
    local methods = {};

    -- private members
    local function __newindex(self, key, value)
        self:bind(key, value);
    end

    local function __index(self, key)
        local method = methods[key];

        if (method ~= nil) then
            return method;
        end

        local metatable = getmetatable(self);
        local events = metatable.events;

        if (events[key] ~= nil) then
            local delegates = metatable.delegates;
            local delegate = delegates[key];

            if (delegate ~= nil) then
                return delegate;
            end

            return dummy;
        else
            error("Unknown event '" .. tostring(key) .. "'");
        end
    end

    -- public members
    methods.bind = function(self, key, value)
        assert(type(value) == "function", "EventTable.bind requires value (function) parameter");

        local metatable = getmetatable(self);
        local events = metatable.events;

        if (events[key] ~= nil) then
            local delegates = metatable.delegates;
            local delegate = delegates[key];

            if (delegate == nil) then
                delegate = MulticastDelegate();
                delegates[key] = delegate;
            end

            metatable._bind(self, key, value, delegate);
            _= delegate + value;
        else
            error("Unknown event '" .. tostring(key) .. "'");
        end
    end

    methods.unbind = function(self, key, value)
        assert(type(value) == "function", "EventTable.unbind requires value (function) parameter");

        local metatable = getmetatable(self);
        local events = metatable.events;

        if (events[key] ~= nil) then
            local delegates = metatable.delegates;
            local delegate = delegates[key];

            if (delegate == nil) then
                return;
            end

            metatable._unbind(self, key, value, delegate);
            _= delegate - value;
        else
            error("Unknown event '" .. tostring(key) .. "'");
        end
    end

    methods.add = function(self, ...)
        local events = getmetatable(self).events;

        for value in values(...) do
            assert(type(value) == "string", "EventTable.add requires ... (string) arguments");
            if (events[value] ~= nil) then
                error(events[value] == nil, "EventTable.add '" .. value .. "' is already registered");
            end

            events[value] = true;
        end
    end

    -- constructor
    EventTable = function(...)
        local events = { };

        for value in values(...) do
            assert(type(value) == "string", "EventTable requires ... (string) parameters");
            events[value] = true;
        end

        return setmetatable({ }, {
            events = events,
            delegates = {},
            __newindex = __newindex,
            __index = __index,
            _bind = dummy,
            _unbind = dummy,
        });
    end
end

UIEventTable = nil;
do
    -- private members
    local function _bind(self, key, value, delegate)
        local metatable = getmetatable(self);
        local nativeEvents = metatable.nativeEvents;

        if (getmetatable(nativeEvents).List[key] ~= nil and nativeEvents[key] == nil) then
            nativeEvents[key] = function(...) self[key](...); end
        end
    end

    local function _unbind(self, key, value, delegate)
        local metatable = getmetatable(self);
        local nativeEvents = metatable.nativeEvents;

        if (#delegate <= 0 and nativeEvents[key] ~= nil) then
            nativeEvents[key] = nil;
        end
    end

    -- constructor
    UIEventTable = function(nativeEvents, ...)
        local self = EventTable(...);

        local metatable = getmetatable(self);
        metatable._bind = _bind;
        metatable._unbind = _unbind;
        metatable.nativeEvents = nativeEvents;

        setmetatable(metatable.events, { __index = getmetatable(nativeEvents).List });

        return self;
    end
end