/*
  +----------------------------------------------------------------------+
  | PHP Version 5                                                        |
  +----------------------------------------------------------------------+
  | Copyright (c) 1997-2009 The PHP Group                                |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | http://www.php.net/license/3_01.txt                                  |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Author: Nicolas Favre-Felix <n.favre-felix@owlient.eu>               |
  | Maintainer: Michael Grunder <michael.grunder@gmail.com>              |
  +----------------------------------------------------------------------+
*/
#include "redis_array_impl.h"
#include "php_redis.h"
#include "library.h"

#include "php_variables.h"
#include "SAPI.h"
#include "ext/standard/url.h"

#define PHPREDIS_INDEX_NAME    "__phpredis_array_index__"

extern int le_redis_sock;
extern zend_class_entry *redis_ce;

RedisArray*
ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b_lazy_connect TSRMLS_DC)
{
    int i = 0, host_len;
    zval *id;
    char *host, *p;
    short port;
    zval *zpData, z_cons, z_ret;
    RedisSock *redis_sock  = NULL;

    /* function calls on the Redis object */
    ZVAL_STRING(&z_cons, "__construct");

    /* init connections */
    for (zend_hash_internal_pointer_reset(hosts);
         zend_hash_has_more_elements(hosts) == SUCCESS;
         zend_hash_move_forward(hosts))
    {
        if ((zpData = zend_hash_get_current_data(hosts)) == NULL || (Z_TYPE_P(zpData) != IS_STRING))
        {
            zval_dtor(&z_cons);
            efree(ra);
            return NULL;
        }

        ra->hosts[i] = estrdup(Z_STRVAL_P(zpData));

        /* default values */
        host = Z_STRVAL_P(zpData);
        host_len = Z_STRLEN_P(zpData);
        port = 6379;

        /* Split host:port by colon */
        if ((p = memchr(host, ':', host_len))) {
            host_len = p - host;
            port = (short)atoi(p+1);
        } else if(strchr(host,'/') != NULL) { /* unix socket */
            port = -1;
        }

        /* create Redis object */
        object_init_ex(&ra->redis[i], redis_ce);
        call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL TSRMLS_CC);

        /* create socket */
        redis_sock = redis_sock_create(host, host_len, port, ra->connect_timeout, ra->pconnect, NULL, retry_interval, b_lazy_connect);

        if (!b_lazy_connect) {
            /* connect */
            redis_sock_server_open(redis_sock, 1 TSRMLS_CC);
        }

        /* attach */
        id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC);
        add_property_resource(&ra->redis[i], "socket", Z_RES_P(id));
        i++;
    }

    /* Cleanup constructor zval */
    zval_dtor(&z_cons);

    return ra;
}

/* List pure functions */
void ra_init_function_table(RedisArray *ra) {
    array_init(&ra->z_pure_cmds);

    add_assoc_bool(&ra->z_pure_cmds, "HGET", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HGETALL", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HKEYS", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HLEN", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SRANDMEMBER", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HMGET", 1);
    add_assoc_bool(&ra->z_pure_cmds, "STRLEN", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SUNION", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HVALS", 1);
    add_assoc_bool(&ra->z_pure_cmds, "TYPE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "EXISTS", 1);
    add_assoc_bool(&ra->z_pure_cmds, "LINDEX", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SCARD", 1);
    add_assoc_bool(&ra->z_pure_cmds, "LLEN", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SDIFF", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZCARD", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZCOUNT", 1);
    add_assoc_bool(&ra->z_pure_cmds, "LRANGE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZRANGE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZRANK", 1);
    add_assoc_bool(&ra->z_pure_cmds, "GET", 1);
    add_assoc_bool(&ra->z_pure_cmds, "GETBIT", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SINTER", 1);
    add_assoc_bool(&ra->z_pure_cmds, "GETRANGE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZREVRANGE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SISMEMBER", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZREVRANGEBYSCORE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZREVRANK", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HEXISTS", 1);
    add_assoc_bool(&ra->z_pure_cmds, "ZSCORE", 1);
    add_assoc_bool(&ra->z_pure_cmds, "HGET", 1);
    add_assoc_bool(&ra->z_pure_cmds, "OBJECT", 1);
    add_assoc_bool(&ra->z_pure_cmds, "SMEMBERS", 1);
}

static int
ra_find_name(const char *name) {

    const char *ini_names, *p, *next;

    ini_names = INI_STR("redis.arrays.names");
    for(p = ini_names; p;) {
        next = strchr(p, ',');
        if(next) {
            if(strncmp(p, name, next - p) == 0) {
                return 1;
            }
        } else {
            if(strcmp(p, name) == 0) {
                return 1;
            }
            break;
        }
        p = next + 1;
    }

    return 0;
}

/* laod array from INI settings */
RedisArray *ra_load_array(const char *name TSRMLS_DC) {

    zval z_params_hosts, *z_hosts;
    zval z_params_prev, *z_prev;
    zval z_params_funs, *z_data_p, z_fun, z_dist;
    zval z_params_index;
    zval z_params_autorehash;
    zval z_params_retry_interval;
    zval z_params_pconnect;
    zval z_params_connect_timeout;
    zval z_params_lazy_connect;
    RedisArray *ra = NULL;

    zend_bool b_index = 0, b_autorehash = 0, b_pconnect = 0;
    long l_retry_interval = 0;
    zend_bool b_lazy_connect = 0;
    double d_connect_timeout = 0;
    HashTable *hHosts = NULL, *hPrev = NULL;

    /* find entry */
    if(!ra_find_name(name))
        return ra;

    /* find hosts */
    array_init(&z_params_hosts);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.hosts")), &z_params_hosts TSRMLS_CC);
    if ((z_hosts = zend_hash_str_find(Z_ARRVAL(z_params_hosts), name, strlen(name))) != NULL) {
        hHosts = Z_ARRVAL_P(z_hosts);
    }

    /* find previous hosts */
    array_init(&z_params_prev);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.previous")), &z_params_prev TSRMLS_CC);
    if ((z_prev = zend_hash_str_find(Z_ARRVAL(z_params_prev), name, strlen(name))) != NULL) {
        hPrev = Z_ARRVAL_P(z_prev);
    }

    /* find function */
    array_init(&z_params_funs);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.functions")), &z_params_funs TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_funs), name, strlen(name))) != NULL) {
        ZVAL_DUP(&z_fun, z_data_p);
    }

    /* find distributor */
    array_init(&z_params_funs);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.distributor")), &z_params_funs TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_funs), name, strlen(name))) != NULL) {
        ZVAL_DUP(&z_dist, z_data_p);
    }

    /* find index option */
    array_init(&z_params_index);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.index")), &z_params_index TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_index), name, strlen(name))) != NULL) {
        if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) {
            b_index = 1;
        }
    }

    /* find autorehash option */
    array_init(&z_params_autorehash);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.autorehash")), &z_params_autorehash TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_autorehash), name, strlen(name))) != NULL) {
        if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) {
            b_autorehash = 1;
        }
    }

    /* find retry interval option */
    array_init(&z_params_retry_interval);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.retryinterval")), &z_params_retry_interval TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_retry_interval), name, strlen(name))) != NULL) {
        if (Z_TYPE_P(z_data_p) == IS_LONG || Z_TYPE_P(z_data_p) == IS_STRING) {
            if (Z_TYPE_P(z_data_p) == IS_LONG) {
                l_retry_interval = Z_LVAL_P(z_data_p);
            }
            else {
                l_retry_interval = atol(Z_STRVAL_P(z_data_p));
            }
        }
    }

    /* find pconnect option */
    array_init(&z_params_pconnect);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.pconnect")), &z_params_pconnect TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_pconnect), name, strlen(name))) != NULL) {
        if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) {
            b_pconnect = 1;
        }
    }

    /* find lazy connect option */
    array_init(&z_params_lazy_connect);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.lazyconnect")), &z_params_lazy_connect TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_lazy_connect), name, strlen(name))) != NULL) {
        if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) {
            b_lazy_connect = 1;
        }
    }

    /* find connect timeout option */
    array_init(&z_params_connect_timeout);
    sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.connecttimeout")), &z_params_connect_timeout TSRMLS_CC);
    if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_connect_timeout), name, strlen(name))) != NULL) {
        if (Z_TYPE_P(z_data_p) == IS_DOUBLE ||
            Z_TYPE_P(z_data_p) == IS_STRING ||
            Z_TYPE_P(z_data_p) == IS_LONG)
        {
        if (Z_TYPE_P(z_data_p) == IS_DOUBLE) {
            d_connect_timeout = Z_DVAL_P(z_data_p);
        } else if (Z_TYPE_P(z_data_p) == IS_LONG) {
            d_connect_timeout = Z_LVAL_P(z_data_p);
        } else {
            d_connect_timeout = atof(Z_STRVAL_P(z_data_p));
        }
        }
    }

    /* create RedisArray object */
    ra = ra_make_array(hHosts, &z_fun, &z_dist, hPrev, b_index, b_pconnect, l_retry_interval, b_lazy_connect, d_connect_timeout TSRMLS_CC);
    ra->auto_rehash = b_autorehash;
    if(ra->prev) ra->prev->auto_rehash = b_autorehash;

    /* cleanup */
    zval_dtor(&z_params_hosts);
    zval_dtor(&z_params_prev);
    zval_dtor(&z_params_funs);
    zval_dtor(&z_params_index);
    zval_dtor(&z_params_autorehash);
    zval_dtor(&z_params_retry_interval);
    zval_dtor(&z_params_pconnect);
    zval_dtor(&z_params_connect_timeout);
    zval_dtor(&z_params_lazy_connect);

    return ra;
}

RedisArray *
ra_make_array(HashTable *hosts, zval *z_fun, zval *z_dist, HashTable *hosts_prev,
              zend_bool b_index, zend_bool b_pconnect, long retry_interval,
              zend_bool b_lazy_connect, double connect_timeout TSRMLS_DC)
{
    int count = zend_hash_num_elements(hosts);

    /* create object */
    RedisArray *ra = emalloc(sizeof(RedisArray));
    ra->hosts = emalloc(count * sizeof(char*));
    ra->redis = ecalloc(count, sizeof(zval));
    ra->count = count;
    ra->index = b_index;
    ra->auto_rehash = 0;
    ra->pconnect = b_pconnect;
    ra->connect_timeout = connect_timeout;
    ra->z_multi_exec = NULL;
    ra->prev = NULL;

    /* init array data structures */
    ra_init_function_table(ra);

    if(NULL == ra_load_hosts(ra, hosts, retry_interval, b_lazy_connect TSRMLS_CC)) {
        return NULL;
    }

    if (hosts_prev) {
        ra->prev = ra_make_array(hosts_prev, z_fun, z_dist, NULL, b_index,
                                 b_pconnect, retry_interval, b_lazy_connect,
                                 connect_timeout TSRMLS_CC);
    }

    /* Set hash function and distribtor if provided */
    if (z_fun != NULL) {
        ZVAL_DUP(&ra->z_fun, z_fun);
    }
    if (z_dist != NULL) {
        ZVAL_DUP(&ra->z_dist, z_dist);
    }

    return ra;
}


/* call userland key extraction function */
char *
ra_call_extractor(RedisArray *ra, const char *key, int key_len, int *out_len TSRMLS_DC) {

    char *out;
    zval z_ret;
    zval z_argv0;

    /* check that we can call the extractor function */
    if(!zend_is_callable_ex(&ra->z_fun, NULL, 0, NULL, NULL, NULL)) {
        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not call extractor function");
        return NULL;
    }
    /* convert_to_string(ra->z_fun); */

    /* call extraction function */
    ZVAL_STRINGL(&z_argv0, key, key_len);
    call_user_function(EG(function_table), NULL, &ra->z_fun, &z_ret, 1, &z_argv0 TSRMLS_CC);

    if(Z_TYPE(z_ret) != IS_STRING) {
        zval_dtor(&z_ret);
        return NULL;
    }

    *out_len = Z_STRLEN(z_ret);
    out = emalloc(*out_len + 1);
    out[*out_len] = 0;
    memcpy(out, Z_STRVAL(z_ret), *out_len);

    zval_dtor(&z_argv0);
    zval_dtor(&z_ret);
    return out;
}

static char *
ra_extract_key(RedisArray *ra, const char *key, int key_len, int *out_len TSRMLS_DC) {

    char *start, *end, *out;
    *out_len = key_len;

    if(Z_TYPE(ra->z_fun) != IS_UNDEF)
        return ra_call_extractor(ra, key, key_len, out_len TSRMLS_CC);

    /* look for '{' */
    start = strchr(key, '{');
    if(!start) return estrndup(key, key_len);

    /* look for '}' */
    end = strchr(start + 1, '}');
    if(!end) return estrndup(key, key_len);

    /* found substring */
    *out_len = end - start - 1;
    out = emalloc(*out_len + 1);
    out[*out_len] = 0;
    memcpy(out, start+1, *out_len);

    return out;
}

/* call userland key distributor function */
zend_bool
ra_call_distributor(RedisArray *ra, const char *key, int key_len, int *pos TSRMLS_DC) {

    zval z_ret;
    zval z_argv0;

    /* check that we can call the extractor function */
    if(!zend_is_callable_ex(&ra->z_dist, NULL, 0, NULL, NULL, NULL)) {
        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not call distributor function");
        return 0;
    }
    /* convert_to_string(ra->z_fun); */

    /* call extraction function */
    ZVAL_STRINGL(&z_argv0, key, key_len);
    call_user_function(EG(function_table), NULL, &ra->z_dist, &z_ret, 1, &z_argv0 TSRMLS_CC);

    if(Z_TYPE(z_ret) != IS_LONG) {
        zval_dtor(&z_ret);
        return 0;
    }

    zval_dtor(&z_argv0);

    *pos = Z_LVAL(z_ret);
    zval_dtor(&z_ret);
    return 1;
}

zval *
ra_find_node(RedisArray *ra, const char *key, int key_len, int *out_pos TSRMLS_DC) {
    uint32_t hash;
    char *out;
    int pos, out_len;

    /* extract relevant part of the key */
    out = ra_extract_key(ra, key, key_len, &out_len TSRMLS_CC);
    if(!out) return NULL;

    if(Z_TYPE(ra->z_dist) != IS_UNDEF) {
        if (!ra_call_distributor(ra, key, key_len, &pos TSRMLS_CC)) {
            efree(out);
            return NULL;
        }
        efree(out);
    } else {
        uint64_t h64;

        /* hash */
        hash = rcrc32(out, out_len);
        efree(out);

        /* get position on ring */
        h64 = hash;
        h64 *= ra->count;
        h64 /= 0xffffffff;
        pos = (int)h64;
    }
    if(out_pos) *out_pos = pos;

    return &ra->redis[pos];
}

zval *
ra_find_node_by_name(RedisArray *ra, const char *host, int host_len TSRMLS_DC) {

    int i;
    for(i = 0; i < ra->count; ++i) {
        if(strncmp(ra->hosts[i], host, host_len) == 0) {
            return &ra->redis[i];
        }
    }
    return NULL;
}


char *
ra_find_key(RedisArray *ra, zval *z_args, const char *cmd, int *key_len) {

    zval *zp_tmp;
    int key_pos = 0; /* TODO: change this depending on the command */

    if( zend_hash_num_elements(Z_ARRVAL_P(z_args)) == 0 ||
        (zp_tmp = zend_hash_index_find(Z_ARRVAL_P(z_args), key_pos)) == NULL ||
        Z_TYPE_P(zp_tmp) != IS_STRING) {

        return NULL;
    }

    *key_len = Z_STRLEN_P(zp_tmp);
    return Z_STRVAL_P(zp_tmp);
}

void
ra_index_multi(zval *z_redis, long multi_value TSRMLS_DC) {
    zval z_fun_multi, z_ret;
    zval z_args[1];

    /* run MULTI */
    ZVAL_STRING(&z_fun_multi, "MULTI");
    ZVAL_LONG(&z_args[0], multi_value);

    call_user_function(&redis_ce->function_table, z_redis, &z_fun_multi, &z_ret, 1, z_args TSRMLS_CC);

    /* Clean up allocated string and return value */
    zval_dtor(&z_fun_multi);
    zval_dtor(&z_ret);
}

static void
ra_index_change_keys(const char *cmd, zval *z_keys, zval *z_redis TSRMLS_DC) {

    int i, argc;
    zval z_fun, z_ret, *z_args;

    /* alloc */
    argc = 1 + zend_hash_num_elements(Z_ARRVAL_P(z_keys));
    z_args = emalloc(argc * sizeof(zval));

    /* prepare first parameters */
    ZVAL_STRING(&z_fun, cmd);
    ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME);

    /* prepare keys */
    for(i = 0; i < argc - 1; ++i) {
        zval *zp;
        zp = zend_hash_index_find(Z_ARRVAL_P(z_keys), i);
        ZVAL_DUP(&z_args[i+1], zp);
    }

    /* run cmd */
    call_user_function(&redis_ce->function_table, z_redis, &z_fun, &z_ret, argc, z_args TSRMLS_CC);

    /* cleanup */
    for (i = 0; i < argc; i++) {
        zval_dtor(&z_args[i]);
    }
    efree(z_args);
    zval_dtor(&z_ret);
    zval_dtor(&z_fun);
}

void
ra_index_del(zval *z_keys, zval *z_redis TSRMLS_DC) {
    ra_index_change_keys("SREM", z_keys, z_redis TSRMLS_CC);
}

void
ra_index_keys(zval *z_pairs, zval *z_redis TSRMLS_DC) {
    /* Initialize key array */
    zval z_keys, *z_entry_p;
    HashPosition pos;
    array_init_size(&z_keys, zend_hash_num_elements(Z_ARRVAL_P(z_pairs)));

    /* Go through input array and add values to the key array */
    zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_pairs), &pos);
    while ((z_entry_p = zend_hash_get_current_data_ex(Z_ARRVAL_P(z_pairs), &pos)) != NULL) {
            zend_string *key;
            zend_ulong num_key;
            zval z_new;

            switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_pairs), &key, &num_key, &pos)) {
                case HASH_KEY_IS_STRING:
                    ZVAL_STRINGL(&z_new, key->val, key->len);
                    zend_hash_next_index_insert(Z_ARRVAL(z_keys), &z_new);
                    break;

                case HASH_KEY_IS_LONG:
                    ZVAL_LONG(&z_new, num_key);
                    zend_hash_next_index_insert(Z_ARRVAL(z_keys), &z_new);
                    break;
            }
            zend_hash_move_forward_ex(Z_ARRVAL_P(z_pairs), &pos);
    }

    /* add keys to index */
    ra_index_change_keys("SADD", &z_keys, z_redis TSRMLS_CC);

    /* cleanup */
    zval_dtor(&z_keys);
}

void
ra_index_key(const char *key, int key_len, zval *z_redis TSRMLS_DC) {

    zval z_fun_sadd, z_ret, z_args[2];

    /* prepare args */
    ZVAL_STRINGL(&z_fun_sadd, "SADD", 4);

    ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME);
    ZVAL_STRINGL(&z_args[1], key, key_len);

    /* run SADD */
    call_user_function(&redis_ce->function_table, z_redis, &z_fun_sadd, &z_ret, 2, z_args TSRMLS_CC);

    zval_dtor(&z_ret);
    zval_dtor(&z_fun_sadd);
    zval_dtor(&z_args[0]);
    zval_dtor(&z_args[1]);
}

void
ra_index_exec(zval *z_redis, zval *return_value, int keep_all TSRMLS_DC) {
    zval z_fun_exec, z_ret, *zp_tmp;

    /* run EXEC */
    ZVAL_STRING(&z_fun_exec, "EXEC");
    call_user_function(&redis_ce->function_table, z_redis, &z_fun_exec, &z_ret, 0, NULL TSRMLS_CC);
    zval_dtor(&z_fun_exec);

    /* extract first element of exec array and put into return_value. */
    if(Z_TYPE(z_ret) == IS_ARRAY) {
        if(return_value) {
            if(keep_all) {
                ZVAL_DUP(return_value, &z_ret);
            } else if((zp_tmp = zend_hash_index_find(Z_ARRVAL(z_ret), 0)) != NULL) {
                ZVAL_DUP(return_value, zp_tmp);
            }
        }
        zval_dtor(&z_ret);
    }
}

void
ra_index_discard(zval *z_redis, zval *return_value TSRMLS_DC) {
    zval z_fun_discard, z_ret;

    /* run DISCARD */
    ZVAL_STRING(&z_fun_discard, "DISCARD");

    call_user_function(&redis_ce->function_table, z_redis, &z_fun_discard, &z_ret, 0, NULL TSRMLS_CC);

    zval_dtor(&z_fun_discard);
    zval_dtor(&z_ret);
}

void
ra_index_unwatch(zval *z_redis, zval *return_value TSRMLS_DC) {

    zval z_fun_unwatch, z_ret;

    /* run UNWATCH */
    ZVAL_STRING(&z_fun_unwatch, "UNWATCH");
    call_user_function(&redis_ce->function_table, z_redis, &z_fun_unwatch, &z_ret, 0, NULL TSRMLS_CC);

    zval_dtor(&z_ret);
}

zend_bool
ra_is_write_cmd(RedisArray *ra, const char *cmd, int cmd_len) {

    zend_bool ret;
    int i;
    char *cmd_up = emalloc(1 + cmd_len);

    /* convert to uppercase */
    for(i = 0; i < cmd_len; ++i) {
        cmd_up[i] = toupper(cmd[i]);
    }
    cmd_up[cmd_len] = 0;

    ret = zend_hash_str_exists(Z_ARRVAL(ra->z_pure_cmds), cmd_up, cmd_len);

    efree(cmd_up);
    return !ret;
}

/* list keys from array index */
static long
ra_rehash_scan(zval *z_redis, char ***keys, int **key_lens, const char *cmd, const char *arg TSRMLS_DC) {

    long count, i;
    zval z_fun_smembers, z_ret, z_arg, *z_data_p;
    HashTable *h_keys;
    HashPosition pointer;
    char *key;
    int key_len;

    /* Function and argument */
    ZVAL_STRING(&z_fun_smembers, cmd);
    ZVAL_STRING(&z_arg, arg);

    /* run SMEMBERS */
    call_user_function(&redis_ce->function_table, z_redis, &z_fun_smembers, &z_ret, 1, &z_arg TSRMLS_CC);
    if(Z_TYPE(z_ret) != IS_ARRAY) { /* failure */
        return -1;    /* TODO: log error. */
    }
    h_keys = Z_ARRVAL(z_ret);

    /* allocate key array */
    count = zend_hash_num_elements(h_keys);
    *keys = emalloc(count * sizeof(char*));
    *key_lens = emalloc(count * sizeof(int));

    for (i = 0, zend_hash_internal_pointer_reset_ex(h_keys, &pointer);
            (z_data_p = zend_hash_get_current_data_ex(h_keys, &pointer)) != NULL;
            zend_hash_move_forward_ex(h_keys, &pointer), ++i) {

        key = Z_STRVAL_P(z_data_p);
        key_len = Z_STRLEN_P(z_data_p);

        /* copy key and length */
        (*keys)[i] = emalloc(1 + key_len);
        memcpy((*keys)[i], key, key_len);
        (*key_lens)[i] = key_len;
        (*keys)[i][key_len] = 0; /* null-terminate string */
    }

    /* cleanup */
    zval_dtor(&z_fun_smembers);
    zval_dtor(&z_arg);
    zval_dtor(&z_ret);

    return count;
}

static long
ra_rehash_scan_index(zval *z_redis, char ***keys, int **key_lens TSRMLS_DC) {
    return ra_rehash_scan(z_redis, keys, key_lens, "SMEMBERS", PHPREDIS_INDEX_NAME TSRMLS_CC);
}

/* list keys using KEYS command */
static long
ra_rehash_scan_keys(zval *z_redis, char ***keys, int **key_lens TSRMLS_DC) {
    return ra_rehash_scan(z_redis, keys, key_lens, "KEYS", "*" TSRMLS_CC);
}

/* run TYPE to find the type */
static zend_bool
ra_get_key_type(zval *z_redis, const char *key, int key_len, zval *z_from, long *res TSRMLS_DC) {
    int i;
    zval z_fun_type, z_ret, z_arg;
    zval *z_data;
    long success = 1;

    /* Pipelined */
    ra_index_multi(z_from, PIPELINE TSRMLS_CC);

    /* Run TYPE on our key */
    ZVAL_STRINGL(&z_fun_type, "TYPE", 4);
    ZVAL_STRINGL(&z_arg, key, key_len);
    call_user_function(&redis_ce->function_table, z_redis, &z_fun_type, &z_ret, 1, &z_arg TSRMLS_CC);

    /* Cleanup type args */
    zval_dtor(&z_fun_type);
    zval_dtor(&z_arg);
    zval_dtor(&z_ret);

    /* Run TTL on our key */
    ZVAL_STRINGL(&z_fun_type, "TTL", 3);
    ZVAL_STRINGL(&z_arg, key, key_len);
    call_user_function(&redis_ce->function_table, z_redis, &z_fun_type, &z_ret, 1, &z_arg TSRMLS_CC);

    /* Cleanup TTL args */
    zval_dtor(&z_fun_type);
    zval_dtor(&z_arg);
    zval_dtor(&z_ret);

    /* Get the result from the pipeline. */
    ra_index_exec(z_from, &z_ret, 1 TSRMLS_CC);

    if(Z_TYPE(z_ret) == IS_ARRAY) {
        HashTable *retHash = Z_ARRVAL(z_ret);
        for(i = 0, zend_hash_internal_pointer_reset(retHash);
                zend_hash_has_more_elements(retHash) == SUCCESS;
                zend_hash_move_forward(retHash)) {

            if((z_data = zend_hash_get_current_data(retHash)) == NULL) {
                success = 0;
                break;
            }
            if(Z_TYPE_P(z_data) != IS_LONG) {
                success = 0;
                break;

            }
            res[i] = Z_LVAL_P(z_data);
            i++;
        }
    }
    zval_dtor(&z_ret);

    return success;
}

/* delete key from source server index during rehashing */
static void
ra_remove_from_index(zval *z_redis, const char *key, int key_len TSRMLS_DC) {

    zval z_fun_srem, z_ret, z_args[2];

    /* run SREM on source index */
    ZVAL_STRINGL(&z_fun_srem, "SREM", 4);
    ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME);
    ZVAL_STRINGL(&z_args[1], key, key_len);

    call_user_function(&redis_ce->function_table, z_redis, &z_fun_srem, &z_ret, 2, z_args TSRMLS_CC);

    zval_dtor(&z_fun_srem);
    zval_dtor(&z_args[0]);
    zval_dtor(&z_args[1]);
    zval_dtor(&z_ret);
}


/* delete key from source server during rehashing */
static zend_bool
ra_del_key(const char *key, int key_len, zval *z_from TSRMLS_DC) {
    zval z_fun_del, z_ret, z_args;

    /* in a transaction */
    ra_index_multi(z_from, MULTI TSRMLS_CC);

    /* run DEL on source */
    ZVAL_STRINGL(&z_fun_del, "DEL", 3);
    ZVAL_STRINGL(&z_args, key, key_len);
    call_user_function(&redis_ce->function_table, z_from, &z_fun_del, &z_ret, 1, &z_args TSRMLS_CC);

    /* Cleanup DEL and key */
    zval_dtor(&z_fun_del);
    zval_dtor(&z_args);
    zval_dtor(&z_ret);

    /* remove key from index */
    ra_remove_from_index(z_from, key, key_len TSRMLS_CC);

    /* close transaction */
    ra_index_exec(z_from, NULL, 0 TSRMLS_CC);

    return 1;
}

static zend_bool
ra_expire_key(const char *key, int key_len, zval *z_to, long ttl TSRMLS_DC) {

    zval z_fun_expire, z_ret, z_args[2];

    if (ttl > 0)
    {
        /* run EXPIRE on target */
        ZVAL_STRINGL(&z_fun_expire, "EXPIRE", 6);
        ZVAL_STRINGL(&z_args[0], key, key_len);
        ZVAL_LONG(&z_args[1], ttl);
        call_user_function(&redis_ce->function_table, z_to, &z_fun_expire, &z_ret, 2, z_args TSRMLS_CC);
    }

    return 1;
}

static zend_bool
ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) {
    zval z_fun_zrange, z_fun_zadd, z_ret, z_ret_dest, z_args[4], *z_score_p, *z_zadd_args;
    int count;
    HashTable *h_zset_vals;
    zend_string *val;
    int i;
    zend_ulong idx;

    /* run ZRANGE key 0 -1 WITHSCORES on source */
    ZVAL_STRINGL(&z_fun_zrange, "ZRANGE", 6);
    ZVAL_STRINGL(&z_args[0], key, key_len);
    ZVAL_STRINGL(&z_args[1], "0", 1);
    ZVAL_STRINGL(&z_args[2], "-1", 2);
    ZVAL_BOOL(&z_args[3], 1);
    call_user_function(&redis_ce->function_table, z_from, &z_fun_zrange, &z_ret, 4, z_args TSRMLS_CC);

    /* cleanup zrange args */
    zval_dtor(&z_fun_zrange);
    for(i = 0; i < 4; ++i) {
        zval_dtor(&z_args[i]); /* FIXME */
    }

    if(Z_TYPE(z_ret) != IS_ARRAY) { /* key not found or replaced */
        /* TODO: report? */
        return 0;
    }

    /* we now have an array of value → score pairs in z_ret. */
    h_zset_vals = Z_ARRVAL(z_ret);

    /* allocate argument array for ZADD */
    count = zend_hash_num_elements(h_zset_vals);
    z_zadd_args = emalloc((1 + 2*count) * sizeof(*z_zadd_args));

    for(i = 1, zend_hash_internal_pointer_reset(h_zset_vals);
            zend_hash_has_more_elements(h_zset_vals) == SUCCESS;
            zend_hash_move_forward(h_zset_vals)) {

        if((z_score_p = zend_hash_get_current_data(h_zset_vals)) == NULL) {
            continue;
        }

        /* add score */
        convert_to_double(z_score_p);
        ZVAL_DOUBLE(&z_zadd_args[i], Z_DVAL_P(z_score_p));

        /* add value */
        switch (zend_hash_get_current_key(h_zset_vals, &val, &idx)) {
            case HASH_KEY_IS_STRING:
                ZVAL_STRINGL(&z_zadd_args[i+1], val->val, val->len);
                break;
            case HASH_KEY_IS_LONG:
                ZVAL_LONG(&z_zadd_args[i+1], (long)idx);
                break;
            default:
                return -1; /* Todo: log error */
                break;
        }
        i += 2;
    }

    /* run ZADD on target */
    ZVAL_STRINGL(&z_fun_zadd, "ZADD", 4);
    ZVAL_STRINGL(&z_zadd_args[0], key, key_len);
    call_user_function(&redis_ce->function_table, z_to, &z_fun_zadd, &z_ret_dest,
        1 + 2 * count, z_zadd_args TSRMLS_CC);

    /* Expire if needed */
    ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC);

    /* cleanup */
    for(i = 0; i < 1 + 2 * count; ++i) {
        zval_dtor(&z_zadd_args[i]);
    }

    zval_dtor(&z_fun_zadd);
    zval_dtor(&z_ret);
    zval_dtor(&z_ret_dest);
    efree(z_zadd_args);

    return 1;
}

static zend_bool
ra_move_string(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) {
    zval z_fun_get, z_fun_set, z_ret, z_args[3];
    int i, argc = 0;

    /* run GET on source */
    ZVAL_STRINGL(&z_fun_get, "GET", 3);
    ZVAL_STRINGL(&z_args[0], key, key_len);
    call_user_function(&redis_ce->function_table, z_from, &z_fun_get, &z_ret, 1, z_args TSRMLS_CC);

    zval_dtor(&z_fun_get);
    zval_dtor(&z_args[0]);

    if(Z_TYPE(z_ret) != IS_STRING) { /* key not found or replaced */
        /* TODO: report? */
        return 0;
    }

    /* run SET on target */
    if (ttl > 0) {
        ZVAL_STRINGL(&z_fun_set, "SETEX", 5);
        ZVAL_STRINGL(&z_args[argc++], key, key_len);
        ZVAL_LONG(&z_args[argc++], ttl);
        ZVAL_STRINGL(&z_args[argc++], Z_STRVAL(z_ret), Z_STRLEN(z_ret)); /* copy z_ret to arg 1 */
    } else {
        ZVAL_STRINGL(&z_fun_set, "SET", 3);
        ZVAL_STRINGL(&z_args[argc++], key, key_len);
        ZVAL_STRINGL(&z_args[argc++], Z_STRVAL(z_ret), Z_STRLEN(z_ret)); /* copy z_ret to arg 1 */
    }

    /* Cleanup get return */
    zval_dtor(&z_ret);

    /* Forward the call */
    call_user_function(&redis_ce->function_table, z_to, &z_fun_set, &z_ret, argc, z_args TSRMLS_CC);

    /* Cleanup */
    zval_dtor(&z_fun_set);
    zval_dtor(&z_ret);

    for (i = 0; i < argc; i++) {
       zval_dtor(&z_args[i]);
    }

    return 1;
}

static zend_bool
ra_move_hash(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) {
    zval z_fun_hgetall, z_fun_hmset, z_ret, z_ret_dest, z_args[2];

    /* run HGETALL on source */
    ZVAL_STRINGL(&z_fun_hgetall, "HGETALL", 7);
    ZVAL_STRINGL(&z_args[0], key, key_len);
    call_user_function(&redis_ce->function_table, z_from, &z_fun_hgetall, &z_ret, 1, z_args TSRMLS_CC);

    /* Cleanup call args */
    zval_dtor(&z_fun_hgetall);
    zval_dtor(&z_args[0]);

    if(Z_TYPE(z_ret) != IS_ARRAY) { /* key not found or replaced */
        /* TODO: report? */
        return 0;
    }

    /* run HMSET on target */
    ZVAL_STRINGL(&z_fun_hmset, "HMSET", 5);
    ZVAL_STRINGL(&z_args[0], key, key_len);
    ZVAL_DUP(&z_args[1], &z_ret);
    call_user_function(&redis_ce->function_table, z_to, &z_fun_hmset, &z_ret_dest, 2, z_args TSRMLS_CC);

    /* Cleanup call args */
    zval_dtor(&z_fun_hmset);
    zval_dtor(&z_args[0]);
    zval_dtor(&z_args[1]);

    /* Expire if needed */
    ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC);

    /* cleanup */
    zval_dtor(&z_ret);
    zval_dtor(&z_ret_dest);

    return 1;
}

static zend_bool
ra_move_collection(const char *key, int key_len, zval *z_from, zval *z_to,
        int list_count, const char **cmd_list,
        int add_count, const char **cmd_add, long ttl TSRMLS_DC) {
    zval z_fun_retrieve, z_fun_sadd, z_ret, *z_data_p, *z_retrieve_args, *z_sadd_args;
    int count, i;
    HashTable *h_set_vals;

    /* run retrieval command on source */
    z_retrieve_args = emalloc((1+list_count) * sizeof(*z_retrieve_args));
    ZVAL_STRING(&z_fun_retrieve, cmd_list[0]);    /* set the command */

    /* set the key */
    ZVAL_STRINGL(&z_retrieve_args[0], key, key_len);

    /* possibly add some other args if they were provided. */
    for(i = 1; i < list_count; ++i) {
        ZVAL_STRING(&z_retrieve_args[i], cmd_list[i]);
    }

    call_user_function(&redis_ce->function_table, z_from, &z_fun_retrieve, &z_ret,
        list_count, z_retrieve_args TSRMLS_CC);

    if(Z_TYPE(z_ret) != IS_ARRAY) { /* key not found or replaced */
        /* TODO: report? */
        return 0;
    }

    /* run SADD/RPUSH on target */
    h_set_vals = Z_ARRVAL(z_ret);
    count = zend_hash_num_elements(h_set_vals);
    z_sadd_args = emalloc((1 + count) * sizeof(*z_sadd_args));
    ZVAL_STRING(&z_fun_sadd, cmd_add[0]);
    ZVAL_STRINGL(&z_sadd_args[0], key, key_len);

    for(i = 0, zend_hash_internal_pointer_reset(h_set_vals);
            zend_hash_has_more_elements(h_set_vals) == SUCCESS;
            zend_hash_move_forward(h_set_vals), i++) {

        if((z_data_p = zend_hash_get_current_data(h_set_vals)) == NULL) {
            continue;
        }

        /* add set elements */
        ZVAL_DUP(&z_sadd_args[i+1], z_data_p);
    }

    /* Clean up our input return value */
    zval_dtor(&z_ret);

    call_user_function(&redis_ce->function_table, z_to, &z_fun_sadd, &z_ret, count+1, z_sadd_args TSRMLS_CC);

    /* Expire if needed */
    ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC);

    /* cleanup */
    for(i = 0; i <= count; ++i) {
        zval_dtor(&z_sadd_args[i]);
    }
    efree(z_sadd_args);

    for (i = 0; i < list_count; i++) {
        zval_dtor(&z_retrieve_args[i]);
    }
    efree(z_retrieve_args);

    /* Clean up our output return value */
    zval_dtor(&z_fun_retrieve);
    zval_dtor(&z_fun_sadd);
    zval_dtor(&z_ret);

    return 1;
}

static zend_bool
ra_move_set(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) {
    const char *cmd_list[] = {"SMEMBERS"};
    const char *cmd_add[] = {"SADD"};
    return ra_move_collection(key, key_len, z_from, z_to, 1, cmd_list, 1, cmd_add, ttl TSRMLS_CC);
}

static zend_bool
ra_move_list(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) {
    const char *cmd_list[] = {"LRANGE", "0", "-1"};
    const char *cmd_add[] = {"RPUSH"};
    return ra_move_collection(key, key_len, z_from, z_to, 3, cmd_list, 1, cmd_add, ttl TSRMLS_CC);
}

void
ra_move_key(const char *key, int key_len, zval *z_from, zval *z_to TSRMLS_DC) {
    long res[2], type, ttl;
    zend_bool success = 0;

    if (ra_get_key_type(z_from, key, key_len, z_from, res TSRMLS_CC)) {
        type = res[0];
        ttl = res[1];

        /* open transaction on target server */
        ra_index_multi(z_to, MULTI TSRMLS_CC);
        switch(type) {
            case REDIS_STRING:
                success = ra_move_string(key, key_len, z_from, z_to, ttl TSRMLS_CC);
                break;

            case REDIS_SET:
                success = ra_move_set(key, key_len, z_from, z_to, ttl TSRMLS_CC);
                break;

            case REDIS_LIST:
                success = ra_move_list(key, key_len, z_from, z_to, ttl TSRMLS_CC);
                break;

            case REDIS_ZSET:
                success = ra_move_zset(key, key_len, z_from, z_to, ttl TSRMLS_CC);
                break;

            case REDIS_HASH:
                success = ra_move_hash(key, key_len, z_from, z_to, ttl TSRMLS_CC);
                break;

            default:
                /* TODO: report? */
                break;
        }
    }

    if(success) {
        ra_del_key(key, key_len, z_from TSRMLS_CC);
        ra_index_key(key, key_len, z_to TSRMLS_CC);
    }

    /* close transaction */
    ra_index_exec(z_to, NULL, 0 TSRMLS_CC);
}

/* callback with the current progress, with hostname and count */
static void zval_rehash_callback(zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache,
    const char *hostname, long count TSRMLS_DC) {

    zval z_ret, z_args[2];

    z_cb->retval = &z_ret;
    z_cb->params = z_args;
    z_cb->param_count = 2;
    z_cb->no_separation = 0;

    /* run cb(hostname, count) */
    ZVAL_STRING(&z_args[0], hostname);
    ZVAL_LONG(&z_args[1], count);

    zend_call_function(z_cb, z_cb_cache TSRMLS_CC);

    zval_dtor(&z_args[0]);
}

static void
ra_rehash_server(RedisArray *ra, zval *z_redis, const char *hostname, zend_bool b_index,
        zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache TSRMLS_DC) {
    char **keys;
    int *key_lens;
    long count, i;
    int target_pos;
    zval *z_target;

    /* list all keys */
    if(b_index) {
        count = ra_rehash_scan_index(z_redis, &keys, &key_lens TSRMLS_CC);
    } else {
        count = ra_rehash_scan_keys(z_redis, &keys, &key_lens TSRMLS_CC);
    }

    /* callback */
    if(z_cb && z_cb_cache) {
        zval_rehash_callback(z_cb, z_cb_cache, hostname, count TSRMLS_CC);
    }

    /* for each key, redistribute */
    for(i = 0; i < count; ++i) {

        /* check that we're not moving to the same node. */
        z_target = ra_find_node(ra, keys[i], key_lens[i], &target_pos TSRMLS_CC);

        if(strcmp(hostname, ra->hosts[target_pos])) { /* different host */
            ra_move_key(keys[i], key_lens[i], z_redis, z_target TSRMLS_CC);
        }
    }

    /* cleanup */
    for(i = 0; i < count; ++i) {
        efree(keys[i]);
    }
    efree(keys);
    efree(key_lens);
}

void
ra_rehash(RedisArray *ra, zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache TSRMLS_DC) {
    int i;

    /* redistribute the data, server by server. */
    if(!ra->prev)
        return;    /* TODO: compare the two rings for equality */

    for(i = 0; i < ra->prev->count; ++i) {
        ra_rehash_server(ra, &ra->prev->redis[i], ra->prev->hosts[i], ra->index, z_cb, z_cb_cache TSRMLS_CC);
    }
}

/* vim: set tabstop=4 softtabstop=4 noexpandtab shiftwidth=4: */
