/* $OpenBSD: cmd-show-options.c,v 1.76 2026/07/27 19:15:58 nicm Exp $ */

/*
 * Copyright (c) 2007 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 MIND, 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 <vis.h>

#include "tmux.h"

/*
 * Show options.
 */

#define SHOW_OPTIONS_TEMPLATE                                           \
        "#{?option_value_only,"                                         \
        "#{option_value},"                                              \
        "#{option_name}#{?option_has_array_key,"                        \
        "[#{option_array_key}],}"                                       \
        "#{?option_is_parent,*,}"                                       \
        "#{?option_has_value, "                                         \
        "#{?option_is_string,#{q/a:option_value},#{option_value}},}}"
#define SHOW_HOOKS_MONITOR_TEMPLATE                                     \
        "#{option_name}:#{hook_monitor_target}:#{hook_monitor_format}"

static enum cmd_retval  cmd_show_options_exec(struct cmd *, struct cmdq_item *);

static void             cmd_show_options_print(struct cmd *, struct cmdq_item *,
                            struct options_entry *, const char *, int);
static void             cmd_show_hooks_print_monitor(struct cmd *,
                            struct cmdq_item *, struct options_entry *);
static enum cmd_retval  cmd_show_options_all(struct cmd *, struct cmdq_item *,
                            int, struct options *);

const struct cmd_entry cmd_show_options_entry = {
        .name = "show-options",
        .alias = "show",

        .args = { "AgF:Hpqst:vw", 0, 1, NULL },
        .usage = "[-AgHpqsvw] [-F format] " CMD_TARGET_PANE_USAGE " [option]",

        .target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },

        .flags = CMD_AFTERHOOK,
        .exec = cmd_show_options_exec
};

const struct cmd_entry cmd_show_window_options_entry = {
        .name = "show-window-options",
        .alias = "showw",

        .args = { "F:gvt:", 0, 1, NULL },
        .usage = "[-gv] [-F format] " CMD_TARGET_WINDOW_USAGE " [option]",

        .target = { 't', CMD_FIND_WINDOW, CMD_FIND_CANFAIL },

        .flags = CMD_AFTERHOOK,
        .exec = cmd_show_options_exec
};

const struct cmd_entry cmd_show_hooks_entry = {
        .name = "show-hooks",
        .alias = NULL,

        .args = { "BF:gpt:w", 0, 1, NULL },
        .usage = "[-Bgpw] [-F format] " CMD_TARGET_PANE_USAGE " [hook]",

        .target = { 't', CMD_FIND_PANE, CMD_FIND_CANFAIL },

        .flags = CMD_AFTERHOOK,
        .exec = cmd_show_options_exec
};

static enum cmd_retval
cmd_show_options_exec(struct cmd *self, struct cmdq_item *item)
{
        struct args                     *args = cmd_get_args(self);
        struct cmd_find_state           *target = cmdq_get_target(item);
        struct options                  *oo;
        char                            *argument, *name = NULL, *cause;
        char                            *array_key = NULL;
        int                              window, ambiguous, parent, print_parent, scope;
        struct options_entry            *o;

        window = (cmd_get_entry(self) == &cmd_show_window_options_entry);

        if (args_count(args) == 0) {
                scope = options_scope_from_flags(args, window, target, &oo,
                    &cause);
                if (scope == OPTIONS_TABLE_NONE) {
                        if (args_has(args, 'q'))
                                return (CMD_RETURN_NORMAL);
                        cmdq_error(item, "%s", cause);
                        free(cause);
                        return (CMD_RETURN_ERROR);
                }
                if (cmd_get_entry(self) == &cmd_show_hooks_entry &&
                    args_has(args, 'B')) {
                        o = options_first(oo);
                        while (o != NULL) {
                                cmd_show_hooks_print_monitor(self, item, o);
                                o = options_next(o);
                        }
                        return (CMD_RETURN_NORMAL);
                }
                return (cmd_show_options_all(self, item, scope, oo));
        }
        argument = format_single_from_target(item, args_string(args, 0));

        name = options_match(argument, &array_key, &ambiguous);
        if (name == NULL) {
                if (args_has(args, 'q'))
                        goto out;
                if (ambiguous)
                        cmdq_error(item, "ambiguous option: %s", argument);
                else
                        cmdq_error(item, "invalid option: %s", argument);
                goto fail;
        }
        scope = options_scope_from_name(args, window, name, target, &oo,
            &cause);
        if (scope == OPTIONS_TABLE_NONE) {
                if (args_has(args, 'q'))
                        goto out;
                cmdq_error(item, "%s", cause);
                free(cause);
                goto fail;
        }
        o = options_get_only(oo, name);
        if (args_has(args, 'A') && o == NULL) {
                o = options_get(oo, name);
                parent = 1;
        } else
                parent = 0;
        if (o != NULL) {
                if (cmd_get_entry(self) == &cmd_show_hooks_entry &&
                    args_has(args, 'B'))
                        cmd_show_hooks_print_monitor(self, item, o);
                else {
                        print_parent = parent;
                        if (array_key == NULL && options_is_array(o) &&
                            options_array_first(o) == NULL) {
                                print_parent = 0;
                        }
                        cmd_show_options_print(self, item, o, array_key,
                            print_parent);
                }
        } else if (*name == '@') {
                if (args_has(args, 'q'))
                        goto out;
                cmdq_error(item, "invalid option: %s", argument);
                goto fail;
        }

out:
        free(name);
        free(array_key);
        free(argument);
        return (CMD_RETURN_NORMAL);

fail:
        free(name);
        free(array_key);
        free(argument);
        return (CMD_RETURN_ERROR);
}

static void
cmd_show_options_print(struct cmd *self, struct cmdq_item *item,
    struct options_entry *o, const char *array_key, int parent)
{
        struct args                      *args = cmd_get_args(self);
        struct options_array_item        *a;
        struct format_tree               *ft;
        const char                       *name = options_name(o);
        const char                       *template = args_get(args, 'F');
        char                             *value, *line;
        struct timeval                    tv = { 0 };
        u_int                             fire_count;
        time_t                            fire_time;
        int                               is_hook = 0, is_user = 0;
        int                               has_value = 1;
        const struct options_table_entry *oe = options_table_entry(o);

        if (array_key != NULL)
                value = options_to_string(o, array_key, 0);
        else if (options_is_array(o)) {
                a = options_array_first(o);
                if (a != NULL) {
                        while (a != NULL) {
                                array_key = options_array_item_key(a);
                                cmd_show_options_print(self, item, o, array_key,
                                    parent);
                                a = options_array_next(a);
                        }
                        return;
                }
                if (template == NULL && args_has(args, 'v'))
                        return;
                value = xstrdup("");
                has_value = 0;
        } else
                value = options_to_string(o, NULL, 0);

        if (template == NULL)
                template = SHOW_OPTIONS_TEMPLATE;

        if (oe != NULL && (oe->flags & OPTIONS_TABLE_IS_HOOK))
                is_hook = 1;
        else if (oe == NULL)
                is_user = 1;

        ft = format_create_from_target(item);
        format_add(ft, "option_name", "%s", name);
        format_add(ft, "option_value", "%s", value);
        format_add(ft, "option_value_only", "%d", args_has(args, 'v'));
        format_add(ft, "option_is_parent", "%d", parent);
        format_add(ft, "option_is_array", "%d", options_is_array(o));
        format_add(ft, "option_is_string", "%d", options_is_string(o));
        format_add(ft, "option_is_hook", "%d", is_hook);
        format_add(ft, "option_is_user", "%d", is_user);
        format_add(ft, "option_has_value", "%d", has_value);
        if (cmd_get_entry(self) == &cmd_show_hooks_entry) {
                fire_count = options_get_fire_count(o);
                format_add(ft, "hook_fire_count", "%u", fire_count);

                fire_time = options_get_fire_time(o);
                if (fire_time != 0) {
                        tv.tv_sec = fire_time;
                        format_add_tv(ft, "hook_fire_time", &tv);
                }
        }
        if (array_key != NULL) {
                format_add(ft, "option_array_key", "%s", array_key);
                format_add(ft, "option_has_array_key", "1");
        } else {
                format_add(ft, "option_array_key", "%s", "");
                format_add(ft, "option_has_array_key", "0");
        }
        line = format_expand(ft, template);
        format_free(ft);

        cmdq_print(item, "%s", line);
        free(line);
        free(value);
}

static void
cmd_show_hooks_print_monitor(struct cmd *self, struct cmdq_item *item,
    struct options_entry *o)
{
        struct args             *args = cmd_get_args(self);
        struct format_tree      *ft;
        enum monitor_type        type;
        const char              *template = args_get(args, 'F'), *format;
        char                    *value, *target, *line;
        struct timeval           tv = { 0 };
        u_int                    fire_count;
        time_t                   fire_time;
        int                      id;

        value = hooks_monitor_to_string(o);
        if (value == NULL)
                return;
        if (!hooks_monitor_get(o, &type, &id, &format)) {
                free(value);
                return;
        }
        if (template == NULL)
                template = SHOW_HOOKS_MONITOR_TEMPLATE;

        switch (type) {
        case MONITOR_SESSION:
                target = xstrdup("");
                break;
        case MONITOR_PANE:
                xasprintf(&target, "%%%d", id);
                break;
        case MONITOR_ALL_PANES:
                target = xstrdup("%*");
                break;
        case MONITOR_WINDOW:
                xasprintf(&target, "@%d", id);
                break;
        case MONITOR_ALL_WINDOWS:
                target = xstrdup("@*");
                break;
        }

        ft = format_create_from_target(item);
        format_add(ft, "option_name", "%s", options_name(o));
        format_add(ft, "option_value", "%s", value);
        format_add(ft, "option_value_only", "%d", 0);
        format_add(ft, "option_is_parent", "%d", 0);
        format_add(ft, "option_is_array", "%d", 0);
        format_add(ft, "option_is_string", "%d", 1);
        format_add(ft, "option_is_hook", "%d", 1);
        format_add(ft, "option_is_user", "%d", 1);
        format_add(ft, "option_has_value", "%d", 1);
        format_add(ft, "option_array_key", "%s", "");
        format_add(ft, "option_has_array_key", "0");

        format_add(ft, "hook_monitor_target", "%s", target);
        format_add(ft, "hook_monitor_format", "%s", format);

        fire_count = hooks_monitor_get_fire_count(o);
        format_add(ft, "hook_fire_count", "%u", fire_count);

        fire_time = hooks_monitor_get_fire_time(o);
        if (fire_time != 0) {
                tv.tv_sec = fire_time;
                format_add_tv(ft, "hook_fire_time", &tv);
        }

        line = format_expand(ft, template);
        format_free(ft);

        cmdq_print(item, "%s", line);
        free(line);
        free(target);
        free(value);
}

static enum cmd_retval
cmd_show_options_all(struct cmd *self, struct cmdq_item *item, int scope,
    struct options *oo)
{
        struct args                             *args = cmd_get_args(self);
        const struct options_table_entry        *oe;
        struct options_entry                    *o;
        const char                              *name;
        int                                      parent, is_user_hook;

        o = options_first(oo);
        while (o != NULL) {
                if (options_table_entry(o) == NULL) {
                        name = options_name(o);
                        is_user_hook = 0;
                        if (*name == '@') {
                                if (hooks_is_event(name) ||
                                    options_get_monitor_data(o) != NULL) {
                                        is_user_hook = 1;
                                }
                        }
                        if (cmd_get_entry(self) != &cmd_show_hooks_entry) {
                                if (!is_user_hook || args_has(args, 'H')) {
                                        cmd_show_options_print(self, item, o,
                                            NULL, 0);
                                }
                        } else if (is_user_hook)
                                cmd_show_options_print(self, item, o, NULL, 0);
                }
                o = options_next(o);
        }
        for (oe = options_table; oe->name != NULL; oe++) {
                if (~oe->scope & scope)
                        continue;

                if ((cmd_get_entry(self) != &cmd_show_hooks_entry &&
                    !args_has(args, 'H') &&
                    (oe->flags & OPTIONS_TABLE_IS_HOOK)) ||
                    (cmd_get_entry(self) == &cmd_show_hooks_entry &&
                    (~oe->flags & OPTIONS_TABLE_IS_HOOK)))
                        continue;

                o = options_get_only(oo, oe->name);
                if (o == NULL) {
                        if (!args_has(args, 'A'))
                                continue;
                        o = options_get(oo, oe->name);
                        if (o == NULL)
                                continue;
                        parent = 1;
                } else
                        parent = 0;

                cmd_show_options_print(self, item, o, NULL, parent);
        }
        return (CMD_RETURN_NORMAL);
}