#include <stdio.h>
#include <stdlib.h>
#include <libcouchbase/couchbase.h>

const string host = "";
const string user = "";
const string passwd = "";
const string bucket = "";

static void errorCallback(lcb_t instance, lcb_error_t error, const char* errinfo) {
    fprintf(stderr, "Error: %s: %s", lcb_strerror(0, error), errinfo);
}

static void
getCallback(lcb_t instance,
            const void *cookie,
            lcb_error_t error,
            const lcb_get_resp_t *resp){
    if(error == LCB_SUCCESS) {
        fprintf(stderr, "getCallback: ok");
    } else {
        fprintf(stderr, "getCallback: %s", lcb_strerror(0, error));
    }
}

static void
httpCompleteCallback(lcb_http_request_t request,
                     lcb_t instance,
                     const void *cookie,
                     lcb_error_t error,
                     const lcb_http_resp_t *resp) {
    if(error == LCB_SUCCESS) {
        fprintf(stderr,"httpCompleteCallback: ok");
    } else {
        fprintf(stderr, "httpCompleteCallback: %s", lcb_strerror(0, error));
    }
}
int
main(int argc, char** argv) {
    lcb_t _instance;
    struct lcb_create_st create_options;
    lcb_error_t err;
    struct lcb_create_io_ops_st io_opts;

    io_opts.version = 0;
    io_opts.v.v0.type = LCB_IO_OPS_DEFAULT;
    io_opts.v.v0.cookie = 0;

    memset(&create_options, 0, sizeof(create_options));
    err = lcb_create_io_ops(&create_options.v.v0.io, &io_opts);
    if (err != LCB_SUCCESS) {
        fprintf(stderr,"IOInstance: %s", lcb_strerror(0, err));
        abort();
    }
    string host = "data.sj.rocketcitystudios.com:8091";
    string user = "store";
    string passwd = "";
    string bucket = "store";
    create_options.v.v0.host = host.c_str();
    create_options.v.v0.user = user.c_str();
    create_options.v.v0.passwd = passwd.c_str();
    create_options.v.v0.bucket = bucket.c_str();

    LOG_O("connect: user=`%s' host=`%s' bucket=`%s'", host, user, bucket);
    err = lcb_create(&_instance, &create_options);
    if (err != LCB_SUCCESS) {
        fprintf(stderr,"Instance: %s", lcb_strerror(0, err));
        abort();
    }

    lcb_set_error_callback(_instance, errorCallback);
    lcb_set_get_callback(_instance, getCallback);
    lcb_set_http_complete_callback(_instance, httpCompleteCallback);

    if ((err = lcb_connect(_instance)) != LCB_SUCCESS) {
        fprintf(stderr,"Connect: %s", lcb_strerror(0, err));
        abort();
    }

    // Block until the connection is established.
    lcb_wait(_instance);

    fprintf(stderr,"->sleeping");
    Sleep(10 * 1000);
    fprintf(stderr,"<-sleeping");

#ifdef never
    lcb_get_cmd_t* commands[1];

    lcb_get_cmd_t cmd;
    commands[0] = &cmd;
    memset(&cmd, 0, sizeof(lcb_get_cmd_t));
    cmd.v.v0.key = "a";
    cmd.v.v0.nkey = 1;

    err = lcb_get(_instance, 0, 1, commands);
    if(err != LCB_SUCCESS) {
        fprintf(stderr,"lcb_get: %s", lcb_strerror(_instance, err));
    } else {
        lcb_wait(_instance);
    }
#endif

    lcb_http_request_t req;
    lcb_http_cmd_t cmd;
    memset(&cmd, 0, sizeof(cmd));
    cmd.version = 0;
    cmd.v.v0.path = "_design/dev_accounts/_view/byUserId";
    cmd.v.v0.npath = strlen(cmd.v.v0.path);
    cmd.v.v0.body = NULL;
    cmd.v.v0.nbody = 0;
    cmd.v.v0.method = LCB_HTTP_METHOD_GET;
    cmd.v.v0.chunked = 1;
    cmd.v.v0.content_type = "application/json";
    err = lcb_make_http_request(_instance, NULL, LCB_HTTP_TYPE_VIEW, &cmd, &req);
    // Block until the connection is established.
    lcb_wait(_instance);
	
	return 0;
}