/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2017 Red Hat, Inc.
 */

#include "c-list-util.h"

/*****************************************************************************/

/**
 * c_list_relink:
 * @lst: the head list entry
 *
 * Takes an invalid list, that has undefined prev pointers.
 * Only the next pointers are valid, and the tail's next
 * pointer points to %NULL instead of the head.
 *
 * c_list_relink() fixes the list by updating all prev pointers
 * and close the circular linking by pointing the tails' next
 * pointer to @lst.
 *
 * The use of this function is to do a bulk update, that lets the
 * list degenerate by not updating the prev pointers. At the end,
 * the list can be fixed by c_list_relink().
 */
void
c_list_relink(CList *lst)
{
    CList *ls, *ls_prev;

    ls_prev = lst;
    ls      = lst->next;
    do {
        ls->prev = ls_prev;
        ls_prev  = ls;
        ls       = ls->next;
    } while (ls);
    ls_prev->next = lst;
    lst->prev     = ls_prev;
}

/*****************************************************************************/

static CList *
_c_list_srt_split(CList *ls)
{
    CList *ls2;

    ls2 = ls;
    ls  = ls->next;
    if (!ls)
        return NULL;
    do {
        ls = ls->next;
        if (!ls)
            break;
        ls  = ls->next;
        ls2 = ls2->next;
    } while (ls);
    ls        = ls2->next;
    ls2->next = NULL;
    return ls;
}

static CList *
_c_list_srt_merge(CList *ls1, CList *ls2, CListSortCmp cmp, const void *user_data)
{
    CList *ls;
    CList  head;

    ls = &head;
    for (;;) {
        /* while invoking the @cmp function, the list
         * elements are not properly linked. Don't try to access
         * their next/prev pointers. */
        if (cmp(ls1, ls2, user_data) <= 0) {
            ls->next = ls1;
            ls       = ls1;
            ls1      = ls1->next;
            if (!ls1)
                break;
        } else {
            ls->next = ls2;
            ls       = ls2;
            ls2      = ls2->next;
            if (!ls2)
                break;
        }
    }
    ls->next = ls1 ?: ls2;

    return head.next;
}

typedef struct {
    CList *ls1;
    CList *ls2;
    char   ls1_sorted;
} SortStack;

static CList *
_c_list_sort(CList *ls, CListSortCmp cmp, const void *user_data)
{
    /* reserve a huge stack-size. We need roughly log2(n) entries, hence this
     * is much more we will ever need. We don't guard for stack-overflow either. */
    SortStack  stack_arr[70];
    SortStack *stack_head = stack_arr;

    stack_arr[0].ls1 = ls;

    /* A simple top-down, non-recursive, stable merge-sort.
     *
     * Maybe natural merge-sort would be better, to do better for
     * partially sorted lists. Doing that would be much more complicated,
     * so it's not done. */
_split:
    stack_head[0].ls2 = _c_list_srt_split(stack_head[0].ls1);
    if (stack_head[0].ls2) {
        stack_head[0].ls1_sorted = 0;
        stack_head[1].ls1        = stack_head[0].ls1;
        stack_head++;
        goto _split;
    }

_backtrack:
    if (stack_head == stack_arr)
        return stack_arr[0].ls1;

    stack_head--;
    if (!stack_head[0].ls1_sorted) {
        stack_head[0].ls1        = stack_head[1].ls1;
        stack_head[0].ls1_sorted = 1;
        stack_head[1].ls1        = stack_head[0].ls2;
        stack_head++;
        goto _split;
    }

    stack_head[0].ls1 = _c_list_srt_merge(stack_head[0].ls1, stack_head[1].ls1, cmp, user_data);
    goto _backtrack;
}

/**
 * c_list_sort_headless:
 * @lst: the list.
 * @cmp: compare function for sorting. While comparing two
 *   CList elements, their next/prev pointers are in undefined
 *   state.
 * @user_data: user data for @cmp.
 *
 * Sorts the list @lst according to @cmp. Contrary to
 * c_list_sort(), @lst is not the list head but a
 * valid entry as well. This function returns the new
 * list head.
 */
CList *
c_list_sort_headless(CList *lst, CListSortCmp cmp, const void *user_data)
{
    if (!c_list_is_empty(lst)) {
        lst->prev->next = NULL;
        lst             = _c_list_sort(lst, cmp, user_data);
        c_list_relink(lst);
    }
    return lst;
}

/**
 * c_list_sort:
 * @head: the list head.
 * @cmp: compare function for sorting. While comparing two
 *   CList elements, their next/prev pointers are in undefined
 *   state.
 * @user_data: user data for @cmp.
 *
 * Sorts the list @head according to @cmp.
 */
void
c_list_sort(CList *head, CListSortCmp cmp, const void *user_data)
{
    if (!c_list_is_empty(head) && head->next->next != head) {
        head->prev->next = NULL;
        head->next       = _c_list_sort(head->next, cmp, user_data);
        c_list_relink(head);
    }
}

/*****************************************************************************/

CList *
c_list_first_unsorted(CList *list, int ascending, CListSortCmp cmp, const void *user_data)
{
    CList *iter_prev = NULL;
    CList *iter;
    int    c;

    /* Returns the first element with the wrong sort order,
     * or NULL, if they are all sorted. */

    c_list_for_each (iter, list) {
        if (iter_prev) {
            c = cmp(iter_prev, iter, user_data);
            if (ascending) {
                if (c > 0)
                    return iter;
            } else {
                if (c < 0)
                    return iter;
            }
        }
        iter_prev = iter;
    }

    return NULL;
}

void
c_list_insert_sorted(CList       *list,
                     CList       *elem,
                     int          ascending,
                     int          append_equal,
                     CListSortCmp cmp,
                     const void  *user_data)
{
    CList *iter;

    /* We iterate the list front-to-end, and insert @elem according
     * to the sort order @cmp. If @append_equal is TRUE, we will
     * skip over equal elements and append afterwards. */
    c_list_for_each (iter, list) {
        int c;

        c = cmp(iter, elem, user_data);

        if (ascending) {
            if (c < 0)
                continue;
            if (c > 0 || !append_equal)
                goto out;
        } else {
            if (c > 0)
                continue;
            if (c < 0 || !append_equal)
                goto out;
        }

        for (iter = iter->next; iter != list; iter = iter->next) {
            c = cmp(iter, elem, user_data);
            if (c != 0) {
                /* We'd expect that the list is sorted, so @c should be
                 * greater than 0. But don't enforce that. */
                goto out;
            }
        }
        goto out;
    }

out:
    c_list_link_before(iter, elem);
}
