#include "cmd_todo.h"

//https://github.com/littlstar/b64.c
//https://www.google.nl/url?sa=t&rct=j&q=&esrc=s&source=web&cd=4&cad=rja&uact=8&ved=0ahUKEwiMu9_F5ZrXAhVLOMAKHZ6NDQYQFghDMAM&url=https%3A%2F%2Fopensource.apple.com%2Fsource%2FQuickTimeStreamingServer%2FQuickTimeStreamingServer-452%2FCommonUtilitiesLib%2Fbase64.c&usg=AOvVaw3tk0M33ne4ru28Bn_R1KI3

#define TODO_MAX_PER_USER 64

static int add_todo(sqlite3 *db, char *user, char *todo)
{
  int rc;
  char sql_add_table[3*256];
  char *b64_user, *b64_todo;
  sqlite3_stmt *res=NULL;

  b64_user = b64_encode(user, strlen(user));
  b64_todo = b64_encode(todo, strlen(todo));

  //check how many todo stuff is for single user
  snprintf(sql_add_table, 1024, "SELECT COUNT(*) FROM todo WHERE user='%s';", b64_user, b64_todo);
  printf("%s\n", sql_add_table);
  if ((rc = sqlite3_prepare_v2(db, sql_add_table, -1, &res, 0)) != SQLITE_OK)
  {
    printf("Cannot prepare statment: %s\n", sqlite3_errmsg(db));
    free(b64_user);
    free(b64_todo);
    return -1;
  }

  rc = sqlite3_step(res);
  if (rc == SQLITE_ROW)
  {
    int iret = sqlite3_column_int(res, 0);
    PRINT("%d\n",iret);
    if (iret >= TODO_MAX_PER_USER)
    {
      free(b64_user);
      free(b64_todo);
      return -1;
    }
  }
  sqlite3_finalize(res);

  //insert new value
  snprintf(sql_add_table, 1024, "INSERT INTO todo(user,todo) VALUES('%s','%s');", b64_user, b64_todo);
  printf("%s\n", sql_add_table);
  free(b64_user);
  free(b64_todo);
  
  if ((rc = sqlite3_exec(db, sql_add_table, 0, 0, 0)) != SQLITE_OK)
  {
    printf("Cannot prepare statment: %s\n", sqlite3_errmsg(db));
    return -1;
  }

  return 0;
}

static int cb_list_todo_table(void *param1, int argc, char **argv, char **cname)
{
  int i;

  sds *out = (sds *)param1;
  //sds local_out = sdsempty();

  for (i=0; i<argc; i++)
  {
    printf("%s = %s, ", cname[i], argv[i] ? argv[i] : "NULL");
    if (strncmp(cname[i],"id",2) == 0)
    {
      *out = sdscat(*out, argv[i]);
      *out = sdscat(*out, " - ");
    } else if (strncmp(cname[i],"todo",4) == 0)
    {
      char *b64_todo = b64_decode(argv[i], strlen(argv[i]));
      *out = sdscat(*out, b64_todo);
      free(b64_todo);
      *out = sdscat(*out, "\n");
    }
  }

  printf("\n");

  return 0;
}

static int list_todo(sqlite3 *db, char *user, sds *out)
{
  int rc;
  char *err_msg = NULL;

  char sql_list_table[1024];
  char *b64_user;

  b64_user = b64_encode(user, strlen(user));
  snprintf(sql_list_table, 1024, "SELECT * FROM todo WHERE user='%s'", b64_user);
  printf("%s\n",sql_list_table);
  free(b64_user);

  if ((rc = sqlite3_exec(db, sql_list_table, cb_list_todo_table, out, &err_msg )) != SQLITE_OK)
  {
    printf("Cant list todo: %s\n", err_msg);

    sqlite3_free(err_msg);

    return -1;
  }

  return 0;
}

static int list_total(sqlite3 *db, sds *out)
{
  int rc;
  char *err_msg = NULL;
  sqlite3_stmt *res=NULL;

  char sql_list_total[1024];

  snprintf(sql_list_total, 1024, "SELECT COUNT(*) FROM todo;");
  printf("%s\n",sql_list_total);

  if ((rc = sqlite3_prepare_v2(db, sql_list_total, -1, &res, 0)) != SQLITE_OK)
  {
    printf("Cannot prepare statment: %s\n", sqlite3_errmsg(db));
    return -1;
  }

  rc = sqlite3_step(res);
  if (rc == SQLITE_ROW)
  {
    const char *cret = sqlite3_column_text(res, 0);
    *out = sdscat(*out, cret);
  }
  sqlite3_finalize(res);

  return 0;
}

static int del_todo(sqlite3 *db, char *user, int id)
{
  int rc;
  char *err_msg;

  char sql_del_table[1024];
  char *b64_user;

  b64_user = b64_encode(user, strlen(user));
  snprintf(sql_del_table, 1024, "DELETE FROM todo WHERE user='%s' AND id=%d;", b64_user, id);
  free(b64_user);
  PRINT("%s\n",sql_del_table);

  if ((rc = sqlite3_exec(db, sql_del_table, 0, 0, &err_msg )) != SQLITE_OK)
  {
    printf("Cant del todo: %s\n", err_msg);

    sqlite3_free(err_msg);
    PNL();
    return -1;
  }

  PNL();
  return 0;
}

void *cmd_todo(void *data)
{
  char *ret = NULL;
  char *req_data = NULL;
  int fret;
  int rc;
  int i;

  int count;
  sds params = sdsempty();
  sds out_result = sdsempty(), out_todo = sdsempty();
  sds *tokens;

  sqlite3 *db=NULL;
  sqlite3_stmt *res=NULL;
  char *err_msg = NULL;
  int table_todo_exists=1;

  rpc_call_request  *req  = NULL;
  rpc_call_response *resp = NULL;
  netbyte_store *nb_req = NULL, *nb_resp=NULL;
  char *nb_buf = NULL;

  PRINT("TODO\n");

  req_data = (char *)data;
  if (!req_data)
  {
    PERM();
    return NULL;
  }

  //----------------------------------------------------------------------------
  //prepare request
  nb_req = malloc(sizeof(netbyte_store));
  nb_init(nb_req);
  nb_load(nb_req, req_data);

  if (nb_req == NULL)
  {
    ERROR("implement response\n");
    return NULL;
  }

  fret = rpc_call_req_unmarsh(nb_req, &req);
  if (fret != 0)
  {
    ERROR("Invalid request format\n");
    return NULL;
  }

  //----------------------------------------------------------------------------
  //main code

  //check if database filesize is not bigger then 1MB, consider it for now as abuse woop woop
  if (file_size("todo.db")>1024*1024)
  {
    printf("File should be limited to just 1MB pal\n");
    return ret;
  }

  if ((rc = sqlite3_open("todo.db", &db)) != SQLITE_OK)
  {
    printf("Cannot open todo database: %s\n", sqlite3_errmsg(db));
    sqlite3_close(db);

    return ret;
  }

  //check if table excists
  char *sql_check_table = "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='todo'";
  if ((rc = sqlite3_prepare_v2(db, sql_check_table, -1, &res, 0)) != SQLITE_OK)
  {
    printf("Cannot prepare statment: %s\n", sqlite3_errmsg(db));
    sqlite3_close(db);
    return ret;
  }

  rc = sqlite3_step(res);
  if (rc == SQLITE_ROW)
  {
    int iret = sqlite3_column_int(res, 0);
    if (iret == 0)
    {
      table_todo_exists = 0;
    } else
    {
      table_todo_exists = 1;
    }
  }

  //if table doesnt excists then create new one
  if (table_todo_exists == 0)
  {
    char *sql_create_table = "CREATE TABLE todo(id INTEGER PRIMARY KEY AUTOINCREMENT, user TEXT, todo TEXT)";
    if ((rc = sqlite3_exec(db, sql_create_table, 0, 0, &err_msg)) != SQLITE_OK)
    {
      printf("Cant create table: %s\n", err_msg);
      sqlite3_free(err_msg);
      sqlite3_close(db);
    }
  }

  params = sdsnew(req->params);
  tokens = sdssplitargs(params, &count);
  if (strncmp(tokens[1],"add",3) == 0)
  {
    PRINT("ADD\n");
    if (count > 2)
    {
      sds sAdd = sdsempty();
      for (i=2;i<count;i++)
      {
        sAdd = sdscat(sAdd, tokens[i]);
        sAdd = sdscat(sAdd, " ");
      }
      add_todo(db, req->user, sAdd);
    }
  } else if (strncmp(tokens[1],"del",3) == 0)
  {
    PRINT("DEL\n");
    if (count > 2)
    {
      int id = atoi(tokens[2]);
      PRINT("%d\n",id);
      del_todo(db, req->user, id);
    }
    
  } else if (strncmp(tokens[1],"list",4) == 0)
  {
    PRINT("LIST\n");
    list_todo(db, req->user, &out_todo);
    PRINT("%s\n",out_todo);
    out_result = sdscatsds(out_result, out_todo);
    out_result[sdslen(out_result)-1] = 0; //dirty hack mate
    sdsfree(out_todo);
  } else if (strncmp(tokens[1],"total",5) == 0)
  {
    PRINT("LIST\n");
    list_total(db, &out_todo);
    PRINT("%s\n",out_todo);
    out_result = sdscatsds(out_result, out_todo);
    //out_result[sdslen(out_result)-1] = 0; //dirty hack mate
    sdsfree(out_todo);
  }

  sqlite3_finalize(res);
  sqlite3_close(db);

  //----------------------------------------------------------------------------
  //prepare response
  nb_resp = malloc(sizeof(netbyte_store));
  nb_init(nb_resp);

  PNL();
  resp = rpc_call_resp_new(out_result,"None",1);
  resp->user = alloc_new_str(" ");
  resp->server = alloc_new_str(" ");
  resp->mask = alloc_new_str(" ");
  PNL();
  rpc_call_resp_marsh(resp, &nb_resp);

  PNL();
  nb_buf = (char *)nb_create(nb_resp);
  if (nb_buf)
  {
    ret = nb_buf;
  }

  nb_free(nb_resp);
  rpc_call_resp_free(resp);

  return ret;
}