CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfLocalizationMgr/pfLocalizationDataMgr.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////
//
// pfLocalizationDataMgr - singleton class for managing the
//                         localization XML data tree
//
//////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "hsUtils.h"
#include "../plResMgr/plLocalization.h"

#include "../plFile/hsFiles.h"
#include "../plFile/plEncryptedStream.h"
#include "../plStatusLog/plStatusLog.h"

#include "pfLocalizedString.h"
#include "pfLocalizationMgr.h"
#include "pfLocalizationDataMgr.h"

#include "expat.h"

#include <stack>

#if HS_BUILD_FOR_MAC
#include <bxwchar.h>
#endif

// Add ..\..\..\..\..\StaticSDKs\XPlatform\expat-1.95.7\StaticLibs\Win32 to your
// lib include path if you include this file.
#pragma comment(lib, "libexpatwMT.lib")


//////////////////////////////////////////////////////////////////////
//
// LocalizationXMLFile - a basic class for storing all the
//                       localization data grabbed from a single XML
//                       file
//
//////////////////////////////////////////////////////////////////////

class LocalizationXMLFile
{
public:
    //replace friend by static because of conflits with subtitleXMLFile
	static void XMLCALL StartTag(void *userData, const XML_Char *element, const XML_Char **attributes);
	static void XMLCALL EndTag(void *userData, const XML_Char *element);
	static void XMLCALL HandleData(void *userData, const XML_Char *data, int stringLength);
	friend class LocalizationDatabase;

	// first wstring is language, second is data
	typedef std::map<std::wstring, std::wstring> element;

	// the wstring is the element name
	typedef std::map<std::wstring, element> set;

	// the wstring is the set name
	typedef std::map<std::wstring, set> age;

	// the wstring is the age name
	typedef std::map<std::wstring, age> ageMap;

protected:
	std::wstring fLastError;
	std::string fFilename;
	XML_Parser fParser;

	struct tagInfo
	{
		std::wstring fTag;
		std::map<std::wstring, std::wstring> fAttributes;
	};
	std::stack<tagInfo> fTagStack;

	int fSkipDepth; // if we need to skip a block, this is the depth we need to skip to

	bool fIgnoreContents; // are we ignoring the contents between tags?
	std::wstring fCurrentAge, fCurrentSet, fCurrentElement, fCurrentTranslation;

	ageMap fData;

	void IHandleLocalizationsTag(const tagInfo & parentTag, const tagInfo & thisTag);

	void IHandleAgeTag(const tagInfo & parentTag, const tagInfo & thisTag);
	void IHandleSetTag(const tagInfo & parentTag, const tagInfo & thisTag);
	void IHandleElementTag(const tagInfo & parentTag, const tagInfo & thisTag);

	void IHandleTranslationTag(const tagInfo & parentTag, const tagInfo & thisTag);

public:
	LocalizationXMLFile() : fLastError(L""), fFilename("") {}

	bool Parse(const std::string & fileName); // returns false on failure
	void AddError(const std::wstring & errorText);

	std::wstring GetLastError() {return fLastError;}
};

// A few small helper structs
// I am setting these up so the header file can use this data without having to put
// the LocalizationXMLFile class into the header file
struct LocElementInfo
{
	LocalizationXMLFile::element fElement;
};

struct LocSetInfo
{
	LocalizationXMLFile::set fSet;
};

struct LocAgeInfo
{
	LocalizationXMLFile::age fAge;
};

//////////////////////////////////////////////////////////////////////
// Memory functions
//////////////////////////////////////////////////////////////////////

static void * XMLCALL XmlMalloc (size_t size) {
	return ALLOC(size);
}

static void * XMLCALL XmlRealloc (void * ptr, size_t size) {
	return REALLOC(ptr, size);
}

static void XMLCALL XmlFree (void * ptr) {
	FREE(ptr);
}

XML_Memory_Handling_Suite gHeapAllocator = {
	XmlMalloc,
	XmlRealloc,
	XmlFree
};


//////////////////////////////////////////////////////////////////////
//// XML Parsing functions ///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//metmet remove static
void XMLCALL LocalizationXMLFile::StartTag(void *userData, const XML_Char *element, const XML_Char **attributes)
{
#if !HS_BUILD_FOR_MAC
	std::wstring wElement = element;
#else
	// jfim
	wchar_t buf[2048], buf2[2048];
	BX_Char16ToWchar(element, buf);
	std::wstring wElement = buf;	// jfim: element;
#endif
	LocalizationXMLFile *file = (LocalizationXMLFile*)userData;
	std::map<std::wstring, std::wstring> wAttributes;

	for (int i = 0; attributes[i]; i += 2)
#if !HS_BUILD_FOR_MAC
		wAttributes[attributes[i]] = attributes[i+1];
#else
	{
		// jfim
		BX_Char16ToWchar(attributes[i], buf);
		BX_Char16ToWchar(attributes[i+1], buf2);
		wAttributes[buf] = buf2;
	}
#endif

	LocalizationXMLFile::tagInfo parentTag;
	if (!file->fTagStack.empty())
		parentTag = file->fTagStack.top();

	LocalizationXMLFile::tagInfo newTag;
	newTag.fTag = wElement;
	newTag.fAttributes = wAttributes;

	file->fTagStack.push(newTag);

	if (file->fSkipDepth != -1) // we're currently skipping
		return;

	// now we handle this tag
	if (wElement == L"localizations")
		file->IHandleLocalizationsTag(parentTag, newTag);
	else if (wElement == L"age")
		file->IHandleAgeTag(parentTag, newTag);
	else if (wElement == L"set")
		file->IHandleSetTag(parentTag, newTag);
	else if (wElement == L"element")
		file->IHandleElementTag(parentTag, newTag);
	else if (wElement == L"translation")
		file->IHandleTranslationTag(parentTag, newTag);
	else
		file->AddError(L"Unknown tag " + wElement + L" found");
}
//metmet remove static and include the function inside LocalizationXMLFile
void XMLCALL LocalizationXMLFile::EndTag(void *userData, const XML_Char *element)
{
#if !HS_BUILD_FOR_MAC
	std::wstring wElement = element;
#else
	// jfim
	wchar_t buf[2048], buf2[2048];
	BX_Char16ToWchar(element, buf);
	std::wstring wElement = buf;	// jfim: element;
#endif
	LocalizationXMLFile *file = (LocalizationXMLFile*)userData;

	if (file->fSkipDepth != -1) // we're currently skipping
	{
		// check to see if we are done with the block we wanted skipped
		if (file->fTagStack.size() == file->fSkipDepth)
			file->fSkipDepth = -1; // we're done skipping
	}

	if (wElement == L"age") // we left the age block
		file->fCurrentAge = L"";
	else if (wElement == L"set") // we left the set block
		file->fCurrentSet = L"";
	else if (wElement == L"element") // we left the element block
		file->fCurrentElement = L"";
	else if (wElement == L"translation") // we left the translation block
	{
		file->fIgnoreContents = true;
		file->fCurrentTranslation = L"";
	}

	file->fTagStack.pop();
}
//metmet remove static and include the function inside LocalizationXMLFile
void XMLCALL LocalizationXMLFile::HandleData(void *userData, const XML_Char *data, int stringLength)
{
	LocalizationXMLFile *file = (LocalizationXMLFile*)userData;
	if (file->fIgnoreContents)
		return; // we're ignoring data, so just return
	if (file->fSkipDepth != -1) // we're currently skipping
		return;

	// This gets all data between tags, including indentation and newlines
	// so we'll have to ignore data when we aren't expecting it (not in a translation tag)
	std::wstring wData = L"";

	for (int i = 0; i < stringLength; i++)
		wData += data[i];

	// we must be in a translation tag since that's the only tag that doesn't ignore the contents
	file->fData[file->fCurrentAge][file->fCurrentSet][file->fCurrentElement][file->fCurrentTranslation] += wData;
}

//////////////////////////////////////////////////////////////////////
//// LocalizationXMLFile Functions ///////////////////////////////////
//////////////////////////////////////////////////////////////////////

#define FILEBUFFERSIZE 8192

//// IHandleSubtitlesTag() ///////////////////////////////////////////

void LocalizationXMLFile::IHandleLocalizationsTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag)
{
	if (parentTag.fTag != L"") // we only allow <localizations> tags at root level
	{
		AddError(L"localizations tag only allowed at root level");
		return;
	}
}

//// IHandleAgeTag() /////////////////////////////////////////////////

void LocalizationXMLFile::IHandleAgeTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag)
{
	// it has to be inside the subtitles tag
	if (parentTag.fTag != L"localizations")
	{
		AddError(L"age tag can only be directly inside a localizations tag");
		return;
	}

	// we have to have a name attribute
	if (thisTag.fAttributes.find(L"name") == thisTag.fAttributes.end())
	{
		AddError(L"age tag is missing the name attribute");
		return;
	}

	fCurrentAge = thisTag.fAttributes.find(L"name")->second;
}

//// IHandleSetTag() /////////////////////////////////////////////////

void LocalizationXMLFile::IHandleSetTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag)
{
	// it has to be inside the age tag
	if (parentTag.fTag != L"age")
	{
		AddError(L"set tag can only be directly inside a age tag");
		return;
	}

	// we have to have a name attribute
	if (thisTag.fAttributes.find(L"name") == thisTag.fAttributes.end())
	{
		AddError(L"set tag is missing the name attribute");
		return;
	}

	fCurrentSet = thisTag.fAttributes.find(L"name")->second;
}

//// IHandleElementTag() /////////////////////////////////////////////

void LocalizationXMLFile::IHandleElementTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag)
{
	// it has to be inside the element tag
	if (parentTag.fTag != L"set")
	{
		AddError(L"element tag can only be directly inside a set tag");
		return;
	}

	// we have to have a name attribute
	if (thisTag.fAttributes.find(L"name") == thisTag.fAttributes.end())
	{
		AddError(L"element tag is missing the name attribute");
		return;
	}

	fCurrentElement = thisTag.fAttributes.find(L"name")->second;
}

//// IHandleTranslationTag() /////////////////////////////////////////

void LocalizationXMLFile::IHandleTranslationTag(const LocalizationXMLFile::tagInfo & parentTag, const LocalizationXMLFile::tagInfo & thisTag)
{
	// it has to be inside the element tag
	if (parentTag.fTag != L"element")
	{
		AddError(L"translation tag can only be directly inside a element tag");
		return;
	}

	// we have to have a language attribute
	if (thisTag.fAttributes.find(L"language") == thisTag.fAttributes.end())
	{
		AddError(L"translation tag is missing the language attribute");
		return;
	}

	fIgnoreContents = false; // we now want contents between tags
	fCurrentTranslation = thisTag.fAttributes.find(L"language")->second;
}

//// Parse() /////////////////////////////////////////////////////////

bool LocalizationXMLFile::Parse(const std::string & fileName)
{
	fFilename = fileName;

	fLastError = L"";

	while (!fTagStack.empty())
		fTagStack.pop();

	fCurrentAge = L"";
	fCurrentSet = L"";
	fCurrentElement = L"";
	fCurrentTranslation = L"";

	fIgnoreContents = true;
	fSkipDepth = -1;

	char Buff[FILEBUFFERSIZE];

	fParser = XML_ParserCreate_MM(NULL, &gHeapAllocator, NULL);
	if (!fParser)
	{
		fLastError = L"ERROR: Couldn't allocate memory for parser";
		return false;
	}

	XML_SetElementHandler(fParser, StartTag, EndTag);
	XML_SetCharacterDataHandler(fParser, HandleData);
	XML_SetUserData(fParser, (void*)this);

	hsStream *xmlStream = plEncryptedStream::OpenEncryptedFile(fileName.c_str(), false);
	if (!xmlStream)
	{
		wchar_t *wFilename = hsStringToWString(fileName.c_str());
		fLastError += L"ERROR: Can't open file stream for ";
		fLastError += wFilename;
		fLastError += L"\n";
		delete [] wFilename;
		return false;
	}

	for (;;)
	{
		int done;
		size_t len;

		len = xmlStream->Read(FILEBUFFERSIZE, Buff);
		done = xmlStream->AtEnd();

		if (XML_Parse(fParser, Buff, (int)len, done) == XML_STATUS_ERROR)
		{
			wchar_t lineNumber[256];
			_itow(XML_GetCurrentLineNumber(fParser), lineNumber, 10);
			fLastError += L"ERROR: Parse error at line ";
			fLastError += lineNumber;
			fLastError += L": ";
#if !HS_BUILD_FOR_MAC
			fLastError += XML_ErrorString(XML_GetErrorCode(fParser));
#else
			// jfim
			wchar_t buf[2048];
			BX_Utf8ToWchar(XML_ErrorString(XML_GetErrorCode(fParser)), buf);
			fLastError += buf;
#endif
			fLastError += L"\n";
			XML_ParserFree(fParser);
			fParser = nil;
			xmlStream->Close();
			delete xmlStream;
			return false;
		}

		if (fLastError != L"") // some error occurred in the parser
		{
			XML_ParserFree(fParser);
			fParser = nil;
			xmlStream->Close();
			delete xmlStream;
			return false;
		}

		if (done)
			break;
	}
	XML_ParserFree(fParser);
	fParser = nil;
	xmlStream->Close();
	delete xmlStream;
	return true;
}

//// AddError() //////////////////////////////////////////////////////

void LocalizationXMLFile::AddError(const std::wstring & errorText)
{
	wchar_t lineNumber[256];
	_itow(XML_GetCurrentLineNumber(fParser), lineNumber, 10);
	fLastError += L"ERROR (line ";
	fLastError += lineNumber;
	fLastError += L"): " + errorText + L"\n";
	fSkipDepth = fTagStack.size(); // skip this block
	return;
}

//////////////////////////////////////////////////////////////////////
//
// LocalizationDatabase - a basic class for storing all the subtitle
//                        data grabbed from a XML directory (handles
//                        the merging and final validation of the data)
//
//////////////////////////////////////////////////////////////////////

class LocalizationDatabase
{
protected:
	std::string fDirectory; // the directory we're supposed to parse
	std::wstring fErrorString; // total sum of all errors encountered (also has warnings and status messages)

	std::vector<LocalizationXMLFile> fFiles; // the various XML files in that directory

	LocalizationXMLFile::ageMap fData;

	LocalizationXMLFile::element IMergeElementData(LocalizationXMLFile::element firstElement, LocalizationXMLFile::element secondElement, const std::wstring & fileName, const std::wstring & path);
	LocalizationXMLFile::set IMergeSetData(LocalizationXMLFile::set firstSet, LocalizationXMLFile::set secondSet, const std::wstring & fileName, const std::wstring & path);
	LocalizationXMLFile::age IMergeAgeData(LocalizationXMLFile::age firstAge, LocalizationXMLFile::age secondAge, const std::wstring & fileName, const std::wstring & path);
	void IMergeData(); // merge all localization data in the files

	void IVerifyElement(const std::wstring &ageName, const std::wstring &setName, LocalizationXMLFile::set::iterator& curElement);
	void IVerifySet(const std::wstring &ageName, const std::wstring &setName);
	void IVerifyAge(const std::wstring &ageName);
	void IVerifyData(); // verify the localization data once it has been merged in

public:
	LocalizationDatabase() {}

	void Parse(const std::string & directory);
	void ResetOutput() {fErrorString = L"";}
	std::wstring GetOutput() {return fErrorString;}

	LocalizationXMLFile::ageMap GetData() {return fData;}
};

//////////////////////////////////////////////////////////////////////
//// LocalizationDatabase Functions //////////////////////////////////
//////////////////////////////////////////////////////////////////////

//// IMergeElementData ///////////////////////////////////////////////

LocalizationXMLFile::element LocalizationDatabase::IMergeElementData(LocalizationXMLFile::element firstElement, LocalizationXMLFile::element secondElement, const std::wstring & fileName, const std::wstring & path)
{
	// copy the data over, alerting the user to any duplicate translations
	LocalizationXMLFile::element::iterator curTranslation;
	for (curTranslation = secondElement.begin(); curTranslation != secondElement.end(); curTranslation++)
	{
		if (firstElement.find(curTranslation->first) != firstElement.end())
			fErrorString += L"Duplicate " + curTranslation->first + L" translation for " + path + L" found in file " + fileName + L" Ignoring second translation\n";
		else
			firstElement[curTranslation->first] = curTranslation->second;
	}

	return firstElement;
}

//// IMergeSetData ///////////////////////////////////////////////////

LocalizationXMLFile::set LocalizationDatabase::IMergeSetData(LocalizationXMLFile::set firstSet, LocalizationXMLFile::set secondSet, const std::wstring & fileName, const std::wstring & path)
{
	// Merge all the elements
	LocalizationXMLFile::set::iterator curElement;
	for (curElement = secondSet.begin(); curElement != secondSet.end(); curElement++)
	{
		// if the element doesn't exist in the current set, add it
		if (firstSet.find(curElement->first) == firstSet.end())
			firstSet[curElement->first] = curElement->second;
		else // merge the element in
			firstSet[curElement->first] = IMergeElementData(firstSet[curElement->first], curElement->second, fileName, path + L"." + curElement->first);
	}

	return firstSet;
}

//// IMergeAgeData ///////////////////////////////////////////////////

LocalizationXMLFile::age LocalizationDatabase::IMergeAgeData(LocalizationXMLFile::age firstAge, LocalizationXMLFile::age secondAge, const std::wstring & fileName, const std::wstring & path)
{
	// Merge all the sets
	LocalizationXMLFile::age::iterator curSet;
	for (curSet = secondAge.begin(); curSet != secondAge.end(); curSet++)
	{
		// if the set doesn't exist in the current age, just add it
		if (firstAge.find(curSet->first) == firstAge.end())
			firstAge[curSet->first] = curSet->second;
		else // merge the data in
			firstAge[curSet->first] = IMergeSetData(firstAge[curSet->first], curSet->second, fileName, path + L"." + curSet->first);
	}

	return firstAge;
}

//// IMergeData() ////////////////////////////////////////////////////

void LocalizationDatabase::IMergeData()
{
	for (int i = 0; i < fFiles.size(); i++)
	{
		std::wstring wFilename;
		wchar_t *buff = hsStringToWString(fFiles[i].fFilename.c_str());
		wFilename = buff;
		delete [] buff;

		LocalizationXMLFile::ageMap fileData = fFiles[i].fData;
		LocalizationXMLFile::ageMap::iterator curAge;
		for (curAge = fileData.begin(); curAge != fileData.end(); curAge++)
		{
			// if the age doesn't exist in the current merged database, just add it with no more checking
			if (fData.find(curAge->first) == fData.end())
				fData[curAge->first] = curAge->second;
			else // otherwise, merge the data in
				fData[curAge->first] = IMergeAgeData(fData[curAge->first], curAge->second, wFilename, curAge->first);
		}
	}
}

//// IVerifyElement() ////////////////////////////////////////////////

void LocalizationDatabase::IVerifyElement(const std::wstring &ageName, const std::wstring &setName, LocalizationXMLFile::set::iterator& curElement)
{
	std::vector<std::wstring> languageNames;
	std::wstring defaultLanguage;

	int numLocales = plLocalization::GetNumLocales();
	for (int curLocale = 0; curLocale <= numLocales; curLocale++)
	{
		char *name = plLocalization::GetLanguageName((plLocalization::Language)curLocale);
		wchar_t *wName = hsStringToWString(name);
		languageNames.push_back(wName);
		delete [] wName;
	}
	defaultLanguage = languageNames[0];

	std::wstring elementName = curElement->first;
	LocalizationXMLFile::element& theElement = curElement->second;
	LocalizationXMLFile::element::iterator curTranslation;
	for (curTranslation = theElement.begin(); curTranslation != theElement.end(); curTranslation++)
	{
		// Make sure this language exists!
		bool languageExists = false;
		for (int i = 0; i < languageNames.size(); i++)
		{
			if (languageNames[i] == curTranslation->first)
			{
				languageExists = true;
				break;
			}
		}
		if (!languageExists)
		{
			fErrorString += L"ERROR: The language " + curTranslation->first + L" used by " + ageName + L"." + setName + L".";
			fErrorString += elementName + L" is not supported, discarding translation\n";
#if !HS_BUILD_FOR_MAC
			curTranslation = theElement.erase(curTranslation);
#else
			// jfim: I thought std::map::erase returned void?
			theElement.erase(curTranslation);
#endif
			curTranslation--; // because this will be incremented on the next run through the loop
			continue;
		}
	}

	LocalizationXMLFile::set& theSet = fData[ageName][setName];
	if (theElement.find(defaultLanguage) == theElement.end())
	{
		fErrorString += L"ERROR: Default language " + defaultLanguage + L" is missing from the translations in element ";
		fErrorString += ageName + L"." + setName + L"." + elementName + L", deleting element\n";
#if !HS_BUILD_FOR_MAC
		curElement = theSet.erase(curElement);
#else
		// jfim: I thought std::map::erase returned void?
		theSet.erase(curElement);
#endif
		curElement--;
		return;
	}
	for (int i = 1; i < languageNames.size(); i++)
	{
		if (theElement.find(languageNames[i]) == theElement.end())
		{
			fErrorString += L"WARNING: Language " + languageNames[i] + L" is missing from the translations in element ";
			fErrorString += ageName + L"." + setName + L"." + elementName + L", you'll want to get translations for that!\n";
		}
	}
}

//// IVerifySet() ////////////////////////////////////////////////////

void LocalizationDatabase::IVerifySet(const std::wstring &ageName, const std::wstring &setName)
{
	LocalizationXMLFile::set& theSet = fData[ageName][setName];
	LocalizationXMLFile::set::iterator curElement;
	for (curElement = theSet.begin(); curElement != theSet.end(); curElement++)
		IVerifyElement(ageName, setName, curElement);
}

//// IVerifyAge() ////////////////////////////////////////////////////

void LocalizationDatabase::IVerifyAge(const std::wstring &ageName)
{
	LocalizationXMLFile::age& theAge = fData[ageName];
	LocalizationXMLFile::age::iterator curSet;
	for (curSet = theAge.begin(); curSet != theAge.end(); curSet++)
		IVerifySet(ageName, curSet->first);
}

//// IVerifyData() ///////////////////////////////////////////////////

void LocalizationDatabase::IVerifyData()
{
	LocalizationXMLFile::ageMap::iterator curAge;
	for (curAge = fData.begin(); curAge != fData.end(); curAge++)
		IVerifyAge(curAge->first);
}

//// Parse() /////////////////////////////////////////////////////////

void LocalizationDatabase::Parse(const std::string & directory)
{
	fDirectory = directory;
	fFiles.clear();
	fErrorString = L"";

	char filename[255];
	hsFolderIterator xmlFolder((directory+PATH_SEPARATOR_STR).c_str());
	while(xmlFolder.NextFileSuffix(".loc"))
	{
		xmlFolder.GetPathAndName(filename);

		wchar_t *buff = hsStringToWString(filename);
		std::wstring wFilename = buff;
		delete [] buff;

		LocalizationXMLFile newFile;
		bool retVal = newFile.Parse(filename);
		if (!retVal)
			fErrorString += L"Errors in file " + wFilename + L":\n" + newFile.GetLastError() + L"\n";

		fFiles.push_back(newFile);

		fErrorString += L"File " + wFilename + L" parsed and added to database\n";
	}

	IMergeData();
	IVerifyData();

	return;
}

//////////////////////////////////////////////////////////////////////
//// pf3PartMap Functions ////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

//// ISplitString() //////////////////////////////////////////////////

template<class mapT>
void pfLocalizationDataMgr::pf3PartMap<mapT>::ISplitString(std::wstring key, std::wstring &age, std::wstring &set, std::wstring &name)
{
	std::wstring::size_type periodLoc = key.find(L".");
	age = key.substr(0, periodLoc);
	if (periodLoc >= key.length())
		return; // don't get set or name if there isn't any period

	key = key.substr(periodLoc + 1, key.length());
	periodLoc = key.find(L".");
	set = key.substr(0, periodLoc);
	if (periodLoc >= key.length())
		return; // don't get name if there isn't another period

	name = key.substr(periodLoc + 1, key.length());
}

//// exists() ////////////////////////////////////////////////////////

template<class mapT>
bool pfLocalizationDataMgr::pf3PartMap<mapT>::exists(const std::wstring & key)
{
	std::wstring age, set, name;
	ISplitString(key, age, set, name);
	if (age == L"" || set == L"" || name == L"") // if any are missing, it's invalid, so we don't have it
		return false;

	// now check individually
	if (fData.find(age) == fData.end()) // age doesn't exist
		return false;
	if (fData[age].find(set) == fData[age].end()) // set doesn't exist
		return false;
	if (fData[age][set].find(name) == fData[age][set].end()) // name doesn't exist
		return false;

	// we passed all the tests, return true!
	return true;
}

//// setExists() /////////////////////////////////////////////////////

template<class mapT>
bool pfLocalizationDataMgr::pf3PartMap<mapT>::setExists(const std::wstring & key)
{
	std::wstring age, set, name;
	ISplitString(key, age, set, name);
	if (age == L"" || set == L"") // if any are missing, it's invalid, so we don't have it (ignoring name)
		return false;

	// now check individually
	if (fData.find(age) == fData.end()) // age doesn't exist
		return false;
	if (fData[age].find(set) == fData[age].end()) // set doesn't exist
		return false;

	// we passed all the tests, return true!
	return true;
}

//// erase() /////////////////////////////////////////////////////////

template<class mapT>
void pfLocalizationDataMgr::pf3PartMap<mapT>::erase(const std::wstring & key)
{
	std::wstring age, set, name;
	ISplitString(key, age, set, name);
	if (age == L"" || set == L"" || name == L"") // if any are missing, it's invalid, so we don't delete it
		return;

	// now check individually
	if (fData.find(age) == fData.end()) // age doesn't exist
		return;
	if (fData[age].find(set) == fData[age].end()) // set doesn't exist
		return;
	if (fData[age][set].find(name) == fData[age][set].end()) // name doesn't exist
		return;

	// ok, so now we want to nuke it!
	fData[age][set].erase(name);
	if (fData[age][set].size() == 0) // is the set now empty?
		fData[age].erase(set); // nuke it!
	if (fData[age].size() == 0) // is the age now empty?
		fData.erase(age); // nuke it!
}

//// operator[]() ////////////////////////////////////////////////////

template<class mapT>
mapT &pfLocalizationDataMgr::pf3PartMap<mapT>::operator[](const std::wstring &key)
{
	std::wstring age, set, name;
	ISplitString(key, age, set, name);
	return fData[age][set][name];
}

//// getAgeList() ////////////////////////////////////////////////////

template<class mapT>
std::vector<std::wstring> pfLocalizationDataMgr::pf3PartMap<mapT>::getAgeList()
{
	std::vector<std::wstring> retVal;
	ThreePartMap::iterator curAge;

	for (curAge = fData.begin(); curAge != fData.end(); curAge++)
		retVal.push_back(curAge->first);

	return retVal;
}

//// getSetList() ////////////////////////////////////////////////////

template<class mapT>
std::vector<std::wstring> pfLocalizationDataMgr::pf3PartMap<mapT>::getSetList(const std::wstring & age)
{
	std::vector<std::wstring> retVal;
	std::map<std::wstring, std::map<std::wstring, mapT> >::iterator curSet;

	if (fData.find(age) == fData.end())
		return retVal; // return an empty list, the age doesn't exist

	for (curSet = fData[age].begin(); curSet != fData[age].end(); curSet++)
		retVal.push_back(curSet->first);

	return retVal;
}

//// getNameList() ///////////////////////////////////////////////////

template<class mapT>
std::vector<std::wstring> pfLocalizationDataMgr::pf3PartMap<mapT>::getNameList(const std::wstring & age, const std::wstring & set)
{
	std::vector<std::wstring> retVal;
	std::map<std::wstring, mapT>::iterator curName;

	if (fData.find(age) == fData.end())
		return retVal; // return an empty list, the age doesn't exist

	if (fData[age].find(set) == fData[age].end())
		return retVal; // return an empty list, the set doesn't exist

	for (curName = fData[age][set].begin(); curName != fData[age][set].end(); curName++)
		retVal.push_back(curName->first);

	return retVal;
}

//////////////////////////////////////////////////////////////////////
//// pfLocalizationDataMgr Functions /////////////////////////////////
//////////////////////////////////////////////////////////////////////

pfLocalizationDataMgr	*pfLocalizationDataMgr::fInstance = nil;
plStatusLog				*pfLocalizationDataMgr::fLog = nil;	// output logfile

//// Constructor/Destructor //////////////////////////////////////////

pfLocalizationDataMgr::pfLocalizationDataMgr(const std::string & path)
{
	hsAssert(!fInstance, "Tried to create the localization data manager more than once!");
	fInstance = this;

	fDataPath = path;

	fDatabase = nil;
}

pfLocalizationDataMgr::~pfLocalizationDataMgr()
{
	fInstance = nil;

	if (fDatabase)
	{
		delete fDatabase;
		fDatabase = nil;
	}
}

//// ICreateLocalizedElement /////////////////////////////////////////

pfLocalizationDataMgr::localizedElement pfLocalizationDataMgr::ICreateLocalizedElement()
{
	int numLocales = plLocalization::GetNumLocales();
	pfLocalizationDataMgr::localizedElement retVal;

	for (int curLocale = 0; curLocale <= numLocales; curLocale++)
	{
		char *name = plLocalization::GetLanguageName((plLocalization::Language)curLocale);
		wchar_t *wName = hsStringToWString(name);
		retVal[wName] = L"";
		delete [] wName;
	}

	return retVal;
}

//// IGetCurrentLanguageName /////////////////////////////////////////

std::wstring pfLocalizationDataMgr::IGetCurrentLanguageName()
{
	std::wstring retVal;
	char *name = plLocalization::GetLanguageName(plLocalization::GetLanguage());
	wchar_t *wName = hsStringToWString(name);
	retVal = wName;
	delete [] wName;
	return retVal;
}

//// IGetAllLanguageNames ////////////////////////////////////////////

std::vector<std::wstring> pfLocalizationDataMgr::IGetAllLanguageNames()
{
	int numLocales = plLocalization::GetNumLocales();
	std::vector<std::wstring> retVal;

	for (int curLocale = 0; curLocale <= numLocales; curLocale++)
	{
		char *name = plLocalization::GetLanguageName((plLocalization::Language)curLocale);
		wchar_t *wName = hsStringToWString(name);
		retVal.push_back(wName);
		delete [] wName;
	}

	return retVal;
}

//// IConvertSubtitle ////////////////////////////////////////////////

void pfLocalizationDataMgr::IConvertElement(LocElementInfo *elementInfo, const std::wstring & curPath)
{
	pfLocalizationDataMgr::localizedElement newElement;
	Int16 numArgs = -1;

	LocalizationXMLFile::element::iterator curTranslation;
	for (curTranslation = elementInfo->fElement.begin(); curTranslation != elementInfo->fElement.end(); curTranslation++)
	{
		newElement[curTranslation->first].FromXML(curTranslation->second);
		UInt16 argCount = newElement[curTranslation->first].GetArgumentCount();
		if (numArgs == -1) // just started
			numArgs = argCount;
		else if (argCount != numArgs)
		{
			std::wstring errorStr = L"WARNING: Argument number mismatch in element " + curPath;
			char* cErrorStr = hsWStringToString(errorStr.c_str());
			fLog->AddLine(cErrorStr);
			delete [] cErrorStr;
		}
	}

	fLocalizedElements[curPath] = newElement;
}

//// IConvertSet /////////////////////////////////////////////////////

void pfLocalizationDataMgr::IConvertSet(LocSetInfo *setInfo, const std::wstring & curPath)
{
	LocalizationXMLFile::set::iterator curElement;
	for (curElement = setInfo->fSet.begin(); curElement != setInfo->fSet.end(); curElement++)
	{
		LocElementInfo elementInfo;
		elementInfo.fElement = curElement->second;

		IConvertElement(&elementInfo, curPath + L"." + curElement->first);
	}
}

//// IConvertAge /////////////////////////////////////////////////////

void pfLocalizationDataMgr::IConvertAge(LocAgeInfo *ageInfo, const std::wstring & curPath)
{
	LocalizationXMLFile::age::iterator curSet;
	for (curSet = ageInfo->fAge.begin(); curSet != ageInfo->fAge.end(); curSet++)
	{
		LocSetInfo setInfo;
		setInfo.fSet = curSet->second;

		IConvertSet(&setInfo, curPath + L"." + curSet->first);
	}
}

//// IConvertToByteStream ////////////////////////////////////////////

char *pfLocalizationDataMgr::IConvertToByteStream(const std::wstring & data, UInt32 &len)
{
	len = data.length() * 2 + 2; // each wchar_t is two chars and add two bytes for the header
	char *retVal = TRACKED_NEW char[len]; // we don't add an extra byte for the 0 because the parser doesn't need it
	char lowbyte = 0, highbyte = 0;
	retVal[0] = (char)0xFF; // insert FFFE for little-endian UTF-16 (big-endian would be FEFF)
	retVal[1] = (char)0xFE;
	int curByteStreamPos = 2;
	for (int curLoc = 0; curLoc < data.length(); curLoc++)
	{
		wchar_t curChar = data[curLoc];
		lowbyte = (char)(curChar & 0x00FF);
		highbyte = (char)((curChar & 0xFF00) >> 8);

		// since the data is AABBCCDD, we need to put in in our byte stream as BBAADDCC
		// (so it kinda looks backward because we're storing this as little-endian)
		retVal[curByteStreamPos + 1] = highbyte;
		retVal[curByteStreamPos] = lowbyte;
		curByteStreamPos += 2;
	}
	return retVal;
}

//// IWriteText //////////////////////////////////////////////////////

void pfLocalizationDataMgr::IWriteText(const std::string & filename, const std::wstring & ageName, const std::wstring & languageName)
{
	bool weWroteData = false; // did we actually write any data of consequence?
	bool setEmpty = true;

	// we will try to pretty print it all so it's easy to read for the devs
	std::wstring fileData = L"<?xml version=\"1.0\" encoding=\"utf-16\"?>\n"; // stores the xml we are going to write to the file (UTF-16 format)
	fileData += L"<localizations>\n";
	fileData += L"\t<age name=\"" + ageName + L"\">\n";

	std::vector<std::wstring> setNames = GetSetList(ageName);
	for (int curSet = 0; curSet < setNames.size(); curSet++)
	{
		setEmpty = true; // so far, this set is empty
		std::wstring setCode = L"";
		setCode += L"\t\t<set name=\"" + setNames[curSet] + L"\">\n";

		std::vector<std::wstring> elementNames = GetElementList(ageName, setNames[curSet]);
		for (int curElement = 0; curElement < elementNames.size(); curElement++)
		{
			setCode += L"\t\t\t<element name=\"" + elementNames[curElement] + L"\">\n";
			std::wstring key = ageName + L"." + setNames[curSet] + L"." + elementNames[curElement];

			if (fLocalizedElements[key].find(languageName) != fLocalizedElements[key].end())
			{
				std::wstring key = ageName + L"." + setNames[curSet] + L"." + elementNames[curElement];
				weWroteData = true;
				setEmpty = false;
				setCode += L"\t\t\t\t<translation language=\"" + languageName + L"\">";
				setCode += fLocalizedElements[key][languageName].ToXML();
				setCode += L"</translation>\n";
			}

			setCode += L"\t\t\t</element>\n";
		}

		setCode += L"\t\t</set>\n";

		if (!setEmpty)
			fileData += setCode;
	}

	fileData += L"\t</age>\n";
	fileData += L"</localizations>\n";

	if (weWroteData)
	{
		// now spit the results out to the file
		UInt32 numBytes;
		char *byteStream = IConvertToByteStream(fileData, numBytes);
		hsStream *xmlStream = plEncryptedStream::OpenEncryptedFileWrite(filename.c_str());
		xmlStream->Write(numBytes, byteStream);
		xmlStream->Close();
		delete xmlStream;
		delete [] byteStream;
	}
}

//// Initialize //////////////////////////////////////////////////////

void pfLocalizationDataMgr::Initialize(const std::string & path)
{
	if (fInstance)
		return;

	fInstance = TRACKED_NEW pfLocalizationDataMgr(path);
	fLog = plStatusLogMgr::GetInstance().CreateStatusLog(30, "LocalizationDataMgr.log",
		plStatusLog::kFilledBackground | plStatusLog::kAlignToTop | plStatusLog::kTimestamp);
	fInstance->SetupData();
}

//// Shutdown ////////////////////////////////////////////////////////

void pfLocalizationDataMgr::Shutdown()
{
	if ( fLog != nil )
	{
		delete fLog;
		fLog = nil;
	}

	if (fInstance)
	{
		delete fInstance;
		fInstance = nil;
	}
}

//// SetupData ///////////////////////////////////////////////////////

void pfLocalizationDataMgr::SetupData()
{
	if (fDatabase)
		delete fDatabase;

	fDatabase = TRACKED_NEW LocalizationDatabase();
	fDatabase->Parse(fDataPath);

	char *temp = hsWStringToString(fDatabase->GetOutput().c_str());
	fLog->AddLine(temp);
	delete [] temp;

	fLog->AddLine("File reading complete, converting to native data format");

	// and now we read all the data out of the database and convert it to our native formats

	// transfer subtitle data
	LocalizationXMLFile::ageMap data = fDatabase->GetData();
	LocalizationXMLFile::ageMap::iterator curAge;
	for (curAge = data.begin(); curAge != data.end(); curAge++)
	{
		LocAgeInfo ageInfo;
		ageInfo.fAge = curAge->second;

		IConvertAge(&ageInfo, curAge->first);
	}

	OutputTreeToLog();
}

//// GetElement //////////////////////////////////////////////////////

pfLocalizedString pfLocalizationDataMgr::GetElement(const std::wstring & name)
{
	pfLocalizedString retVal; // if this returns before we initialize it, it will be empty, indicating failure

	if (!fLocalizedElements.exists(name)) // does the requested element exist?
		return retVal; // nope, so return failure

	std::wstring languageName = IGetCurrentLanguageName();
	if (fLocalizedElements[name].find(languageName) == fLocalizedElements[name].end()) // current language isn't specified
	{
		languageName = L"English"; // force to english
		if (fLocalizedElements[name].find(languageName) == fLocalizedElements[name].end()) // make sure english exists
			return retVal; // language doesn't exist
	}
	retVal = fLocalizedElements[name][languageName];
	return retVal;
}

//// GetSpecificElement //////////////////////////////////////////////

pfLocalizedString pfLocalizationDataMgr::GetSpecificElement(const std::wstring & name, const std::wstring & language)
{
	pfLocalizedString retVal; // if this returns before we initialize it, it will have an ID of 0, indicating failure

	if (!fLocalizedElements.exists(name)) // does the requested subtitle exist?
		return retVal; // nope, so return failure

	if (fLocalizedElements[name].find(language) == fLocalizedElements[name].end())
		return retVal; // language doesn't exist

	retVal = fLocalizedElements[name][language];
	return retVal;
}

//// GetAgeList //////////////////////////////////////////////////////

std::vector<std::wstring> pfLocalizationDataMgr::GetAgeList()
{
	return fLocalizedElements.getAgeList();
}

//// GetSetList //////////////////////////////////////////////////////

std::vector<std::wstring> pfLocalizationDataMgr::GetSetList(const std::wstring & ageName)
{
	return fLocalizedElements.getSetList(ageName);
}

//// GetElementList //////////////////////////////////////////////////

std::vector<std::wstring> pfLocalizationDataMgr::GetElementList(const std::wstring & ageName, const std::wstring & setName)
{
	return fLocalizedElements.getNameList(ageName, setName);
}

//// GetLanguages ////////////////////////////////////////////////////

std::vector<std::wstring> pfLocalizationDataMgr::GetLanguages(const std::wstring & ageName, const std::wstring & setName, const std::wstring & elementName)
{
	std::vector<std::wstring> retVal;
	std::wstring key = ageName + L"." + setName + L"." + elementName;
	if (fLocalizedElements.exists(key))
	{
		// age, set, and element exists
		localizedElement elem = fLocalizedElements[key];
		localizedElement::iterator curLanguage;
		for (curLanguage = elem.begin(); curLanguage != elem.end(); curLanguage++)
		{
			std::wstring language = curLanguage->first;
			if (language != L"") // somehow blank language names sneak in... so don't return them
				retVal.push_back(curLanguage->first);
		}
	}
	return retVal;
}

//// GetElementXMLData ///////////////////////////////////////////////

std::wstring pfLocalizationDataMgr::GetElementXMLData(const std::wstring & name, const std::wstring & languageName)
{
	std::wstring retVal = L"";
	if (fLocalizedElements.exists(name))
	{
		if (fLocalizedElements[name].find(languageName) != fLocalizedElements[name].end())
			retVal = fLocalizedElements[name][languageName].ToXML();
	}
	return retVal;
}

//// GetElementPlainTextData /////////////////////////////////////////

std::wstring pfLocalizationDataMgr::GetElementPlainTextData(const std::wstring & name, const std::wstring & languageName)
{
	std::wstring retVal = L"";
	if (fLocalizedElements.exists(name))
	{
		if (fLocalizedElements[name].find(languageName) != fLocalizedElements[name].end())
			retVal = (std::wstring)fLocalizedElements[name][languageName];
	}
	return retVal;
}

//// SetElementXMLData ///////////////////////////////////////////////

bool pfLocalizationDataMgr::SetElementXMLData(const std::wstring & name, const std::wstring & languageName, const std::wstring & xmlData)
{
	if (!fLocalizedElements.exists(name))
		return false; // doesn't exist

	fLocalizedElements[name][languageName].FromXML(xmlData);
	return true;
}

//// SetElementPlainTextData /////////////////////////////////////////

bool pfLocalizationDataMgr::SetElementPlainTextData(const std::wstring & name, const std::wstring & languageName, const std::wstring & plainText)
{
	if (!fLocalizedElements.exists(name))
		return false; // doesn't exist

	fLocalizedElements[name][languageName] = plainText;
	return true;
}

//// AddLocalization /////////////////////////////////////////////////

bool pfLocalizationDataMgr::AddLocalization(const std::wstring & name, const std::wstring & newLanguage)
{
	if (!fLocalizedElements.exists(name))
		return false; // doesn't exist

	// copy the english over so it can be localized
	fLocalizedElements[name][newLanguage] = fLocalizedElements[name][L"English"];
	return true;
}

//// AddElement //////////////////////////////////////////////////////

bool pfLocalizationDataMgr::AddElement(const std::wstring & name)
{
	if (fLocalizedElements.exists(name))
		return false; // already exists

	pfLocalizedString newElement;
	fLocalizedElements[name][L"English"] = newElement;
	return true;
}

//// DeleteLocalization //////////////////////////////////////////////

bool pfLocalizationDataMgr::DeleteLocalization(const std::wstring & name, const std::wstring & languageName)
{
	if (!fLocalizedElements.exists(name))
		return false; // doesn't exist

	if (fLocalizedElements[name].find(languageName) == fLocalizedElements[name].end())
		return false; // doesn't exist

	fLocalizedElements[name].erase(languageName);
	return true;
}

//// DeleteElement ///////////////////////////////////////////////////

bool pfLocalizationDataMgr::DeleteElement(const std::wstring & name)
{
	if (!fLocalizedElements.exists(name))
		return false; // doesn't exist

	// delete it!
	fLocalizedElements.erase(name);
	return true;
}

//// WriteDatabaseToDisk /////////////////////////////////////////////

void pfLocalizationDataMgr::WriteDatabaseToDisk(const std::string & path)
{
	// first, write the styles and panel settings to styles.sub
	std::vector<std::wstring> ageNames = GetAgeList();
	std::vector<std::wstring> languageNames = IGetAllLanguageNames();
	for (int curAge = 0; curAge < ageNames.size(); curAge++)
	{
		for (int curLanguage = 0; curLanguage < languageNames.size(); curLanguage++)
		{
			std::string cAgeName, cLanguageName;
			char *temp = hsWStringToString(ageNames[curAge].c_str());
			cAgeName = temp;
			delete [] temp;
			temp = hsWStringToString(languageNames[curLanguage].c_str());
			cLanguageName = temp;
			delete [] temp;

			IWriteText(path + "/" + cAgeName + cLanguageName + ".loc", ageNames[curAge], languageNames[curLanguage]);
		}
	}
}

//// OutputTreeToLog /////////////////////////////////////////////////

void pfLocalizationDataMgr::OutputTreeToLog()
{
	std::vector<std::wstring> ages = GetAgeList();

	fLog->AddLine("\n");
	fLog->AddLine("Localization tree:\n");

	for (int i = 0; i < ages.size(); i++)
	{
		char *ageName = hsWStringToString(ages[i].c_str());
		std::string temp = ageName;
		delete [] ageName;

		temp = "\t" + temp + "\n";
		fLog->AddLine(temp.c_str());

		std::vector<std::wstring> sets = GetSetList(ages[i]);

		for (int j = 0; j < sets.size(); j++)
		{
			char *setName = hsWStringToString(sets[j].c_str());
			std::string temp = setName;
			delete [] setName;

			temp = "\t\t" + temp + "\n";
			fLog->AddLine(temp.c_str());

			std::vector<std::wstring> names = GetElementList(ages[i], sets[j]);

			for (int k = 0; k < names.size(); k++)
			{
				char *elemName = hsWStringToString(names[k].c_str());
				std::string temp = elemName;
				delete [] elemName;

				temp = "\t\t\t" + temp + "\n";
				fLog->AddLine(temp.c_str());
			}
		}
	}
}