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

/**
 * SECTION:nmtui-edit
 * @short_description: nm-connection-editor-like functionality
 *
 * nmtui-edit implements editing #NMConnections.
 */

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

#include <stdlib.h>

#include "nmtui.h"
#include "nmtui-edit.h"
#include "nmt-edit-connection-list.h"
#include "nmt-editor.h"
#include "nmt-utils.h"

#include "nm-editor-utils.h"

static void
list_add_connection(NmtEditConnectionList *list, gpointer form)
{
    nmt_add_connection();
    nmt_newt_form_set_focus(form, NMT_NEWT_WIDGET(list));
}

static void
list_edit_connection(NmtEditConnectionList *list, NMConnection *connection, gpointer form)
{
    nmt_edit_connection(connection);
    nmt_newt_form_set_focus(form, NMT_NEWT_WIDGET(list));
}

static void
list_remove_connection(NmtEditConnectionList *list, NMRemoteConnection *connection, gpointer form)
{
    nmt_remove_connection(connection);
    nmt_newt_form_set_focus(form, NMT_NEWT_WIDGET(list));
}

static gboolean
edit_connection_list_filter(NmtEditConnectionList *list,
                            NMConnection *         connection,
                            gpointer               user_data)
{
    NMSettingConnection *s_con;
    const char *         master, *slave_type;
    const char *         uuid, *ifname;
    const GPtrArray *    conns;
    int                  i;
    gboolean             found_master = FALSE;

    s_con = nm_connection_get_setting_connection(connection);
    g_return_val_if_fail(s_con != NULL, FALSE);

    master = nm_setting_connection_get_master(s_con);
    if (!master)
        return TRUE;
    slave_type = nm_setting_connection_get_slave_type(s_con);
    if (g_strcmp0(slave_type, NM_SETTING_BOND_SETTING_NAME) != 0
        && g_strcmp0(slave_type, NM_SETTING_TEAM_SETTING_NAME) != 0
        && g_strcmp0(slave_type, NM_SETTING_BRIDGE_SETTING_NAME) != 0)
        return TRUE;

    conns = nm_client_get_connections(nm_client);
    for (i = 0; i < conns->len; i++) {
        NMConnection *candidate = conns->pdata[i];

        uuid   = nm_connection_get_uuid(candidate);
        ifname = nm_connection_get_interface_name(candidate);
        if (!g_strcmp0(master, uuid) || !g_strcmp0(master, ifname)) {
            found_master = TRUE;
            break;
        }
    }

    return !found_master;
}

static NmtNewtForm *
nmt_edit_main_connection_list(gboolean is_top)
{
    int            screen_width, screen_height;
    NmtNewtForm *  form;
    NmtNewtWidget *quit, *list;

    newtGetScreenSize(&screen_width, &screen_height);

    form = g_object_new(NMT_TYPE_NEWT_FORM,
                        "y",
                        2,
                        "height",
                        screen_height - 4,
                        "escape-exits",
                        TRUE,
                        NULL);

    quit = nmt_newt_button_new(is_top ? _("Quit") : _("Back"));
    nmt_newt_widget_set_exit_on_activate(quit, TRUE);

    list = g_object_new(NMT_TYPE_EDIT_CONNECTION_LIST,
                        "extra-widget",
                        quit,
                        "connection-filter",
                        edit_connection_list_filter,
                        NULL);

    g_signal_connect(list, "add-connection", G_CALLBACK(list_add_connection), form);
    g_signal_connect(list, "edit-connection", G_CALLBACK(list_edit_connection), form);
    g_signal_connect(list, "remove-connection", G_CALLBACK(list_remove_connection), form);

    nmt_newt_form_set_content(form, list);
    return form;
}

#define NMT_TYPE_ADD_CONNECTION (nmt_add_connection_get_type())
#define NMT_ADD_CONNECTION(obj) \
    (G_TYPE_CHECK_INSTANCE_CAST((obj), NMT_TYPE_ADD_CONNECTION, NmtAddConnection))
#define NMT_IS_ADD_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NMT_TYPE_ADD_CONNECTION))

typedef NmtNewtForm      NmtAddConnection;
typedef NmtNewtFormClass NmtAddConnectionClass;

GType nmt_add_connection_get_type(void);

G_DEFINE_TYPE(NmtAddConnection, nmt_add_connection, NMT_TYPE_NEWT_FORM)

#define NMT_ADD_CONNECTION_GET_PRIVATE(o) \
    (G_TYPE_INSTANCE_GET_PRIVATE((o), NMT_TYPE_ADD_CONNECTION, NmtAddConnectionPrivate))

typedef struct {
    NmtNewtTextbox *textbox;
    NmtNewtListbox *listbox;

    char *                     primary_text;
    char *                     secondary_text;
    NMConnection *             master;
    NmtAddConnectionTypeFilter type_filter;
    gpointer                   type_filter_data;

    gboolean single_type;
} NmtAddConnectionPrivate;

enum {
    PROP_0,

    PROP_PRIMARY_TEXT,
    PROP_SECONDARY_TEXT,
    PROP_MASTER,
    PROP_TYPE_FILTER,
    PROP_TYPE_FILTER_DATA,

    LAST_PROP
};

static void
create_connection(NmtNewtWidget *widget, gpointer list)
{
    NmtAddConnectionPrivate *priv = NMT_ADD_CONNECTION_GET_PRIVATE(list);
    GType         type = (GType) GPOINTER_TO_SIZE(nmt_newt_listbox_get_active_key(priv->listbox));
    NMConnection *connection;

    connection = nm_editor_utils_create_connection(type, priv->master, nm_client);
    nmt_edit_connection(connection);
    g_object_unref(connection);
}

static void
create_connection_and_quit(NmtNewtWidget *widget, gpointer list)
{
    create_connection(widget, list);
    nmt_newt_form_quit(list);
}

static void
nmt_add_connection_init(NmtAddConnection *form)
{
    NmtAddConnectionPrivate *priv = NMT_ADD_CONNECTION_GET_PRIVATE(form);
    NmtNewtWidget *          textbox, *listbox, *button;
    NmtNewtGrid *            grid, *buttons;

    grid = NMT_NEWT_GRID(nmt_newt_grid_new());

    textbox       = nmt_newt_textbox_new(0, 60);
    priv->textbox = NMT_NEWT_TEXTBOX(textbox);
    nmt_newt_grid_add(grid, textbox, 0, 0);

    listbox       = nmt_newt_listbox_new(5, NMT_NEWT_LISTBOX_SCROLL);
    priv->listbox = NMT_NEWT_LISTBOX(listbox);
    g_signal_connect(priv->listbox, "activated", G_CALLBACK(create_connection_and_quit), form);
    nmt_newt_grid_add(grid, listbox, 0, 1);
    nmt_newt_widget_set_padding(listbox, 0, 1, 0, 0);
    nmt_newt_grid_set_flags(grid, listbox, NMT_NEWT_GRID_EXPAND_X);

    // FIXME: VPN description textbox

    buttons = NMT_NEWT_GRID(nmt_newt_grid_new());
    nmt_newt_grid_add(grid, NMT_NEWT_WIDGET(buttons), 0, 2);
    nmt_newt_widget_set_padding(NMT_NEWT_WIDGET(buttons), 0, 1, 0, 0);

    button = g_object_ref_sink(nmt_newt_button_new(_("Cancel")));
    nmt_newt_widget_set_exit_on_activate(button, TRUE);
    nmt_newt_grid_add(NMT_NEWT_GRID(buttons), button, 0, 0);
    nmt_newt_widget_set_padding(button, 0, 0, 1, 0);
    nmt_newt_grid_set_flags(NMT_NEWT_GRID(buttons),
                            button,
                            NMT_NEWT_GRID_EXPAND_X | NMT_NEWT_GRID_ANCHOR_RIGHT
                                | NMT_NEWT_GRID_FILL_Y);

    button = g_object_ref_sink(nmt_newt_button_new(_("Create")));
    g_signal_connect(button, "clicked", G_CALLBACK(create_connection_and_quit), form);
    nmt_newt_grid_add(NMT_NEWT_GRID(buttons), button, 1, 0);

    nmt_newt_form_set_content(NMT_NEWT_FORM(form), NMT_NEWT_WIDGET(grid));
}

static void
nmt_add_connection_constructed(GObject *object)
{
    NmtAddConnectionPrivate *    priv = NMT_ADD_CONNECTION_GET_PRIVATE(object);
    NMEditorConnectionTypeData **types;
    char *                       text;
    int                          i, num_types;

    if (priv->secondary_text) {
        text = g_strdup_printf("%s\n\n%s", priv->primary_text, priv->secondary_text);
    } else
        text = g_strdup(priv->primary_text);
    nmt_newt_textbox_set_text(priv->textbox, text);
    g_free(text);

    types = nm_editor_utils_get_connection_type_list();
    for (i = num_types = 0; types[i]; i++) {
        if (priv->type_filter && !priv->type_filter(types[i]->setting_type, priv->type_filter_data))
            continue;
        nmt_newt_listbox_append(priv->listbox,
                                types[i]->name,
                                GSIZE_TO_POINTER(types[i]->setting_type));
        num_types++;
    }

    if (num_types == 1)
        priv->single_type = TRUE;

    G_OBJECT_CLASS(nmt_add_connection_parent_class)->constructed(object);
}

static void
nmt_add_connection_show(NmtNewtForm *form)
{
    NmtAddConnectionPrivate *priv = NMT_ADD_CONNECTION_GET_PRIVATE(form);

    if (priv->single_type) {
        nmt_newt_listbox_set_active(priv->listbox, 0);
        create_connection(NMT_NEWT_WIDGET(priv->listbox), g_object_ref(form));
    } else
        NMT_NEWT_FORM_CLASS(nmt_add_connection_parent_class)->show(form);
}

static void
nmt_add_connection_finalize(GObject *object)
{
    NmtAddConnectionPrivate *priv = NMT_ADD_CONNECTION_GET_PRIVATE(object);

    g_free(priv->primary_text);
    g_free(priv->secondary_text);
    g_clear_object(&priv->master);

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

static void
nmt_add_connection_set_property(GObject *     object,
                                guint         prop_id,
                                const GValue *value,
                                GParamSpec *  pspec)
{
    NmtAddConnectionPrivate *priv = NMT_ADD_CONNECTION_GET_PRIVATE(object);

    switch (prop_id) {
    case PROP_PRIMARY_TEXT:
        priv->primary_text = g_value_dup_string(value);
        break;
    case PROP_SECONDARY_TEXT:
        priv->secondary_text = g_value_dup_string(value);
        break;
    case PROP_MASTER:
        priv->master = g_value_dup_object(value);
        break;
    case PROP_TYPE_FILTER:
        priv->type_filter = g_value_get_pointer(value);
        break;
    case PROP_TYPE_FILTER_DATA:
        priv->type_filter_data = g_value_get_pointer(value);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

static void
nmt_add_connection_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    NmtAddConnectionPrivate *priv = NMT_ADD_CONNECTION_GET_PRIVATE(object);

    switch (prop_id) {
    case PROP_PRIMARY_TEXT:
        g_value_set_string(value, priv->primary_text);
        break;
    case PROP_SECONDARY_TEXT:
        g_value_set_string(value, priv->secondary_text);
        break;
    case PROP_MASTER:
        g_value_set_object(value, priv->master);
        break;
    case PROP_TYPE_FILTER:
        g_value_set_pointer(value, priv->type_filter);
        break;
    case PROP_TYPE_FILTER_DATA:
        g_value_set_pointer(value, priv->type_filter_data);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

static void
nmt_add_connection_class_init(NmtAddConnectionClass *add_class)
{
    GObjectClass *    object_class = G_OBJECT_CLASS(add_class);
    NmtNewtFormClass *form_class   = NMT_NEWT_FORM_CLASS(add_class);

    g_type_class_add_private(add_class, sizeof(NmtAddConnectionPrivate));

    /* virtual methods */
    object_class->constructed  = nmt_add_connection_constructed;
    object_class->set_property = nmt_add_connection_set_property;
    object_class->get_property = nmt_add_connection_get_property;
    object_class->finalize     = nmt_add_connection_finalize;

    form_class->show = nmt_add_connection_show;

    g_object_class_install_property(
        object_class,
        PROP_PRIMARY_TEXT,
        g_param_spec_string("primary-text",
                            "",
                            "",
                            _("Select the type of connection you wish to create."),
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
    g_object_class_install_property(
        object_class,
        PROP_SECONDARY_TEXT,
        g_param_spec_string("secondary-text",
                            "",
                            "",
#if 0
                              _("If you are creating a VPN, and the VPN connection you "
                              "wish to create does not appear in the list, you may "
                              "not have the correct VPN plugin installed."),
#else
                            NULL,
#endif
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
    g_object_class_install_property(
        object_class,
        PROP_MASTER,
        g_param_spec_object("master",
                            "",
                            "",
                            NM_TYPE_CONNECTION,
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
    g_object_class_install_property(
        object_class,
        PROP_TYPE_FILTER,
        g_param_spec_pointer("type-filter",
                             "",
                             "",
                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
    g_object_class_install_property(
        object_class,
        PROP_TYPE_FILTER_DATA,
        g_param_spec_pointer("type-filter-data",
                             "",
                             "",
                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
}

void
nmt_add_connection(void)
{
    NmtNewtForm *form;

    form = g_object_new(NMT_TYPE_ADD_CONNECTION, "title", _("New Connection"), NULL);
    nmt_newt_form_show(form);
    g_object_unref(form);
}

void
nmt_add_connection_full(const char *               primary_text,
                        const char *               secondary_text,
                        NMConnection *             master,
                        NmtAddConnectionTypeFilter type_filter,
                        gpointer                   type_filter_data)
{
    NmtNewtForm *form;

    form = g_object_new(NMT_TYPE_ADD_CONNECTION,
                        "title",
                        _("New Connection"),
                        "primary-text",
                        primary_text,
                        "secondary-text",
                        secondary_text,
                        "master",
                        master,
                        "type-filter",
                        type_filter,
                        "type-filter-data",
                        type_filter_data,
                        NULL);
    nmt_newt_form_show(form);
    g_object_unref(form);
}

void
nmt_edit_connection(NMConnection *connection)
{
    NmtNewtForm *editor;

    editor = nmt_editor_new(connection);
    if (!editor)
        return;

    nmt_newt_form_show(editor);
    g_object_unref(editor);
}

typedef struct {
    NmtSyncOp           op;
    gboolean            got_callback, got_signal;
    NMRemoteConnection *connection;
} ConnectionDeleteData;

static void
connection_deleted_callback(GObject *connection, GAsyncResult *result, gpointer user_data)
{
    ConnectionDeleteData *data  = user_data;
    GError *              error = NULL;

    if (!nm_remote_connection_delete_finish(data->connection, result, &error)) {
        nmt_newt_message_dialog(_("Unable to delete connection: %s"), error->message);
    } else
        data->got_callback = TRUE;

    if (error || (data->got_callback && data->got_signal))
        nmt_sync_op_complete_boolean(&data->op, error == NULL, error);
    g_clear_error(&error);
}

static void
connection_removed_signal(NMClient *client, NMRemoteConnection *connection, gpointer user_data)
{
    ConnectionDeleteData *data = user_data;

    if (connection == data->connection) {
        data->got_signal = TRUE;
        if (data->got_callback && data->got_signal)
            nmt_sync_op_complete_boolean(&data->op, TRUE, NULL);
    }
}

static void
remove_one_connection(NMRemoteConnection *connection)
{
    ConnectionDeleteData data;
    GError *             error = NULL;

    data.got_callback = data.got_signal = FALSE;
    nmt_sync_op_init(&data.op);

    data.connection = connection;
    g_signal_connect(nm_client,
                     NM_CLIENT_CONNECTION_REMOVED,
                     G_CALLBACK(connection_removed_signal),
                     &data);
    nm_remote_connection_delete_async(connection, NULL, connection_deleted_callback, &data);

    if (!nmt_sync_op_wait_boolean(&data.op, &error)) {
        nmt_newt_message_dialog(_("Could not delete connection '%s': %s"),
                                nm_connection_get_id(NM_CONNECTION(connection)),
                                error->message);
        g_error_free(error);
    }

    g_signal_handlers_disconnect_by_func(nm_client, G_CALLBACK(connection_removed_signal), &data);
}

void
nmt_remove_connection(NMRemoteConnection *connection)
{
    const GPtrArray *    all_conns;
    GSList *             slaves, *iter;
    int                  i;
    NMRemoteConnection * slave;
    NMSettingConnection *s_con;
    const char *         uuid, *iface, *master;
    int                  choice;

    choice = nmt_newt_choice_dialog(_("Cancel"),
                                    _("Delete"),
                                    _("Are you sure you want to delete the connection '%s'?"),
                                    nm_connection_get_id(NM_CONNECTION(connection)));
    if (choice == 1)
        return;

    g_object_ref(connection);
    remove_one_connection(connection);

    uuid  = nm_connection_get_uuid(NM_CONNECTION(connection));
    iface = nm_connection_get_interface_name(NM_CONNECTION(connection));

    all_conns = nm_client_get_connections(nm_client);
    slaves    = NULL;
    for (i = 0; i < all_conns->len; i++) {
        slave  = all_conns->pdata[i];
        s_con  = nm_connection_get_setting_connection(NM_CONNECTION(slave));
        master = nm_setting_connection_get_master(s_con);
        if (master) {
            if (!g_strcmp0(master, uuid) || !g_strcmp0(master, iface))
                slaves = g_slist_prepend(slaves, g_object_ref(slave));
        }
    }

    for (iter = slaves; iter; iter = iter->next)
        remove_one_connection(iter->data);
    g_slist_free_full(slaves, g_object_unref);

    g_object_unref(connection);
}

NmtNewtForm *
nmtui_edit(gboolean is_top, int argc, char **argv)
{
    NMConnection *conn = NULL;

    if (argc == 2) {
        if (nm_utils_is_uuid(argv[1]))
            conn = NM_CONNECTION(nm_client_get_connection_by_uuid(nm_client, argv[1]));
        if (!conn)
            conn = NM_CONNECTION(nm_client_get_connection_by_id(nm_client, argv[1]));

        if (!conn) {
            nmt_newt_message_dialog("%s: no such connection '%s'\n", argv[0], argv[1]);
            return NULL;
        }

        return nmt_editor_new(conn);
    } else
        return nmt_edit_main_connection_list(is_top);
}