/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#include <stdexcept>

#include "ConvertUTF.h"
#include "string.hh"


namespace moof {


// TODO this code is ugly

wstring multi_to_wide(const string& multi)
{
	size_t length = multi.length();

	if (sizeof(wchar_t) == 2)
	{
		wchar_t* wide = new wchar_t[length + 1];

		const UTF8* srcStart = reinterpret_cast<const UTF8*>(multi.c_str());
		const UTF8* srcEnd = srcStart + length;
		UTF16* targetStart = reinterpret_cast<UTF16*>(wide);
		UTF16* targetEnd = targetStart + length+1;

		ConversionResult res = ConvertUTF8toUTF16(&srcStart, srcEnd,
				&targetStart, targetEnd, lenientConversion);
		if (res != conversionOK)
		{
			delete[] wide;
			throw std::runtime_error("bad conversion from multi to wide characters");
		}

		*targetStart = 0;
		wstring convertedStr(wide);
		delete[] wide;

		return convertedStr;
	}
	else if (sizeof(wchar_t) == 4)
	{
		wchar_t* wide = new wchar_t[length];

		const UTF8* srcStart = reinterpret_cast<const UTF8*>(multi.c_str());
		const UTF8* srcEnd = srcStart + length;
		UTF32* targetStart = reinterpret_cast<UTF32*>(wide);
		UTF32* targetEnd = targetStart + length;

		ConversionResult res = ConvertUTF8toUTF32(&srcStart, srcEnd,
				&targetStart, targetEnd, lenientConversion);
		if (res != conversionOK)
		{
			delete[] wide;
			throw std::runtime_error("bad conversion from multi to wide characters");
		}

		*targetStart = 0;
		wstring convertedStr(wide);
		delete[] wide;

		return convertedStr;
	}
	else
	{
		throw std::runtime_error("unknown size of wide characters");
	}
	return L"";
}

string wide_to_multi(const wstring& wide)
{
	size_t length = wide.length();

	if (sizeof(wchar_t) == 2)
	{
		size_t multiLength = 3 * length + 1;
		char* multi = new char[multiLength];

		const UTF16* srcStart = reinterpret_cast<const UTF16*>(wide.c_str());
		const UTF16* srcEnd = srcStart + length;
		UTF8* targetStart = reinterpret_cast<UTF8*>(multi);
		UTF8* targetEnd = targetStart + multiLength;

		ConversionResult res = ConvertUTF16toUTF8(&srcStart, srcEnd,
				&targetStart, targetEnd, lenientConversion);
		if (res != conversionOK)
		{
			delete[] multi;
			throw std::runtime_error("bad conversion from wide to multi-characters");
		}

		*targetStart = 0;
		string convertedStr(multi);
		delete[] multi;

		return convertedStr;
	}
	else if (sizeof(wchar_t) == 4)
	{
		size_t multiLength = 4 * length + 1;
		char* multi = new char[multiLength];

		const UTF32* srcStart = reinterpret_cast<const UTF32*>(wide.c_str());
		const UTF32* srcEnd = srcStart + length;
		UTF8* targetStart = reinterpret_cast<UTF8*>(multi);
		UTF8* targetEnd = targetStart + multiLength;

		ConversionResult res = ConvertUTF32toUTF8(&srcStart, srcEnd,
				&targetStart, targetEnd, lenientConversion);
		if (res != conversionOK)
		{
			delete[] multi;
			throw std::runtime_error("bad conversion from wide to multi-characters");
		}

		*targetStart = 0;
		string convertedStr(multi);
		delete[] multi;

		return convertedStr;
	}
	else
	{
		throw std::runtime_error("unknown size of wide characters");
	}
	return "";
}


} // namespace moof