/****************************************************************************
  Copyright (c) 2015 libo All rights reserved.

  losemymind.libo@gmail.com

****************************************************************************/
#include <locale>
#include <stdarg.h>
#include <algorithm>
#include <functional>
#include <cctype>
#include <sstream>
//#include <codecvt>
#include "StringUtils.h"
#include "ConvertUTF/ConvertUTF.h"

NS_FK_BEGIN

std::string StringUtils::tolower( const std::string& str )
{
	std::string ret;
	for (auto ch : str)
	{
		if (ch >= 'A' && ch <= 'Z')
			ret += ch | 32;
		else
			ret += ch;
	}
	return ret;
}

std::string StringUtils::toupper( const std::string& str )
{
	std::string ret;
	for (auto ch : str)
	{
		if (ch >= 'a' && ch <= 'z')
			ret += ch ^ 32;
		else
			ret += ch;
	}
	return ret;
}

std::string StringUtils::format( const char* format, ... )
{
	const static unsigned int MAX_STRING_LENGTH = 64;
	va_list arglist;
	int size = MAX_STRING_LENGTH;
	std::vector<char> dynamicBuffer(MAX_STRING_LENGTH);
	char* str = &dynamicBuffer[0];
	for (;;)
	{
        va_start(arglist, format);
        // Pass one less than size to leave room for NULL terminator
        int needed = vsnprintf(str, size - 1, format, arglist);
        va_end(arglist);

		// NOTE: Some platforms return -1 when vsnprintf runs out of room, while others return
		// the number of characters actually needed to fill the buffer.
		if (needed >= 0 && needed < size)
		{
			// Successfully wrote buffer. Added a NULL terminator in case it wasn't written.
			str[needed] = '\0';
			break;
		}
		size = needed > 0 ? (needed + 1) : (size * 2);
		dynamicBuffer.resize(size);
		str = &dynamicBuffer[0];
	}
	return str;
}

std::string & StringUtils::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 & StringUtils::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 & StringUtils::trim( std::string &s )
{
	return ltrim(rtrim(s));
}

std::vector<std::string> & StringUtils::split( const std::string &s, char delim, std::vector<std::string> &elems )
{
	std::stringstream ss(s);
	std::string item;
	while (std::getline(ss, item, delim))
	{
		elems.push_back(item);
	}
	return elems;
}

std::vector<std::string> StringUtils::split( const std::string &s, char delim )
{
	std::vector<std::string> elems;
	split(s, delim, elems);
	return elems;
}

std::string StringUtils::join(std::string delim, std::vector<std::string> values)
{
	std::string ret;
	size_t index = 0;
	size_t valuesSize = values.size();
	for (auto& str : values)
	{
		++index;
		ret.append(str);
		if (index < valuesSize)
		{
			ret.append(delim);
		}
	}
	return ret;
}

bool StringUtils::isNumber( const std::string& val )
{
	std::stringstream str(val);
	float tst;
	str >> tst;
	return !str.fail() && str.eof();
}


// Other impl see:http://blog.poxiao.me/p/unicode-character-encoding-conversion-in-cpp11/

std::string StringUtils::wstring2UTF8string(const std::wstring &input)
{
    std::locale old_loc = std::locale::global(std::locale(""));
    const wchar_t* src_wstr = input.c_str();
    size_t buffer_size = input.size() * 4 + 1;
    char* dst_str = new char[buffer_size];
    memset(dst_str, 0, buffer_size);
    wcstombs(dst_str, src_wstr, buffer_size);
    std::string result = dst_str;
    delete[]dst_str;
    std::locale::global(old_loc);
    return result;
}

std::wstring StringUtils::string2UTF8wstring(const std::string &input)
{
    std::locale old_loc = std::locale::global(std::locale(""));
    const char* src_str = input.c_str();
    const size_t buffer_size = input.size() + 1;
    wchar_t* dst_wstr = new wchar_t[buffer_size];
    wmemset(dst_wstr, 0, buffer_size);
    mbstowcs(dst_wstr, src_str, buffer_size);
    std::wstring result = dst_wstr;
    delete[]dst_wstr;
    std::locale::global(old_loc);
    return result;
}


bool StringUtils::UTF8ToUTF16(const std::string& utf8, std::u16string& outUtf16)
{
    if (utf8.empty())
    {
        outUtf16.clear();
        return true;
    }

    bool ret = false;

    const size_t utf16Bytes = (utf8.length() + 1) * sizeof(char16_t);
    char16_t* utf16 = (char16_t*)malloc(utf16Bytes);
    memset(utf16, 0, utf16Bytes);

    char* utf16ptr = reinterpret_cast<char*>(utf16);
    const UTF8* error = nullptr;

    if (llvm::ConvertUTF8toWide(2, utf8, utf16ptr, error))
    {
        outUtf16 = utf16;
        ret = true;
    }
    free(utf16);
    return ret;
}

bool StringUtils::UTF16ToUTF8(const std::u16string& utf16, std::string& outUtf8)
{
    if (utf16.empty())
    {
        outUtf8.clear();
        return true;
    }

    return llvm::convertUTF16ToUTF8String(utf16, outUtf8);
}

/*
std::u16string StringUtils::UTF8ToUTF16(const std::string &s)
{
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
    return conv.from_bytes(s);
}

std::u32string StringUtils::UTF8ToUTF32(const std::string &s)
{
    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv;
    return conv.from_bytes(s);
}

std::string StringUtils::UTF16ToUTF8(const std::u16string &s)
{
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
    return conv.to_bytes(s);
}

std::u32string StringUtils::UTF16ToUTF32(const std::u16string &s)
{
    const char16_t *pData = s.c_str();
    std::wstring_convert<std::codecvt_utf16<char32_t>, char32_t> conv;
    return conv.from_bytes(reinterpret_cast<const char*>(pData), reinterpret_cast<const char*>(pData + s.length()));
}

std::string StringUtils::UTF32ToUTF8(const std::u32string &s)
{
    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv;
    return conv.to_bytes(s);
}


std::u16string StringUtils::UTF32ToUTF16(const std::u32string &s)
{
    std::wstring_convert<std::codecvt_utf16<char32_t>, char32_t> conv;
    std::string bytes = conv.to_bytes(s);
    return std::u16string(reinterpret_cast<const char16_t*>(bytes.c_str()), bytes.length() / sizeof(char16_t));
}
*/
NS_FK_END