/* $OpenBSD: events.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 <stdlib.h>
#include <string.h>

#include "tmux.h"

/* Event sink. */
struct events_sink {
        char                            *name;
        events_cb                        cb;
        void                            *data;
        int                              dead;
        u_int                            generation;

        TAILQ_ENTRY(events_sink)         entry;
};

TAILQ_HEAD(events_sinks, events_sink);
static struct events_sinks events_sinks = TAILQ_HEAD_INITIALIZER(events_sinks);

static u_int events_dispatching;
static u_int events_generation;

/* Free an event sink. */
static void
events_free_sink(struct events_sink *es)
{
        TAILQ_REMOVE(&events_sinks, es, entry);
        free(es->name);
        free(es);
}

/* Free dead event sinks. */
static void
events_free_dead(void)
{
        struct events_sink      *es, *es1;

        TAILQ_FOREACH_SAFE(es, &events_sinks, entry, es1) {
                if (es->dead)
                        events_free_sink(es);
        }
}

/* Add an event sink. */
struct events_sink *
events_add_sink(const char *name, events_cb cb, void *data)
{
        struct events_sink      *es;

        es = xcalloc(1, sizeof *es);
        es->name = xstrdup(name);
        es->cb = cb;
        es->data = data;
        es->generation = ++events_generation;

        TAILQ_INSERT_TAIL(&events_sinks, es, entry);
        return (es);
}

/* Remove an event sink. */
void
events_remove_sink(struct events_sink *es)
{
        if (es != NULL && !es->dead) {
                if (events_dispatching != 0)
                        es->dead = 1;
                else
                        events_free_sink(es);
        }
}

/* Fire an event. */
void
events_fire(const char *name, struct event_payload *ep)
{
        struct events_sink      *es;
        u_int                    generation = events_generation;

        event_payload_set_string(ep, "event", "%s", name);

        if (log_get_level() != 0)
                event_payload_log(ep, "%s: %s: ", __func__, name);

        events_dispatching++;
        TAILQ_FOREACH(es, &events_sinks, entry) {
                if (es->dead || es->generation > generation)
                        continue;
                if (strcmp(es->name, name) == 0)
                        es->cb(name, ep, es->data);
        }
        if (--events_dispatching == 0)
                events_free_dead();
        event_payload_free(ep);
}

/* Fire a client event. */
void
events_fire_client(const char *name, struct client *c)
{
        struct event_payload    *ep;
        struct cmd_find_state    fs;

        ep = event_payload_create();
        cmd_find_from_client(&fs, c, 0);
        event_payload_set_target(ep, &fs);
        event_payload_set_client(ep, "client", c);
        if (fs.s != NULL)
                event_payload_set_session(ep, "session", fs.s);
        if (fs.w != NULL)
                event_payload_set_window(ep, "window", fs.w);
        if (fs.wl != NULL)
                event_payload_set_int(ep, "window_index", fs.wl->idx);
        else if (fs.idx != -1)
                event_payload_set_int(ep, "window_index", fs.idx);
        if (fs.wp != NULL)
                event_payload_set_pane(ep, "pane", fs.wp);
        events_fire(name, ep);
}

/* Fire a session event. */
void
events_fire_session(const char *name, struct session *s)
{
        struct event_payload    *ep;
        struct cmd_find_state    fs;

        ep = event_payload_create();
        if (session_alive(s)) {
                cmd_find_from_session(&fs, s, 0);
                event_payload_set_target(ep, &fs);
        }
        event_payload_set_session(ep, "session", s);
        events_fire(name, ep);
}

/* Fire a window event. */
void
events_fire_window(const char *name, struct window *w)
{
        struct event_payload    *ep;
        struct cmd_find_state    fs;

        ep = event_payload_create();
        cmd_find_from_window(&fs, w, 0);
        event_payload_set_target(ep, &fs);
        event_payload_set_window(ep, "window", w);
        events_fire(name, ep);
}

/* Fire a pane event. */
void
events_fire_pane(const char *name, struct window_pane *wp)
{
        struct event_payload    *ep;
        struct cmd_find_state    fs;

        ep = event_payload_create();
        cmd_find_from_pane(&fs, wp, 0);
        event_payload_set_target(ep, &fs);
        event_payload_set_pane(ep, "pane", wp);
        event_payload_set_window(ep, "window", wp->window);
        events_fire(name, ep);
}

/* Fire a winlink event. */
void
events_fire_winlink(const char *name, struct winlink *wl)
{
        struct event_payload    *ep;
        struct cmd_find_state    fs;

        ep = event_payload_create();
        cmd_find_from_winlink(&fs, wl, 0);
        event_payload_set_target(ep, &fs);
        event_payload_set_session(ep, "session", wl->session);
        event_payload_set_window(ep, "window", wl->window);
        event_payload_set_int(ep, "window_index", wl->idx);
        events_fire(name, ep);
}