#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <glib.h>
#include <blockdev/blockdev.h>
#include <blockdev/lvm.h>
#include <bytesize/bs_size.h>

void print_usage (const char *cmd) {
    fprintf (stderr, "Usage: %s CACHED_LV [CACHED_LV2...]\n", cmd);
}

void print_size (guint64 bytes, gboolean newline) {
    BSSize size = bs_size_new_from_bytes (bytes, 1);
    char *size_str = bs_size_human_readable (size, BS_BUNIT_MiB, 2, true);
    printf ("%10s%s", size_str, newline ? "\n" : "");
    free (size_str);
    bs_size_free (size);
}

void print_ratio (guint64 part, guint64 total, gboolean space, gboolean newline) {
    float percent = ((float) part / total) * 100;
    printf ("%s[%6.2f%%]%s", space ? " " : "", percent, newline ? "\n" : "");
}

gboolean print_lv_stats (const char *vg_name, const char *lv_name, GError **error) {
    BDLVMLVdata *lv_data = bd_lvm_lvinfo (vg_name, lv_name, error);
    if (!lv_data)
        return FALSE;
    BDLVMCacheStats *stats = bd_lvm_cache_stats (vg_name, lv_name, error);
    if (!stats)
        return FALSE;

    printf ("%s/%s:\n", vg_name, lv_name);
    printf ("  mode:      %13s\n", bd_lvm_cache_get_mode_str (stats->mode, error)); /* ignoring 'error', must be a valid mode */
    printf ("  LV size:      "); print_size (lv_data->size, TRUE);
    printf ("  cache size:   "); print_size (stats->cache_size, TRUE);
    printf ("  cache used:   "); print_size (stats->cache_used, FALSE); print_ratio (stats->cache_used, stats->cache_size, TRUE, TRUE);
    printf ("  read misses:  %10"G_GUINT64_FORMAT"\n", stats->read_misses);
    printf ("  read hits:    %10"G_GUINT64_FORMAT, stats->read_hits); print_ratio (stats->read_hits, stats->read_hits + stats->read_misses, TRUE, TRUE);
    printf ("  write misses: %10"G_GUINT64_FORMAT"\n", stats->write_misses);
    printf ("  write hits:   %10"G_GUINT64_FORMAT, stats->write_hits); print_ratio (stats->write_hits, stats->write_hits + stats->write_misses, TRUE, TRUE);

    bd_lvm_lvdata_free (lv_data);
    bd_lvm_cache_stats_free (stats);

    return TRUE;
}

int main (int argc, char *argv[]) {
    gboolean ret = FALSE;
    GError *error = NULL;

    if (argc < 2) {
        fprintf (stderr, "No cached LV to get the stats for specified!\n");
        print_usage (argv[0]);
        return 1;
    }

    if ((g_strcmp0(argv[1], "-h") == 0) || g_strcmp0(argv[1], "--help") == 0) {
        print_usage (argv[0]);
        return 1;
    }

    /* check that we are runnig as root */
    if ((getuid() != 0) || (geteuid() != 0)) {
        fprintf (stderr, "This utility must be run as root.\n");
        return 1;
    }

    /* initialize the library -- we only need the LVM plugin */
    BDPluginSpec lvm_plugin = {BD_PLUGIN_LVM, NULL};
    BDPluginSpec *plugins[] = {&lvm_plugin, NULL};
    ret = bd_init (plugins, NULL, &error);

    if (!ret) {
        fprintf (stderr, "Failed to initialize the libblockdev library: %s\n",
                 error->message);
        return 2;
    }

    gboolean ok = TRUE;
    for (int i = 1; i < argc; i++) {
        char *slash = strchr (argv[i], '/');
        if (!slash) {
            fprintf (stderr, "Invalid LV specified: '%s'. Has to be in the VG/LV format.\n", argv[i]);
            ok = FALSE;
            continue;
        }
        *slash = '\0';
        const char *vg_name = argv[i];
        const char *lv_name = slash + 1;

        ret = print_lv_stats (vg_name, lv_name, &error);
        if (!ret) {
            fprintf (stderr, "Failed to get stats for '%s/%s': %s\n",
                     vg_name, lv_name, error->message);
            ok = FALSE;
        }
    }

    return ok ? 0 : 3;
}