/* SPDX-License-Identifier: GPL-3.0-or-later
 * Copyright © 2016-2026 The TokTok team.
 * Copyright © 2014 Tox project.
 */

/**
 * Simple struct with functions to create a list which associates ids with data
 * - Allows for finding ids associated with data such as IPs or public keys in a short time
 * - Should only be used if there are relatively few add/remove calls to the list
 */
#include "list.h"

#include <assert.h>
#include <stdbool.h>
#include <string.h>

#include "attributes.h"
#include "ccompat.h"
#include "mem.h"

/**
 * Basically, the elements in the list are placed in order so that they can be searched for easily
 * - each element is seen as a big-endian integer when ordering them
 * - the ids array is maintained so that each id always matches
 * - the search algorithm cuts down the time to find the id associated with a piece of data
 *   at the cost of slow add/remove functions for large lists
 * - Starts at `1/2` of the array, compares the element in the array with the data,
 *   then moves `+/- 1/4` of the array depending on whether the value is greater or lower,
 *   then `+- 1/8`, etc, until the value is matched or its position where it should be in the array is found
 * - some considerations since the array size is never perfect
 */

static int32_t list_index(uint32_t i)
{
    return ~i;
}

/** @brief Find data in list
 *
 * @retval >=0 index of data in array
 * @retval <0  no match, returns index (return value is `list_index(index)`) where
 *   the data should be inserted
 */
static int find(const BS_List *_Nonnull list, const uint8_t *_Nonnull data)
{
    // should work well, but could be improved
    if (list->n == 0) {
        return list_index(0);
    }

    uint32_t i = list->n / 2; // current position in the array
    uint32_t delta = i / 2;   // how much we move in the array

    if (delta == 0) {
        delta = 1;
    }

    int d = -1; // used to determine if closest match is found
    // closest match is found if we move back to where we have already been

    while (true) {
        const int r = list->cmp_callback(data, list->data + list->element_size * i, list->element_size);

        if (r == 0) {
            return i;
        }

        if (r > 0) {
            // data is greater
            // move down
            i += delta;

            if (d == 0 || i == list->n) {
                // reached bottom of list, or closest match
                return list_index(i);
            }

            delta = delta / 2;

            if (delta == 0) {
                delta = 1;
                d = 1;
            }
        } else {
            // data is smaller
            if (d == 1 || i == 0) {
                // reached top or list or closest match
                return list_index(i);
            }

            // move up
            i -= delta;

            delta = delta / 2;

            if (delta == 0) {
                delta = 1;
                d = 0;
            }
        }
    }
}

/**
 * Resizes the list.
 *
 * @return true on success.
 */
static bool resize(BS_List *_Nonnull list, uint32_t new_size)
{
    if (new_size == 0) {
        bs_list_free(list);
        return true;
    }

    uint8_t *data = (uint8_t *)mem_brealloc(list->mem, list->data, new_size * list->element_size);

    if (data == nullptr) {
        return false;
    }

    list->data = data;

    int *ids = (int *)mem_vrealloc(list->mem, list->ids, new_size, sizeof(int));

    if (ids == nullptr) {
        return false;
    }

    list->ids = ids;

    return true;
}

int bs_list_init(BS_List *list, const Memory *mem, uint32_t element_size, uint32_t initial_capacity, bs_list_cmp_cb *cmp_callback)
{
    list->mem = mem;

    // set initial values
    list->n = 0;
    list->element_size = element_size;
    list->capacity = 0;
    list->data = nullptr;
    list->ids = nullptr;
    list->cmp_callback = cmp_callback;

    if (initial_capacity != 0) {
        if (!resize(list, initial_capacity)) {
            return 0;
        }
    }

    list->capacity = initial_capacity;

    return 1;
}

void bs_list_free(BS_List *list)
{
    if (list == nullptr) {
        return;
    }

    // free both arrays
    mem_delete(list->mem, list->data);
    list->data = nullptr;

    mem_delete(list->mem, list->ids);
    list->ids = nullptr;
}

int bs_list_find(const BS_List *list, const uint8_t *data)
{
    const int r = find(list, data);

    // return only -1 and positive values
    if (r < 0) {
        return -1;
    }

    return list->ids[r];
}

bool bs_list_add(BS_List *list, const uint8_t *data, int id)
{
    // find where the new element should be inserted
    // see: return value of find()
    int i = find(list, data);

    if (i >= 0) {
        // already in list
        return false;
    }

    i = ~i;

    // increase the size of the arrays if needed
    if (list->n == list->capacity) {
        // 1.5 * n + 1
        const uint32_t new_capacity = list->n + list->n / 2 + 1;

        if (!resize(list, new_capacity)) {
            return false;
        }

        list->capacity = new_capacity;
    }

    // insert data to element array
    assert(list->data != nullptr);
    memmove(list->data + (i + 1) * list->element_size, list->data + i * list->element_size,
            (list->n - i) * list->element_size);
    memcpy(list->data + i * list->element_size, data, list->element_size);

    // insert id to id array
    memmove(&list->ids[i + 1], &list->ids[i], (list->n - i) * sizeof(int));
    list->ids[i] = id;

    // increase n
    ++list->n;

    return true;
}

bool bs_list_remove(BS_List *list, const uint8_t *data, int id)
{
    const int i = find(list, data);

    if (i < 0) {
        return false;
    }

    if (list->ids[i] != id) {
        // this should never happen
        return false;
    }

    // decrease the size of the arrays if needed
    if (list->n < list->capacity / 2) {
        const uint32_t new_capacity = list->capacity / 2;

        if (resize(list, new_capacity)) {
            list->capacity = new_capacity;
        }
    }

    --list->n;

    memmove(list->data + i * list->element_size, list->data + (i + 1) * list->element_size,
            (list->n - i) * list->element_size);
    memmove(&list->ids[i], &list->ids[i + 1], (list->n - i) * sizeof(int));

    return true;
}
