#pragma once

#include <locale>

#include <vector>

#include <unordered_map>

namespace Utils

{

void toLower(std::string &str) noexcept;

std::string getLowerString(const std::string &str);

void trim(std::string &str);

std::string getTrimmedString(const std::string &str);

std::vector<std::string> explode(const std::string &str, const char sep);

std::string encodeHtmlSymbols(const std::string &str);

std::string binToHexString(const void *bin, const size_t size);

std::string hexStringToBin(const std::string &hexStr);

uint64_t hton64(const uint64_t host64) noexcept;

uint64_t ntoh64(const uint64_t net64) noexcept;

void hton24(void *dest, const uint32_t host32) noexcept;

uint32_t ntoh24(const void *src24) noexcept;

std::string getUniqueName();

size_t getPackNumberSize(const size_t number) noexcept;

size_t getPackStringSize(const std::string &str) noexcept;

template<typename T>

size_t getPackContainerSize(const T &container) noexcept

}

uint8_t *packPointer(uint8_t *dest, void *pointer) noexcept;

uint8_t *packNumber(uint8_t *dest, const size_t number) noexcept;

uint8_t *packString(uint8_t *dest, const std::string &str) noexcept;

template<typename T>

uint8_t *packContainer(void *dest, const T &container) noexcept

{

uint8_t *addr = reinterpret_cast<uint8_t *>(dest);

addr = packNumber(addr, container.size() );

for (auto const &pair : container) {

addr = packString(addr, pair.first);

addr = packString(addr, pair.second);

}

return addr;

}

void packPointer(std::vector<char> &buf, void *pointer);

void packNumber(std::vector<char> &buf, const size_t number);

void packString(std::vector<char> &buf, const std::string &str);

template<typename T>

void packContainer(std::vector<char> &buf, const T &container)

}

const uint8_t *unpackPointer(void **pointer, const uint8_t *src) noexcept;

const uint8_t *unpackNumber(size_t *number, const uint8_t *src) noexcept;

const uint8_t *unpackString(std::string &str, const uint8_t *src);

template<typename T>

const uint8_t *unpackContainer(T &container, const uint8_t *src)

{

size_t count;

src = unpackNumber(&count, src);

for (size_t i = 0; i < count; ++i) {

std::string key;

src = unpackString(key, src);

std::string value;

src = unpackString(value, src);

container.emplace(std::move(key), std::move(value) );

}

return src;

}

template<typename T>

const uint8_t *unpackVector(T &vector, const uint8_t *src)

{

size_t count;

src = unpackNumber(&count, src);

for (size_t i = 0; i < count; ++i) {

std::string key;

src = unpackString(key, src);

std::string value;

src = unpackString(value, src);

vector.emplace_back(std::move(key), std::move(value) );

}

return src;

}

time_t rfc822DatetimeToTimestamp(const std::string &strTime);

time_t predefinedDatetimeToTimestamp(const char *strTime);

std::string getDatetimeAsString(time_t tTime = ~0, const bool isGmtTime = false);

std::string predefinedDatetimeToRfc822(const char *strTime);

size_t getNumberLength(size_t number) noexcept;

bool parseCookies(

const std::string &cookieHeader,

std::unordered_multimap<std::string, std::string> &cookies

);

std::string urlEncode(const std::string &str);

std::string urlDecode(const std::string &str);

}