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

#include "ppport.h"

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

#include "const-c.inc"

HV * blergref_to_perl_hash(struct blergref *list) {
        HV *tmp;
        char buf[21];
        int n;

        tmp = newHV();
        hv_store(tmp, "author", 6, newSVpv(list->author, 0), 0);
        n = snprintf(buf, 21, "%llu", list->record);
        hv_store(tmp, "record", 6, newSVpv(buf, n), 0);

        return tmp;
}

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)));

int _set_mute(struct blerg *ptr, int v)
    CODE:
        RETVAL = blerg_set_mute(ptr, v);
    OUTPUT:
        RETVAL

int _get_mute(struct blerg *ptr)
    CODE:
        RETVAL = blerg_get_mute(ptr);
    OUTPUT:
        RETVAL

void tag_list(const char *tag, const char *str_offset, int direction)
    INIT:
        HV * tmp;
        struct blergref *list;
        uint64_t offset;
        int count, i;
    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 = blergref_to_perl_hash(&list[i]);
            XPUSHs(sv_2mortal(newRV_noinc((SV*)tmp)));
            i--;
        }
        free(list);

int subscription_add(const char *from, const char *to)
    CODE:
        RETVAL = subscription_add(from, to);
    OUTPUT:
        RETVAL

int subscription_remove(const char *from, const char *to)
    CODE:
        RETVAL = subscription_remove(from, to);
    OUTPUT:
        RETVAL

void _subscription_list(const char *author, const char *str_offset, int direction)
    INIT:
        HV *tmp;
        struct blergref *list;
        uint64_t offset;
        int count, i;
    PPCODE:
        offset = strtoull(str_offset, NULL, 0);
        list = subscription_list(author, offset, &count, direction);
        if (list == NULL) {
            XSRETURN_UNDEF;
        }

        i = count - 1;
        while (i >= 0) {
            tmp = blergref_to_perl_hash(&list[i]);
            XPUSHs(sv_2mortal(newRV_noinc((SV*)tmp)));
            i--;
        }
        free(list);

int valid_tag_name(const char *name)

int valid_name(const char *name)