common/core/command.c

#include <concord/chash.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include "command.h"
#include "../utils/strutils.h"
#include "../utils/xmalloc.h"
#include "../io/log.h"
#include "../commands/commands.h"

static void command_argv_create(const char *content, size_t *_argc, char ***_argv)
{
    char **argv = NULL;
    size_t argc = 0;
    char *trimmed_content = str_trim(content);
    size_t content_length = strlen(trimmed_content);
    char *tmpstr = NULL;
    size_t tmpstrlen = 0;

    for (size_t i = 0; i < content_length; i++)
    {
        if (isspace(trimmed_content[i]))
        {
            tmpstr = xrealloc(tmpstr, ++tmpstrlen);
            tmpstr[tmpstrlen - 1] = 0;
            argv = xrealloc(argv, (++argc) * (sizeof(char *)));
            argv[argc - 1] = tmpstr;
            tmpstr = NULL;
            tmpstrlen = 0;
            continue;
        }

        tmpstr = xrealloc(tmpstr, ++tmpstrlen);
        tmpstr[tmpstrlen - 1] = trimmed_content[i];
    }

    if (tmpstrlen > 0)
    {
        tmpstr = xrealloc(tmpstr, ++tmpstrlen);
        tmpstr[tmpstrlen - 1] = 0;
        argv = xrealloc(argv, (++argc) * (sizeof(char *)));
        argv[argc - 1] = tmpstr;
    }

    *_argc = argc;
    *_argv = argv;
    free(trimmed_content);
}

static void command_argv_free(size_t argc, char **argv)
{
    for (size_t i = 0; i < argc; i++)
    {
        free(argv[i]);
    }

    free(argv);
}

static void command_argv_print(size_t argc, char **argv)
{
#ifndef NDEBUG
    log_debug("%s(%zu, %p):", __func__, argc, argv);

    for (size_t i = 0; i < argc; i++)
    {
        log_debug("    argv[%zu]: %s", i, argv[i]);
    }
#endif
}

#define PREFIX "-"

const struct command_info *command_find_by_name(const char *name)
{
    for (size_t i = 0; i < command_count; i++)
    {
        if (strcmp(name, command_list[i].name) == 0)
        {
            return &command_list[i];
        }
    }

    return NULL;
}

void command_on_interaction_handler(struct discord *client, const struct discord_interaction *interaction)
{
    if (interaction->type != DISCORD_INTERACTION_APPLICATION_COMMAND)
        return;

    const char *command_name = interaction->data->name;

    const struct command_info *command = command_find_by_name(command_name);
    
    if (command == NULL)
    {
        log_debug("Command not found: %s", command_name);
        return;
    }

    if ((command->mode & CMD_MODE_CHAT_INPUT_COMMAND_INTERACTION) != CMD_MODE_CHAT_INPUT_COMMAND_INTERACTION) {
        log_debug("Command does not support chat input command interaction mode: %s", command_name);
        return;
    }

    cmd_callback_t callback = command->callback;

    cmdctx_t context = {
        .type = CMDCTX_CHAT_INPUT_COMMAND_INTERACTION,
        .is_legacy = false,
        .is_chat_input_command_interaction = true,
        .is_interaction = true,
        .command_name = command_name,
        .interaction = interaction
    };

    callback(client, context);
}

void command_on_message_handler(struct discord *client, const struct discord_message *message)
{
    if (message->author->bot || !str_starts_with(message->content, PREFIX))
    {
        return;
    }

    size_t prefix_len = strlen(PREFIX);
    assert(prefix_len != 0 && "Prefix cannot be an empty string");
    const char *content = message->content + prefix_len;
    char **argv;
    size_t argc;

    command_argv_create(content, &argc, &argv);
    command_argv_print(argc, argv);

    const char *command_name = argv[0];
    const struct command_info *command = command_find_by_name(command_name);
    
    if (command == NULL)
    {
        log_debug("Command not found: %s", command_name);
        goto command_on_message_handler_end;
    }

    if ((command->mode & CMD_MODE_LEGACY) != CMD_MODE_LEGACY) {
        log_debug("Command does not support legacy mode: %s", command_name);
        goto command_on_message_handler_end;
    }

    cmd_callback_t callback = command->callback;

    cmdctx_t context = {
        .type = CMDCTX_LEGACY,
        .is_legacy = true,
        .is_chat_input_command_interaction = false,
        .is_interaction = false,
        .argc = argc,
        .argv = (const char **)argv,
        .command_name = command_name,
        .message = message,
    };

    callback(client, context);

command_on_message_handler_end:
    command_argv_free(argc, argv);
}

void register_slash_commands(struct discord *client, u64snowflake guild)
{
    const struct discord_user *self = discord_get_self(client);
    struct discord_bulk_overwrite_guild_application_commands *params = xcalloc(1, sizeof (*params));
    size_t count = 1;

    for (size_t i = 0; i < command_count; i++)
    {
        const struct command_info command = command_list[i];

        params = xrealloc(params, sizeof (*params) * (++count));

        params[i].name = (char *) command.name;
        params[i].type = command.type;
        params[i].description = (char *) command.description;
    }

    memset(&params[count - 1], 0, sizeof (*params));

    assert(guild != 0);

    discord_bulk_overwrite_guild_application_commands(client, self->id, guild, params, NULL);
}
1	#include <concord/chash.h>
2	#include <string.h>
3	#include <ctype.h>
4	#include <assert.h>
5	#include "command.h"
6	#include "../utils/strutils.h"
7	#include "../utils/xmalloc.h"
8	#include "../io/log.h"
9	#include "../commands/commands.h"
10
11	static void command_argv_create(const char content, size_t _argc, char ***_argv)
12	{
13	char **argv = NULL;
14	size_t argc = 0;
15	char *trimmed_content = str_trim(content);
16	size_t content_length = strlen(trimmed_content);
17	char *tmpstr = NULL;
18	size_t tmpstrlen = 0;
19
20	for (size_t i = 0; i < content_length; i++)
21	{
22	if (isspace(trimmed_content[i]))
23	{
24	tmpstr = xrealloc(tmpstr, ++tmpstrlen);
25	tmpstr[tmpstrlen - 1] = 0;
26	argv = xrealloc(argv, (++argc) * (sizeof(char *)));
27	argv[argc - 1] = tmpstr;
28	tmpstr = NULL;
29	tmpstrlen = 0;
30	continue;
31	}
32
33	tmpstr = xrealloc(tmpstr, ++tmpstrlen);
34	tmpstr[tmpstrlen - 1] = trimmed_content[i];
35	}
36
37	if (tmpstrlen > 0)
38	{
39	tmpstr = xrealloc(tmpstr, ++tmpstrlen);
40	tmpstr[tmpstrlen - 1] = 0;
41	argv = xrealloc(argv, (++argc) * (sizeof(char *)));
42	argv[argc - 1] = tmpstr;
43	}
44
45	*_argc = argc;
46	*_argv = argv;
47	free(trimmed_content);
48	}
49
50	static void command_argv_free(size_t argc, char **argv)
51	{
52	for (size_t i = 0; i < argc; i++)
53	{
54	free(argv[i]);
55	}
56
57	free(argv);
58	}
59
60	static void command_argv_print(size_t argc, char **argv)
61	{
62	#ifndef NDEBUG
63	log_debug("%s(%zu, %p):", __func__, argc, argv);
64
65	for (size_t i = 0; i < argc; i++)
66	{
67	log_debug(" argv[%zu]: %s", i, argv[i]);
68	}
69	#endif
70	}
71
72	#define PREFIX "-"
73
74	const struct command_info command_find_by_name(const char name)
75	{
76	for (size_t i = 0; i < command_count; i++)
77	{
78	if (strcmp(name, command_list[i].name) == 0)
79	{
80	return &command_list[i];
81	}
82	}
83
84	return NULL;
85	}
86
87	void command_on_interaction_handler(struct discord client, const struct discord_interaction interaction)
88	{
89	if (interaction->type != DISCORD_INTERACTION_APPLICATION_COMMAND)
90	return;
91
92	const char *command_name = interaction->data->name;
93
94	const struct command_info *command = command_find_by_name(command_name);
95
96	if (command == NULL)
97	{
98	log_debug("Command not found: %s", command_name);
99	return;
100	}
101
102	if ((command->mode & CMD_MODE_CHAT_INPUT_COMMAND_INTERACTION) != CMD_MODE_CHAT_INPUT_COMMAND_INTERACTION) {
103	log_debug("Command does not support chat input command interaction mode: %s", command_name);
104	return;
105	}
106
107	cmd_callback_t callback = command->callback;
108
109	cmdctx_t context = {
110	.type = CMDCTX_CHAT_INPUT_COMMAND_INTERACTION,
111	.is_legacy = false,
112	.is_chat_input_command_interaction = true,
113	.is_interaction = true,
114	.command_name = command_name,
115	.interaction = interaction
116	};
117
118	callback(client, context);
119	}
120
121	void command_on_message_handler(struct discord client, const struct discord_message message)
122	{
123	if (message->author->bot \|\| !str_starts_with(message->content, PREFIX))
124	{
125	return;
126	}
127
128	size_t prefix_len = strlen(PREFIX);
129	assert(prefix_len != 0 && "Prefix cannot be an empty string");
130	const char *content = message->content + prefix_len;
131	char **argv;
132	size_t argc;
133
134	command_argv_create(content, &argc, &argv);
135	command_argv_print(argc, argv);
136
137	const char *command_name = argv[0];
138	const struct command_info *command = command_find_by_name(command_name);
139
140	if (command == NULL)
141	{
142	log_debug("Command not found: %s", command_name);
143	goto command_on_message_handler_end;
144	}
145
146	if ((command->mode & CMD_MODE_LEGACY) != CMD_MODE_LEGACY) {
147	log_debug("Command does not support legacy mode: %s", command_name);
148	goto command_on_message_handler_end;
149	}
150
151	cmd_callback_t callback = command->callback;
152
153	cmdctx_t context = {
154	.type = CMDCTX_LEGACY,
155	.is_legacy = true,
156	.is_chat_input_command_interaction = false,
157	.is_interaction = false,
158	.argc = argc,
159	.argv = (const char **)argv,
160	.command_name = command_name,
161	.message = message,
162	};
163
164	callback(client, context);
165
166	command_on_message_handler_end:
167	command_argv_free(argc, argv);
168	}
169
170	void register_slash_commands(struct discord *client, u64snowflake guild)
171	{
172	const struct discord_user *self = discord_get_self(client);
173	struct discord_bulk_overwrite_guild_application_commands params = xcalloc(1, sizeof (params));
174	size_t count = 1;
175
176	for (size_t i = 0; i < command_count; i++)
177	{
178	const struct command_info command = command_list[i];
179
180	params = xrealloc(params, sizeof (params) (++count));
181
182	params[i].name = (char *) command.name;
183	params[i].type = command.type;
184	params[i].description = (char *) command.description;
185	}
186
187	memset(&params[count - 1], 0, sizeof (*params));
188
189	assert(guild != 0);
190
191	discord_bulk_overwrite_guild_application_commands(client, self->id, guild, params, NULL);
192	}