/*
 * libvirt-gconfig-domain-os.c: libvirt domain OS configuration
 *
 * Copyright (C) 2011 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * Author: Christophe Fergeau <cfergeau@gmail.com>
 */

#include <config.h>

#include "libvirt-gconfig/libvirt-gconfig.h"
#include "libvirt-gconfig/libvirt-gconfig-private.h"

#define GVIR_CONFIG_DOMAIN_OS_GET_PRIVATE(obj)                         \
        (G_TYPE_INSTANCE_GET_PRIVATE((obj), GVIR_CONFIG_TYPE_DOMAIN_OS, GVirConfigDomainOsPrivate))

struct _GVirConfigDomainOsPrivate
{
    gboolean unused;
};

G_DEFINE_TYPE_WITH_PRIVATE(GVirConfigDomainOs, gvir_config_domain_os, GVIR_CONFIG_TYPE_OBJECT);


static void gvir_config_domain_os_class_init(GVirConfigDomainOsClass *klass G_GNUC_UNUSED)
{
}


static void gvir_config_domain_os_init(GVirConfigDomainOs *os)
{
    os->priv = GVIR_CONFIG_DOMAIN_OS_GET_PRIVATE(os);
}


GVirConfigDomainOs *gvir_config_domain_os_new(void)
{
    GVirConfigObject *object;

    object = gvir_config_object_new(GVIR_CONFIG_TYPE_DOMAIN_OS, "os", NULL);
    return GVIR_CONFIG_DOMAIN_OS(object);
}

GVirConfigDomainOs *gvir_config_domain_os_new_from_xml(const gchar *xml, GError **error)
{
    GVirConfigObject *object;

    object = gvir_config_object_new_from_xml(GVIR_CONFIG_TYPE_DOMAIN_OS, "os",
                                             NULL, xml, error);
    return GVIR_CONFIG_DOMAIN_OS(object);
}

void gvir_config_domain_os_set_os_type(GVirConfigDomainOs *os,
                                       GVirConfigDomainOsType type)
{
    const char *type_str;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    type_str = gvir_config_genum_get_nick(GVIR_CONFIG_TYPE_DOMAIN_OS_TYPE, type);
    g_return_if_fail(type_str != NULL);

    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(os),
                                        "type", type_str);
}

GVirConfigDomainOsType gvir_config_domain_os_get_os_type(GVirConfigDomainOs *os)
{
    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os),
                         GVIR_CONFIG_DOMAIN_OS_TYPE_HVM);

    return gvir_config_object_get_node_content_genum
            (GVIR_CONFIG_OBJECT(os),
             "type",
             GVIR_CONFIG_TYPE_DOMAIN_OS_TYPE,
             GVIR_CONFIG_DOMAIN_OS_TYPE_HVM);
}

/**
 * gvir_config_domain_os_set_kernel:
 * @os: a #GVirConfigDomainOs
 * @kernel: (allow-none): The kernel path
 */
void gvir_config_domain_os_set_kernel(GVirConfigDomainOs *os,
                                      const char * kernel)
{
    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(os),
                                        "kernel", kernel);
}

/**
 * gvir_config_domain_os_set_ramdisk:
 * @os: a #GVirConfigDomainOs
 * @ramdisk: (allow-none): The ramdisk path
 */
void gvir_config_domain_os_set_ramdisk(GVirConfigDomainOs *os,
                                       const char * ramdisk)
{
    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(os),
                                        "initrd", ramdisk);
}

/**
 * gvir_config_domain_os_set_cmdline:
 * @os: a #GVirConfigDomainOs
 * @cmdline: (allow-none): The direct boot commandline
 */
void gvir_config_domain_os_set_cmdline(GVirConfigDomainOs *os,
                                       const char * cmdline)
{
    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(os),
                                        "cmdline", cmdline);
}

/**
 * gvir_config_domain_os_set_init:
 * @os: a #GVirConfigDomainOs
 * @init: (allow-none):
 */
void gvir_config_domain_os_set_init(GVirConfigDomainOs *os,
                                    const char * init)
{
    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(os),
                                        "init", init);
}

/**
 * gvir_config_domain_os_set_loader:
 * @os: a #GVirConfigDomainOs
 * @loader: (allow-none):
 */
void gvir_config_domain_os_set_loader(GVirConfigDomainOs *os,
                                      const char * loader)
{
    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(os),
                                        "loader", loader);
}

void gvir_config_domain_os_enable_boot_menu(GVirConfigDomainOs *os,
                                            gboolean enable)
{
    GVirConfigObject *node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    node = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(os), "bootmenu");
    g_return_if_fail(GVIR_CONFIG_IS_OBJECT(node));
    gvir_config_object_set_attribute_with_type(node, "enable",
                                               G_TYPE_BOOLEAN, enable,
                                               NULL);
    g_object_unref(G_OBJECT(node));
}

void gvir_config_domain_os_bios_enable_serial(GVirConfigDomainOs *os,
                                              gboolean enable)
{
    GVirConfigObject *node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    node = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(os), "bios");
    g_return_if_fail(GVIR_CONFIG_IS_OBJECT(node));
    gvir_config_object_set_attribute_with_type(node, "useserial",
                                               G_TYPE_BOOLEAN, enable,
                                               NULL);
    g_object_unref(G_OBJECT(node));
}

void gvir_config_domain_os_set_smbios_mode(GVirConfigDomainOs *os,
                                           GVirConfigDomainOsSmBiosMode mode)
{
    GVirConfigObject *node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    node = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(os), "smbios");
    g_return_if_fail(GVIR_CONFIG_IS_OBJECT(node));
    gvir_config_object_set_attribute_with_type(node, "mode",
                                               GVIR_CONFIG_TYPE_DOMAIN_OS_SM_BIOS_MODE,
                                               mode, NULL);
    g_object_unref(G_OBJECT(node));
}

/**
 * gvir_config_domain_os_set_boot_devices:
 * @os: a #GVirConfigDomainOs
 * @boot_devices: (in) (element-type LibvirtGConfig.DomainOsBootDevice):
 */
void gvir_config_domain_os_set_boot_devices(GVirConfigDomainOs *os, GList *boot_devices)
{
    GList *it;
    xmlNodePtr os_node;
    xmlNodePtr node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    os_node = gvir_config_object_get_xml_node(GVIR_CONFIG_OBJECT(os));
    g_return_if_fail(os_node != NULL);

    node = os_node->children;
    while (node != NULL) {
        xmlNodePtr next_node;
        next_node = node->next;
        if (g_strcmp0("boot", (char *)node->name) == 0) {
            xmlUnlinkNode(node);
            xmlFreeNode(node);
        }
        node = next_node;
    }

    for (it = boot_devices; it != NULL; it = it->next) {
        const char *dev;

        dev = gvir_config_genum_get_nick(GVIR_CONFIG_TYPE_DOMAIN_OS_BOOT_DEVICE,
                                         GPOINTER_TO_INT(it->data));
        g_warn_if_fail(dev != NULL);
        if (dev != NULL) {
            node = xmlNewDocNode(NULL, NULL, (xmlChar*)"boot", NULL);
            xmlNewProp(node, (xmlChar*)"dev", (xmlChar*)dev);
            xmlAddChild(os_node, node);
        }
    }
}

static gboolean add_boot_device(xmlNodePtr node, gpointer opaque)
{
    GList **devices = (GList **)opaque;
    const gchar *value;

    if (g_strcmp0((const gchar *)node->name, "boot") != 0)
        return TRUE;

    value = gvir_config_xml_get_attribute_content(node, "dev");
    if (value != NULL) {
        GVirConfigDomainOsBootDevice device;

        device = gvir_config_genum_get_value
                        (GVIR_CONFIG_TYPE_DOMAIN_OS_BOOT_DEVICE,
                         value,
                         GVIR_CONFIG_DOMAIN_OS_BOOT_DEVICE_HD);
        *devices = g_list_append(*devices, GINT_TO_POINTER(device));
    } else
        g_debug("Failed to parse attribute 'dev' of node 'boot'");

    return TRUE;
}

/**
 * gvir_config_domain_os_get_boot_devices:
 * @os: a #GVirConfigDomainOs
 *
 * Gets the list of devices attached to @os. The returned list should be
 * freed with g_list_free().
 *
 * Returns: (element-type LibvirtGConfig.DomainOsBootDevice) (transfer container):
 * a newly allocated #GList of #GVirConfigDomainOsBootDevice.
 */
GList *gvir_config_domain_os_get_boot_devices(GVirConfigDomainOs *os)
{
    GList *devices = NULL;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os), NULL);

    gvir_config_object_foreach_child(GVIR_CONFIG_OBJECT(os),
                                     NULL,
                                     add_boot_device,
                                     &devices);

    return devices;
}

const char *gvir_config_domain_os_get_arch(GVirConfigDomainOs *os)
{
    return gvir_config_object_get_attribute(GVIR_CONFIG_OBJECT(os),
                                            "type",
                                            "arch");
}

void gvir_config_domain_os_set_arch(GVirConfigDomainOs *os, const char *arch)
{
    xmlNodePtr os_node;
    xmlNodePtr os_type_node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    os_node = gvir_config_object_get_xml_node(GVIR_CONFIG_OBJECT(os));
    g_return_if_fail(os_node != NULL);

    os_type_node = gvir_config_xml_get_element(os_node, "type", NULL);
    g_return_if_fail(os_type_node != NULL);

    xmlNewProp(os_type_node, (xmlChar*)"arch", (xmlChar*)arch);
}

const char *gvir_config_domain_os_get_machine(GVirConfigDomainOs *os)
{
    return gvir_config_object_get_attribute(GVIR_CONFIG_OBJECT(os),
                                            "type",
                                            "machine");
}

void gvir_config_domain_os_set_machine(GVirConfigDomainOs *os, const char *machine)
{
    xmlNodePtr os_node;
    xmlNodePtr os_type_node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    os_node = gvir_config_object_get_xml_node(GVIR_CONFIG_OBJECT(os));
    g_return_if_fail(os_node != NULL);

    os_type_node = gvir_config_xml_get_element(os_node, "type", NULL);
    g_return_if_fail(os_type_node != NULL);

    xmlNewProp(os_type_node, (xmlChar*)"machine", (xmlChar*)machine);
}

void gvir_config_domain_os_set_firmware(GVirConfigDomainOs *os, GVirConfigDomainOsFirmware firmware)
{
    xmlNodePtr node;
    const gchar *firmware_str;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os));

    node = gvir_config_object_get_xml_node(GVIR_CONFIG_OBJECT(os));
    g_return_if_fail(node != NULL);

    firmware_str = gvir_config_genum_get_nick(GVIR_CONFIG_TYPE_DOMAIN_OS_FIRMWARE,
                   firmware);
    g_return_if_fail(firmware_str != NULL);

    xmlNewProp(node, (xmlChar*)"firmware", (xmlChar*)firmware_str);
}

GVirConfigDomainOsFirmware gvir_config_domain_os_get_firmware(GVirConfigDomainOs *os)
{
    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN_OS(os),
                         GVIR_CONFIG_DOMAIN_OS_FIRMWARE_BIOS);

    return gvir_config_object_get_attribute_genum
            (GVIR_CONFIG_OBJECT(os),
             NULL, "firmware",
             GVIR_CONFIG_TYPE_DOMAIN_OS_FIRMWARE,
             GVIR_CONFIG_DOMAIN_OS_FIRMWARE_BIOS);
}
