#include <string>
#include <vector>
#include <fstream>
#include <cstdlib>
#include "util.hpp"
#include <sys/types.h>
#include <sys/stat.h>
#include <cmath>
#include <iomanip>
#include <cassert>
#include <algorithm>

#ifdef WIN32
#endif

#ifndef WIN32
#include <time.h>
#include <unistd.h>
#endif

namespace util {

int64_t profiling_clock() {
#ifdef WIN32
    return 0.0;
#else
    struct timespec ts;
    assert(0 == clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts));
    return int64_t(ts.tv_nsec) + (int64_t(ts.tv_sec)*int64_t(1000000000));
#endif
}

static bool ascii_isalpha(char c) {
    return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));
}

static bool ascii_isdigit(char c) {
    return ((c >= '0') && (c <= '9'));
}

bool is_identifier(const std::string &str) {
    if (str.size() == 0) return false;
    char c=str[0];
    if ((!ascii_isalpha(c)) && (c!='_')) return false;
    for (int i = 1; i < int(str.size()); i++) {
        char c = str[i];
        if ((!ascii_isalpha(c)) && (!ascii_isdigit(c)) && (c!='_')) return false;
    }
    return true;
}

void quote_string(const std::string &s, std::ostream *os) {
    bool anysq = false;
    bool anydq = false;
    for (char c : s) {
        if (c == '\'') anysq = true;
        if (c == '"') anydq = true;
    }
    bool usesinglequote = (!anysq)||(anydq);
    (*os) << (usesinglequote ? '\'' : '"');
    for (char c : s) {
        if (c >= 32) {
            if (c == '"') {
                (*os) << (usesinglequote ? "\"" : "\\\"");
            } else if (c == '\'') {
                (*os) << (usesinglequote ? "\\'" : "'");
            } else {
                (*os) << c;
            }
        } else {
            switch (c) {
            case '\n': (*os) << "\\n"; break;
            case '\t': (*os) << "\\t"; break;
            case '\r': (*os) << "\\r"; break;
            default:
                (*os) << "\\" << std::setw(3) << int(c);
                break;
            }
        }
    }
    (*os) << (usesinglequote ? '\'' : '"');
}

IdVector id_vector_create(int64_t id1, int64_t id2, int64_t id3, int64_t id4) {
    IdVector result;
    if (id1 >= 0) result.push_back(id1);
    if (id2 >= 0) result.push_back(id2);
    if (id3 >= 0) result.push_back(id3);
    if (id4 >= 0) result.push_back(id4);
    return result;
}

std::string id_vector_debug_string(const IdVector &idv) {
    std::ostringstream oss;
    bool first = true;
    for (int64_t id : idv) {
        if (!first) oss << ",";
        oss << id;
        first = false;
    }
    return oss.str();
}

IdVector sort_union_id_vectors(const IdVector &v1, const IdVector &v2) {
    IdVector result(v1.size() + v2.size());
    int next = 0;
    for (int64_t id : v1) result[next++] = id;
    for (int64_t id : v2) result[next++] = id;
    std::sort(result.begin(), result.end());
    int64_t prev = -1;
    int64_t count = 0;
    for (int64_t id : result) {
        if (id != prev) {
            prev = id;
            result[count++] = id;
        }
    }
    result.resize(count);
    return result;
}

HashValue hash_string(const std::string &s) {
    uint64_t hash1 = 0;
    uint64_t hash2 = 0;
    SpookyHash::Hash128(s.c_str(), s.size(), &hash1, &hash2);
    return util::HashValue(hash1, hash2);
}

HashValue hash_id_vector(const IdVector &idv) {
    uint64_t hash1 = 0;
    uint64_t hash2 = 0;
    SpookyHash::Hash128(&idv[0], idv.size() * sizeof(int64_t), &hash1, &hash2);
    return util::HashValue(hash1, hash2);
}

std::string hash_to_hex(const HashValue &hv) {
    std::ostringstream oss;
    oss << std::hex << std::setw(16) << std::setfill('0') << hv.first;
    oss << std::hex << std::setw(16) << std::setfill('0') << hv.second;
    return oss.str();    
}

StringVec split(const std::string &s, char sep) {
    StringVec result;
    int start = 0;
    for (int i = 0; i < int(s.size()); i++) {
        if (s[i] == sep) {
            result.push_back(s.substr(start, i-start));
            start = i+1;
        }
    }
    if (start < int(s.size())) {
        result.push_back(s.substr(start));
    }
    return result;
}

static std::string substr_nocr(const std::string &s, int start, int len) {
    if ((len > 0) && (s[start + len - 1] == '\r')) {
        len -= 1;
    }
    return s.substr(start, len);
}

StringVec split_lines(const std::string &s) {
    StringVec result;
    int start = 0;
    for (int i = 0; i < int(s.size()); i++) {
        if (s[i]=='\n') {
            result.push_back(substr_nocr(s, start, i-start));
            start = i + 1;
        }
    }
    if (start < int(s.size())) {
        result.push_back(substr_nocr(s, start, s.size()-start));
    }
    return result;
}

StringVec split_docstring(const std::string &s) {
    StringVec result;
    int start = 0;
    for (int i = 0; i < int(s.size()); i++) {
        if (s[i]=='|') {
            int len = i-start;
            if ((len > 0)||(start > 0)) {
                result.push_back(s.substr(start, i-start));
            }
            start = i + 1;
        }
    }
    if (start < int(s.size())) {
        result.push_back(s.substr(start, s.size()-start));
    }
    return result;
}

std::string join(const StringVec &strs, const std::string &sep) {
    if (strs.empty()) return "";
    std::ostringstream oss;
    oss << strs[0];
    for (int i = 1; i < int(strs.size()); i++) {
        oss << sep << strs[i];
    }
    return oss.str();
}

std::string repeat_string(const std::string &a, int n) {
    int len = a.size();
    std::string result(len * n, ' ');
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < len; j++) {
            result[i*len + j] = a[j];
        }
    }
    return result;
}

int common_prefix_length(const std::string &a, const std::string &b) {
    int minlen = std::min(a.size(), b.size());
    for (int i = 0; i < minlen; i++) {
        if (a[i] != b[i]) return i;
    }
    return minlen;
}
    
std::string tolower(std::string input) {
    for (int i = 0; i < int(input.size()); i++) {
        input[i] = std::tolower(input[i]);
    }
    return input;
}

std::string toupper(std::string input) {
    for (int i = 0; i < int(input.size()); i++) {
        input[i] = std::toupper(input[i]);
    }
    return input;
}

bool has_prefix(const std::string &s, const std::string &prefix) {
    return 0 == s.compare(0, prefix.size(), prefix);
}

bool has_suffix(const std::string &s, const std::string &suffix) {
    if (s.length() >= suffix.length()) {
        return (0 == s.compare (s.length() - suffix.length(), suffix.length(), suffix));
    } else {
        return false;
    }
}

bool validinteger(const std::string &value) {
    char *endptr;
    if (value.size() == 0) return false;
    strtoll(value.c_str(), &endptr, 10);
    return (endptr == value.c_str() + value.size());
}

int64_t strtoint(const std::string &value, int64_t errval) {
    char *endptr;
    if (value.size() == 0) return errval;
    int64_t result = strtoll(value.c_str(), &endptr, 10);
    if (endptr == value.c_str() + value.size()) {
        return result;
    } else {
        return errval;
    }
}

double strtodouble(const std::string &value) {
    char *endptr;
    if (value.size() == 0) return std::nan("");
    double result = strtod(value.c_str(), &endptr);
    if (endptr == value.c_str() + value.size()) {
        return result;
    } else {
        return std::nan("");
    }
}

void split_host_port(const std::string &target, std::string &host, std::string &port) {
    size_t lastcolon = target.rfind(':');
    if (lastcolon == std::string::npos) {
        host = ""; port = ""; return;
    }
    host = target.substr(0, lastcolon);
    port = target.substr(lastcolon + 1);
    if ((host == "") || (port == "")) {
        host = ""; port = ""; return;
    }
}

std::string ltrim(std::string s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
            std::not1(std::ptr_fun<int, int>(std::isspace))));
    return s;
}

std::string rtrim(std::string s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
            std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
    return s;
}

std::string trim(std::string s) {
    return ltrim(rtrim(s));
}

double distance_squared(double x1, double y1, double x2, double y2) {
    double dx = x1 - x2;
    double dy = y1 - y2;
    return dx*dx + dy*dy;
}

bool world_type_authoritative(util::WorldType wt) {
    return (wt == WORLD_TYPE_MASTER) || (wt == WORLD_TYPE_STANDALONE);
}

LuaSourcePtr make_lua_source(const std::string &code) {
    LuaSourcePtr result(new LuaSourceVec);
    std::string fn = "file.lua";
    result->push_back(std::make_pair(fn, code));
    return result;
}

bool is_lua_comment(const std::string &s) {
    int start = 0;
    while ((start < int(s.size())) && ((s[start]==' ') || (s[start]=='\t'))) start++;
    return s.substr(start, 2) == "--";
}

static std::string get_file_contents(const std::string &fn) {
    std::ifstream fs(fn);
    std::stringstream buffer;
    buffer << fs.rdbuf();
    return buffer.str();
}

static StringVec read_control_lst(const std::string &path) {
    StringVec lines = split(get_file_contents(path), '\n');
    util::StringVec result;
    for (int i = 0; i < int(lines.size()); i++) {
        std::string trimmed = trim(lines[i]);
        if ((trimmed.size() > 0) && (trimmed[0] != '#')) {
            result.push_back(trimmed);
        }
    }
    return result;
}

LuaSourcePtr read_lua_source(const std::string &dir) {
    StringVec files = read_control_lst(dir + "/control.lst");
    assert (!files.empty());
    LuaSourcePtr result(new LuaSourceVec);
    for (const std::string &file : files) {
        std::string data = get_file_contents(dir + "/" + file);
        result->emplace_back(file, data);
    }
    return result;
}

std::string XYZ::debug_string() const {
    std::ostringstream oss;
    oss << "(" << x << "," << y << "," << z << ")";
    return oss.str();
}

} // namespace util

std::ostream &operator<<(std::ostream &oss, const util::hex64 &v) {
    oss << "0x" << std::setw(16) << std::setfill('0') << std::hex;
    return oss;
}

std::ostream &operator<<(std::ostream &oss, const util::hex32 &v) {
    oss << "0x" << std::setw(8) << std::setfill('0') << std::hex;
    return oss;
}

std::ostream &operator<<(std::ostream &oss, const util::hex16 &v) {
    oss << "0x" << std::setw(4) << std::setfill('0') << std::hex;
    return oss;
}

std::ostream &operator<<(std::ostream &oss, const util::hex8 &v) {
    oss << "0x" << std::setw(2) << std::setfill('0') << std::hex;
    return oss;
}

LuaDefine(unittests_util, "", "some unit tests") {
    // Test the unioning of ID vectors.
    util::IdVector idv1,idv2;
    idv1.push_back(1);
    idv1.push_back(6);
    idv1.push_back(4);
    idv2.push_back(5);
    idv2.push_back(1);
    idv2.push_back(6);
    util::IdVector joined = util::sort_union_id_vectors(idv1, idv2);
    LuaAssert(L, joined.size() == 4);
    LuaAssert(L, joined[0] == 1);
    LuaAssert(L, joined[1] == 4);
    LuaAssert(L, joined[2] == 5);
    LuaAssert(L, joined[3] == 6);

    // Test the string split routine.
    util::StringVec sv1 = util::split("foo,bar,baz", ',');
    LuaAssert(L, sv1.size() == 3);
    LuaAssert(L, sv1[0] == "foo");
    LuaAssert(L, sv1[1] == "bar");
    LuaAssert(L, sv1[2] == "baz");
    util::StringVec sv2 = util::split(",foo,,bar", ',');
    LuaAssert(L, sv2.size() == 4);
    LuaAssert(L, sv2[0]=="");
    LuaAssert(L, sv2[1]=="foo");
    LuaAssert(L, sv2[2]=="");
    LuaAssert(L, sv2[3]=="bar");

    // Test the split_lines routine.
    util::StringVec sv3 = util::split_lines("foo\n\nbar\r\nbaz\r\n\r\n");
    LuaAssert(L, sv3.size() == 5);
    LuaAssert(L, sv3[0] == "foo");
    LuaAssert(L, sv3[1] == "");
    LuaAssert(L, sv3[2] == "bar");
    LuaAssert(L, sv3[3] == "baz");
    LuaAssert(L, sv3[4] == "");

    // Test the repeat string routine.
    LuaAssertStrEq(L, util::repeat_string("abc", 3), "abcabcabc");

    // test toupper and tolower
    LuaAssert(L, util::toupper("fooBar") == "FOOBAR");
    LuaAssert(L, util::tolower("fooBar") == "foobar");

    // test validinteger, strtoint, strtodouble
    LuaAssert(L, util::validinteger("123") == true);
    LuaAssert(L, util::validinteger("123.4") == false);
    LuaAssert(L, util::validinteger("12ab") == false);
    LuaAssert(L, util::validinteger("") == false);
    LuaAssert(L, util::strtoint("123", -5) == 123);
    LuaAssert(L, util::strtoint("123.4", -5) == -5);
    LuaAssert(L, util::strtoint("12ab", -5) == -5);
    LuaAssert(L, util::strtoint("", -5) == -5);
    LuaAssert(L, util::strtodouble("123.5") == 123.5);
    LuaAssert(L, std::isnan(util::strtodouble("12ab")));
    LuaAssert(L, std::isnan(util::strtodouble("")));
    
    // Test split_host_port
    std::string host, port;
    util::split_host_port("stanford.edu:80", host, port);
    LuaAssertStrEq(L, host, "stanford.edu");
    LuaAssertStrEq(L, port, "80");
    
    // Test trim, ltrim, rtrim
    LuaAssert(L, util::ltrim("  foo  ") == "foo  ");
    LuaAssert(L, util::rtrim("  foo  ") == "  foo");
    LuaAssert(L, util::trim("  foo  ") == "foo");
    LuaAssert(L, util::trim("foo") == "foo");
    LuaAssert(L, util::trim("") == "");
    
    // Test distance_squared
    LuaAssert(L, util::distance_squared(1, 1, 5, 4) == 25.0);
    LuaAssert(L, util::distance_squared(5, 4, 1, 1) == 25.0);

    // Test XYZ.
    util::XYZ xyza(3,4,5), xyzb(3,4,5), xyzc(3,4,6);
    LuaAssert(L, xyza.x == 3);
    LuaAssert(L, xyza.y == 4);
    LuaAssert(L, xyza.z == 5);
    LuaAssert(L, xyza == xyzb);
    LuaAssert(L, xyza != xyzc);
    LuaAssert(L, xyza.debug_string() == "(3,4,5)");
    
    // Test hash_to_string
    LuaAssertStrEq(L, util::hash_to_hex(util::HashValue(0x1234,0x789a)),
        "0000000000001234000000000000789a");
    
    return 0;
}