#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "ppport.h"

#include "const-c.inc"

#include "database/database.h"
#include "database/blergref.h"
#include "database/tags.h"
#include "database/subscription.h"
#include "database/util.h"

MODULE = Blerg::Database		PACKAGE = Blerg::Database		

INCLUDE: const-xs.inc
PROTOTYPES: ENABLE

int exists(const char *name)
    CODE:
        RETVAL = blerg_exists(name);
    OUTPUT:
        RETVAL

struct blerg * _open(const char *name)
    CODE:
        RETVAL = blerg_open(name);
    OUTPUT:
        RETVAL

int _close(struct blerg *ptr)
    CODE:
        RETVAL = blerg_close(ptr);
    OUTPUT:
        RETVAL

int _store(struct blerg *ptr, const char *data, int length(data))
    PROTOTYPE: $$
    CODE:
        RETVAL = blerg_store(ptr, data, XSauto_length_of_data);
    OUTPUT:
        RETVAL

const char * _fetch(struct blerg *ptr, int record)
    INIT:
        char *buf;
        int buflen;
        int n;
    PPCODE:
        n = blerg_fetch(ptr, record, &buf, &buflen);
        if (!n) {
            XSRETURN_UNDEF;
        }
        XPUSHs(sv_2mortal(newSVpvn(buf, buflen)));
        free(buf);

const char * _get_record_count(struct blerg *ptr)
    INIT:
        uint64_t count;
        char buf[21];
        int n;
    PPCODE:
        count = blerg_get_record_count(ptr);
        n = snprintf(buf, 21, "%llu", count);
        XPUSHs(sv_2mortal(newSVpv(buf, n)));

time_t _get_timestamp(struct blerg *ptr, int record)
    CODE:
        RETVAL = blerg_get_timestamp(ptr, record);
    OUTPUT:
        RETVAL

int _set_subscription_mark(struct blerg *ptr)
    CODE:
        RETVAL = blerg_set_subscription_mark(ptr);
    OUTPUT:
        RETVAL

const char * _get_subscription_mark(struct blerg *ptr)
    INIT:
        uint64_t mark;
        char buf[21];
        int n;
    PPCODE:
        mark = blerg_get_subscription_mark(ptr);
        n = snprintf(buf, 21, "%llu", mark);
        XPUSHs(sv_2mortal(newSVpv(buf, n)));

void _tag_list(const char *tag, const char *str_offset, int direction)
    INIT:
        HV * tmp;
        struct blergref *list;
        uint64_t offset;
        char buf[21];
        int count, i, n;
    PPCODE:
        offset = strtoull(str_offset, NULL, 0);
        list = tag_list(tag, offset, &count, direction);
        if (list == NULL) {
            XSRETURN_UNDEF;
        }

        i = count - 1;
        while (i >= 0) {
            tmp = newHV();
            hv_store(tmp, "author", 6, newSVpv(list[i].author, 0), 0);
            n = snprintf(buf, 21, "%llu", list[i].record);
            hv_store(tmp, "record", 6, newSVpv(buf, n), 0);
            XPUSHs(sv_2mortal(newRV_noinc((SV*)tmp)));
            i--;
        }
        free(list);