/*
 * libvirt-gobject-domain-interface.c: libvirt gobject integration
 *
 * 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: Marc-André Lureau <marcandre.lureau@redhat.com>
 */

#include <config.h>

#include <libvirt/virterror.h>
#include <string.h>

#include "libvirt-glib/libvirt-glib.h"
#include "libvirt-gobject/libvirt-gobject.h"
#include "libvirt-gobject-compat.h"

#include "libvirt-gobject/libvirt-gobject-domain-device-private.h"

#define GVIR_DOMAIN_INTERFACE_GET_PRIVATE(obj)                         \
        (G_TYPE_INSTANCE_GET_PRIVATE((obj), GVIR_TYPE_DOMAIN_INTERFACE, GVirDomainInterfacePrivate))

struct _GVirDomainInterfacePrivate
{
    gboolean unused;
};

G_DEFINE_TYPE_WITH_PRIVATE(GVirDomainInterface, gvir_domain_interface, GVIR_TYPE_DOMAIN_DEVICE);

#define GVIR_DOMAIN_INTERFACE_ERROR gvir_domain_interface_error_quark()

static GQuark
gvir_domain_interface_error_quark(void)
{
    return g_quark_from_static_string("gvir-domain-interface");
}

static void gvir_domain_interface_class_init(GVirDomainInterfaceClass *klass G_GNUC_UNUSED)
{
}

static void gvir_domain_interface_init(GVirDomainInterface *self)
{
    self->priv = GVIR_DOMAIN_INTERFACE_GET_PRIVATE(self);
}

static GVirDomainInterfaceStats *
gvir_domain_interface_stats_copy(GVirDomainInterfaceStats *stats)
{
    return g_slice_dup(GVirDomainInterfaceStats, stats);
}

static void
gvir_domain_interface_stats_free(GVirDomainInterfaceStats *stats)
{
    g_slice_free(GVirDomainInterfaceStats, stats);
}

G_DEFINE_BOXED_TYPE(GVirDomainInterfaceStats, gvir_domain_interface_stats,
                    gvir_domain_interface_stats_copy, gvir_domain_interface_stats_free)

static const gchar *gvir_domain_interface_get_path(GVirDomainInterface *self)
{
    GVirConfigDomainDevice *config;
    const gchar *path = NULL;

    config = gvir_domain_device_get_config(GVIR_DOMAIN_DEVICE(self));
    if (GVIR_CONFIG_IS_DOMAIN_INTERFACE_USER(self))
        /* FIXME: One of the limitations of user-mode networking of libvirt */
        g_debug("Statistics gathering for user-mode network not yet supported");
    else
        path = gvir_config_domain_interface_get_ifname(GVIR_CONFIG_DOMAIN_INTERFACE (config));

    g_object_unref (config);

    return path;
}

/**
 * gvir_domain_interface_get_stats:
 * @self: the domain interface
 * @err: an error
 *
 * This function returns network interface stats. Individual fields
 * within the stats structure may be returned as -1, which indicates
 * that the hypervisor does not support that particular statistic.
 *
 * Returns: (transfer full): the stats or %NULL in case of error. The
 * returned object should be unreffed with g_object_unref() when no longer
 * needed.
 **/
GVirDomainInterfaceStats *gvir_domain_interface_get_stats(GVirDomainInterface *self, GError **err)
{
    GVirDomainInterfaceStats *ret = NULL;
    virDomainInterfaceStatsStruct stats;
    virDomainPtr handle;
    const gchar *path;

    g_return_val_if_fail(GVIR_IS_DOMAIN_INTERFACE(self), NULL);
    g_return_val_if_fail(err == NULL || *err == NULL, NULL);

    handle = gvir_domain_device_get_domain_handle(GVIR_DOMAIN_DEVICE(self));
    path = gvir_domain_interface_get_path (self);
    if (path == NULL) {
        ret = g_slice_new0(GVirDomainInterfaceStats);
        goto end;
    }

    if (virDomainInterfaceStats(handle, path, &stats, sizeof (stats)) < 0) {
        gvir_set_error_literal(err, GVIR_DOMAIN_INTERFACE_ERROR,
                               0,
                               "Unable to get domain interface stats");
        goto end;
    }

    ret = g_slice_new(GVirDomainInterfaceStats);
    ret->rx_bytes = stats.rx_bytes;
    ret->rx_packets = stats.rx_packets;
    ret->rx_errs = stats.rx_errs;
    ret->rx_drop = stats.rx_drop;
    ret->tx_bytes = stats.tx_bytes;
    ret->tx_packets = stats.tx_packets;
    ret->tx_errs = stats.tx_errs;
    ret->tx_drop = stats.tx_drop;

end:
    virDomainFree(handle);
    return ret;
}