#include "evsql.h"

 #include "lib/log.h"

 #include "lib/signals.h"

 #include "lib/misc.h"

 #include <event2/event.h>

 #include <event2/event_struct.h>

 #include <assert.h>

 #define CONNINFO_DEFAULT "dbname=dbfs port=5433"

 struct evsql_test_ctx {

     struct evsql *db;

     struct evsql_trans *trans;

 };

 // forward-declare

 void query_send (struct evsql *db, struct evsql_trans *trans);

 void query_timer (int fd, short what, void *arg) {

     struct evsql *db = arg;

     INFO("[evsql_test.timer] *tick*");

     query_send(db, NULL);

 }

 void query_start (struct event_base *base, struct evsql *db) {

     static struct event ev;

     struct timeval tv = { 5, 0 };

     evperiodic_assign(&ev, base, &tv, &query_timer, db);

     event_add(&ev, &tv);

     INFO("[evsql_test.timer_start] started timer");

 }

 void query_results (struct evsql_result *result, void *arg) {

     struct evsql *db = arg;

     uint32_t val;

     (void) db;

     static struct evsql_result_info result_info = {

         0, {

             {   EVSQL_FMT_BINARY,   EVSQL_TYPE_UINT32   },

             {   0,                  0                   }

         }

     };

     // begin

     assert(evsql_result_begin(&result_info, result) == 0);

     // one row

     assert(evsql_result_next(result, 

         &val

     ) > 0);

     // print

     INFO("[evsql_test.results] got result: %p: val=%lu", result, (unsigned long) val);

     // done

     evsql_result_end(result);

 }

 void query_send (struct evsql *db, struct evsql_trans *trans) {

     struct evsql_query *query = NULL;

     static int query_id = 0;

     static struct evsql_query_info query_info = {

         .sql    = "SELECT $1::int4 + 5",

         .params = {

             {   EVSQL_FMT_BINARY,   EVSQL_TYPE_UINT32   },

             {   0,                  0                   }

         }

     };

     // query

     if ((query = evsql_query_exec(db, trans, &query_info, query_results, db,

         (uint32_t) ++query_id

     )) == NULL)

         WARNING("evsql_query_exec failed");

     INFO("[evsql_test.query_send] enqueued query, trans=%p: %p: %d", trans, query, query_id);

 }

 void trans_commit (struct evsql_test_ctx *ctx) {

     if (evsql_trans_commit(ctx->trans))

         FATAL("evsql_trans_commit failed");

     INFO("[evsql_test.trans_commit] commiting transaction");

 }

 void trans_insert_result (struct evsql_result *res, void *arg) {

     struct evsql_test_ctx *ctx = arg;

     err_t err;

     // the result info

     uint32_t id;

     const char *str;

     static struct evsql_result_info result_info = {

         0, {

             {   EVSQL_FMT_BINARY,   EVSQL_TYPE_UINT32   },

             {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

             {   0,                  0                   }

         }

     };

     // begin

     if ((err = evsql_result_begin(&result_info, res)))

         EFATAL(err, "query failed%s", err == EIO ? evsql_result_error(res) : "");

     INFO("[evsql_test.insert] got %zu rows:", evsql_result_rows(res));

     // iterate over rows

     while ((err = evsql_result_next(res, &id, &str)) > 0) {

         INFO("\t%-4lu %s", (unsigned long) id, str);

     }

     if (err)

         EFATAL(err, "evsql_result_next failed");

     INFO("\t(done)");

     // done

     evsql_result_end(res);

     // commit the transaction

     trans_commit(ctx);

 }

 void trans_insert (struct evsql_test_ctx *ctx) {

     struct evsql_query *query = NULL;

     // the query info

     static struct evsql_query_info query_info = {

         .sql    = "INSERT INTO evsql_test (str) VALUES ($1::varchar), ($2::varchar) RETURNING id, str",

         .params = {

             {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

             {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

             {   0,                  0                   }

         }

     };

     // run the query

     assert((query = evsql_query_exec(ctx->db, ctx->trans, &query_info, trans_insert_result, ctx,

         (const char *) "row A",

         (const char *) "row B"

     )) != NULL);

     INFO("[evsql_test.insert] enqueued query: %p", query);

 }

 void trans_create_result (struct evsql_result *res, void *arg) {

     struct evsql_test_ctx *ctx = arg;

     // check

     if (evsql_result_check(res))

         FATAL("query failed: %s", evsql_result_error(res));

     INFO("[evsql_test.create_result] table created succesfully: %p", res);

     // free result

     evsql_result_free(res);

     // insert

     trans_insert(ctx);

 }

 void trans_create_query (struct evsql_test_ctx *ctx) {

     struct evsql_query *query = NULL;

     // the query info

     static struct evsql_query_info query_info = {

         .sql    = "CREATE TEMPORARY TABLE evsql_test ( id serial4, str varchar(32) DEFAULT 'foobar' ) ON COMMIT DROP",

         .params = {

 //            {   EVSQL_FMT_BINARY,   EVSQL_TYPE_STRING   },

             {   0,                  0,                  }

         }

     };

     // run the query

     assert((query = evsql_query_exec(ctx->db, ctx->trans, &query_info, trans_create_result, ctx

 //        (const char *) "foobar"

     )) != NULL);

     INFO("[evsql_test.trans_create_query] enqueued query: %p", query);

 }

 void trans_error (struct evsql_trans *trans, void *arg) {

     struct evsql_test_ctx *ctx = arg;

     FATAL("[evsql_test.trans_error] failure: trans=%p: %s", ctx->trans, evsql_trans_error(trans));

 }

 void trans_ready (struct evsql_trans *trans, void *arg) {

     struct evsql_test_ctx *ctx = arg;

     INFO("[evsql_test.trans_ready] ready");

     trans_create_query(ctx);

 }

 void trans_done (struct evsql_trans *trans, void *arg) {

     struct evsql_test_ctx *ctx = arg;

     INFO("[evsql_test.trans_done] done: trans=%p", ctx->trans);

 }

 void begin_transaction (struct evsql_test_ctx *ctx) {

     assert((ctx->trans = evsql_trans(ctx->db, EVSQL_TRANS_DEFAULT, 

         &trans_error, &trans_ready, &trans_done,

         ctx

     )) != NULL);

     INFO("[evsql_test.begin_trans] created transaction");

  }

 int main (int argc, char **argv) {

     struct evsql_test_ctx ctx;

     struct event_base *ev_base = NULL;

     struct signals *signals = NULL;

     const char *db_conninfo;

     // parse args

     db_conninfo = CONNINFO_DEFAULT;

     // init libevent

     if ((ev_base = event_base_new()) == NULL)

         ERROR("event_base_new");

     // setup signals

     if ((signals = signals_default(ev_base)) == NULL)

         ERROR("signals_default");

     // setup evsql

     if ((ctx.db = evsql_new_pq(ev_base, db_conninfo, NULL, NULL)) == NULL)

         ERROR("evsql_new_pq");

     // send query

     query_send(ctx.db, NULL);

     // being transaction

     begin_transaction(&ctx);

     // send query

     query_send(ctx.db, NULL);

     // start query timer

     query_start(ev_base, ctx.db);

     // run libevent

     INFO("[evsql_test.main] running libevent loop");

     if (event_base_dispatch(ev_base))

         PERROR("event_base_dispatch");

     // clean shutdown

 error :

     if (ctx.db) {

         /* evsql_close(db); */

     }

     if (signals)

         signals_free(signals);

     if (ev_base)

         event_base_free(ev_base);

 }