/*
 * This file is a part of Winix
 * and is not publicly distributed
 * 
 * Copyright (c) 2010, Tomasz Sowa
 * All rights reserved.
 * 
 */
 
#include "locale.h"
#include "core/log.h"


Locale::Locale()
{
	loc_tab.resize(lang_unknown);
	default_lang = lang_en;
	current_lang = lang_en;
	input_as_utf8 = false;
}



void Locale::AddLocale(Lang lang)
{
	ConfParser::TableSingle::iterator i = loc_parser.table_single.begin();

	for( ; i != loc_parser.table_single.end() ; ++i)
		loc_tab[lang][i->first] = i->second;
}



void Locale::ReadFile(const char * dir, const char * dir_def, Lang lang, const char * file)
{
	if( static_cast<size_t>(lang) >= loc_tab.size() )
	{
		// ops, something wrong
		return;
	}

	loc_tab[lang].clear();
	bool read = false;

	if( dir_def && ReadFile(dir_def, lang, file) )
		read = true;

	if( dir && ReadFile(dir, lang, file) )
		read = true;

	if( !read )
		log << log1 <<  "Locale: can't open locale's file: " << file << logend;
}


bool Locale::ReadFile(const char * dir, Lang lang, const char * file)
{
bool read = false;

	file_name = dir;
	file_name += '/';
	file_name += file;

	loc_parser.SplitSingle(true);
	loc_parser.UTF8(input_as_utf8);

	if( loc_parser.Parse(file_name) == ConfParser::ok )
	{
		read = true;
		AddLocale(lang);
		log << log3 << "Locale: read locale from: " << file_name << logend;
	}

return read;
}


void Locale::ReadSubstTable(const char * dir, const char * dir_def)
{
bool read = false;

	subst_original.clear();
	subst_changeto.clear();

	if( dir_def && ReadSubstTable(dir_def) )
		read = true;

	if( dir && ReadSubstTable(dir) )
		read = true;

	if( !read )
		log << log1 <<  "Locale: can't open file for characters substitution" << logend;
}


bool Locale::ReadSubstTable(const char * dir)
{
bool read = false;

	file_name = dir;
	file_name += '/';
	file_name += "substitute";

	loc_parser.SplitSingle(true);
	loc_parser.UTF8(input_as_utf8);

	if( loc_parser.Parse(file_name) == ConfParser::ok )
	{
		read = true;
		subst_original = loc_parser.table_single[L"original"];
		subst_changeto = loc_parser.table_single[L"changeto"];
		log << log3 << "Locale: read characters substitution tables from: " << file_name << logend;
	}

return read;
}



void Locale::Read(const char * dir, const char * dir_def)
{
	ReadFile(dir, dir_def, lang_pl, "pl");
	ReadFile(dir, dir_def, lang_en, "en");

	ReadSubstTable(dir, dir_def);

	if( subst_original.size() != subst_changeto.size() )
		log << log1 << "Locale: substitution tables have different sizes" << logend;
}


void Locale::Read(const std::string & dir, const std::string & dir_def)
{
	if( dir_def.empty() )
		Read(dir.c_str());
	else
		Read(dir.c_str(), dir_def.c_str());
}


void Locale::Read(const wchar_t * dir, const wchar_t * dir_def)
{
	AssignString(dir, adir1);

	if( !dir_def )
	{
		Read(adir1.c_str());
	}
	else
	{
		AssignString(dir_def, adir2);
		Read(adir1.c_str(), adir2.c_str());
	}
}


void Locale::Read(const std::wstring & dir, const std::wstring & dir_def)
{
	Read(dir.c_str(), dir_def.c_str());
}


void Locale::SetLang(Lang lang)
{
	current_lang = lang;
}


Locale::Lang Locale::GetLang()
{
	return current_lang;
}



void Locale::SetLangDef(Lang lang)
{
	default_lang = lang_en;
}


bool Locale::IsKey(const std::wstring & key) const
{
	return IsKey(key, current_lang);
}


bool Locale::IsKey(const std::wstring & key, Lang lang) const
{
	if( static_cast<size_t>(lang) >= loc_tab.size() )
	{
		// ops, something wrong
		return false;
	}
	
	// looking in the lang language
	ConfParser::TableSingle::const_iterator i = loc_tab[lang].find(key);

	if( i != loc_tab[lang].end() )
		return true;

	if( lang == default_lang )
		return false;


	if( static_cast<size_t>(default_lang) >= loc_tab.size() )
	{
		// ops, something wrong
		return false;
	}

	// looking in a default language
	i = loc_tab[default_lang].find(key);

	if( i != loc_tab[default_lang].end() )
		return true;

	// there is no such a key 
	return false;
}


const std::wstring & Locale::Get(const std::wstring & key) const
{
	return Get(key, current_lang);
}



const std::wstring & Locale::Get(const std::wstring & key, Lang lang) const
{
	if( static_cast<size_t>(lang) >= loc_tab.size() )
	{
		// ops, something wrong
		return empty;
	}
	
	// looking in the lang language
	ConfParser::TableSingle::const_iterator i = loc_tab[lang].find(key);

	if( i != loc_tab[lang].end() )
		return i->second;

	if( lang == default_lang )
		return empty;


	if( static_cast<size_t>(default_lang) >= loc_tab.size() )
	{
		// ops, something wrong
		return empty;
	}

	// looking in a default language
	i = loc_tab[default_lang].find(key);

	if( i != loc_tab[default_lang].end() )
		return i->second;

	// there is no such a key 
	return empty;
}


Locale::Lang Locale::StrToLang(const std::wstring & str)
{
	if( str == L"en" )
		return lang_en;
	else
	if( str == L"pl" )
		return lang_pl;

return lang_unknown;
}



const wchar_t * Locale::LangToStr(Lang lang)
{
static wchar_t buffer[30];
size_t buffer_len = sizeof(buffer) / sizeof(wchar_t);

	switch(lang)
	{
	case lang_en:
		swprintf(buffer, buffer_len, L"en");
		break;

	case lang_pl:
		swprintf(buffer, buffer_len, L"pl");
		break;
	
	default:
		swprintf(buffer, buffer_len, L"unknown");
	}


return buffer;
}



size_t Locale::Size()
{
	return loc_tab.size();
}


void Locale::UTF8(bool utf)
{
	input_as_utf8 = utf;
}


wchar_t Locale::Subst(wchar_t c)
{
size_t i = subst_original.find(c);

	if( i == std::wstring::npos || i >= subst_changeto.size() )
		return c;

return subst_changeto[i];
}



void Locale::Subst(std::wstring & str)
{
	for(size_t i=0 ; i<str.size() ; ++i)
		str[i] = Subst(str[i]);
}