path: root/src/tools/autocomplete.c

/*
 * autocomplete.c
 * vim: expandtab:ts=4:sts=4:sw=4
 *
 * Copyright (C) 2012 - 2019 James Booth <boothj5@gmail.com>
 *
 * This file is part of Profanity.
 *
 * Profanity is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Profanity is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Profanity.  If not, see <https://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give permission to
 * link the code of portions of this program with the OpenSSL library under
 * certain conditions as described in each individual source file, and
 * distribute linked combinations including the two.
 *
 * You must obey the GNU General Public License in all respects for all of the
 * code used other than OpenSSL. If you modify file(s) with this exception, you
 * may extend this exception to your version of the file(s), but you are not
 * obligated to do so. If you do not wish to do so, delete this exception
 * statement from your version. If you delete this exception statement from all
 * source files in the program, then also delete it here.
 *
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>

#include "common.h"
#include "tools/autocomplete.h"
#include "tools/parser.h"
#include "ui/ui.h"

typedef enum {
    PREVIOUS,
    NEXT
} search_direction;

struct autocomplete_t
{
    GList* items;
    GList* last_found;
    gchar* search_str;
};

static gchar* _search(Autocomplete ac, GList* curr, gboolean quote, search_direction direction);

Autocomplete
autocomplete_new(void)
{
    Autocomplete new = malloc(sizeof(struct autocomplete_t));
    new->items = NULL;
    new->last_found = NULL;
    new->search_str = NULL;

    return new;
}

void
autocomplete_clear(Autocomplete ac)
{
    if (ac) {
        if (ac->items) {
            g_list_free_full(ac->items, free);
            ac->items = NULL;
        }

        autocomplete_reset(ac);
    }
}

void
autocomplete_reset(Autocomplete ac)
{
    ac->last_found = NULL;
    FREE_SET_NULL(ac->search_str);
}

void
autocomplete_free(Autocomplete ac)
{
    if (ac) {
        autocomplete_clear(ac);
        free(ac);
    }
}

gint
autocomplete_length(Autocomplete ac)
{
    if (!ac) {
        return 0;
    } else if (!ac->items) {
        return 0;
    } else {
        return g_list_length(ac->items);
    }
}

void
autocomplete_update(Autocomplete ac, char** items)
{
    gchar* last_found = NULL;
    gchar* search_str = NULL;

    if (ac->last_found) {
        last_found = strdup(ac->last_found->data);
    }

    if (ac->search_str) {
        search_str = strdup(ac->search_str);
    }

    autocomplete_clear(ac);
    autocomplete_add_all(ac, items);

    if (last_found) {
        // NULL if last_found was removed on update.
        ac->last_found = g_list_find_custom(ac->items, last_found, (GCompareFunc)strcmp);
        free(last_found);
    }

    if (search_str) {
        ac->search_str = strdup(search_str);
        free(search_str);
    }
}

void
autocomplete_add_reverse(Autocomplete ac, const char* item)
{
    if (ac) {
        char* item_cpy;
        GList* curr = g_list_find_custom(ac->items, item, (GCompareFunc)strcmp);

        // if item already exists
        if (curr) {
            return;
        }

        item_cpy = strdup(item);
        ac->items = g_list_prepend(ac->items, item_cpy);
    }
}

void
autocomplete_add(Autocomplete ac, const char* item)
{
    if (ac) {
        char* item_cpy;
        GList* curr = g_list_find_custom(ac->items, item, (GCompareFunc)strcmp);

        // if item already exists
        if (curr) {
            return;
        }

        item_cpy = strdup(item);
        ac->items = g_list_insert_sorted(ac->items, item_cpy, (GCompareFunc)strcmp);
    }
}

void
autocomplete_add_all(Autocomplete ac, char** items)
{
    for (int i = 0; i < g_strv_length(items); i++) {
        autocomplete_add(ac, items[i]);
    }
}

void
autocomplete_remove(Autocomplete ac, const char* const item)
{
    if (ac) {
        GList* curr = g_list_find_custom(ac->items, item, (GCompareFunc)strcmp);

        if (!curr) {
            return;
        }

        // reset last found if it points to the item to be removed
        if (ac->last_found == curr) {
            ac->last_found = NULL;
        }

        free(curr->data);
        ac->items = g_list_delete_link(ac->items, curr);
    }

    return;
}

void
autocomplete_remove_all(Autocomplete ac, char** items)
{
    for (int i = 0; i < g_strv_length(items); i++) {
        autocomplete_remove(ac, items[i]);
    }
}

GList*
autocomplete_create_list(Autocomplete ac)
{
    GList* copy = NULL;
    GList* curr = ac->items;

    while (curr) {
        copy = g_list_append(copy, strdup(curr->data));
        curr = g_list_next(curr);
    }

    return copy;
}

gboolean
autocomplete_contains(Autocomplete ac, const char* value)
{
    GList* curr = ac->items;

    while (curr) {
        if (strcmp(curr->data, value) == 0) {
            return TRUE;
        }
        curr = g_list_next(curr);
    }

    return FALSE;
}

gchar*
autocomplete_complete(Autocomplete ac, const gchar* search_str, gboolean quote, gboolean previous)
{
    gchar* found = NULL;

    // no autocomplete to search
    if (!ac) {
        return NULL;
    }

    // no items to search
    if (!ac->items) {
        return NULL;
    }

    // first search attempt
    if (!ac->last_found) {
        if (ac->search_str) {
            FREE_SET_NULL(ac->search_str);
        }

        ac->search_str = strdup(search_str);
        found = _search(ac, ac->items, quote, NEXT);

        return found;

        // subsequent search attempt
    } else {
        if (previous) {
            // search from here-1 to beginning
            found = _search(ac, g_list_previous(ac->last_found), quote, PREVIOUS);
            if (found) {
                return found;
            }
        } else {
            // search from here+1 to end
            found = _search(ac, g_list_next(ac->last_found), quote, NEXT);
            if (found) {
                return found;
            }
        }

        if (previous) {
            // search from end
            found = _search(ac, g_list_last(ac->items), quote, PREVIOUS);
            if (found) {
                return found;
            }
        } else {
            // search from beginning
            found = _search(ac, ac->items, quote, NEXT);
            if (found) {
                return found;
            }
        }

        // we found nothing, reset search
        autocomplete_reset(ac);

        return NULL;
    }
}

// autocomplete_func func is used -> autocomplete_param_with_func
// Autocomplete ac, gboolean quote are used -> autocomplete_param_with_ac
static char*
_autocomplete_param_common(const char* const input, char* command, autocomplete_func func, Autocomplete ac, gboolean quote, gboolean previous, void* context)
{
    GString* auto_msg;
    char* command_cpy;
    char* result = NULL;
    int len;

    len = asprintf(&command_cpy, "%s ", command);
    if (len == -1) {
        return NULL;
    }

    if (strncmp(input, command_cpy, len) == 0) {
        int inp_len = strlen(input);
        char prefix[inp_len];
        char *found;

        for (int i = len; i < inp_len; i++) {
            prefix[i - len] = input[i];
        }

        prefix[inp_len - len] = '\0';

        if (func) {
            found = func(prefix, previous, context);
        } else {
            found = autocomplete_complete(ac, prefix, quote, previous);
        }

        if (found) {
            auto_msg = g_string_new(command_cpy);
            g_string_append(auto_msg, found);
            free(found);
            result = auto_msg->str;
            g_string_free(auto_msg, FALSE);
        }
    }
    free(command_cpy);

    return result;
}

char*
autocomplete_param_with_func(const char* const input, char* command, autocomplete_func func, gboolean previous, void* context)
{
    return _autocomplete_param_common(input, command, func, NULL, FALSE, previous, context);
}

char*
autocomplete_param_with_ac(const char* const input, char* command, Autocomplete ac, gboolean quote, gboolean previous)
{
    return _autocomplete_param_common(input, command, NULL, ac, quote, previous, NULL);
}

char*
autocomplete_param_no_with_func(const char* const input, char* command, int arg_number, autocomplete_func func, gboolean previous, void* context)
{
    if (strncmp(input, command, strlen(command)) == 0) {
        GString* result_str = NULL;

        // count tokens properly
        int num_tokens = count_tokens(input);

        // if correct number of tokens, then candidate for autocompletion of last param
        if (num_tokens == arg_number) {
            gchar* start_str = get_start(input, arg_number);
            gchar* comp_str = g_strdup(&input[strlen(start_str)]);

            // autocomplete param
            if (comp_str) {
                char* found = func(comp_str, previous, context);
                if (found) {
                    result_str = g_string_new("");
                    g_string_append(result_str, start_str);
                    g_string_append(result_str, found);

                    free(start_str);
                    free(comp_str);

                    char* result = result_str->str;
                    g_string_free(result_str, FALSE);

                    return result;
                }
            } else {
                free(start_str);
            }
        }
    }

    return NULL;
}

/* remove the last message if we have more than max */
void
autocomplete_remove_older_than_max_reverse(Autocomplete ac, int maxsize)
{
    if (autocomplete_length(ac) > maxsize) {
        GList* last = g_list_last(ac->items);
        if (last) {
            free(last->data);
            ac->items = g_list_delete_link(ac->items, last);
        }
    }
}

static gchar*
_search(Autocomplete ac, GList* curr, gboolean quote, search_direction direction)
{
    gchar* search_str_ascii = g_str_to_ascii(ac->search_str, NULL);
    gchar* search_str_lower = g_ascii_strdown(search_str_ascii, -1);
    g_free(search_str_ascii);

    while (curr) {
        gchar* curr_ascii = g_str_to_ascii(curr->data, NULL);
        gchar* curr_lower = g_ascii_strdown(curr_ascii, -1);
        g_free(curr_ascii);

        // match found
        if (strncmp(curr_lower, search_str_lower, strlen(search_str_lower)) == 0) {

            // set pointer to last found
            ac->last_found = curr;

            // if contains space, quote before returning
            if (quote && g_strrstr(curr->data, " ")) {
                GString* quoted = g_string_new("\"");
                g_string_append(quoted, curr->data);
                g_string_append(quoted, "\"");

                gchar* result = quoted->str;
                g_string_free(quoted, FALSE);

                g_free(search_str_lower);
                g_free(curr_lower);
                return result;

                // otherwise just return the string
            } else {
                g_free(search_str_lower);
                g_free(curr_lower);
                return strdup(curr->data);
            }
        }

        g_free(curr_lower);

        if (direction == PREVIOUS) {
            curr = g_list_previous(curr);
        } else {
            curr = g_list_next(curr);
        }
    }

    g_free(search_str_lower);
    return NULL;
}