#pragma once
/**
	@file
	@brief convert integer to string(ascii)

	@author MITSUNARI Shigeo(@herumi)
*/
#include <limits.h>
#ifndef CYBOZU_DONT_USE_STRING
#include <string>
#endif
#include <memory.h>
#include <cybozu/inttype.hpp>
#include <cybozu/bit_operation.hpp>

namespace cybozu {

template<class T>
size_t getHexLength(T x)
{
	return x == 0 ? 1 : cybozu::bsr(x) / 4 + 1;
}

template<class T>
size_t getBinLength(T x)
{
	return x == 0 ? 1 : cybozu::bsr(x) + 1;
}
/*
	convert x to hex string with len
	@note out should have getHexLength(x) size
	out is not NUL terminated
*/
template<class T>
void itohex(char *out, size_t len, T x, bool upCase = true)
{
	static const char *hexTbl[] = {
		"0123456789abcdef",
		"0123456789ABCDEF"
	};
	const char *tbl = hexTbl[upCase];
	for (size_t i = 0; i < len; i++) {
		out[len - i - 1] = tbl[x % 16];
		x /= 16;
	}
}
/*
	convert x to bin string with len
	@note out should have getBinLength(x) size
	out is not NUL terminated
*/
template<class T>
void itobin(char *out, size_t len, T x)
{
	for (size_t i = 0; i < len; i++) {
		out[len - i - 1] = '0' + (x & 1);
		x >>= 1;
	}
}

namespace itoa_local {

/*
	convert x to dec
	use buf[0, bufSize)
	return 0 if false
	return writtenSize which is not terminated
	@REMARK the top of string is buf + bufSize - writtenSize
*/
template<class UT>
size_t uintToDec(char *buf, size_t bufSize, UT x)
{
	for (size_t i = 0; i < bufSize; i++) {
		buf[bufSize - 1 - i] = '0' + static_cast<int>(x % 10);
		x /= 10;
		if (x == 0) return i + 1;
	}
	return 0;
}

/*
	convert x to hex
	use buf[0, bufSize)
	return 0 if false
	return writtenSize which is not terminated
	@REMARK the top of string is buf + bufSize - writtenSize
*/
template<class UT>
size_t uintToHex(char *buf, size_t bufSize, UT x, bool upCase = true)
{
	static const char *hexTbl[] = {
		"0123456789abcdef",
		"0123456789ABCDEF"
	};
	const char *tbl = hexTbl[upCase];
	for (size_t i = 0; i < bufSize; i++) {
		buf[bufSize - 1 - i] = tbl[x % 16];
		x /= 16;
		if (x == 0) return i + 1;
	}
	return 0;
}

/*
	convert x to bin
	use buf[0, bufSize)
	return 0 if false
	return writtenSize which is not terminated
	@REMARK the top of string is buf + bufSize - writtenSize
*/
template<class UT>
size_t uintToBin(char *buf, size_t bufSize, UT x)
{
	for (size_t i = 0; i < bufSize; i++) {
		buf[bufSize - 1 - i] = '0' + (x & 1);
		x >>= 1;
		if (x == 0) return i + 1;
	}
	return 0;
}

template<class T>
size_t intToDec(char *buf, size_t bufSize, T x)
{
	if (x == LLONG_MIN) {
		const char minStr[] = "-9223372036854775808";
		const size_t minStrLen = sizeof(minStr) - 1;
		if (bufSize < minStrLen) {
			return 0;
		} else {
			memcpy(buf + bufSize - minStrLen, minStr, minStrLen);
			return minStrLen;
		}
	}
	bool negative = x < 0;
	uint64_t absX = negative ? -x : x;
	size_t n = uintToDec(buf, bufSize, absX);
	if (n == 0) return 0;
	if (negative) {
		if (bufSize == n) return 0;
		n++;
		buf[bufSize - n] = '-';
	}
	return n;
}

#ifndef CYBOZU_DONT_USE_STRING
template<typename T>
void convertFromUint(std::string& out, T x)
{
	char buf[40];
	size_t n = uintToDec(buf, sizeof(buf), x);
	assert(n > 0);
	out.assign(buf + sizeof(buf) - n, n);
}

inline void convertFromInt(std::string& out, long long x)
{
	char buf[40];
	size_t n = intToDec(buf, sizeof(buf), x);
	assert(n > 0);
	out.assign(buf + sizeof(buf) - n, n);
}

template<typename T>
void itohexLocal(std::string& out, T x, bool upCase, bool withZero)
{
	const size_t size = withZero ? sizeof(T) * 2 : getHexLength(x);
	out.resize(size);
	itohex(&out[0], size, x, upCase);
}

template<class T>
void itobinLocal(std::string& out, T x, bool withZero)
{
	const size_t size = withZero ? sizeof(T) * 8 : getBinLength(x);
	out.resize(size);
	itobin(&out[0], size, x);
}
#endif

} // itoa_local

#ifndef CYBOZU_DONT_USE_STRING
/**
	convert int to string
	@param out [out] string
	@param x [in] int
*/
inline void itoa(std::string& out, int x)
{
	itoa_local::convertFromInt(out, x);
}

/**
	convert long long to string
	@param out [out] string
	@param x [in] long long
*/
inline void itoa(std::string& out, long long x)
{
	itoa_local::convertFromInt(out, x);
}

/**
	convert unsigned int to string
	@param out [out] string
	@param x [in] unsigned int
*/
inline void itoa(std::string& out, unsigned int x)
{
	itoa_local::convertFromUint(out, x);
}

/**
	convert unsigned long long to string
	@param out [out] string
	@param x [in] unsigned long long
*/
inline void itoa(std::string& out, unsigned long long x)
{
	itoa_local::convertFromUint(out, x);
}

#if defined(__SIZEOF_LONG__) && (__SIZEOF_LONG__ == 8)
inline void itoa(std::string& out, long x) { itoa(out, static_cast<long long>(x)); }
inline void itoa(std::string& out, unsigned long x) { itoa(out, static_cast<unsigned long long>(x)); }
#else
inline void itoa(std::string& out, long x) { itoa(out, static_cast<int>(x)); }
inline void itoa(std::string& out, unsigned long x) { itoa(out, static_cast<int>(x)); }
#endif
/**
	convert integer to string
	@param x [in] int
*/
template<typename T>
inline std::string itoa(T x)
{
	std::string ret;
	itoa(ret, x);
	return ret;
}

inline void itohex(std::string& out, unsigned char x, bool upCase = true, bool withZero = true)
{
	itoa_local::itohexLocal(out, x, upCase, withZero);
}

inline void itohex(std::string& out, unsigned short x, bool upCase = true, bool withZero = true)
{
	itoa_local::itohexLocal(out, x, upCase, withZero);
}

inline void itohex(std::string& out, unsigned int x, bool upCase = true, bool withZero = true)
{
	itoa_local::itohexLocal(out, x, upCase, withZero);
}

inline void itohex(std::string& out, unsigned long x, bool upCase = true, bool withZero = true)
{
	itoa_local::itohexLocal(out, x, upCase, withZero);
}

inline void itohex(std::string& out, unsigned long long x, bool upCase = true, bool withZero = true)
{
	itoa_local::itohexLocal(out, x, upCase, withZero);
}

template<typename T>
inline std::string itobin(T x, bool withZero = true)
{
	std::string out;
	itoa_local::itobinLocal(out, x, withZero);
	return out;
}

inline void itobin(std::string& out, unsigned char x, bool withZero = true)
{
	itoa_local::itobinLocal(out, x, withZero);
}

inline void itobin(std::string& out, unsigned short x, bool withZero = true)
{
	itoa_local::itobinLocal(out, x, withZero);
}

inline void itobin(std::string& out, unsigned int x, bool withZero = true)
{
	itoa_local::itobinLocal(out, x, withZero);
}

inline void itobin(std::string& out, unsigned long x, bool withZero = true)
{
	itoa_local::itobinLocal(out, x, withZero);
}

inline void itobin(std::string& out, unsigned long long x, bool withZero = true)
{
	itoa_local::itobinLocal(out, x, withZero);
}

template<typename T>
inline std::string itohex(T x, bool upCase = true, bool withZero = true)
{
	std::string out;
	itohex(out, x, upCase, withZero);
	return out;
}
/**
	convert integer to string with zero padding
	@param x [in] int
	@param len [in] minimum lengh of string
	@param c [in] padding character
	@note
	itoa(12, 4) == "0012"
	itoa(1234, 4) == "1234"
	itoa(12345, 4) == "12345"
	itoa(-12, 4) == "-012"
*/
template<typename T>
inline std::string itoaWithZero(T x, size_t len, char c = '0')
{
	std::string ret;
	itoa(ret, x);
	if (ret.size() < len) {
		std::string zero(len - ret.size(), c);
		if (x >= 0) {
			ret = zero + ret;
		} else {
			ret = "-" + zero + ret.substr(1);
		}
	}
	return ret;
}
#endif

} // cybozu