int list_cmd(char *args){
	// todo get page number from strtok
	size_t cmd_len = cgc_strlen(args);
	char * pg_num_txt = args;//\\\strtok(NULL, cmd_len);
	if(pg_num_txt == NULL){
		return CMDBADARG;
	}
	if(buf_is_numeric(pg_num_txt) != 1){
		return CMDBADNUMERIC;
	}

	int pg_num_i = atoi(pg_num_txt);
	if(pg_num_i < 0)
		return CMDNEGNUMERIC;

	return transmit_compound_list_page(pg_num_i);
}

char *strncat ( char *dest, const char *src, size_t n )
{
    size_t dest_len = cgc_strlen(dest);
    size_t i;

    if (dest == NULL || src == NULL)
    {
      return(dest);
    }
    for (i = 0; i < n && src[i] != '\0'; i++)
    {
      dest[dest_len+i] = src[i];
    }
    dest[dest_len+i] = '\0';

    return(dest);
}

compounds_sample_t *sample_compounds(const char *seed, const size_t sample_size){
	if(sample_size > N_FORMULAS-1)
		return NULL;
	unsigned int h = crazy_hash(seed, cgc_strlen(seed), 0xcafeb4b4);

	compounds_sample_t *sample = alloc_sample_st(sample_size);
	// todo check alloc
	if(sample == NULL)
		return NULL;
	for(int i =0; i < sample_size; ++i){
		set_sample_at_idx(sample, i,  (h % (N_FORMULAS-1)));
		
		h = crazy_hash((const char *) &h, sizeof(h), h);
	}

	return sample;
}

int input_matrix(matrix_t *m, char *buf, int buf_size)
{
    if (resize_matrix(m, buf, buf_size) == ERROR)
        return ERROR;

    int num_cells = m->num_rows * m->num_cols;
    int cell_val = 0, retval = 0;
    char *num_str = NULL;

    retval = readline(buf, buf_size);
    if (retval == ERROR || retval == FAIL)
    {
        printf("Bad Input\n");
        return retval;
    }

    int number_count = 1;
    int i, j;

    for (i = 0; i < cgc_strlen(buf); i++)
    {
        if (buf[i] == ' ')
            number_count++;
    }

    if (number_count != num_cells)
    {
        printf("Bad Input\n");
        return FAIL;
    }

    for (i = 0; i < m->num_rows; i++)
    {
        for (j = 0; j < m->num_cols; j++)
        {
            num_str = strsep(&buf, " ");
            if (!num_str)
                return ERROR;

            cell_val = strtol(num_str, NULL, 10);
            m->set_cell(m, i, j, cell_val);
        }
    }

    return SUCCESS;
}

static int addvar(var_t *var, char *name, varenum type) {

    if (!(var->name = calloc(cgc_strlen(name)+1)))
        return ERRNOMEM;

    strcpy(var->name, name);

    var->type = type;
    if (global_nspace.last)
        global_nspace.last->next = var;
    global_nspace.last = var;
    if (!global_nspace.first)
        global_nspace.first = var; 
    var->next = NULL; //just to be safe
    global_nspace.count++;
    return 0;
}

/* 
   help command
 */
int cgc_HelpHandler() {
	ShellCmds *c;
	int len;

	c = cgc_cmds;
	while (c->command) {
		cgc_printf("@s", c->command);
		len = 20-cgc_strlen(c->command);
		while (len-- > 0) {
			cgc_printf(" ");
		}
		cgc_printf("@s\n", c->help);
		c++;
	}

	return(0);
}

message *add_random_message(mail_queue *mq) {
    message *m = calloc(sizeof(message));
    m->sender = pick_address();
    m->recipient = pick_address();
    m->subject = gen_random_string(5, 32);
    m->data = gen_random_string(5,256);
    m->data_length = cgc_strlen(m->data);

    if (mq->root != NULL) {
        message *next = mq->root;
        while (next->next != NULL) {
            next = next->next;
        }
        next->next = m;
    }
    return m;
}

// examine str to determine if it can be converted to a number
// return 0 if yes and 0/positive, 1 if yes and negative, -1 if no.
int is_numeric(const char *str) {
    int sign = 0;

    if (cgc_strlen(str) == 0)
        return -1;

    if (*str == '-') {
        str++;
        sign = 1;
    }

    while (*str != '\0') {
        if (*str < '0' || *str > '9')
            return -1;
        str++;
    }
    return sign;
}

int bloomy_check(bloomy_t *bloomy, const char *buf)
{
  uint8_t bit;
  unsigned int i, n;
  if (bloomy == NULL || bloomy->bits == NULL)
    return -1;
  for (i = 0; i < sizeof(bloomy->hashes) / sizeof(hash_t); ++i)
  {
    if (bloomy->hashes[i])
    {
      n = (bloomy->hashes[i](buf, cgc_strlen(buf)) % bloomy->size);
      bit = (bloomy->bits[n/8] & (1 << (n%8)));
      if (!bit)
        return 0;
    }
  }
  return 1;
}

int init(int rot)
{
  int ret = 0;
  size_t numWords = NUM_WORDS;

  //first allocate enough space for the wordlist
  ret = allocate( sizeof(gSeedWords), 0, (void**)(&gWords));
  if (ret != 0)
  {
    return (ret);
  }

  //now calculate how many bytes we need to store the words themselves
  size_t total = 0;
  int i = 0;
  for (i = 0; i < numWords; i++)
  {
    total += cgc_strlen(gSeedWords[i]);
    total += 1; //for the NULL character
  }
 
  ret = allocate(total, 0, (void**)(&gWordData));
  if (ret != 0)
  {
    return (ret);
  } 

  //now that we have both we can fill in the data  
  size_t temp = 0;
  char* pTemp = gWordData;
  for (i = 0; i < numWords; i++)
  {
    gWords[i] = pTemp;
    pTemp += strrotcpy(pTemp, gSeedWords[i], rot);
    pTemp += 1; //for the NULL character
  }
  
  for ( ; i < (PAGE_SIZE / sizeof(char*)); i++)
  {
    gWords[i] = 0;
  }

  return (0);
}

int getopt(int argc, char **argv, char *optstring, int *opt_index) {
  
  int option = -1;
  if (*opt_index >= argc || !argv[*opt_index]) {
    goto DONE;
  }
  for (int i = 0; i < cgc_strlen(optstring); i++) {
    if (*argv[*opt_index] == optstring[i]) {
      option = optstring[i];
      (*opt_index)++;
      goto DONE;
    }
  }
  (*opt_index)++;
  option = 0;
    
DONE:
  return option;
}

/**
* Destroy the dungeon and free all memory
*
* @param dungeon A pointer to the dungeon structure
*
* @return None
*/
void destroyDungeon(Dungeon* dungeon) {
    size_t len;

    bzero((char *)&dungeon->moveTypes, sizeof(Moves));
    if(dungeon->moveList) {
        len = cgc_strlen(dungeon->moveList);
        bzero(dungeon->moveList, len);
        free(dungeon->moveList);
    }
    dungeon->moveList = NULL;

    Room* nextRoom;
    for(Room* room=dungeon->start; room!=NULL; room=nextRoom) {
        nextRoom = (Room *)room->next;
        destroyRoom(&room->contents);
        free(room);
    }

}

size_t strcat( char *dest, char* src )
{
    size_t length = 0;
    size_t start = 0;

    if ( dest == NULL || src == NULL) {
        goto end;
    }

    start = cgc_strlen( dest );

    for ( ; src[length] != 0x00 ; start++, length++ ) {
        dest[start] = src[length];
    }

    length = start;
end:
    return length;
}

static char *
append_to_path(char *path, const char *toappend)
{
    char *tmp;
    size_t len;

    len = cgc_strlen(path);
    if ((tmp = realloc(path, len + MAX_FILE_NAME_LENGTH + 2)) == NULL) {
        free(path);
        return NULL;
    }
    path = tmp;

    strcat(path, "/");
    strncat(path, toappend, MAX_FILE_NAME_LENGTH);
    path[len + MAX_FILE_NAME_LENGTH + 1] = '\0';

    return path;
}

static cell_t *get_cell(char *cell_id)
{
    char row_str[3];
    char col_str[3];
    int row_idx = 0, col_idx = 0;
    int i, len;

    if (get_rowcol(cell_id, row_str, col_str, '\0') == -1)
        return NULL;

    len = cgc_strlen(row_str);
    for (i = 0; i < len; i++)
        row_idx += ((row_str[i] - 64) * pow(26, len - i - 1));

    --row_idx;
    col_idx = strtol(col_str, NULL, 10);
    return &g_sheet[row_idx][col_idx];

}

int run_viewscript(char *script) {

    char *cur = script;
    char **lines;
    int res = 0;
    int idx = 0;
    int count = 0;
    //this is properly null-terminated by main()
    int len = cgc_strlen(script);

    if (len > MAXSCRIPTSIZE)
        return ERRTOOBIG;

    while(*cur) {
        if (*cur == '\n')
            count++;
        cur++;
    }

    if (count == 0)
        return ERRSHORT;

    if (!(lines = calloc((count+1)*sizeof(char *))))
        return ERRNOMEM;

    lines[0] = strtok(script,'\n');
    #ifdef PATCHED
    while (idx < count && (lines[++idx] = strtok(NULL,'\n')));
    #else 
    while ((lines[++idx] = strtok(NULL,'\n')));
    #endif
    for (idx = 0; idx < count; idx++) {
        if ((res = runcmd(lines[idx])))
            return res;
    }

    free(lines);

    LOG("Done.");

    return 0;
}

list *str_to_wordlists(const char *s)
{
    size_t len = cgc_strlen(s);
    char *x = calloc(1, len + 1);
    strncpy(x, s, len);
    x[len] = '\0';

    list *words = split_words(x, 1);
    if (!words)
        return NULL;

    free(x);

#define CHAIN_LENGTH 2
    list *chunks = chunk_words(words, CHAIN_LENGTH);
    if (!chunks)
        return NULL;

    return chunks;
}

int cgc_rev_cmd(const char *s)
{
  char *r = cgc_calloc(1, cgc_strlen(s) + 1);
  cgc_strcpy(r, s);
  if (!cgc_strchr(r, '\0'))
    return -1;

  char *start = r;
  char *end = cgc_strchr(r, '\0') - 1;
  while (start < end) {
    *start ^= *end;
    *end ^= *start;
    *start ^= *end;
    start++, end--;
  }

  cgc_printf("case > %s\n", r);
  cgc_free(r);
  return 0;
}

static int cgc_set_field(interp_t *interp, unsigned int num, const char *value)
{
    char **fields, *copy;
    if (num > MAX_FIELDS)
        return 0;

    if (interp->fields == NULL && num > 0)
    {
        if (!cgc_read_fields(interp))
            return 0;
    }

    if (num > interp->num_fields)
    {
        fields = cgc_realloc(interp->fields, num * sizeof(char *));
        if (fields == NULL)
            return 0;
        interp->fields = fields;
        cgc_memset(&interp->fields[interp->num_fields], 0, sizeof(char *) * (num - interp->num_fields));
        interp->num_fields = num;
    }

    if (num == 0)
    {
        if (cgc_strlen(value) >= BUF_SIZE - 1)
            return 0;
        cgc_strcpy(interp->buf, value);
        free_fields(interp);
        interp->field0 = interp->buf;
    }
    else
    {
        copy = cgc_strdup(value);
        if (copy == NULL)
            return 0;

        interp->fields[num-1] = copy;
        interp->field0 = NULL;
    }
    return 1;
}

static int newview(char *name, char *arg) {
    viewvar_t *v = NULL;
    arrvar_t *a = NULL;
    int i = 0;
    int res = 0;

    char *type = strtok(NULL,' ');

    if (!type || cgc_strlen(type) == 0)
        return ERRNOTYPE;

    if (!(a = (arrvar_t*)getvar(arg))) 
        return ERRNOSUCHVAR;

    if (a->v.type != ARRTYPE) 
        return ERRWRONGTYPE;

    if (!(v = calloc(sizeof(viewvar_t))))
        return ERRNOMEM;

    for (i=0; i < sizeof(viewtypes)/sizeof(viewtype_t); i++) {
        if (streq(type,viewtypes[i].name)) {
            v->view = &viewtypes[i];
            break;
        }
    }

    if (!v->view) {
        free(v);
        return ERRNOSUCHTYPE;
    }

    v->arr = a;

    res = addvar((var_t*)v, name, VIEWTYPE);

    if (res)
        free(v);

    return res;
}