func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	userkey := util.FormatUserKey(args.UserID)
	_, userErr := ts.libstore.Get(userkey)

	if userErr != nil {
		reply.Status = tribrpc.NoSuchUser
	} else {
		reply.Status = tribrpc.OK
		subskey := util.FormatSubListKey(args.UserID)
		subsList, _ := ts.libstore.GetList(subskey)

		totalTribList := make(Tribbles, 0)
		for i := 0; i < len(subsList); i++ {
			curUser := subsList[i]
			curtribList := ts.GetTribblesOneUser(curUser)

			for j := 0; j < len(curtribList); j++ {
				totalTribList = append(totalTribList, curtribList[j])
			}
			//totalTribList = append(totalTribList, curtribList)
		}

		sort.Sort(totalTribList)
		totalLen := len(totalTribList)
		if totalLen > 100 {
			totalLen = 100
		}
		reply.Tribbles = make(Tribbles, totalLen)
		for j := 0; j < totalLen; j++ {
			reply.Tribbles[j] = totalTribList[j]
		}
	}
	return nil

}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	user := args.UserID

	_, err := ts.Libstore.Get(user)
	switch err {
	case nil: // expected case, do nothing
	case libstore.ErrorKeyNotFound:
		reply.Status = tribrpc.NoSuchUser
		return nil
	default:
		return err
	}

	subscListKey := makeSubscListKey(user)
	subscList, err := ts.Libstore.GetList(subscListKey)
	switch err {
	case nil:
	case libstore.ErrorKeyNotFound:
		reply.Tribbles = make([]tribrpc.Tribble, 0)
		reply.Status = tribrpc.OK
		return nil
	default:
		return err
	}

	tribbles, err := ts.getTribsFromSubs(subscList)
	if err != nil { // ignore error
		// return err
	}

	reply.Tribbles = tribbles
	reply.Status = tribrpc.OK
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	key := util.FormatUserKey(args.UserID)
	if ts.checkIfKnown(key) {
		triblist_key := util.FormatTribListKey(args.UserID)
		post_ids, err := ts.storage.GetList(triblist_key)
		if err != nil {
			post_ids = []string{}
		}
		sort.Sort(ByChrono(post_ids))
		bound := min(100, len(post_ids))
		tribs := make([]tribrpc.Tribble, bound)
		for i, v := range post_ids[0:bound] {
			postStr, err := ts.storage.Get(v)
			if err != nil {
				return err
			}
			trib := tribrpc.Tribble{}
			json.Unmarshal([]byte(postStr), &trib)
			tribs[i] = trib
		}
		reply.Tribbles = tribs
		reply.Status = tribrpc.OK
	} else {
		reply.Status = tribrpc.NoSuchUser
	}
	return nil
}

/*
-format sublist
*/
func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {

	if DBG {
		fmt.Println("-----> GetTribblesBySubscription")
	}
	var usrID string = args.UserID

	//check if user present in server
	_, err := ts.libStore.Get(util.FormatUserKey(usrID))

	if err != nil {
		switch err.Error() {
		case WRONG_SERVER:
			fmt.Println("ERROR: WRONG SERVER in tribserver")
			return errors.New("Wrong server contacted!")

		case KEY_NOT_FOUND:
			reply.Status = tribrpc.NoSuchUser
			return nil

		default:
			fmt.Println("ERROR in tribserver: wrong error message received")
		}
	}

	//get list of subscribers
	subscrList, err := ts.libStore.GetList(util.FormatSubListKey(usrID))

	if err != nil {
		//return err
		fmt.Println("No subscribers, or error getting list of subscribers")
		reply.Status = tribrpc.OK
		return nil
	}

	//initialise empty slice of all postKeys from subscribers
	var allPostKeys []string = make([]string, 0)

	//populate allPostKeys
	for _, currUser := range subscrList {
		currPostKeys, err := ts.libStore.GetList(util.FormatTribListKey(currUser))

		if err == nil {
			allPostKeys = append(allPostKeys, currPostKeys...)

		} else {
			//fmt.Println("0 tribs for user detected")
		}
	}

	sort.Sort(PostByTime(allPostKeys))

	//choose most recent posts, and get tribbles
	var tribList []tribrpc.Tribble = ts.getTribbleList(allPostKeys)

	reply.Tribbles = tribList
	reply.Status = tribrpc.OK
	return nil

}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	// Getsublist by key
	// Get tribble list by user_ids in sublist
	// sort the tribble list by the timestamp
	// retrive the first 100 tribble (Be careful about the delete operation)
	user_id := util.FormatUserKey(args.UserID)

	// If the user_id doesn't exist
	// Reture NoSuchUser
	_, err := ts.lib_store.Get(user_id)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	// Get user's subscription_list
	user_id_list := util.FormatSubListKey(args.UserID)
	// list of IDs
	user_list, _ := ts.lib_store.GetList(user_id_list)

	if user_list == nil {
		reply.Status = tribrpc.OK
		return nil
	}

	// Get tribble_ids from the user_ids in the subscription list
	tribble_id_list := make([]string, 0)
	for _, usr_id := range user_list {
		t_id_list, err := ts.lib_store.GetList(util.FormatTribListKey(usr_id))
		if err == nil {
			tribble_id_list = append(tribble_id_list, t_id_list...)
		}
	}

	sort.Sort(SortTribbleByTimestamp(tribble_id_list))

	counter := 0
	tribble_list := make([]tribrpc.Tribble, 100)
	for _, tid := range tribble_id_list {
		tribble, err := ts.lib_store.Get(tid)
		if err == nil {
			json.Unmarshal([]byte(tribble), &tribble_list[counter])
			counter += 1
		}
		if counter >= 100 {
			break
		}
	}

	reply.Status = tribrpc.OK
	reply.Tribbles = tribble_list[:counter]
	return nil
}

/*
-getList, formatTribListKey to get all the post keys
-Slice it off at 100
-reverse it or wtv (if needed)
-Get() with that post key, and get the marshalled tribble
*/
func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {

	if DBG {
		fmt.Println("-----> GetTribbles")
	}
	var usrID string = args.UserID

	//check if user present in server
	_, err := ts.libStore.Get(util.FormatUserKey(usrID))

	if err != nil {
		switch err.Error() {
		case WRONG_SERVER:
			fmt.Println("ERROR: WRONG SERVER in tribserver")
			return errors.New("Wrong server contacted!")

		case KEY_NOT_FOUND:
			reply.Status = tribrpc.NoSuchUser
			return nil

		default:
			fmt.Println("ERROR in tribserver: wrong error message received")
		}
	}

	postKeysList, err := ts.libStore.GetList(util.FormatTribListKey(usrID))

	if err != nil {
		//fmt.Println("Could not get list of postKeys for user")
		//return empty tribble list, as the list is not yet created (0 tribbles)

		switch err.Error() {
		case KEY_NOT_FOUND:
			reply.Status = tribrpc.OK
			reply.Tribbles = make([]tribrpc.Tribble, 0)
			return nil
		case WRONG_SERVER:
			fmt.Println("WRONG SERVER CONTACTED!")
			return nil
		default:
			fmt.Println("ERROR in tribserver: wrong error message received!")
			return nil
		}

	}

	reply.Status = tribrpc.OK
	reply.Tribbles = ts.getTribbleList(postKeysList)

	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	if ts.userExist(args.UserID) == false {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}
	tribbles, err := ts.GetAllTribblesByUser(args.UserID)
	if err != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = make([]tribrpc.Tribble, 0)
		return nil
	}
	reply.Status = tribrpc.OK
	reply.Tribbles = prepareTribbles(tribbles)
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	userid := args.UserID
	useridkey := util.FormatUserKey(userid)

	_, userExists := ts.ls.Get(useridkey)

	if userExists != nil {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	userTribListKey := util.FormatTribListKey(userid)
	tribbleIdList, err := ts.ls.GetList(userTribListKey)

	if err != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = nil
		return nil
	}

	tmp := tribbleIDs(tribbleIdList)
	sort.Sort(tmp)
	tribbleIdsChrono := []string(tmp)

	// Calculate the length of the tribbles we want to get
	length := 100
	if len(tribbleIdsChrono) < 100 {
		length = len(tribbleIdsChrono)
	}
	allTribbles := make([]tribrpc.Tribble, length)
	var tribTmp tribrpc.Tribble
	i := 0
	for i < length {
		trib, err := ts.ls.Get(tribbleIdsChrono[i])
		if err == nil {
			json.Unmarshal([]byte(trib), &tribTmp)
			allTribbles[i] = tribTmp
			i += 1 // If error occurs, we do NOT increment i
		}
	}

	reply.Status = tribrpc.OK
	reply.Tribbles = allTribbles

	return nil

}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	if ts.userExist(args.UserID) == false {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}
	subscriptions, err := ts.ls.GetList(util.FormatSubListKey(args.UserID))
	if err != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = make([]tribrpc.Tribble, 0)
		return nil
	}
	reply.Tribbles = make([]tribrpc.Tribble, 0)
	mychan := make(chan []tribrpc.Tribble, 1000)
	go func() {
		for i := 0; i < len(subscriptions); i++ {
			user := subscriptions[i]
			go func() {
				tribbles, _ := ts.GetAllTribblesByUser(user)
				mychan <- tribbles
			}()
		}
	}()
	for i := 0; i < len(subscriptions); i++ {
		tribbles := <-mychan
		reply.Tribbles = append(reply.Tribbles, tribbles...)
	}
	reply.Status = tribrpc.OK
	reply.Tribbles = prepareTribbles(reply.Tribbles)
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	user := args.UserID

	_, err := ts.Libstore.Get(user)
	switch err {
	case nil: // expected case, do nothing
	case libstore.ErrorKeyNotFound:
		reply.Status = tribrpc.NoSuchUser
		return nil
	default:
		return err
	}

	tribListKey := makeTribListKey(user)

	totalHashIds, err := ts.Libstore.GetList(tribListKey)
	switch err {
	case nil:
	case libstore.ErrorKeyNotFound:
		reply.Tribbles = make([]tribrpc.Tribble, 0)
		reply.Status = tribrpc.OK
		return nil
	default:
		return err
	}

	// reverse hash Id to achieve most recent tribbles first.
	length := Min(len(totalHashIds), maxGetTribbleNum)
	hashIds := make([]string, length)
	for i := range hashIds {
		hashIds[i] = totalHashIds[len(totalHashIds)-i-1]
	}

	tribValues, err := ts.getTribValuesFromHashIds(user, hashIds)
	if err != nil { // ignore error
		// return err
	}

	reply.Tribbles = makeTribbles(user, tribValues)
	reply.Status = tribrpc.OK
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	user_id := util.FormatUserKey(args.UserID)

	// If the user_id doesn't exist
	// Reture NoSuchUser
	_, err := ts.lib_store.Get(user_id)
	if err != nil {
		fmt.Println(1)
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	// Return a list of tribble_ids
	raw_tribble_list, _ := ts.lib_store.GetList(util.FormatTribListKey(args.UserID))

	if raw_tribble_list == nil {
		reply.Status = tribrpc.OK
		return nil
	}

	// Sort the tribble_ids by timestamp reversely
	sort.Sort(SortTribbleByTimestamp(raw_tribble_list))

	counter := 0
	tribble_list := make([]tribrpc.Tribble, 100)
	for _, tid := range raw_tribble_list {
		tribble, err := ts.lib_store.Get(tid)
		if err == nil {
			// var t tribrpc.Tribble
			json.Unmarshal([]byte(tribble), &tribble_list[counter])
			counter += 1
		}
		if counter >= 100 {
			break
		}
	}

	reply.Status = tribrpc.OK
	reply.Tribbles = tribble_list[:counter]
	return nil
}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	UserKey := GenerateUserKey(args.UserID)

	_, err := ts.lib.Get(UserKey)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		reply.Tribbles = nil
		return nil
	}

	SubsKey := GenerateSubsKey(args.UserID)
	SubsList, err := ts.lib.GetList(SubsKey)
	if err != nil {
		//reply.Status = tribrpc.NoSuchUser
		reply.Status = tribrpc.OK
		reply.Tribbles = nil
		return nil
	}

	for i := 0; i < len(SubsList); i++ {
		var Subargs tribrpc.GetTribblesArgs
		var Subreply tribrpc.GetTribblesReply

		Subargs.UserID = SubsList[i]
		err = ts.GetTribbles(&Subargs, &Subreply)
		if err != nil {
			return err
		}

		reply.Tribbles = append(reply.Tribbles, Subreply.Tribbles...)
	}

	var tempTrib Tribs
	tempTrib = reply.Tribbles
	sort.Sort(tempTrib)
	if len(tempTrib) > 100 {
		reply.Status = tribrpc.OK
		reply.Tribbles = tempTrib[:100]
	} else {
		reply.Status = tribrpc.OK
		reply.Tribbles = tempTrib
	}

	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	userkey := util.FormatUserKey(args.UserID)

	// Make sure user exists
	if _, eu := ts.ls.Get(userkey); eu != nil {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	// Store list of marshalled Tribbles in lst.  Return empty list if user had no subscriptions.
	var lst []string
	var err error
	if lst, err = ts.ls.GetList(util.FormatTribListKey(args.UserID)); err != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = make([]tribrpc.Tribble, 0)
		return nil
	}

	// Find out how many posts we will return
	var recentPosts []string
	if len(lst) > 100 {
		recentPosts = lst[len(lst)-100:]
	} else {
		recentPosts = lst
	}

	// Loop through this users Tribbles in reverse order and grab up to 100
	tribbles := make([]tribrpc.Tribble, len(recentPosts))
	var mtribble string
	var tribble tribrpc.Tribble
	for i := 0; i < len(tribbles); i++ {
		mtribble, _ = ts.ls.Get(recentPosts[len(tribbles)-1-i])
		json.Unmarshal([]byte(mtribble), &tribble)
		tribbles[i] = tribble
	}
	reply.Status = tribrpc.OK
	reply.Tribbles = tribbles
	return nil
}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	LOGE.Printf("GetTribblesBySubscription:: args=%s\n", string(marshal(*args)))
	userIDKey := GetUserKey(args.UserID)
	_, err := ts.lib.Get(userIDKey)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		reply.Tribbles = nil
		return nil
	}

	userTribleListKey := GetsSubsKey(args.UserID)
	subsList, err := ts.lib.GetList(userTribleListKey)
	if err != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = nil
		return nil
	}

	for i := 0; i < len(subsList); i++ {
		var subArgs tribrpc.GetTribblesArgs
		var subReply tribrpc.GetTribblesReply

		subArgs.UserID = subsList[i]

		err = ts.GetTribbles(&subArgs, &subReply)
		if err != nil {
			return err
		}
		reply.Tribbles = append(reply.Tribbles, subReply.Tribbles...)
	}

	var tempTribbles Tribs
	tempTribbles = reply.Tribbles
	sort.Sort(tempTribbles)
	if len(tempTribbles) > 100 {
		reply.Status = tribrpc.OK
		reply.Tribbles = tempTribbles[:100]
	} else {
		reply.Status = tribrpc.OK
		reply.Tribbles = tempTribbles
	}
	LOGE.Printf("GetTribblesBySubscription:: reply=%s\n", string(marshal(reply)))
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	//fmt.Println("get tribble begin!")
	UserKey := GenerateUserKey(args.UserID)

	_, err := ts.lib.Get(UserKey)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		reply.Tribbles = nil
		return nil
	}

	TribListKey := GenerateTribListKey(args.UserID)
	TribIDs, err := ts.lib.GetList(TribListKey)
	if err != nil {
		//reply.Status = tribrpc.NoSuchUser
		//return nil
		reply.Status = tribrpc.OK
		return nil
	}

	//for i := 0; i < len(TribIDs); i++ {
	//	fmt.Println(TribIDs[i])
	//}

	var length int
	length = len(TribIDs)
	//fmt.Println("actual length:",length)
	//log.Print(length)
	if length > 100 {
		length = 100
	}
	reply.Tribbles = make([]tribrpc.Tribble, length)

	for i := 0; i < length; i++ {
		//TribIDKey := GenerateTribIDKey(args.UserID, TribIDs[len(TribIDs)-1-i])
		TribIDKey := TribIDs[len(TribIDs)-1-i]
		val, err := ts.lib.Get(TribIDKey)
		if err != nil {
			//	continue
			reply.Status = tribrpc.NoSuchUser
			return errors.New("get invalid tribble")
		}
		if val == "" {
			return errors.New("empty string!!!!")
		}
		json.Unmarshal([]byte(val), &(reply.Tribbles[i]))
	}

	reply.Status = tribrpc.OK
	//for i := 0; i < len(reply.Tribbles); i++ {
	//	fmt.Println("result of getting tribbles")
	//	fmt.Print(reply.Tribbles[i].UserID+" ")
	//	//fmt.Print(reply.Tribbles[i].Posted)
	//	fmt.Print(reply.Tribbles[i].Contents)
	//	fmt.Println()
	//}
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {

	userkey := util.FormatUserKey(args.UserID)
	_, userErr := ts.libstore.Get(userkey)
	if userErr != nil {
		reply.Status = tribrpc.NoSuchUser
	} else {
		reply.Status = tribrpc.OK
		tribList := ts.GetTribblesOneUser(args.UserID)

		if tribList != nil {
			length := len(tribList)

			reply.Tribbles = make([]tribrpc.Tribble, length)
			for i := 0; i < length; i++ {
				reply.Tribbles[i] = tribList[i]
			}

		}
	}

	return nil
}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	key := util.FormatUserKey(args.UserID)
	if ts.checkIfKnown(key) {
		sublist_key := util.FormatSubListKey(args.UserID)
		sublist_ids, err := ts.storage.GetList(sublist_key)
		if err != nil {
			sublist_ids = []string{}
		}

		post_ids := []string{}
		for _, userid := range sublist_ids {
			triblist_key := util.FormatTribListKey(userid)
			local_post_ids, err := ts.storage.GetList(triblist_key)
			if err != nil {
				sublist_ids = []string{}
			}
			post_ids = append(post_ids, local_post_ids...)
		}

		sort.Sort(ByChrono(post_ids))
		tribs := []tribrpc.Tribble{}
		for _, v := range post_ids[0:min(100, len(post_ids))] {
			postStr, err := ts.storage.Get(v)
			if err != nil {
				return err
			}
			trib := tribrpc.Tribble{}
			json.Unmarshal([]byte(postStr), &trib)
			tribs = append(tribs, trib)
		}
		reply.Tribbles = tribs
		reply.Status = tribrpc.OK
	} else {
		reply.Status = tribrpc.NoSuchUser
	}
	return nil
}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	if args == nil {
		return errors.New("ts: Can't getSubscription nil")
	}
	if reply == nil {
		return errors.New("ts: Can't reply with nil in getSubscription")
	}

	_, err := ts.ls.Get(util.FormatUserKey(args.UserID))
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		reply.Tribbles = make([]tribrpc.Tribble, 0, 0)
		return nil
	}

	users, err := ts.ls.GetList(util.FormatSubListKey(args.UserID))
	if err != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = make([]tribrpc.Tribble, 0, 0)
		return nil
	}

	postIDs := make([]string, 0)
	for _, userID := range users {
		lst, err := ts.ls.GetList(util.FormatTribListKey(userID))
		if err == nil {
			postIDs = append(postIDs, lst...)
		}
	}

	tmp := tribbleIDs(postIDs)

	sort.Sort(tmp)
	tribbleIdsChrono := []string(tmp)

	length := 100
	if len(tribbleIdsChrono) < 100 {
		length = len(tribbleIdsChrono)
	}

	tribbles := make([]tribrpc.Tribble, length)
	var tribTmp tribrpc.Tribble
	i := 0
	for i < length {
		trib, err := ts.ls.Get(tribbleIdsChrono[i])
		if err == nil {
			json.Unmarshal([]byte(trib), &tribTmp)
			tribbles[i] = tribTmp
			i += 1 // If error occurs, we do NOT increment i
		}
	}
	reply.Status = tribrpc.OK
	reply.Tribbles = tribbles
	return nil
}

func (ts *tribServer) GetTribbles(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	LOGE.Printf("GetTribbles:: args=%s\n", string(marshal(*args)))

	userIDKey := GetUserKey(args.UserID)
	_, err := ts.lib.Get(userIDKey)
	if err != nil {
		reply.Status = tribrpc.NoSuchUser
		reply.Tribbles = nil
		return nil
	}
	userTribleListKey := GetsTribleListKey(args.UserID)
	tribles, err := ts.lib.GetList(userTribleListKey)

	if err != nil {
		reply.Status = tribrpc.OK
		return nil
	}

	length := len(tribles)
	if length > 100 {
		length = 100
	}

	reply.Tribbles = make([]tribrpc.Tribble, length)
	for i := 0; i < length; i++ {
		triblePutKey := tribles[len(tribles)-1-i]
		val, err := ts.lib.Get(triblePutKey)
		if err != nil {
			reply.Status = tribrpc.NoSuchUser
			return err
		}
		json.Unmarshal([]byte(val), &(reply.Tribbles[i]))
	}
	reply.Status = tribrpc.OK
	LOGE.Printf("GetTribbles:: reply=%s\n", string(marshal(reply)))
	return nil
}

func (ts *tribServer) GetTribblesBySubscription(args *tribrpc.GetTribblesArgs, reply *tribrpc.GetTribblesReply) error {
	userkey := util.FormatUserKey(args.UserID)

	// Make sure user exists
	if _, eu := ts.ls.Get(userkey); eu != nil {
		reply.Status = tribrpc.NoSuchUser
		return nil
	}

	// Get list of subscriptions.  return empty list if user has no subscriptions.
	var subs []string
	var esubs error
	if subs, esubs = ts.ls.GetList(util.FormatSubListKey(args.UserID)); esubs != nil {
		reply.Status = tribrpc.OK
		reply.Tribbles = make([]tribrpc.Tribble, 0)
		return nil
	}

	numTribbles := 0

	// Get the last 100 tribble IDs from each subscribed user
	tribIDs := make([][]string, len(subs))
	for i := 0; i < len(subs); i++ {
		if lst, err := ts.ls.GetList(util.FormatTribListKey(subs[i])); err == nil {
			if len(lst) > 100 {
				tribIDs[i] = lst[len(lst)-100:]
			} else {
				tribIDs[i] = lst
			}
			numTribbles += len(lst)
		}
	}

	// lastTribs is the most recent tribble seen from each subscribed user
	lastTribs := make([]tribrpc.Tribble, len(subs))
	// index is the list of indexes into tribIDs for each subscribed user
	index := make([]int, len(subs))

	if numTribbles > 100 {
		numTribbles = 100
	}

	finalTribbles := make([]tribrpc.Tribble, numTribbles)
	var mtribble string
	var tribble tribrpc.Tribble

	// valid[i] marks if an unused Tribble is located at lastTribs[i]
	valid := make([]bool, len(lastTribs))

	for j := 0; j < numTribbles; j++ {
		minIndex := -1
		for check := 0; check < len(lastTribs); check++ {
			// If this user has more tribbles left
			if index[check] < len(tribIDs[check]) {
				// If we need to get a new tribble for this user
				if valid[check] == false {
					mtribble, _ = ts.ls.Get(tribIDs[check][len(tribIDs[check])-1-index[check]])
					json.Unmarshal([]byte(mtribble), &tribble)
					lastTribs[check] = tribble
					valid[check] = true
				}
				// This tribble is more
				if minIndex == -1 || cmpLessTribble(lastTribs[check], lastTribs[minIndex]) {
					minIndex = check
				}
			}
		}
		copyTribble := lastTribs[minIndex]
		finalTribbles[j] = copyTribble
		valid[minIndex] = false
		index[minIndex] += 1

	}

	reply.Status = tribrpc.OK
	reply.Tribbles = finalTribbles
	return nil
}