/*
 *	subtitle editor
 *
 *	http://kitone.free.fr/subtitleeditor/
 *
 *	Copyright @ 2005-2006, kitone
 *
 *	Contact: kitone at free dot fr
 *
 *	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 2 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, write to the Free Software
 *	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA	02111-1307	USA
 *
 *	See gpl.txt for more information regarding the GNU General Public License.
 *
 *
 *	\file
 *	\brief 
 *	\author kitone (kitone at free dot fr)
 */

#include "Config.h"
#include <iostream>
#include <fstream>
#include <glibmm.h>
#include "utility.h"


/*
 *
 */
Config& Config::getInstance()
{
	static Config cfg;
	return cfg;
}
/*
 *
 */
Config::Config()
{
	se_debug(SE_DEBUG_APP);

	loadCfg();
}

/*
 *
 */
Config::~Config()
{
	se_debug(SE_DEBUG_APP);

	saveCfg();
}

/*
 *
 */
bool Config::loadCfg()
{
	se_debug_message(SE_DEBUG_APP, "load config...");

	GError *error = NULL;
	m_keyFile = NULL;

	m_keyFile = g_key_file_new();

	Glib::ustring filename = Glib::build_filename(Glib::get_home_dir(), ".subtitleeditor/config");

	if(!g_key_file_load_from_file(m_keyFile, filename.c_str(), G_KEY_FILE_KEEP_COMMENTS, &error))
	{
		se_debug_message(SE_DEBUG_APP, "open <%s> failed : %s", filename.c_str(), error->message);

		std::cerr << "Config::Config > " << error->message << std::endl;
		g_error_free(error);
		return false;
	}

	return true;
}

/*
 *
 */
bool Config::saveCfg()
{
	se_debug_message(SE_DEBUG_APP, "save config...");

	GError *error = NULL;
	gsize size = 0;

	gchar *data = g_key_file_to_data(m_keyFile, &size, &error);
	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "save config failed : %s", error->message);

		std::cerr << "Config::~Config > " << error->message << std::endl;
		g_error_free(error);
		return false;
	}
	else
	{
		Glib::ustring filename = Glib::build_filename(Glib::get_home_dir(), ".subtitleeditor/config");

		std::ofstream file(filename.c_str());
		if(file)
		{
			file << data ;
			file.close();
		}
		g_free(data);
	}

	g_key_file_free(m_keyFile);

	return true;
}

/*
 *
 */
bool Config::set_comment(const Glib::ustring &group, const Glib::ustring &key, const Glib::ustring &comment)
{
	g_return_val_if_fail(m_keyFile, false);

	se_debug_message(SE_DEBUG_APP, "[%s] %s=%s", group.c_str(), key.c_str(), comment.c_str());
	/*
	g_key_file_set_comment(m_keyFile, group.c_str(), key.c_str(), comment.c_str(), NULL);
	*/
	return true;
}

/*
 *
 */
bool Config::has_group(const Glib::ustring &group)
{
	g_return_val_if_fail(m_keyFile, false);

	se_debug_message(SE_DEBUG_APP, "[%s]", group.c_str());

	bool value = (bool)g_key_file_has_group(m_keyFile, group.c_str());
	return value;

}

bool Config::has_key(const Glib::ustring &group, const Glib::ustring &key)
{
	g_return_val_if_fail(m_keyFile, false);

	se_debug_message(SE_DEBUG_APP, "[%s] %s", group.c_str(), key.c_str());

	GError *error = NULL;
	bool value = (bool)g_key_file_has_key(m_keyFile, group.c_str(), key.c_str(), &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "has not key [%s] %s : %s", group.c_str(), key.c_str(), error->message);
		
		g_error_free(error);
		return false;
	}
	return value;

}

bool Config::get_keys(const Glib::ustring &group, std::list<Glib::ustring> &list)
{
	g_return_val_if_fail(m_keyFile, false);

	
	GError *error = NULL;

	gsize size = 0;

	gchar** value = g_key_file_get_keys(m_keyFile, group.c_str(), &size, &error);
	
	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "[%s] failed : %s", group.c_str(), error->message);
	
		g_error_free(error);
		return false;
	}

	for(unsigned int i=0; i<size; ++i)
	{
		list.push_back(Glib::ustring(value[i]));
	}

	g_strfreev(value);

	se_debug_message(SE_DEBUG_APP, "[%s]", group.c_str());

	return true;
}


/*
 *
 */
bool Config::set_value_bool(const Glib::ustring &group, const Glib::ustring &key, const bool &value)
{
	g_return_val_if_fail(m_keyFile, false);

	se_debug_message(SE_DEBUG_APP, "[%s] %s=%i", group.c_str(), key.c_str(), value);

	g_key_file_set_boolean(m_keyFile, group.c_str(), key.c_str(), (gboolean)value);
	return true;
}

/*
 *
 */
bool Config::get_value_bool(const Glib::ustring &group, const Glib::ustring &key, bool &value)
{
	g_return_val_if_fail(m_keyFile, false);

	GError *error = NULL;
	value = g_key_file_get_boolean(m_keyFile, group.c_str(), key.c_str(), &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "[%s] %s failed : %s", group.c_str(), key.c_str(), error->message);
		g_error_free(error);
		return false;
	}
	
	se_debug_message(SE_DEBUG_APP, "[%s] %s=%i", group.c_str(), key.c_str(), value);

	return true;
}


/*
 *
 */
bool Config::set_value_int(const Glib::ustring &group, const Glib::ustring &key, const int &value)
{
	g_return_val_if_fail(m_keyFile, false);

	se_debug_message(SE_DEBUG_APP, "[%s] %s=%i", group.c_str(), key.c_str(), value);

	g_key_file_set_integer(m_keyFile, group.c_str(), key.c_str(), value);
	return true;
}

/*
 *
 */
bool Config::get_value_int(const Glib::ustring &group, const Glib::ustring &key, int &value)
{
	g_return_val_if_fail(m_keyFile, false);

	GError *error = NULL;
	
	value = g_key_file_get_integer(m_keyFile, group.c_str(), key.c_str(), &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "[%s] %s failed : %s", group.c_str(), key.c_str(), error->message);

		g_error_free(error);
		return false;
	}

	se_debug_message(SE_DEBUG_APP, "[%s] %s=%i", group.c_str(), key.c_str(), value);
	
	return true;
}

/*
 *
 */
bool Config::set_value_string(const Glib::ustring &group, const Glib::ustring &key, const Glib::ustring &value)
{
	g_return_val_if_fail(m_keyFile, false);

	se_debug_message(SE_DEBUG_APP, "[%s] %s=%s", group.c_str(), key.c_str(), value.c_str());

	g_key_file_set_string(m_keyFile, group.c_str(), key.c_str(), value.c_str());
	return true;
}

/*
 *
 */
bool Config::get_value_string(const Glib::ustring &group, const Glib::ustring &key, Glib::ustring &str)
{
	g_return_val_if_fail(m_keyFile, false);

	GError *error = NULL;
	gchar* value = g_key_file_get_string(m_keyFile, group.c_str(), key.c_str(), &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "[%s] %s failed : %s", group.c_str(), key.c_str(), error->message);
		g_error_free(error);
		return false;
	}
		
	str = value;
		
	g_free(value);
		
	se_debug_message(SE_DEBUG_APP, "[%s] %s=%s", group.c_str(), key.c_str(), str.c_str());

	return true;
}

bool Config::get_value_string_list(const Glib::ustring &group, const Glib::ustring &key, std::list<Glib::ustring> &list)
{
	g_return_val_if_fail(m_keyFile, false);

	GError *error = NULL;

	gsize size;

	gchar** value = g_key_file_get_string_list(m_keyFile, group.c_str(), key.c_str(), &size, &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "[%s] %s failed : %s", group.c_str(), key.c_str(), error->message);
		g_error_free(error);
		return false;
	}
	
	for(unsigned int i=0; i<size; ++i)
	{
		list.push_back(Glib::ustring(value[i]));
	}
	
	g_strfreev(value);
		
	return true;
}

bool Config::set_value_string_list(const Glib::ustring &group, const Glib::ustring &key, const std::list<Glib::ustring> &list)
{
	g_return_val_if_fail(m_keyFile, false);

	Glib::ustring text;
	std::list<Glib::ustring>::const_iterator it;
	for(it=list.begin(); it!=list.end(); ++it)
	{
		text+=*it;
		text+=";";
	}

	se_debug_message(SE_DEBUG_APP, "[%s] %s=%s", group.c_str(), key.c_str(), text.c_str());

	return set_value_string(group,key,text);
}



/*
 *
 */
bool Config::remove_group(const Glib::ustring &group)
{
	g_return_val_if_fail(m_keyFile, false);

	GError *error = NULL;
	
	g_key_file_remove_group(m_keyFile, group.c_str(), &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "[%s] failed : %s", group.c_str(), error->message);
		g_error_free(error);
		return false;
	}
	se_debug_message(SE_DEBUG_APP, "remove group [%s]", group.c_str());
	return true;
}

/*
 *
 */
bool Config::remove_key(const Glib::ustring &group, const Glib::ustring &key)
{
	g_return_val_if_fail(m_keyFile, false);

	GError *error = NULL;
	
	g_key_file_remove_key(m_keyFile, group.c_str(), key.c_str(), &error);

	if(error)
	{
		se_debug_message(SE_DEBUG_APP, "remove [%s] %s failed : %s", group.c_str(), key.c_str(), error->message);

		g_error_free(error);
		return false;
	}

	se_debug_message(SE_DEBUG_APP, "remove [%s] %s", group.c_str(), key.c_str());
	
	return true;
}