int c_zht_compare_swap_std(ZHTClient_c zhtClient, const char *key,
		const char *seen_value, const char *new_value, char *value_queried) {

#ifdef IND_MUTEX
	LockGuard lock(&c_zht_compare_swap_mutex);
#elif SHARED_MUTEX
	LockGuard lock(&c_zht_client_mutex);
#else
#endif

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string skey(key);
	string sseenValue(seen_value);
	string snewValue(new_value);

	string resultStr;
	int rc = zhtcppClient->compare_swap(skey, sseenValue, snewValue, resultStr);

	memset(value_queried, 0, strlen(value_queried));

	strncpy(value_queried, resultStr.c_str(), resultStr.size());

	return rc;
}

int c_zht_init_std(ZHTClient_c *zhtClient, const char *zhtConfig,
		const char *neighborConf) {

#ifdef IND_MUTEX
	pthread_mutex_init(&c_zht_lookup_mutex, NULL);
	pthread_mutex_init(&c_zht_remove_mutex, NULL);
	pthread_mutex_init(&c_zht_insert_mutex, NULL);
	pthread_mutex_init(&c_zht_append_mutex, NULL);
	pthread_mutex_init(&c_zht_compare_swap_mutex, NULL);
	pthread_mutex_init(&c_zht_state_change_callback_mutex, NULL);
#elif SHARED_MUTEX
	pthread_mutex_init(&c_zht_client_mutex, NULL);
#else
#endif

	ZHTClient *zhtcppClient = new ZHTClient();

	string zhtConfigStr(zhtConfig);
	string neighborConfStr(neighborConf);

	if (zhtcppClient->init(zhtConfigStr, neighborConfStr) != 0) {

		printf("ZHTClient initialization failed, program exits.");
		return -1;
	}

	*zhtClient = (ZHTClient_c) zhtcppClient;

	return 0;
}

int benchmark(string &zhtConf, string &neighborConf) {

    srand(getpid() + TimeUtil::getTime_usec());

    if (zc.init(zhtConf, neighborConf) != 0) {

        cout << "ZHTClient initialization failed, program exits." << endl;
        return -1;
    }

    init_packages();

    benchmarkInsert();

    benchmarkLookup();

    benchmarkAppend();

    benchmarkRemove();

    zc.teardown();

    return 0;

}

int c_zht_compare_and_swap_std(ZHTClient_c zhtClient, const char *key,
		const char *seen_value, const char *new_value, char **value_queried) {

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;
	string sKey(key);
	string sSeenValue(seen_value);
	string sNewValue(new_value);

	Package package;
	package.set_virtualpath(sKey);
	package.set_isdir(true);
	package.set_replicano(5);
	package.set_operation(5);  // 5 for comapre and swap
	if (!sSeenValue.empty()) {
		package.set_realfullpath(sSeenValue);
	}
	if (!sNewValue.empty()) {
		package.set_newfullpath(sNewValue);
	}

	string return_str;
	int rc = zhtcppClient->compare_and_swap(package.SerializeAsString(),
			return_str);

	Package ret_pack;
	ret_pack.ParseFromString(return_str);

	strcpy(*value_queried, ret_pack.realfullpath().c_str());

	return rc;
}

int c_zht_remove_std(ZHTClient_c zhtClient, const char *pair) {

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string str(pair);

	return zhtcppClient->remove(str);
}

int c_zht_insert_std(ZHTClient_c zhtClient, const char *pair) {

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string str(pair);

	return zhtcppClient->insert(str);
}

int c_zht_append_std(ZHTClient_c zhtClient, const char *pair) {

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string str(pair);

	return zhtcppClient->append(str);
}

int zht_insert_meta(ZHTClient_c zhtClient, struct metadata * meta){

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	Package package;
	string keyStr(meta->key);
	
	//1. General infos on the file/storage
	package.set_virtualpath(keyStr); //as key
	package.set_isdir(false);
	package.set_replicano(1);
	package.set_operation(3); //1 for look up, 2 for remove, 3 for insert
	package.set_realfullpath(keyStr);
	
	//2. General infos on the encoding
	package.set_k(meta->k);
	package.set_m(meta->m);
	package.set_encodinglib(meta->encodingLib);
	package.set_filesize(meta->fileSize);
	package.set_bufsize(meta->bufsize);
	
	//3. Chunks/Replicas locations
	struct comTransfer * current = meta->loc->transfers;
	Package_Location*  location;

	while(current != NULL){
		location = package.add_location();
		
		location->set_hostname(string(current->hostName));
		location->set_port(current->port);
		location->set_distantchunkname(string(current->distantChunkName));
		
		current=current->next;
	}
	//4. Insertion
	std::string serialized = package.SerializeAsString();
	
	dbgprintf("Package Length:%i\n",serialized.size());
	
	//TEST
	Package package4;
	package4.ParseFromString(serialized);
	dbgprintf("Serialized: %s \n",serialized.c_str());
	dbgprintf("key: %s \n",(package4.virtualpath()).c_str());
	dbgprintf("k:%i,m:%i,encodinglib:%i,filesize:%i \n",package4.k(),package4.m(),package4.encodinglib(),package4.filesize());
	
	for (int j = 0; j < package4.location_size(); j++) {
		const Package_Location& location = package4.location(j);
		
		dbgprintf("chunk:%s, port:%i\n",location.distantchunkname().c_str(), location.port());
	}	
	//END TEST
	
	
	int res = zhtcppClient->insert(serialized);
	
	return res;
}

int benchmarkInsert(string cfgFile, string memberList, vector<string> &pkgList,
		ZHTClient &clientRet, int numTest, int lenString) {

//	if (clientRet.initialize(cfgFile, memberList) != 0) { //zhouxb
	if (clientRet.initialize(cfgFile, memberList, TCP) != 0) {
		cout << "Crap! ZHTClient initialization failed, program exits." << endl;
		return -1;
	}

	for (int i = 0; i < numTest; i++) {
		Package package, package_ret;
		package.set_virtualpath(randomString(lenString)); //as key
		package.set_isdir(true);
		package.set_replicano(5); //orginal--Note: never let it be nagative!!!
		package.set_operation(3); // 3 for insert, 1 for look up, 2 for remove
		package.set_realfullpath(
				"Some-Real-longer-longer-and-longer-Paths--------");
		package.add_listitem("item-----2");
		package.add_listitem("item-----3");
		package.add_listitem("item-----4");
		package.add_listitem("item-----5");
		package.add_listitem("item-----6");
		string str = package.SerializeAsString();
//		cout << "package size = " << str.size() << endl;
//		cout<<"Client.cpp:benchmarkInsert: "<<endl;
//		cout<<"string: "<<str<<endl;
//		cout<<"Insert str: "<<str.c_str()<<endl;
//		cout<<"data(): "<< str.data()<<endl;
		pkgList.push_back(str);
	}
	double start = 0;
	double end = 0;
	start = getTime_msec();
	int errCount = 0;
	vector<string>::iterator it;
	int c = 0;
//	cout << "-----2" << endl;
	for (it = pkgList.begin(); it != pkgList.end(); it++) {
		//	cerr <<"insert count "<< c << endl;
		c++;
		string str_ins = *it;
//cout << "-----1" << endl;
		int ret = clientRet.insert(str_ins);
//cout << "-----2" << endl;
		if (ret < 0) {
			errCount++;
		}
	}
//close(sock);
	end = getTime_msec();
	cout << "Inserted " << numTest - errCount << " packages out of " << numTest
			<< ", cost " << end - start << " ms" << endl;
	return 0;
}

int c_zht_remove2_std(ZHTClient_c zhtClient, const char *key) {

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string sKey(key);

	Package package;
	package.set_virtualpath(sKey);
	package.set_operation(2); //1 for look up, 2 for remove, 3 for insert, 4 append

	return zhtcppClient->remove(package.SerializeAsString());
}

int c_zht_remove_std(ZHTClient_c zhtClient, const char *key) {

#ifdef IND_MUTEX
	LockGuard lock(&c_zht_remove_mutex);
#elif SHARED_MUTEX
	LockGuard lock(&c_zht_client_mutex);
#else
#endif

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string skey(key);

	return zhtcppClient->remove(skey);
}

float benchmarkLookup(vector<string> strList, ZHTClient &client) {
	vector<string>::iterator it;

	double start = 0;
	double end = 0;
	start = getTime_msec();
	int errCount = 0;
//cout << "Client: benchmarkLookup: start lookup \n";
	int c = 0;
	for (it = strList.begin(); it != strList.end(); it++) {
		string result;
//		cout << c << endl;
		c++;
//		cout<<"lookup: "<<c<<endl;
//sleep(1);
//
//		cout << "Client: What I want to find: \n";
//		cout <<"Lookup: "<< (*it).c_str() << endl;
		if (client.lookup((*it), result) < 0) {

			errCount++;
		} else if (result.empty()) { //empty string
			errCount++;
		}
//		cout << "Client: What I get: ";
//		cout << result.c_str() << endl;
	}

	end = getTime_msec();

	cout << "Lookup " << strList.size() - errCount << " packages out of "
			<< strList.size() << ", cost " << end - start << " ms" << endl;
	return 0;
}

int initconfig(ZHTClient &clientRet, string cfgFile, string memberList) {
	if (clientRet.initialize(cfgFile, memberList, TCP) != 0) {
		cout << "Crap! ZHTClient initialization failed, program exits." << endl;
		return -1;
	}

	return 0;
}

int main(int argc, char* argv[]) {

    //cout << "Usage: ./client <num_operations> <memberList> <configFile>"<< endl;
    /*	For BG/P:
    const string cmd = "cat /proc/personality.sh | grep BG_PSETORG";
    string torusID = executeShell(cmd);
    torusID.resize(torusID.size() - 1);
    int pid = getpid();
    unsigned int v = myhash(torusID.c_str(), 1000000) + pid;
    //cout<<"client: pid = "<<pid<<endl;

    //cout<<"Client random n = "<<v<<endl;
    srand(v);
    */

    char* isTCP = argv[4];
    //cout<<"Protocol = "<<isTCP<<endl;
    if (!strcmp("TCP", isTCP)) {
        TCP = true;
    } else {
        TCP = false;
    }

    int numOper = atoi(argv[1]);
    //cout<<"numOper = "<<numOper<<endl;
    string cfgFile(argv[3]);
    //cout<<"cfgFile = "<<cfgFile<<endl;
    string memberList(argv[2]);
    //cout<<"memberList: "<<memberList<<endl;
    vector<string> pkgList;
    ZHTClient testClient;
    //	int pid = getpid();
    char* tmpStr;
    stringstream ss; //create a stringstream
    //	ss << pid;

    //	string recordFile = "record." + ss.str();
    //	benchmarkTimeAnalize(cfgFile, memberList, pkgList, testClient, numOper, 15, recordFile);
    //cout<<"start to insert..."<<endl;
    insertMetadata(cfgFile, memberList, pkgList, testClient, numOper, 15); //25fro 128bytes.
    //cout << "Client:main, start lookup \n";
    benchmarkLookup(pkgList, testClient);
    benchmarkRemove(pkgList, testClient);
    testClient.tearDownTCP(TCP);
    return 0;
}

int c_zht_insert_std(ZHTClient_c zhtClient, const char *key,
		const char *value) {

#ifdef IND_MUTEX
	LockGuard lock(&c_zht_insert_mutex);
#elif SHARED_MUTEX
	LockGuard lock(&c_zht_client_mutex);
#else
#endif

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string skey(key);
	string sval(value);

	return zhtcppClient->insert(skey, sval);
}

int c_zht_insert2_std(ZHTClient_c zhtClient, const char *key,
		const char *value) {

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string sKey(key);
	string sValue(value);

	Package package;
	package.set_virtualpath(sKey); //as key
	package.set_isdir(true);
	package.set_replicano(5);
	package.set_operation(3); //1 for look up, 2 for remove, 3 for insert, 4 append
	if (!sValue.empty())
		package.set_realfullpath(sValue);

	return zhtcppClient->insert(package.SerializeAsString());
}

int c_zht_init_std(ZHTClient_c * zhtClient, const char *memberConfig,
		const char *zhtConfig, bool tcp) {

	ZHTClient * zhtcppClient = new ZHTClient();

	string zhtStr(zhtConfig);
	string memberStr(memberConfig);

	if (zhtcppClient->initialize(zhtStr, memberStr, tcp) != 0) {
		printf("Crap! ZHTClient initialization failed, program exits.");

		return -1;
	}

	*zhtClient = (ZHTClient_c) zhtcppClient;

	return 0;
}

void submittaskszht(ZHTClient &clientRet, string client_id)
{
	int ret = 0;
	Package package;
	package.set_virtualpath(client_id);
	package.set_operation(21);
	cout << "Ok, what is the hell!\n" << endl;

	for (map<uint32_t, NodeList>::iterator map_it = update_map_zht.begin(); map_it != update_map_zht.end(); ++map_it)
	{
		uint32_t index = map_it->first;
		NodeList &update_list = map_it->second;
		while (!update_list.empty())
		{
			int num_vector_count, per_vector_count;
			string alltasks;
			vector< vector<string> > tokenize_string = tokenize_1(update_list.front(), '$', '#', num_vector_count, per_vector_count);
			//cout << " num_vector_count = " << num_vector_count << " per_vector_count = " << per_vector_count << endl;
			for(int i = 0; i < per_vector_count; i++)
			{
				Package tmpPackage;
				tmpPackage.ParseFromString(tokenize_string.at(0).at(i));
				string key = tmpPackage.virtualpath();
				alltasks.append(key); alltasks.append("\'\"");
			} //cout << "Serve
			package.set_realfullpath(alltasks);
			string str = package.SerializeAsString();
			ret += clientRet.svrtosvr(str, str.length(), index);
			update_list.pop_front();
		}
	}

//	Package package; string alltasks;
//			package.set_virtualpath(client_id); // Here key is just the client ID
//			package.set_operation(21);
//			//package.set_operation(22);
//			num_packages++;
//
//			int num_tasks_this_package = max_tasks_per_package;
//			int num_tasks_left = num_tasks - total_submitted1;
//			if (num_tasks_left < max_tasks_per_package) {
//				num_tasks_this_package = num_tasks_left;
//			}
//			for(int j = 0; j < num_tasks_this_package; j++) {
//				int task_id = it->first; ++it;
//
//	        	        stringstream task_id_ss;
//	                	task_id_ss << task_id << client_id; // Task ID + Client ID
//				alltasks.append(task_id_ss.str()); alltasks.append("\'\""); // Task ID
//			}
//			total_submitted1 = total_submitted1 + num_tasks_this_package;
//			package.set_realfullpath(alltasks);
//			string str = package.SerializeAsString();
//			//cout << "String size = " << str.size() << " str length = " << strlen(str.c_str());
//			int32_t ret = clientRet.svrtosvr(str, str.length(), toserver);
}

int c_zht_lookup2_std(ZHTClient_c zhtClient, const char *key, char *result,
		size_t *n) {

	ZHTClient *zhtcppClient = (ZHTClient *) zhtClient;

	string sKey(key);

	Package package;
	package.set_virtualpath(sKey); //as key
	package.set_isdir(true);
	package.set_replicano(5);
	package.set_operation(1); //1 for look up, 2 for remove, 3 for insert, 4 append

	string resultStr;
	int ret = zhtcppClient->lookup(package.SerializeAsString(), resultStr);

	/*
	 * hello,zht:hello,zht ==> hello,zht:zht
	 * */
	string store;
	char * pch, *sp;
	pch = strtok_r((char*) resultStr.c_str(), ":", &sp);
	Package package2;

	while (pch != NULL) {

		package2.ParseFromString(pch);
		string strRealfullpath = package2.realfullpath();

		store.append(strRealfullpath);
		store.append(":");

		pch = strtok_r(NULL, ":", &sp);
	}

	size_t found = store.find_last_of(":");
	store = store.substr(0, found);

	strncpy(result, store.c_str(), strlen(store.c_str()));
	*n = store.size();

	return ret;
}

int c_zht_state_change_callback_std(ZHTClient_c zhtClient, const char *key,
		const char *expected_val, int lease) {

#ifdef IND_MUTEX
	LockGuard lock(&c_zht_state_change_callback_mutex);
#elif SHARED_MUTEX
	LockGuard lock(&c_zht_client_mutex);
#else
#endif

	ZHTClient * zhtcppClient = (ZHTClient *) zhtClient;

	string skey(key);
	string expectedval(expected_val);

	int rc = zhtcppClient->state_change_callback(skey, expectedval, lease);

	return rc;
}