#include "helper_str.h"
#include "convert_utf.h"
#include <iostream>
#include <sstream>
#include <locale>

// --------------------------------------------------------
// ExtStr
// --------------------------------------------------------
namespace ExtStr
{
std::wstring num2wstr(int val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    std::string str( ostream.str() );
    return std::wstring( str.begin(), str.end() );
}

std::wstring num2wstr(long val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    std::string str( ostream.str() );
    return std::wstring( str.begin(), str.end() );
}

std::wstring num2wstr(long64 val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    std::string str( ostream.str() );
    return std::wstring( str.begin(), str.end() );
}

std::wstring num2wstr(double val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    std::string str( ostream.str() );
    return std::wstring( str.begin(), str.end() );
}

std::string num2str(int val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    return ostream.str();
}

std::string num2str(long val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    return ostream.str();
}

std::string num2str(long64 val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    return ostream.str();
}

std::string num2str(double val_, bool imbueUserLocale_)
{
    std::ostringstream ostream;
	if ( imbueUserLocale_ )
	{
		ostream.imbue(std::locale(""));
	}
    ostream << val_;
    return ostream.str();
}

// from http://www.codeproject.com/useritems/UtfConverter.asp
std::wstring FromUtf8(const std::string& utf8string)
{
    std::wstring resultstring;
    size_t widesize = utf8string.length();
    resultstring.resize(widesize+1, L'\0');
    const UTF8* sourcestart = reinterpret_cast<const UTF8*>(utf8string.c_str());
    const UTF8* sourceend = sourcestart + widesize;

    if (sizeof(wchar_t) == 2)
    {
        UTF16* targetstart = reinterpret_cast<UTF16*>(&resultstring[0]);
        UTF16* targetend = targetstart + widesize;
        ConversionResult res = ConvertUTF8toUTF16(&sourcestart, sourceend, &targetstart, targetend, strictConversion);
        if (res != conversionOK)
        {
            return L"";
        }
        *targetstart = 0;
    }
    else if (sizeof(wchar_t) == 4)
    {
        UTF32* targetstart = reinterpret_cast<UTF32*>(&resultstring[0]);
        UTF32* targetend = targetstart + widesize;
        ConversionResult res = ConvertUTF8toUTF32(&sourcestart, sourceend, &targetstart, targetend, strictConversion);
        if (res != conversionOK)
        {
            return L"";
        }
        *targetstart = 0;
    }
    return std::wstring( resultstring.c_str() ); // this intentional! resultstring is different from the returned string.
}

std::string ToUtf8(const wchar_t* widestring_)
{
	if ( !widestring_ || !wcslen(widestring_) )
	{
		std::string str;
		return str;
	}

	return ToUtf8( std::wstring(widestring_) );
}

// from http://www.codeproject.com/useritems/UtfConverter.asp
std::string ToUtf8(const std::wstring& widestring)
{
    size_t widesize = widestring.length();
    std::string resultstring;

    if (sizeof(wchar_t) == 2)
    {
        size_t utf8size = 3 * widesize + 1;
        resultstring.resize(utf8size, '\0');
        const UTF16* sourcestart = reinterpret_cast<const UTF16*>(widestring.c_str());
        const UTF16* sourceend = sourcestart + widesize;
        UTF8* targetstart = reinterpret_cast<UTF8*>(&resultstring[0]);
        UTF8* targetend = targetstart + utf8size;
        ConversionResult res = ConvertUTF16toUTF8(&sourcestart, sourceend, &targetstart, targetend, strictConversion);
        if (res != conversionOK)
        {
            return "";
        }
        *targetstart = 0;
    }
    else if (sizeof(wchar_t) == 4)
    {
        size_t utf8size = 4 * widesize + 1;
        resultstring.resize(utf8size, '\0');
        const UTF32* sourcestart = reinterpret_cast<const UTF32*>(widestring.c_str());
        const UTF32* sourceend = sourcestart + widesize;
        UTF8* targetstart = reinterpret_cast<UTF8*>(&resultstring[0]);
        UTF8* targetend = targetstart + utf8size;
        ConversionResult res = ConvertUTF32toUTF8(&sourcestart, sourceend, &targetstart, targetend, strictConversion);
        if (res != conversionOK)
        {
            return "";
        }
        *targetstart = 0;
    }
    return std::string( resultstring.c_str() ); // this intentional! resultstring is different from the returned string.
}

void ToUpper(std::string &string_)
{
	const int length = string_.length();
	for ( int i=0; i!=length; ++i )
	{
		string_[i] = std::toupper(string_[i]);
	}
}

void ToLower(std::string &string_)
{
	const int length = string_.length();
	for ( int i=0; i!=length; ++i )
	{
		string_[i] = std::tolower(string_[i]);
	}
}

}; // namespace ExtStr