//返回下标处于区域 [begin, end] 的元素. begin 和 end 可以是负数
//
//  name queue 的名字.
//  begin 正整数, 从此下标处开始返回。从 0 开始。
//  end 整数, 结束下标。可以是负数, 表示返回所有。
//  [slice，range] 命令
//  返回 v，返回元素的数组，为空时返回 nil
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) slice(name string, args ...int) (v []Value, err error) {
	begin := 0
	end := -1
	index := 0
	if len(args) > 0 {
		begin = args[0]
	}
	if len(args) > 1 {
		end = args[1]
	}
	if len(args) > 2 {
		index = args[2]
	}
	resp, err := this.Do(qslice_cmd[index], name, begin, end)
	if err != nil {
		return nil, goerr.NewError(err, "%s %s error", qslice_cmd[index], name)
	}
	size := len(resp)
	if size >= 1 && resp[0] == "ok" {
		for i := 1; i < size; i++ {
			v = append(v, Value(resp[i]))
		}
		return
	}
	return nil, makeError(resp, name)
}

//设置过期
//
//  key 要设置过期的 key
//  ttl 存活时间(秒)
//  返回 re，设置是否成功，如果当前 key 不存在返回 false
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Expire(key string, ttl int64) (re bool, err error) {
	resp, err := this.Do("expire", key, ttl)
	if err != nil {
		return false, goerr.NewError(err, "Expire %s error", key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return resp[1] == "1", nil
	}
	return false, makeError(resp, key, ttl)
}

//更新 key 对应的 value, 并返回更新前的旧的 value.
//
//  key 键值
//  val 存贮的 value 值,val只支持基本的类型，如果要支持复杂的类型，需要开启连接池的 Encoding 选项
//  返回 一个 Value,可以方便的向其它类型转换.如果 key 不存在则返回 "", 否则返回 key 对应的值内容.
//  返回 一个可能的错误，操作成功返回 nil
func (this *Client) Getset(key string, val interface{}) (Value, error) {
	resp, err := this.Do("getset", key, val)
	if err != nil {
		return "", goerr.NewError(err, "Getset %s error", key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]), nil
	}
	return "", makeError(resp, key)
}

//返回队列的最后一个元素.
//
//  key  队列的名字
//  返回 val，返回的值.
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qback(key string) (Value, error) {
	resp, err := this.Do("qback", key)
	if err != nil {
		return "", goerr.NewError(err, "Qback %s error", key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]), nil
	}
	return "", makeError(resp, key)
}

//返回指定位置的元素. 0 表示第一个元素, 1 是第二个 ... -1 是最后一个.
//
//  key  队列的名字
//  index 指定的位置，可传负数.
//  返回 val，返回的值.
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qget(key string, index int64) (Value, error) {
	resp, err := this.Do("qget", key, index)
	if err != nil {
		return "", goerr.NewError(err, "Qget %s error", key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]), nil
	}
	return "", makeError(resp, key)
}

//获取 hashmap 中指定 key 的值内容.
//
//  setName hashmap 的名字
//  key hashmap 的 key
//  返回 value key 的值
//  返回 err，执行的错误
func (this *Client) Hget(setName, key string) (value Value, err error) {
	resp, err := this.Do("hget", setName, key)
	if err != nil {
		return "", goerr.NewError(err, "Hget %s/%s error", setName, key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]), nil
	}
	return "", makeError(resp, setName, key)
}

//删除 hashmap 中的指定 key，不能通过返回值来判断被删除的 key 是否存在.
//
//  setName hashmap 的名字
//  key hashmap 的 key
//  返回 err，执行的错误
func (this *Client) Hdel(setName, key string) (err error) {
	resp, err := this.Do("hdel", setName, key)
	if err != nil {
		return goerr.NewError(err, "Hdel %s/%s error", setName, key)
	}
	if len(resp) > 0 && resp[0] == "ok" {
		return nil
	}
	return makeError(resp, setName, key)
}

func (this *Client) Zget(setName, key string) (score int64, err error) {
	resp, err := this.Do("zget", setName, key)
	if err != nil {
		return 0, goerr.NewError(err, "Zget %s/%s error", setName, key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]).Int64(), nil
	}
	return 0, makeError(resp, setName, key)
}

//当 key 不存在时, 设置指定 key 的值内容. 如果已存在, 则不设置.
//
//  key 键值
//  val 存贮的 value 值,val只支持基本的类型，如果要支持复杂的类型，需要开启连接池的 Encoding 选项
//  返回 err，可能的错误，操作成功返回 nil
//  返回 val 1: value 已经设置, 0: key 已经存在, 不更新.
func (this *Client) Setnx(key string, val interface{}) (Value, error) {
	resp, err := this.Do("setnx", key, this.encoding(val, false))

	if err != nil {
		return "", goerr.NewError(err, "Setnx %s error", key)
	}
	if len(resp) > 0 && resp[0] == "ok" {
		return Value(resp[1]), nil
	}
	return "", makeError(resp, key)
}

//返回队列的长度.
//
//  name  队列的名字
//  返回 size，队列的长度；
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Qsize(name string) (size int64, err error) {
	resp, err := this.Do("qsize", name)
	if err != nil {
		return -1, goerr.NewError(err, "Qsize %s error", name)
	}

	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]).Int64(), nil
	}
	return -1, makeError(resp, name)
}

//删除 hashmap 中的所有 key
//
//  setName hashmap 的名字
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Hclear(setName string) (err error) {
	resp, err := this.Do("hclear", setName)
	if err != nil {
		return goerr.NewError(err, "Hclear %s error", setName)
	}

	if len(resp) > 0 && resp[0] == "ok" {
		return nil
	}
	return makeError(resp, setName)
}

func (this *Client) Zset(setName, key string, score int64) (err error) {
	resp, err := this.Do("zset", setName, key, this.encoding(score, false))
	if err != nil {
		return goerr.NewError(err, "Zset %s/%s error", setName, key)
	}

	if len(resp) > 0 && resp[0] == "ok" {
		return nil
	}
	return makeError(resp, setName, key)
}

//判断指定的 key 是否存在于 hashmap 中.
//
//  setName hashmap 的名字
//  key hashmap 的 key
//  返回 re，如果当前 key 不存在返回 false
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Hexists(setName, key string) (re bool, err error) {
	resp, err := this.Do("hexists", setName, key)
	if err != nil {
		return false, goerr.NewError(err, "Hexists %s/%s error", setName, key)
	}

	if len(resp) == 2 && resp[0] == "ok" {
		return resp[1] == "1", nil
	}
	return false, makeError(resp, setName, key)
}

//设置 hashmap 中指定 key 对应的值内容.
//
//  setName hashmap 的名字
//  key hashmap 的 key
//  value key 的值
//  返回 err，执行的错误
func (this *Client) Hset(setName, key string, value interface{}) (err error) {
	resp, err := this.Do("hset", setName, key, this.encoding(value, false))
	if err != nil {
		return goerr.NewError(err, "Hset %s/%s error", setName, key)
	}

	if len(resp) > 0 && resp[0] == "ok" {
		return nil
	}
	return makeError(resp, setName, key)
}

//返回 key(只针对 KV 类型) 的存活时间.
//
//  key 要删除的 key
//  返回 ttl，key 的存活时间(秒), -1 表示没有设置存活时间.
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Ttl(key string) (ttl int64, err error) {
	resp, err := this.Do("ttl", key)
	if err != nil {
		return -1, goerr.NewError(err, "Ttl %s error", key)
	}

	//response looks like this: [ok 1]
	if len(resp) > 0 && resp[0] == "ok" {
		return Value(resp[1]).Int64(), nil
	}
	return -1, makeError(resp, key)
}

func (this *Client) Zcount(setName string, start, end interface{}) (count int64, err error) {
	resp, err := this.Do("zcount", setName, this.encoding(start, false), this.encoding(end, false))
	if err != nil {
		return -1, goerr.NewError(err, "Zcount %s %v %v error", setName, start, end)
	}

	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]).Int64(), nil
	}
	return -1, makeError(resp, setName)

}

//计算字符串的长度(字节数).
//
//  key 键值
//  返回 字符串的长度, key 不存在则返回 0.
//  返回 err，可能的错误，操作成功返回 nil
func (this *Client) Strlen(key string) (int64, error) {

	resp, err := this.Do("strlen", key)

	if err != nil {
		return -1, goerr.NewError(err, "Strlen %s error", key)
	}
	if len(resp) > 1 && resp[0] == "ok" {
		return Value(resp[1]).Int64(), nil
	}
	return -1, makeError(resp, key)
}

//列出处于区间 (key_start, key_end] 的 key 列表.("", ""] 表示整个区间.
//
//  keyStart int 返回的起始 key(不包含), 空字符串表示 -inf.
//  keyEnd int 返回的结束 key(包含), 空字符串表示 +inf.
//  limit int 最多返回这么多个元素.
//  返回 返回包含 key 的数组.
//  返回 err，可能的错误，操作成功返回 nil
func (this *Client) Keys(keyStart, keyEnd string, limit int64) ([]string, error) {

	resp, err := this.Do("keys", keyStart, keyEnd, limit)

	if err != nil {
		return nil, goerr.NewError(err, "Keys %s error", keyStart, keyEnd, limit)
	}
	if len(resp) > 0 && resp[0] == "ok" {
		return resp[1:], nil
	}
	return nil, makeError(resp, keyStart, keyEnd, limit)
}

//删除指定 key
//
//  key 要删除的 key
//  返回 err，执行的错误，操作成功返回 nil
func (this *Client) Del(key string) error {
	resp, err := this.Do("del", key)
	if err != nil {
		return goerr.NewError(err, "Del %s error", key)
	}

	//response looks like this: [ok 1]
	if len(resp) > 0 && resp[0] == "ok" {
		return nil
	}
	return makeError(resp, key)
}

//设置 hashmap 中指定 key 对应的值增加 num. 参数 num 可以为负数.
//
//  setName - hashmap 的名字.
//  key 键值
//  num 增加的值
//  返回 val，整数，增加 num 后的新值
//  返回 err，可能的错误，操作成功返回 nil
func (this *Client) Hincr(setName, key string, num int64) (val int64, err error) {

	resp, err := this.Do("hincr", setName, key, num)

	if err != nil {
		return -1, goerr.NewError(err, "Hincr %s error", key)
	}
	if len(resp) == 2 && resp[0] == "ok" {
		return Value(resp[1]).Int64(), nil
	}
	return -1, makeError(resp, key)
}