/*-------------------------------------------------------------------------
 *
 * lemmatizer.cpp
 *
 *         Лицензия: BSD.
 *         Copyright (c) 2005 Andrei V. Shetuhin
 *
 *         Главный модуль.
 *
 *
 *-------------------------------------------------------------------------
 */

// Local Includes
#include "LemClient.hpp"
#include "../common/utilit.h"
#include "../AgramtabLib/RusGramTab.h"
#include "../AgramtabLib/EngGramTab.h"
#include "../AgramtabLib/GerGramTab.h"
#include "../LemmatizerLib/Lemmatizers.h"
#include "../LemmatizerLib/Paradigm.h"

// C++ Includes
#include <stdexcept>

namespace lem
{

// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Класс Lemmatizer
//

//
// Конструктор
//
Lemmatizer::Lemmatizer(const std::string &sRML, const int iLang)
{
	for(size_t iI = 0; iI < C_LANG_COUNT; iI++) { aLemmatizers[iI] = NULL; aAGramtabs[iI] = NULL; }

	if (iLang & C_RUS_GRAM_TAB) { aLemmatizers[0] = new CLemmatizerRussian(); aAGramtabs[0] = new CRusGramTab(); }
	if (iLang & C_ENG_GRAM_TAB) { aLemmatizers[1] = new CLemmatizerEnglish(); aAGramtabs[1] = new CEngGramTab(); }
	if (iLang & C_GER_GRAM_TAB) { aLemmatizers[2] = new CLemmatizerGerman();  aAGramtabs[2] = new CGerGramTab(); }

	for(size_t iI = 0; iI < C_LANG_COUNT; iI++)
	{
		if (aLemmatizers[iI] != NULL && aAGramtabs[iI] != NULL)
		{
			if (!aLemmatizers[iI] -> LoadDictionariesRegistry()) { Fatal("Cannot load morphological dictionary"); }
			if (!aAGramtabs[iI]   -> LoadFromRegistry())         { Fatal("Cannot load gramtab."); }
		}
	}
}

//
// Лемматизация всего слова
//
std::vector<LemmResult> Lemmatizer::Lemmatize(const std::string &sIWord, bool bOnlyVocabulary)
{
	using std::string;
	using std::vector;

	string sWord(sIWord);
	vector<LemmResult> vLemmResult;

	size_t iLangNum = 0;
	bool bBreakFlag = false;
	while(iLangNum < C_LANG_COUNT && !bBreakFlag)
	{
		// Русский язык
		if (iLangNum == 0)
		{
			std::string::const_iterator itChar = sWord.begin();
			bool bFlag = false;
			while(itChar != sWord.end())
			{
				if (!((*itChar >= 'А' && *itChar <= 'Я') || (*itChar >= 'а' && *itChar <= 'я'))) { bFlag = true; break; }
				itChar++;
			}

			if (bFlag) { iLangNum++; continue; }
		}
		// Английский / немецкий
		else
		{
			std::string::const_iterator itChar = sWord.begin();
			bool bFlag = false;
			while(itChar != sWord.end())
			{
				if (!((*itChar >= 'a' && *itChar <= 'z') || (*itChar >= 'A' && *itChar <= 'Z'))) {bFlag = true; break; }
				itChar++;
			}

			if (bFlag) { iLangNum++; continue; }
		}

		if (aLemmatizers[iLangNum] != NULL && aAGramtabs[iLangNum] != NULL)
		{
			vector<CFormInfo> vParadigms;
			aLemmatizers[iLangNum] -> CreateParadigmCollection(bOnlyVocabulary, sWord, false, vParadigms);
			// Что-то нашлося.
			if (vParadigms.size())
			{
				vector<CFormInfo>::iterator itvParadigms = vParadigms.begin();
				while (itvParadigms != vParadigms.end())
				{
					LemmResult oLemmResult;
					// Первая форма
					oLemmResult.first_form         = itvParadigms -> GetWordForm(0);
					// Язык
					oLemmResult.lang               = iLangNum;

					// Описание текущей формы
					string sSrcAncode = itvParadigms -> GetSrcAncode();
					if (sSrcAncode.length())
					{
						// Часть речи
						oLemmResult.part_of_speech     = aAGramtabs[iLangNum] -> GetPartOfSpeech(sSrcAncode.c_str());
						oLemmResult.part_of_speech_str = aAGramtabs[iLangNum] -> GetPartOfSpeechStr(oLemmResult.part_of_speech);

						QWORD G;
						aAGramtabs[iLangNum] -> GetGrammems(sSrcAncode.c_str(), G);
						string sGrammem = aAGramtabs[iLangNum] -> GrammemsToStr (G);
						if (sGrammem.length() && (sGrammem[sGrammem.length() -1] == ',')) { sGrammem.erase(sGrammem.length() - 1); }
						oLemmResult.src_ancode = sGrammem;
					}
					else { oLemmResult.part_of_speech = -1; }

					// Описание форм
					string sCommonAncode = itvParadigms -> GetCommonAncode();
					for (size_t iI = 0; iI < sCommonAncode.length(); iI += 2)
					{
						QWORD G;
						aAGramtabs[iLangNum] -> GetGrammems(sCommonAncode.c_str() + iI, G);
						string sGrammem = aAGramtabs[iLangNum] -> GrammemsToStr (G);
						if (sGrammem.length() && (sGrammem[sGrammem.length() -1] == ',')) { sGrammem.erase(sGrammem.length() - 1); }
						oLemmResult.all_ancodes.push_back(sGrammem);
					}

					// Словарное слово?
					if (itvParadigms -> m_bFound) { oLemmResult.vocabulary = true; bBreakFlag = true; }
					else                          { oLemmResult.vocabulary = false; }

					// Словоформы; первая форма - в начале.
					for (size_t iI = 0; iI < itvParadigms -> GetCount(); iI++) { oLemmResult.all_words.push_back(itvParadigms -> GetWordForm(iI)); }

					vLemmResult.push_back(oLemmResult);
					itvParadigms++;
				}
			}
		}
		iLangNum++;
	}

return vLemmResult;
}


//
// Деструктор
//
Lemmatizer::~Lemmatizer() throw()
{
	try
	{
		for(size_t iI = 0; iI < C_LANG_COUNT; iI++)
		{
			if (aLemmatizers[iI] != NULL) { delete aLemmatizers[iI]; }
			if (aAGramtabs[iI]   != NULL) { delete aAGramtabs[iI];   }
		}
	}
	catch(...) { ;; }
}

//
// Падаем
//
void Lemmatizer::Fatal(const std::string &sError)
{
	for(size_t iI = 0; iI < C_LANG_COUNT; iI++)
	{
		if (aLemmatizers[iI] != NULL) { delete aLemmatizers[iI]; }
		if (aAGramtabs[iI]   != NULL) { delete aAGramtabs[iI];   }
	}
	throw std::logic_error(sError.c_str());
}

} // namespace lem
// End.