bc = {}

_bc_backend = require("_bc_backend")

function bc:init(master_id)
  local o = {}
  setmetatable(o, self)
  self.__index = self
  -- Init backend and cb handler
  o._listen_callbacks = {}
  o._verb_handlers = {}
  o._listeners = {}
  local function cb_handler(cb_type, param, arg)
    if cb_type == "listen" then
      if type(o._listen_callbacks[param]) == "function" then
        o._listen_callbacks[param]()
      end
    elseif cb_type == "verb" then
      o._verb_handlers[param](arg)
    elseif cb_type == "noun" then
      return o._mynouns[param]
    elseif cb_type == "reg_nl" then
      -- Create array if there is not one already
      o._listeners[param] = o._listeners[param] or {}
      -- Insert parameters
      table.insert(o._listeners[param], arg)
      return #o._listeners[param]
    elseif cb_type == "unreg_nl" then
      o._listeners[param][arg] = true;
    else
      error("Wrong cb type")
    end
  end
  o._backend = _bc_backend:init(cb_handler)
  -- Fetch list of nouns and verbs from master
  local list = o._backend:fetch_list(master_id)
  o._nouns = list.nouns
  o._verbs = list.verbs
  -- Initialize own nouns
  o._mynouns = {}
  for noun, addr in pairs(o._nouns) do
    if addr == o._backend.local_addr then
      o._mynouns[noun] = 0
    end
  end
  list = nil
  return o
end

function bc:get_noun(n)
  if self._nouns[n] == self._backend.local_addr then
    return self._mynouns[n]
  else
    return self._backend:request_noun(self._nouns[n], n)
  end
end

function bc:set_noun(n, val)
  if self._nouns[n] == self._backend.local_addr then
    -- Call listeners
    if type(self._listeners[n]) == "table" then
      for i, listener in ipairs(self._listeners[n]) do
        -- Check condition
        if type(listener) == "table" and
           ( (listener.query == "onchange" and self._mynouns[n] ~= val)
          or (listener.query == "onrising" and self._mynouns[n] < val)
          or (listener.query == "onfalling" and self._mynouns[n] > val)
          or (listener.query == "onabove" and val > listener.qparam)
          or (listener.query == "onbelow" and val < listener.qparam)
          or (listener.query == "onvalue" and val == listener.qparam)
          ) then
            self._backend:call_listener(listener.addr, n, i, val)
        end
      end
    end
    -- Set value
    self._mynouns[n] = val
    return true
  end
  return false
end

function bc:on_verb(v, handler)
  self._verb_handlers[v] = handler
end

function bc:call_verb(v, param)
  self._backend:call_verb(self._verbs[v], v, param)
end

function bc:listen_noun(n, query, qparam, cb)
  local id = self._backend:register_callback(self._nouns[n], n, query, qparam)
  self._listen_callbacks[id] = cb
  return id
end

function bc:listen_cancel(n, id)
  self._backend:cancel_callback(n, id)
end

return bc