static void logger(void *data, mrp_log_level_t level, const char *file,
                   int line, const char *func, const char *format, va_list ap)
{
    console_t  *c = (console_t *)data;
    va_list     cp;
    const char *prefix;

    MRP_UNUSED(file);
    MRP_UNUSED(line);
    MRP_UNUSED(func);

    switch (level) {
    case MRP_LOG_ERROR:   prefix = "[log] E: "; break;
    case MRP_LOG_WARNING: prefix = "[log] W: "; break;
    case MRP_LOG_INFO:    prefix = "[log] I: "; break;
    case MRP_LOG_DEBUG:   prefix = "[log] D: "; break;
    default:              prefix = "[log] ?: ";
    }

    va_copy(cp, ap);
    mrp_console_printf(c->mc, "%s", prefix);
    mrp_console_vprintf(c->mc, format, cp);
    mrp_console_printf(c->mc, "\n");
    va_end(cp);
}

static void ignore_invalid_request(wrt_client_t *c, mrp_json_t *req, ...)
{
    MRP_UNUSED(c);
    MRP_UNUSED(req);

    mrp_log_error("Ignoring invalid WRT resource request");
}

static void server_status_cb(mrp_dbus_t *dbus, const char *name, int up,
                             const char *owner, void *user_data)
{
    context_t *c = (context_t *)user_data;

    MRP_UNUSED(dbus);
    MRP_UNUSED(name);

    if (up) {
        mrp_log_info("%s came up (as %s)", name, owner);

        if (c->timer == NULL) {
            c->timer = mrp_add_timer(c->ml, 1000, send_cb, c);

            if (c->timer == NULL) {
                mrp_log_error("Failed to create D-BUS sending timer.");
                exit(1);
            }
        }
    }
    else {
        mrp_log_info("%s went down", name);

        if (c->timer != NULL) {
            mrp_del_timer(c->timer);
            c->timer = NULL;
        }
    }
}

static void render_notify(srs_t *srs, srs_voice_event_t *e, void *user_data,
                          void *notify_data)
{
    client_t *c = (client_t *)user_data;

    MRP_UNUSED(srs);
    MRP_UNUSED(notify_data);

    switch (e->type) {
    case SRS_VOICE_EVENT_STARTED:
        print(c, "Rendering of TTS #%u started...", e->id);
        break;

    case SRS_VOICE_EVENT_PROGRESS:
        print(c, "%f %% (%u msec) of TTS #%u rendered...",
              e->data.progress.pcnt, e->data.progress.msec, e->id);
        break;

    case SRS_VOICE_EVENT_COMPLETED:
        print(c, "Rendering of TTS #%u completed.", e->id);
        break;

    case SRS_VOICE_EVENT_TIMEOUT:
        print(c, "Rendering of TTS #%u timed out.", e->id);
        break;

    case SRS_VOICE_EVENT_ABORTED:
        print(c, "Rendering of TTS #%u terminated abnormally.", e->id);
        break;

    default:
        break;
    }
}

static void log_target(mrp_console_t *c, void *user_data,
                       int argc, char **argv)
{
    const char *target;
    const char *targets[32];
    int         i, n;

    MRP_UNUSED(c);
    MRP_UNUSED(user_data);

    if (argc == 2) {
        target = mrp_log_get_target();
        n      = mrp_log_get_targets(targets, MRP_ARRAY_SIZE(targets));

        printf("available log targets:\n");
        for (i = 0; i < n; i++)
            printf("    %s%s\n", targets[i],
                   !strcmp(targets[i], target) ? " (active)" : "");
    }
    else if (argc == 3) {
        target = argv[2];

        if (!mrp_log_set_target(target))
            printf("failed to change logging target to %s", target);
        else {
            printf("changed log target to %s\n", target);
            mrp_log_info("changed log target to %s", target);
        }
    }
    else {
        printf("%s/%s invoked with wrong number of arguments\n",
               argv[0], argv[1]);
    }
}

static int notify_focus(srs_client_t *srs_client, srs_voice_focus_t focus)
{
    MRP_UNUSED(srs_client);
    MRP_UNUSED(focus);

    return TRUE;
}

int main(int argc, char **argv)
{
    mrp_mainloop_t *ml;
    int mask;
    mrp_io_watch_t *watch;

    my_app_data app_data;

    MRP_UNUSED(argc);
    MRP_UNUSED(argv);

    if ((ml = mrp_mainloop_create()) == NULL)
        exit(1);

    app_data.rs = NULL;
    app_data.cx = mrp_res_create(ml, state_callback, &app_data);

    mask = MRP_IO_EVENT_IN | MRP_IO_EVENT_HUP | MRP_IO_EVENT_ERR;
    watch = mrp_add_io_watch(ml, fileno(stdin), (mrp_io_event_t) mask,
            handle_input, &app_data);

    if (!watch)
        exit(1);

    /* start looping */
    mrp_mainloop_run(ml);

    mrp_res_destroy(app_data.cx);
    mrp_mainloop_destroy(ml);

    app_data.cx = NULL;
    app_data.rs = NULL;

    return 0;
}

void event_cb(uint32_t request_id, mrp_resource_set_t *resource_set, void *user_data)
{
    resource_set_lua_t *rset = (resource_set_lua_t *) user_data;
    mrp_resource_mask_t grant, advice;
    int                 top;

    MRP_UNUSED(request_id);
    MRP_UNUSED(resource_set);

    mrp_debug("> event_cb");

    top = lua_gettop(rset->L);

    grant = mrp_get_resource_set_grant(rset->resource_set);
    advice = mrp_get_resource_set_advice(rset->resource_set);

    /* update resource set */
    rset->acquired = !!grant;
    rset->available = !!advice;

    if (mrp_lua_object_deref_value(rset, rset->L, rset->callback, false)) {
        mrp_lua_push_object(rset->L, rset);

        if (lua_pcall(rset->L, 1, 0, 0) != 0)
            mrp_log_error("failed to invoke Lua resource set callback: %s",
                    lua_tostring(rset->L, -1));
    }

    lua_settop(rset->L, top);
}

static int config_loader(srs_plugin_t *plugin, srs_cfg_t *settings)
{
    MRP_UNUSED(plugin);
    MRP_UNUSED(settings);

    return TRUE;
}

static int command_notify(srs_client_t *c, int idx, int ntoken, char **tokens,
                          uint32_t *start, uint32_t *end, srs_audiobuf_t *audio)
{
    dbusif_t      *bus   = (dbusif_t *)c->user_data;
    const char    *dest  = c->id;
    const char    *path  = SRS_CLIENT_PATH;
    const char    *iface = SRS_CLIENT_INTERFACE;
    const char    *sig   = SRS_CLIENT_NOTIFY_COMMAND;

    char           buf[1024], *cmd, *p, *t;
    int            i, n, l;

    MRP_UNUSED(idx);
    MRP_UNUSED(start);
    MRP_UNUSED(end);
    MRP_UNUSED(audio);

    p = cmd = buf;
    l = sizeof(buf) - 1;
    t = "";

    for (i = 0; i < ntoken; i++) {
        n = snprintf(p, l, "%s%s", t, tokens[i]);

        if (n >= l)
            return FALSE;

        p += n;
        l -= n;
        t  = " ";
    }

    return mrp_dbus_signal(bus->dbus, dest, path, iface, sig,
                           MRP_DBUS_TYPE_STRING, cmd, MRP_DBUS_TYPE_INVALID);
}

static void wakeup_cb(mrp_wakeup_t *w, mrp_wakeup_event_t event,
                      void *user_data)
{
    static struct timeval  prev[2] = { {0, 0}, {0, 0} };
    const char            *evt;
    struct timeval         now;
    double                 diff;
    int                    id;

    MRP_UNUSED(w);
    MRP_UNUSED(user_data);

    timeval_now(&now);

    switch (event) {
    case MRP_WAKEUP_EVENT_TIMER: evt = "timer";           break;
    case MRP_WAKEUP_EVENT_IO:    evt = "I/O (or signal)"; break;
    case MRP_WAKEUP_EVENT_LIMIT: evt = "limit";           break;
    default:                     evt = "???";
    }

    id = user_data ? 1 : 0;

    if (MRP_LIKELY(prev[id].tv_usec != 0)) {
        diff = timeval_diff(&now, &prev[id]) / 1000.0;
        info("woken up #%d by %s, %.2f msecs since previous", id, evt, diff);
    }

    prev[id] = now;
}

static void ignore_unknown_request(wrt_client_t *c, mrp_json_t *req,
                                   const char *type)
{
    MRP_UNUSED(c);
    MRP_UNUSED(req);

    mrp_log_error("Ignoring unknown WRT resource request '%s'", type);
}

static void resource_lua_changed(void *data, lua_State *L, int member)
{
    MRP_UNUSED(data);
    MRP_UNUSED(L);
    MRP_UNUSED(member);

    mrp_debug("> resource_changed");
}

static void attribute_lua_changed(void *data, lua_State *L, int member)
{
    MRP_UNUSED(data);
    MRP_UNUSED(L);
    MRP_UNUSED(member);

    mrp_debug("> attribute_changed");
    return;
}

static const char *translate_glob(const char *pattern, char *glob, size_t size)
{
    MRP_UNUSED(glob);
    MRP_UNUSED(size);

    /* XXX FIXME: translate pattern to glob-like */

    return pattern;
}

static void debug_show(mrp_console_t *c, void *user_data,
                       int argc, char **argv)
{
    MRP_UNUSED(user_data);
    MRP_UNUSED(argc);
    MRP_UNUSED(argv);

    mrp_debug_dump_config(c->stdout);
}

static void read_status(long int i, paranoia_cb_mode_t mode)
{
#if 1
    MRP_UNUSED(i);
    MRP_UNUSED(mode);
#else
    mrp_debug("roffset: %ld, mode: 0x%x (%s)", i, mode,
              paranoia_cb_mode2str[mode]);
#endif
}

static int resource_set_get_resources(void *data, lua_State *L, int member, mrp_lua_value_t *v)
{
    resource_set_lua_t *rset;
    void *iter = NULL;
    mrp_resource_t *resource;
    mrp_resource_mask_t grant, advice;

    MRP_UNUSED(member);
    MRP_UNUSED(v);

    mrp_debug("> resource_set_get_resources");

    rset = (resource_set_lua_t *) data;

    if (!rset)
        return luaL_error(L, "internal error");

    grant = mrp_get_resource_set_grant(rset->resource_set);
    advice = mrp_get_resource_set_advice(rset->resource_set);

    lua_newtable(L);

    /* push all resource objects to a table and return it */

    while ((resource = mrp_resource_set_iterate_resources(rset->resource_set, &iter))) {
        const char *name = mrp_resource_get_name(resource);
        mrp_resource_mask_t mask = mrp_resource_get_mask(resource);

        /* fetch and update the resource object */

        resource_lua_t *res =
                (resource_lua_t *) mrp_htbl_lookup(rset->resources,
                (void *) name);

        if (!res) {
            mrp_log_error("resources out of sync: %s not found", name);
            continue;
        }

        /* mrp_lua_object_ref_value(res, L, 0); */

        res->acquired = !!(mask & grant);
        res->available = !!(mask & advice);

        /* TODO: update attributes */

        /* push the resource to the table */
        lua_pushstring(L, res->resource_name);
        mrp_lua_push_object(L, res);
        lua_settable(L, -3);
    }

    return 1;
}

void two_cb(mrp_console_t *c, void *user_data, int argc, char **argv)
{
    int i;

    MRP_UNUSED(c);
    MRP_UNUSED(user_data);

    for (i = 0; i < argc; i++) {
        printf("%s(): #%d: '%s'\n", __FUNCTION__, i, argv[i]);
    }
}

static void debug_set(mrp_console_t *c, void *user_data,
                      int argc, char **argv)
{
    int i;

    MRP_UNUSED(c);
    MRP_UNUSED(user_data);

    for (i = 2; i < argc; i++)
        mrp_debug_set_config(argv[i]);
}