/* $OpenBSD: events-payload.c,v 1.1 2026/07/10 13:38:45 nicm Exp $ */

/*
 * Copyright (c) 2026 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <event.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "tmux.h"

/* Event payload item. */
struct event_payload_item {
        char                                    *name;
        enum event_payload_type                  type;

        union {
                char                            *string;
                time_t                           time;
                int                              number;
                u_int                            unsigned_number;
                struct client                   *client;
                struct session                  *session;
                struct window                   *window;
                struct window_pane              *pane;
                struct {
                        void                    *ptr;
                        event_payload_free_cb    free_cb;
                        event_payload_print_cb   print_cb;
                } pointer;
        };

        RB_ENTRY(event_payload_item)     entry;
};

RB_HEAD(event_payload_tree, event_payload_item);

struct event_payload {
        struct event_payload_tree        items;
        struct cmd_find_state            target;
};

static int
event_payload_cmp(struct event_payload_item *epi1,
    struct event_payload_item *epi2)
{
        return (strcmp(epi1->name, epi2->name));
}
RB_GENERATE_STATIC(event_payload_tree, event_payload_item, entry,
    event_payload_cmp);

/* Find an item. */
static struct event_payload_item *
event_payload_find(struct event_payload *ep, const char *name)
{
        struct event_payload_item       find = { .name = (char *)name };

        return (RB_FIND(event_payload_tree, &ep->items, &find));
}

/* Free the target in a payload. */
static void
event_payload_free_target(struct event_payload *ep)
{
        struct cmd_find_state   *target = &ep->target;

        if (target->s != NULL)
                session_remove_ref(target->s, __func__);
        if (target->w != NULL)
                window_remove_ref(target->w, __func__);
        if (target->wp != NULL)
                window_pane_remove_ref(target->wp, __func__);

        cmd_find_clear_state(target, 0);
}

/* Free the value in an item. */
static void
event_payload_free_value(struct event_payload_item *epi)
{
        switch (epi->type) {
        case EVENT_PAYLOAD_STRING:
                free(epi->string);
                break;
        case EVENT_PAYLOAD_CLIENT:
                server_client_unref(epi->client);
                break;
        case EVENT_PAYLOAD_SESSION:
                session_remove_ref(epi->session, __func__);
                break;
        case EVENT_PAYLOAD_WINDOW:
                window_remove_ref(epi->window, __func__);
                break;
        case EVENT_PAYLOAD_PANE:
                window_pane_remove_ref(epi->pane, __func__);
                break;
        case EVENT_PAYLOAD_POINTER:
                if (epi->pointer.free_cb != NULL)
                        epi->pointer.free_cb(epi->pointer.ptr);
                break;
        case EVENT_PAYLOAD_INT:
        case EVENT_PAYLOAD_UINT:
        case EVENT_PAYLOAD_TIME:
                break;
        }
}

/* Set an item. */
static void
event_payload_set_item(struct event_payload *ep, const char *name,
    struct event_payload_item *new)
{
        struct event_payload_item       *old;

        new->name = xstrdup(name);
        old = RB_INSERT(event_payload_tree, &ep->items, new);
        if (old != NULL) {
                RB_REMOVE(event_payload_tree, &ep->items, old);
                event_payload_free_value(old);
                free(old->name);
                free(old);
                RB_INSERT(event_payload_tree, &ep->items, new);
        }
}

/* Create an event payload. */
struct event_payload *
event_payload_create(void)
{
        struct event_payload    *ep;

        ep = xcalloc(1, sizeof *ep);
        RB_INIT(&ep->items);
        cmd_find_clear_state(&ep->target, 0);
        return (ep);
}

/* Free an event payload. */
void
event_payload_free(struct event_payload *ep)
{
        struct event_payload_item       *epi, *epi1;

        if (ep != NULL) {
                RB_FOREACH_SAFE(epi, event_payload_tree, &ep->items, epi1) {
                        RB_REMOVE(event_payload_tree, &ep->items, epi);
                        event_payload_free_value(epi);
                        free(epi->name);
                        free(epi);
                }
                event_payload_free_target(ep);
                free(ep);
        }
}

/* Set the target. */
void
event_payload_set_target(struct event_payload *ep, struct cmd_find_state *fs)
{
        struct cmd_find_state   *target = &ep->target;

        event_payload_free_target(ep);

        if (fs->s != NULL) {
                session_add_ref(fs->s, __func__);
                target->s = fs->s;
        }
        if (fs->wl != NULL) {
                target->idx = fs->wl->idx;
                if (target->s == NULL) {
                        session_add_ref(fs->wl->session, __func__);
                        target->s = fs->wl->session;
                }
        } else
                target->idx = -1;
        if (fs->w != NULL) {
                window_add_ref(fs->w, __func__);
                target->w = fs->w;
        } else if (fs->wl != NULL) {
                window_add_ref(fs->wl->window, __func__);
                target->w = fs->wl->window;
        }
        if (fs->wp != NULL) {
                window_pane_add_ref(fs->wp, __func__);
                target->wp = fs->wp;
        }
}

/* Get the target. */
int
event_payload_get_target(struct event_payload *ep, struct cmd_find_state *fs)
{
        struct cmd_find_state   *t = &ep->target;
        struct winlink          *wl = NULL;
        int                      flags = fs->flags;

        if (t->idx != -1 &&
            t->s != NULL &&
            t->w != NULL &&
            session_alive(t->s)) {
                wl = winlink_find_by_index(&t->s->windows, t->idx);
                if (wl != NULL && wl->window != t->w)
                        wl = NULL;
        }

        cmd_find_clear_state(fs, flags);
        fs->s = t->s;
        fs->w = t->w;
        fs->wp = t->wp;
        fs->wl = wl;
        fs->idx = (wl != NULL ? wl->idx : -1);
        if (cmd_find_valid_state(fs))
                return (1);

        if (wl != NULL &&
            t->wp != NULL &&
            window_has_pane(wl->window, t->wp)) {
                cmd_find_from_winlink_pane(fs, wl, t->wp, flags);
                if (cmd_find_valid_state(fs))
                        return (1);
        }

        if (t->wp != NULL &&
            cmd_find_from_pane(fs, t->wp, flags) == 0 &&
            cmd_find_valid_state(fs))
                return (1);

        if (wl != NULL) {
                cmd_find_from_winlink(fs, wl, flags);
                if (cmd_find_valid_state(fs))
                        return (1);
        }

        if (t->s != NULL &&
            t->w != NULL &&
            session_alive(t->s) &&
            cmd_find_from_session_window(fs, t->s, t->w, flags) == 0 &&
            cmd_find_valid_state(fs))
                return (1);

        if (t->s != NULL && session_alive(t->s)) {
                cmd_find_from_session(fs, t->s, flags);
                if (cmd_find_valid_state(fs))
                        return (1);
        }

        if (cmd_find_from_nothing(fs, flags) == 0)
                return (1);

        cmd_find_clear_state(fs, flags);
        return (0);
}

/* Set a string item. */
void
event_payload_set_string(struct event_payload *ep, const char *name,
    const char *fmt, ...)
{
        struct event_payload_item       *epi;
        va_list                          ap;

        va_start(ap, fmt);

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_STRING;
        xvasprintf(&epi->string, fmt, ap);
        event_payload_set_item(ep, name, epi);

        va_end(ap);
}

/* Set a time item. */
void
event_payload_set_time(struct event_payload *ep, const char *name,
    time_t value)
{
        struct event_payload_item       *epi;

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_TIME;
        epi->time = value;
        event_payload_set_item(ep, name, epi);
}

/* Set a number item. */
void
event_payload_set_int(struct event_payload *ep, const char *name, int value)
{
        struct event_payload_item       *epi;

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_INT;
        epi->number = value;
        event_payload_set_item(ep, name, epi);
}

/* Set an unsigned number item. */
void
event_payload_set_uint(struct event_payload *ep, const char *name, u_int value)
{
        struct event_payload_item       *epi;

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_UINT;
        epi->unsigned_number = value;
        event_payload_set_item(ep, name, epi);
}

/* Set a client item. */
void
event_payload_set_client(struct event_payload *ep, const char *name,
    struct client *c)
{
        struct event_payload_item       *epi;

        c->references++;

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_CLIENT;
        epi->client = c;
        event_payload_set_item(ep, name, epi);
}

/* Set a session item. */
void
event_payload_set_session(struct event_payload *ep, const char *name,
    struct session *s)
{
        struct event_payload_item       *epi;

        session_add_ref(s, __func__);

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_SESSION;
        epi->session = s;
        event_payload_set_item(ep, name, epi);
}

/* Set a window item. */
void
event_payload_set_window(struct event_payload *ep, const char *name,
    struct window *w)
{
        struct event_payload_item       *epi;

        window_add_ref(w, __func__);

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_WINDOW;
        epi->window = w;
        event_payload_set_item(ep, name, epi);
}

/* Set a pane item. */
void
event_payload_set_pane(struct event_payload *ep, const char *name,
    struct window_pane *wp)
{
        struct event_payload_item       *epi;

        window_pane_add_ref(wp, __func__);

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_PANE;
        epi->pane = wp;
        event_payload_set_item(ep, name, epi);
}

/* Set a pointer item. */
void
event_payload_set_pointer(struct event_payload *ep, const char *name,
    void *ptr, event_payload_free_cb free_cb, event_payload_print_cb print_cb)
{
        struct event_payload_item       *epi;

        epi = xcalloc(1, sizeof *epi);
        epi->type = EVENT_PAYLOAD_POINTER;
        epi->pointer.ptr = ptr;
        epi->pointer.free_cb = free_cb;
        epi->pointer.print_cb = print_cb;
        event_payload_set_item(ep, name, epi);
}

/* Get a string item. */
const char *
event_payload_get_string(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_STRING)
                return (NULL);
        return (epi->string);
}

/* Print a payload item. */
static void
event_payload_add_item(struct event_payload_item *epi, struct evbuffer *evb)
{
        switch (epi->type) {
        case EVENT_PAYLOAD_STRING:
                evbuffer_add_printf(evb, "%s", epi->string);
                break;
        case EVENT_PAYLOAD_TIME:
                evbuffer_add_printf(evb, "%lld", (long long)epi->time);
                break;
        case EVENT_PAYLOAD_INT:
                evbuffer_add_printf(evb, "%d", epi->number);
                break;
        case EVENT_PAYLOAD_UINT:
                evbuffer_add_printf(evb, "%u", epi->unsigned_number);
                break;
        case EVENT_PAYLOAD_CLIENT:
                evbuffer_add_printf(evb, "%s", epi->client->name);
                break;
        case EVENT_PAYLOAD_SESSION:
                evbuffer_add_printf(evb, "$%u", epi->session->id);
                break;
        case EVENT_PAYLOAD_WINDOW:
                evbuffer_add_printf(evb, "@%u", epi->window->id);
                break;
        case EVENT_PAYLOAD_PANE:
                evbuffer_add_printf(evb, "%%%u", epi->pane->id);
                break;
        case EVENT_PAYLOAD_POINTER:
                if (epi->pointer.print_cb != NULL)
                        epi->pointer.print_cb(epi->pointer.ptr, evb);
                else
                        evbuffer_add_printf(evb, "%p", epi->pointer.ptr);
                break;
        }
}

/* Print a payload item. */
char *
event_payload_item_print(struct event_payload_item *epi)
{
        struct evbuffer                 *evb;
        char                            *value = NULL;
        size_t                           size;

        evb = evbuffer_new();
        if (evb == NULL)
                fatalx("out of memory");
        event_payload_add_item(epi, evb);
        if ((size = EVBUFFER_LENGTH(evb)) != 0)
                value = xmemdup(EVBUFFER_DATA(evb), size);
        else
                value = xstrdup("");
        evbuffer_free(evb);
        return (value);
}

/* Print an item value. */
char *
event_payload_print(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL)
                return (NULL);
        return (event_payload_item_print(epi));
}

/* Add payload items as formats. */
void
event_payload_add_formats(struct event_payload *ep, struct format_tree *ft,
    const char *prefix)
{
        struct event_payload_item       *epi;
        char                            *name, *value;
        const char                      *key;

        if (prefix == NULL)
                prefix = "";

        RB_FOREACH(epi, event_payload_tree, &ep->items) {
                key = epi->name;
                if (*key == '_')
                        continue;

                value = event_payload_item_print(epi);
                xasprintf(&name, "%s%s", prefix, key);
                format_add(ft, name, "%s", value);
                free(name);
                free(value);

                if (epi->type == EVENT_PAYLOAD_SESSION) {
                        xasprintf(&name, "%s%s_name", prefix, key);
                        format_add(ft, name, "%s", epi->session->name);
                        free(name);
                } else if (epi->type == EVENT_PAYLOAD_WINDOW) {
                        xasprintf(&name, "%s%s_name", prefix, key);
                        format_add(ft, name, "%s", epi->window->name);
                        free(name);
                }
        }
}

/* Get the first payload item. */
struct event_payload_item *
event_payload_first(struct event_payload *ep)
{
        return (RB_MIN(event_payload_tree, &ep->items));
}

/* Get the next payload item. */
struct event_payload_item *
event_payload_next(struct event_payload_item *epi)
{
        return (RB_NEXT(event_payload_tree, , epi));
}

/* Get a payload item name. */
const char *
event_payload_item_name(struct event_payload_item *epi)
{
        return (epi->name);
}

/* Get a payload item type. */
enum event_payload_type
event_payload_item_type(struct event_payload_item *epi)
{
        return (epi->type);
}

/* Log a payload. */
void
event_payload_log(struct event_payload *ep, const char *fmt, ...)
{
        struct event_payload_item       *epi;
        struct evbuffer                 *evb;
        va_list                          ap;
        char                            *prefix;

        va_start(ap, fmt);
        xvasprintf(&prefix, fmt, ap);
        va_end(ap);

        evb = evbuffer_new();
        if (evb == NULL)
                fatalx("out of memory");
        if (ep != NULL) {
                RB_FOREACH(epi, event_payload_tree, &ep->items) {
                        if (EVBUFFER_LENGTH(evb) != 0)
                                evbuffer_add_printf(evb, ", ");
                        evbuffer_add_printf(evb, "%s=", epi->name);
                        event_payload_add_item(epi, evb);
                }
        }
        log_debug("%s%.*s", prefix, (int)EVBUFFER_LENGTH(evb),
            (char *)EVBUFFER_DATA(evb));
        evbuffer_free(evb);
        free(prefix);
}

/* Get a time item. */
time_t
event_payload_get_time(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_TIME)
                return (0);
        return (epi->time);
}

/* Get a number item. */
int
event_payload_get_int(struct event_payload *ep, const char *name, int *value)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_INT)
                return (-1);
        *value = epi->number;
        return (0);
}

/* Get an unsigned number item. */
int
event_payload_get_uint(struct event_payload *ep, const char *name, u_int *value)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_UINT)
                return (-1);
        *value = epi->unsigned_number;
        return (0);
}

/* Get a client item. */
struct client *
event_payload_get_client(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_CLIENT)
                return (NULL);
        return (epi->client);
}

/* Get a session item. */
struct session *
event_payload_get_session(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_SESSION)
                return (NULL);
        return (epi->session);
}

/* Get a window item. */
struct window *
event_payload_get_window(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_WINDOW)
                return (NULL);
        return (epi->window);
}

/* Get a pane item. */
struct window_pane *
event_payload_get_pane(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_PANE)
                return (NULL);
        return (epi->pane);
}

/* Get a pointer item. */
void *
event_payload_get_pointer(struct event_payload *ep, const char *name)
{
        struct event_payload_item       *epi;

        epi = event_payload_find(ep, name);
        if (epi == NULL || epi->type != EVENT_PAYLOAD_POINTER)
                return (NULL);
        return (epi->pointer.ptr);
}