/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2013 Red Hat, Inc.
 */

/**
 * SECTION:nmt-newt-grid
 * @short_description: Grid container
 *
 * #NmtNewtGrid is the most general-purpose container widget in NmtNewt.
 *
 * An #NmtNewtGrid consists of a number of rows and columns. There is
 * no pre-established maximum row or columns. Rather, rows and columns
 * exist if and only if there are widgets in them.
 *
 * The width of each column is the width of the widest widget in that
 * column, and the height of each row is the height of the tallest
 * widget in that row. Empty rows and empty columns take up no space,
 * so a grid with a single widget at 0,0 would look exactly the same
 * if the widget was at 5,10 instead.
 *
 * If a widget's cell ends up being larger than the widget's requested
 * size, then by default the widget will be centered in its cell.
 * However, this can be modified by changing its #NmtNewtGridFlags.
 * FIXME: the FILL/ANCHOR flags can be implemented in #NmtNewtWidget
 * and so should move there. Less clear about the EXPAND flags, which
 * must be implemented by the container...
 */

#include "libnm/nm-default-client.h"

#include "nmt-newt-grid.h"

G_DEFINE_TYPE(NmtNewtGrid, nmt_newt_grid, NMT_TYPE_NEWT_CONTAINER)

#define NMT_NEWT_GRID_GET_PRIVATE(o) \
    (G_TYPE_INSTANCE_GET_PRIVATE((o), NMT_TYPE_NEWT_GRID, NmtNewtGridPrivate))

typedef struct {
    NmtNewtWidget *  widget;
    int              x, y;
    NmtNewtGridFlags flags;
    int              req_height, req_width;
} NmtNewtGridChild;

typedef struct {
    GArray *  children;
    int       max_x, max_y;
    int *     row_heights, *col_widths;
    gboolean *expand_rows, *expand_cols;
    int       n_expand_rows, n_expand_cols;
    int       req_height, req_width;
} NmtNewtGridPrivate;

/**
 * nmt_newt_grid_new:
 *
 * Creates a new #NmtNewtGrid
 *
 * Returns: a new #NmtNewtGrid
 */
NmtNewtWidget *
nmt_newt_grid_new(void)
{
    return g_object_new(NMT_TYPE_NEWT_GRID, NULL);
}

static void
nmt_newt_grid_init(NmtNewtGrid *grid)
{
    NmtNewtGridPrivate *priv = NMT_NEWT_GRID_GET_PRIVATE(grid);

    priv->children = g_array_new(FALSE, FALSE, sizeof(NmtNewtGridChild));
}

static void
nmt_newt_grid_finalize(GObject *object)
{
    NmtNewtGridPrivate *priv = NMT_NEWT_GRID_GET_PRIVATE(object);

    g_array_unref(priv->children);
    nm_clear_g_free(&priv->row_heights);
    nm_clear_g_free(&priv->col_widths);
    nm_clear_g_free(&priv->expand_rows);
    nm_clear_g_free(&priv->expand_cols);

    G_OBJECT_CLASS(nmt_newt_grid_parent_class)->finalize(object);
}

static int
child_sort_func(gconstpointer a, gconstpointer b)
{
    NmtNewtGridChild *child_a = (NmtNewtGridChild *) a;
    NmtNewtGridChild *child_b = (NmtNewtGridChild *) b;

    if (child_a->y != child_b->y)
        return child_a->y - child_b->y;
    else
        return child_a->x - child_b->x;
}

static newtComponent *
nmt_newt_grid_get_components(NmtNewtWidget *widget)
{
    NmtNewtGridPrivate *priv = NMT_NEWT_GRID_GET_PRIVATE(widget);
    NmtNewtGridChild *  children;
    GPtrArray *         cos;
    newtComponent *     child_cos;
    int                 i, c;

    g_array_sort(priv->children, child_sort_func);
    children = (NmtNewtGridChild *) priv->children->data;

    cos = g_ptr_array_new();

    for (i = 0; i < priv->children->len; i++) {
        if (!nmt_newt_widget_get_visible(children[i].widget))
            continue;

        child_cos = nmt_newt_widget_get_components(children[i].widget);
        for (c = 0; child_cos[c]; c++)
            g_ptr_array_add(cos, child_cos[c]);
        g_free(child_cos);
    }
    g_ptr_array_add(cos, NULL);

    return (newtComponent *) g_ptr_array_free(cos, FALSE);
}

static void
nmt_newt_grid_size_request(NmtNewtWidget *widget, int *width, int *height)
{
    NmtNewtGrid *       grid     = NMT_NEWT_GRID(widget);
    NmtNewtGridPrivate *priv     = NMT_NEWT_GRID_GET_PRIVATE(grid);
    NmtNewtGridChild *  children = (NmtNewtGridChild *) priv->children->data;
    int                 row, col, i;

    g_free(priv->row_heights);
    g_free(priv->col_widths);
    g_free(priv->expand_rows);
    g_free(priv->expand_cols);

    priv->row_heights   = g_new0(int, priv->max_y + 1);
    priv->col_widths    = g_new0(int, priv->max_x + 1);
    priv->expand_rows   = g_new0(gboolean, priv->max_y + 1);
    priv->expand_cols   = g_new0(gboolean, priv->max_x + 1);
    priv->n_expand_rows = priv->n_expand_cols = 0;

    for (row = 0; row < priv->max_y + 1; row++) {
        for (col = 0; col < priv->max_x + 1; col++) {
            for (i = 0; i < priv->children->len; i++) {
                if (children[i].x != col || children[i].y != row)
                    continue;
                if (!nmt_newt_widget_get_visible(children[i].widget))
                    continue;

                nmt_newt_widget_size_request(children[i].widget,
                                             &children[i].req_width,
                                             &children[i].req_height);
                if (children[i].req_height > priv->row_heights[row])
                    priv->row_heights[row] = children[i].req_height;
                if (children[i].req_width > priv->col_widths[col])
                    priv->col_widths[col] = children[i].req_width;

                if ((children[i].flags & NMT_NEWT_GRID_EXPAND_X)
                    && !priv->expand_cols[children[i].x]) {
                    priv->expand_cols[children[i].x] = TRUE;
                    priv->n_expand_cols++;
                }
                if ((children[i].flags & NMT_NEWT_GRID_EXPAND_Y)
                    && !priv->expand_rows[children[i].y]) {
                    priv->expand_rows[children[i].y] = TRUE;
                    priv->n_expand_rows++;
                }
            }
        }
    }

    priv->req_height = priv->req_width = 0;
    for (row = 0; row < priv->max_y + 1; row++)
        priv->req_height += priv->row_heights[row];
    for (col = 0; col < priv->max_x + 1; col++)
        priv->req_width += priv->col_widths[col];

    *height = priv->req_height;
    *width  = priv->req_width;
}

static void
nmt_newt_grid_size_allocate(NmtNewtWidget *widget, int x, int y, int width, int height)
{
    NmtNewtGridPrivate *priv     = NMT_NEWT_GRID_GET_PRIVATE(widget);
    NmtNewtGridChild *  children = (NmtNewtGridChild *) priv->children->data, *child;
    int                 i, row, col;
    int                 child_x, child_y, child_width, child_height;
    int                 extra, extra_all, extra_some;

    extra = width - priv->req_width;
    if (extra > 0 && priv->n_expand_cols) {
        extra_all  = extra / priv->n_expand_cols;
        extra_some = extra % priv->n_expand_cols;

        for (col = 0; col < priv->max_x + 1; col++) {
            if (!priv->expand_cols[col])
                continue;
            priv->col_widths[col] += extra_all;
            if (extra_some) {
                priv->col_widths[col]++;
                extra_some--;
            }
        }
    }

    extra = height - priv->req_height;
    if (extra > 0 && priv->n_expand_rows) {
        extra_all  = extra / priv->n_expand_rows;
        extra_some = extra % priv->n_expand_rows;

        for (row = 0; row < priv->max_y + 1; row++) {
            if (!priv->expand_rows[row])
                continue;
            priv->row_heights[row] += extra_all;
            if (extra_some) {
                priv->row_heights[row]++;
                extra_some--;
            }
        }
    }

    for (i = 0; i < priv->children->len; i++) {
        child = &children[i];
        if (!nmt_newt_widget_get_visible(child->widget))
            continue;

        child_x = x;
        for (col = 0; col < child->x; col++)
            child_x += priv->col_widths[col];

        if ((child->flags & NMT_NEWT_GRID_FILL_X) == NMT_NEWT_GRID_FILL_X) {
            child_width = priv->col_widths[child->x];
        } else {
            child_width = child->req_width;
            if (child->flags & NMT_NEWT_GRID_ANCHOR_RIGHT)
                child_x += priv->col_widths[child->x] - child->req_width;
            else if (!(child->flags & NMT_NEWT_GRID_ANCHOR_LEFT))
                child_x += (priv->col_widths[child->x] - child->req_width) / 2;
        }

        child_y = y;
        for (row = 0; row < child->y; row++)
            child_y += priv->row_heights[row];

        if ((child->flags & NMT_NEWT_GRID_FILL_Y) == NMT_NEWT_GRID_FILL_Y) {
            child_height = priv->row_heights[child->y];
        } else {
            child_height = child->req_height;
            if (child->flags & NMT_NEWT_GRID_ANCHOR_BOTTOM)
                child_y += priv->row_heights[child->y] - child->req_height;
            else if (!(child->flags & NMT_NEWT_GRID_ANCHOR_TOP))
                child_y += (priv->row_heights[child->y] - child->req_height) / 2;
        }

        nmt_newt_widget_size_allocate(child->widget, child_x, child_y, child_width, child_height);
    }
}

static void
nmt_newt_grid_find_size(NmtNewtGrid *grid)
{
    NmtNewtGridPrivate *priv     = NMT_NEWT_GRID_GET_PRIVATE(grid);
    NmtNewtGridChild *  children = (NmtNewtGridChild *) priv->children->data;
    int                 i;

    priv->max_x = priv->max_y = 0;
    for (i = 0; i < priv->children->len; i++) {
        if (children[i].x > priv->max_x)
            priv->max_x = children[i].x;
        if (children[i].y > priv->max_y)
            priv->max_y = children[i].y;
    }
}

/**
 * nmt_newt_grid_add:
 * @grid: an #NmtNewtGrid
 * @widget: the widget to add
 * @x: x coordinate
 * @y: y coordinate
 *
 * Adds @widget to @grid at @x, @y. See the discussion above for more
 * details of exactly how this works.
 */
void
nmt_newt_grid_add(NmtNewtGrid *grid, NmtNewtWidget *widget, int x, int y)
{
    NmtNewtGridPrivate *priv = NMT_NEWT_GRID_GET_PRIVATE(grid);
    NmtNewtGridChild    child;

    NMT_NEWT_CONTAINER_CLASS(nmt_newt_grid_parent_class)->add(NMT_NEWT_CONTAINER(grid), widget);

    memset(&child, 0, sizeof(child));
    child.widget = widget;
    child.x      = x;
    child.y      = y;
    child.flags  = NMT_NEWT_GRID_FILL_X | NMT_NEWT_GRID_FILL_Y;
    g_array_append_val(priv->children, child);

    if (x > priv->max_x)
        priv->max_x = x;
    if (y > priv->max_y)
        priv->max_y = y;
}

static int
find_child(NmtNewtGrid *grid, NmtNewtWidget *widget)
{
    NmtNewtGridPrivate *priv     = NMT_NEWT_GRID_GET_PRIVATE(grid);
    NmtNewtGridChild *  children = (NmtNewtGridChild *) priv->children->data;
    int                 i;

    for (i = 0; i < priv->children->len; i++) {
        if (children[i].widget == widget)
            return i;
    }

    return -1;
}

static void
nmt_newt_grid_remove(NmtNewtContainer *container, NmtNewtWidget *widget)
{
    NmtNewtGrid *       grid = NMT_NEWT_GRID(container);
    NmtNewtGridPrivate *priv = NMT_NEWT_GRID_GET_PRIVATE(grid);
    int                 i;

    i = find_child(grid, widget);
    if (i != -1) {
        g_array_remove_index(priv->children, i);
        nmt_newt_grid_find_size(grid);
    }

    NMT_NEWT_CONTAINER_CLASS(nmt_newt_grid_parent_class)->remove(container, widget);
}

/**
 * nmt_newt_grid_move:
 * @grid: an #NmtNewtGrid
 * @widget: a child of @grid
 * @x: x coordinate
 * @y: y coordinate
 *
 * Moves @widget to the given new coordinates.
 */
void
nmt_newt_grid_move(NmtNewtGrid *grid, NmtNewtWidget *widget, int x, int y)
{
    NmtNewtGridPrivate *priv     = NMT_NEWT_GRID_GET_PRIVATE(grid);
    NmtNewtGridChild *  children = (NmtNewtGridChild *) priv->children->data;
    int                 i;

    i = find_child(grid, widget);
    if (i != -1 && (children[i].x != x || children[i].y != y)) {
        children[i].x = x;
        children[i].y = y;
        nmt_newt_grid_find_size(grid);
        nmt_newt_widget_needs_rebuild(NMT_NEWT_WIDGET(grid));
    }
}

/**
 * NmtNewtGridFlags:
 * @NMT_NEWT_GRID_EXPAND_X: The widget's cell should expand
 *   horizontally if the grid as a whole is given more width than
 *   it requested.
 * @NMT_NEWT_GRID_EXPAND_Y: The widget's cell should expand
 *   vertically if the grid as a whole is given more height than
 *   it requested.
 * @NMT_NEWT_GRID_ANCHOR_LEFT: If the widget's cell is wider than
 *   the widget requested, the widget should be anchored to the
 *   left of its cell rather than being centered.
 * @NMT_NEWT_GRID_ANCHOR_RIGHT: If the widget's cell is wider than
 *   the widget requested, the widget should be anchored to the
 *   right of its cell rather than being centered.
 * @NMT_NEWT_GRID_FILL_X: If the widget's cell is wider than
 *   the widget requested, the widget should be allocated the
 *   full width of the cell; this is equivalent to specifying
 *   both %NMT_NEWT_GRID_ANCHOR_LEFT and %NMT_NEWT_GRID_ANCHOR_RIGHT.
 * @NMT_NEWT_GRID_ANCHOR_TOP: If the widget's cell is taller than
 *   the widget requested, the widget should be anchored to the
 *   top of its cell rather than being centered.
 * @NMT_NEWT_GRID_ANCHOR_BOTTOM: If the widget's cell is taller than
 *   the widget requested, the widget should be anchored to the
 *   bottom of its cell rather than being centered.
 * @NMT_NEWT_GRID_FILL_Y: If the widget's cell is taller than
 *   the widget requested, the widget should be allocated the
 *   full height of the cell; this is equivalent to specifying
 *   both %NMT_NEWT_GRID_ANCHOR_TOP and %NMT_NEWT_GRID_ANCHOR_BOTTOM.
 *
 * Flags describing how a widget is placed within its grid cell.
 */

/**
 * nmt_newt_grid_set_flags:
 * @grid: an #NmtNewtGrid
 * @widget: a child of @grid
 * @flags: #NmtNewtGridFlags for @widget
 *
 * Sets the #NmtNewtGridFlags on @widget
 */
void
nmt_newt_grid_set_flags(NmtNewtGrid *grid, NmtNewtWidget *widget, NmtNewtGridFlags flags)
{
    NmtNewtGridPrivate *priv     = NMT_NEWT_GRID_GET_PRIVATE(grid);
    NmtNewtGridChild *  children = (NmtNewtGridChild *) priv->children->data;
    int                 i;

    i = find_child(grid, widget);
    if (i != -1)
        children[i].flags = flags;
}

static void
nmt_newt_grid_class_init(NmtNewtGridClass *grid_class)
{
    GObjectClass *         object_class    = G_OBJECT_CLASS(grid_class);
    NmtNewtWidgetClass *   widget_class    = NMT_NEWT_WIDGET_CLASS(grid_class);
    NmtNewtContainerClass *container_class = NMT_NEWT_CONTAINER_CLASS(grid_class);

    g_type_class_add_private(grid_class, sizeof(NmtNewtGridPrivate));

    /* virtual methods */
    object_class->finalize = nmt_newt_grid_finalize;

    widget_class->get_components = nmt_newt_grid_get_components;
    widget_class->size_request   = nmt_newt_grid_size_request;
    widget_class->size_allocate  = nmt_newt_grid_size_allocate;

    container_class->remove = nmt_newt_grid_remove;
}
