#include "hstring.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

namespace hv {

std::string empty_string;
std::map<std::string, std::string> empty_map;

std::string& toupper(std::string& str) {
 // std::transform(str.begin(), str.end(), str.begin(), ::toupper);
 char* p = (char*)str.c_str();
 while (*p != '0円') {
 if (*p >= 'a' && *p <= 'z') {
 *p &= ~0x20;
 }
 ++p;
 }
 return str;
}

std::string& tolower(std::string& str) {
 // std::transform(str.begin(), str.end(), str.begin(), ::tolower);
 char* p = (char*)str.c_str();
 while (*p != '0円') {
 if (*p >= 'A' && *p <= 'Z') {
 *p |= 0x20;
 }
 ++p;
 }
 return str;
}

std::string& reverse(std::string& str) {
 // std::reverse(str.begin(), str.end());
 char* b = (char*)str.c_str();
 char* e = b + str.length() - 1;
 char tmp;
 while (e > b) {
 tmp = *e;
 *e = *b;
 *b = tmp;
 --e;
 ++b;
 }
 return str;
}

bool startswith(const std::string& str, const std::string& start) {
 if (str.length() < start.length()) return false;
 return str.compare(0, start.length(), start) == 0;
}

bool endswith(const std::string& str, const std::string& end) {
 if (str.length() < end.length()) return false;
 return str.compare(str.length() - end.length(), end.length(), end) == 0;
}

bool contains(const std::string& str, const std::string& sub) {
 if (str.length() < sub.length()) return false;
 return str.find(sub) != std::string::npos;
}

static inline int vscprintf(const char* fmt, va_list ap) {
 return vsnprintf(NULL, 0, fmt, ap);
}

std::string asprintf(const char* fmt, ...) {
 va_list ap;
 va_start(ap, fmt);
 int len = vscprintf(fmt, ap);
 va_end(ap);

 std::string str;
 str.reserve(len+1);
 // must resize to set str.size
 str.resize(len);
 // must recall va_start on unix
 va_start(ap, fmt);
 vsnprintf((char*)str.data(), len+1, fmt, ap);
 va_end(ap);

 return str;
}

StringList split(const std::string& str, char delim) {
 /*
 std::stringstream ss;
 ss << str;
 string item;
 StringList res;
 while (std::getline(ss, item, delim)) {
 res.push_back(item);
 }
 return res;
 */
 const char* p = str.c_str();
 const char* value = p;
 StringList res;
 while (*p != '0円') {
 if (*p == delim) {
 res.push_back(std::string(value, p-value));
 value = p+1;
 }
 ++p;
 }
 res.push_back(value);
 return res;
}

hv::KeyValue splitKV(const std::string& str, char kv_kv, char k_v) {
 enum {
 s_key,
 s_value,
 } state = s_key;
 const char* p = str.c_str();
 const char* key = p;
 const char* value = NULL;
 int key_len = 0;
 int value_len = 0;
 hv::KeyValue kvs;
 while (*p != '0円') {
 if (*p == kv_kv) {
 if (key_len && value_len) {
 kvs[std::string(key, key_len)] = std::string(value, value_len);
 key_len = value_len = 0;
 }
 state = s_key;
 key = p+1;
 }
 else if (*p == k_v && state != s_value) {
 state = s_value;
 value = p+1;
 }
 else {
 state == s_key ? ++key_len : ++value_len;
 }
 ++p;
 }
 if (key_len && value_len) {
 kvs[std::string(key, key_len)] = std::string(value, value_len);
 }
 return kvs;
}

std::string trim(const std::string& str, const char* chars) {
 std::string::size_type pos1 = str.find_first_not_of(chars);
 if (pos1 == std::string::npos) return "";

 std::string::size_type pos2 = str.find_last_not_of(chars);
 return str.substr(pos1, pos2-pos1+1);
}

std::string ltrim(const std::string& str, const char* chars) {
 std::string::size_type pos = str.find_first_not_of(chars);
 if (pos == std::string::npos) return "";
 return str.substr(pos);
}

std::string rtrim(const std::string& str, const char* chars) {
 std::string::size_type pos = str.find_last_not_of(chars);
 return str.substr(0, pos+1);
}

std::string trim_pairs(const std::string& str, const char* pairs) {
 const char* s = str.c_str();
 const char* e = str.c_str() + str.size() - 1;
 const char* p = pairs;
 bool is_pair = false;
 while (*p != '0円' && *(p+1) != '0円') {
 if (*s == *p && *e == *(p+1)) {
 is_pair = true;
 break;
 }
 p += 2;
 }
 return is_pair ? str.substr(1, str.size()-2) : str;
}

std::string replace(const std::string& str, const std::string& find, const std::string& rep) {
 std::string res(str);
 std::string::size_type pos = res.find(find);
 if (pos != std::string::npos) {
 res.replace(pos, find.size(), rep);
 }
 return res;
}

std::string replaceAll(const std::string& str, const std::string& find, const std::string& rep) {
 std::string::size_type pos = 0;
 std::string::size_type a = find.size();
 std::string::size_type b = rep.size();

 std::string res(str);
 while ((pos = res.find(find, pos)) != std::string::npos) {
 res.replace(pos, a, rep);
 pos += b;
 }
 return res;
}

void NetAddr::from_string(const std::string& ipport) {
 auto pos = ipport.find_last_of(':');
 if (pos != std::string::npos) {
 ip = trim_pairs(ipport.substr(0, pos), "[]");
 std::string strPort = ipport.substr(pos + 1);
 port = atoi(strPort.c_str());
 } else if (ipport.find('.') != std::string::npos) {
 ip = ipport;
 port = 0;
 } else {
 port = atoi(ipport.c_str());
 }
}

std::string NetAddr::to_string() {
 const char* fmt = "%s:%d";
 if (ip.find(':') != std::string::npos) {
 fmt = "[%s]:%d";
 }
 return hv::asprintf(fmt, ip.c_str(), port);
}

} // end namespace hv