#include <stdio.h>
#include <stdlib.h>
#include <NdbApi.hpp>
#include <iostream>


#define PRINT_ERROR(code,msg) \
  std::cout << "Error in " << __FILE__ << ", line: " << __LINE__ \
            << ", code: " << code \
            << ", msg: " << msg << "." << std::endl
#define APIERROR(error) { \
  PRINT_ERROR(error.code,error.message); \
  exit(-1); }

static void do_pk_read(Ndb *, char *);



int main()
{
  Ndb_cluster_connection *c;
  int retries, delay, verbose;
  int timeoutBefore, timeoutAfter;


  if (ndb_init())
    return(EXIT_FAILURE);

  c = new Ndb_cluster_connection();

  retries = 4;    // times to retry the connection if it failed
  delay   = 5;    // seconds between recoonect attempts
  verbose = 1;    // enable reporting (1) or not (0)

  if (c->connect(retries, delay, verbose)) {
    fprintf(stderr, "Unable to connect to cluster within 30 seconds.\n\n");
    return(EXIT_FAILURE);
  }

  timeoutBefore = 30;
  timeoutAfter  = 0;

  if (c->wait_until_ready(timeoutBefore, timeoutAfter) < 0) {
    fprintf(stderr, "Cluster was not ready within 30 seconds.\n\n");
    return(EXIT_FAILURE);
  }


  Ndb *myNdb = new Ndb(c, "test");

  if (myNdb->init(4))
    APIERROR(myNdb->getNdbError());

  do_pk_read(myNdb,"b");
  do_pk_read(myNdb,"c");
  do_pk_read(myNdb,"d");
  do_pk_read(myNdb,"e");
  do_pk_read(myNdb,"f");

  delete c;
  
  ndb_end(0);

  return(EXIT_SUCCESS);
}


/*
  Check if int32_value() returns a positive result when it should be negative.

  CREATE TABLE test.t (
     a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
     b TINYINT,
     c SMALLINT,
     d MEDIUMINT,
     e INT,
     f BIGINT
  ) ENGINE=NDB;
  INSERT INTO test.t (b,c,d,e,f) VALUES (-1,-1,-1,-1,-1);
*/

static void do_pk_read(Ndb *myNdb, char *colName)
{
  int check;
  const NdbDictionary::Dictionary *myDict = myNdb->getDictionary();
  const NdbDictionary::Table *myTable = myDict->getTable("t");

  if (myTable == NULL)
    APIERROR(myDict->getNdbError());

  NdbTransaction *myTransaction = myNdb->startTransaction(myTable);
  if (myTransaction == NULL)
    APIERROR(myNdb->getNdbError());

  NdbOperation *myOp = myTransaction->getNdbOperation(myTable);
  if (myOp == NULL)
    APIERROR(myTransaction->getNdbError());

  if (myOp->readTuple(NdbOperation::LM_CommittedRead) == -1)
    APIERROR(myTransaction->getNdbError());

  NdbRecAttr *myRecAttr[2];

  myOp->equal("a", 1);
  myRecAttr[0] = myOp->getValue(colName);

  if (myRecAttr[0] == NULL)
    APIERROR(myTransaction->getNdbError());

  if (myTransaction->execute(NdbTransaction::NoCommit) != 0)
    APIERROR(myTransaction->getNdbError());

  printf("Column Name: `%s`\n", colName);

  switch (myRecAttr[0]->getType()) {
  case NDB_TYPE_TINYINT:
    std::cout << "  type: Tinyint\n";
    std::cout << "  value: " << myRecAttr[0]->int32_value() << std::endl;
    break;
  case NDB_TYPE_TINYUNSIGNED:
    std::cout << "  type: Tinyunsigned\n";
    std::cout << "  value: " << myRecAttr[0]->u_32_value() << std::endl;
    break;
  case NDB_TYPE_SMALLINT:
    std::cout << "  type: Smallint\n";
    std::cout << "  value: " << myRecAttr[0]->int32_value() << std::endl;
    break;
  case NDB_TYPE_SMALLUNSIGNED:
    std::cout << "  type: Smallunsigned\n";
    std::cout << "  value: " << myRecAttr[0]->u_32_value() << std::endl;
    break;
  case NDB_TYPE_MEDIUMINT:
    std::cout << "  type: Mediumint\n";
    std::cout << "  value: " << myRecAttr[0]->int32_value() << std::endl;
    break;
  case NDB_TYPE_MEDIUMUNSIGNED:
    std::cout << "  type: Mediumunsigned\n";
    std::cout << "  value: " << myRecAttr[0]->u_32_value() << std::endl;
    break;
  case NDB_TYPE_INT:
    std::cout << "  type: Int\n";
    std::cout << "  value: " << myRecAttr[0]->int32_value() << std::endl;
    break;
  case NDB_TYPE_UNSIGNED:
    std::cout << "  type: Unsigned\n";
    std::cout << "  value: " << myRecAttr[0]->u_32_value() << std::endl;
    break;
  case NDB_TYPE_BIGINT:
    std::cout << "  type: Bigint\n";
    std::cout << "  value: " << myRecAttr[0]->int64_value() << std::endl;
    break;
  case NDB_TYPE_BIGUNSIGNED:
    std::cout << "  type: Bigunsigned\n";
    std::cout << "  value: " << myRecAttr[0]->u_64_value() << std::endl;
    break;
  default:
    std::cout << "unhandled column type\n";
  }
  std::cout << "\n";

  myNdb->closeTransaction(myTransaction);
}