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



Config::Config()
{
	errors_to_stdout = true;
}



//!! czy tu w ogole mozemy uzywac log << ?
//!! przeciez jeszcze nie zostal przetworzony plik konfiguracyjny


void Config::ShowError()
{
	
	switch( parser.status )
	{
		case ConfParser::ok:
			log << log2 << "Config: syntax ok" << logend;
			break;
		
		case ConfParser::cant_open_file:
			if( errors_to_stdout )
				std::cout << "Config: cant open a config file: " << config_file << std::endl;
			
			log	<< log1 << "Config: cant open a config file: " << config_file << logend;
			break;

		case ConfParser::syntax_error:
			if( errors_to_stdout )
				std::cout << "Config: syntax error, line: " << parser.line << std::endl;
			
			log << log1 << "Config: syntax error, line: " << parser.line << logend;
			break;
	}
}






bool Config::ReadConfig(bool errors_to_stdout_, bool stdout_is_closed)
{
	errors_to_stdout = errors_to_stdout_;
	
	if( config_file.empty() )
	{
		log << log2 << "Config: name of the config file is empty" << logend;
		return false;	
	}

	log << log2 << "Config: reading a config file" << logend;

	parser.SplitSingle(true);
	parser.UTF8(true); // config is always read in UTF-8
	ConfParser::Status status = parser.Parse( config_file );


	if( status == ConfParser::ok )
	{
		AssignValues(stdout_is_closed);
		SetAdditionalVariables();
		return true;
	}
	else
	{
		ShowError();
		return false;
	}
}




void Config::AssignValues(bool stdout_is_closed)
{
	demonize = Bool(L"demonize", true);

	user  = AText(L"user");
	group = AText(L"group");
	additional_groups = Bool(L"additional_groups", true);

	log_file          = AText(L"log_file");
	log_notify_file   = AText(L"log_notify_file");
	log_delimiter     = Text(L"log_delimiter", L"---------------------------------------------------------------------------------");
	fcgi_socket       = AText(L"fcgi_socket");
	fcgi_socket_chmod = Int(L"fcgi_socket_chmod", 0770);
	fcgi_socket_user  = AText(L"fcgi_socket_user");
	fcgi_socket_group = AText(L"fcgi_socket_group");
	log_level         = Int(L"log_level", 1);
	log_request       = Int(L"log_request", 1);
	log_stdout        = Bool(L"log_stdout", false);
	log_db_query      = Bool(L"log_db_query", false);
	log_plugin_call   = Bool(L"log_plugin_call", false);
	
	post_file_max      = Size(L"post_file_max", 8388608); // 8 MB
	upload_dir         = Text(L"upload_dir");
	upload_dirs_chmod  = Int(L"upload_dirs_chmod", 0750);
	upload_files_chmod = Int(L"upload_files_chmod", 0640);
	create_thumb       = Bool(L"create_thumb", true);
	thumb_mode         = Int(L"thumb_mode", 2);
	thumb_cx           = Size(L"thumb_cx", 150);
	thumb_cy           = Size(L"thumb_cy", 150);
	convert_cmd        = Text(L"convert_cmd", L"/usr/local/bin/convert");

	templates_dir             = Text(L"templates_dir");
	templates_dir_default     = Text(L"templates_dir_default");
	txt_templates_dir         = Text(L"txt_templates_dir");
	txt_templates_dir_default = Text(L"txt_templates_dir_default");
	templates_fun_prefix      = Text(L"templates_fun_prefix", L"fun_");
	templates_fun_postfix     = Text(L"templates_fun_postfix", L".html");
	templates_index           = Text(L"templates_index", L"index.html");
	template_only_root_use_template_fun = Bool(L"template_only_root_use_template_fun", false);

	http_session_id_name  = AText(L"http_session_id_name");
	db_database           = AText(L"db_database");
	db_user               = AText(L"db_user");
	db_pass               = AText(L"db_pass");
	item_url_empty        = Text(L"item_url_empty");

	base_server           = Text(L"base_server");
	base_url              = Text(L"base_url");
	base_url_static       = Text(L"base_url_static");
	base_url_common       = Text(L"base_url_common");

	NoLastSlash(base_server);
	NoLastSlash(base_url);
	NoLastSlash(base_url_static);
	NoLastSlash(base_url_common);

	priv_no_user  = Text(L"priv_no_user", L"-- no user --");
	priv_no_group = Text(L"priv_no_group", L"-- no group --");
	
	session_max_idle          = Int(L"session_max_idle", 10800); // 3h
	session_remember_max_idle = Int(L"session_remember_max_idle", 16070400); // 3 months
	session_file              = AText(L"session_file");
	session_max               = Size(L"session_max", 1000000);

	compression = Bool(L"compression", true);
	compression_page_min_size = Int(L"compression_page_min_size", 512);

	html_filter             = Bool(L"html_filter", true);
	html_filter_trim_white  = Bool(L"html_filter_trim_white", true);
	html_filter_break_lines = Int(L"html_filter_break_lines", 60);
	html_filter_tabs        = Size(L"html_filter_tabs", 2);
	html_filter_orphans		= Bool(L"html_filter_orphans", false);
	html_filter_orphans_lang_str = AText(L"html_filter_orphans_lang", L"pl");
	html_filter_orphans_mode_str = AText(L"html_filter_orphans_mode_str", L"nbsp");

	locale_str         = Text(L"locale", L"en");
	locale_dir         = Text(L"locale_dir");
	locale_dir_default = Text(L"locale_dir_default");

	title_separator  = Text(L"title_separator", L" / ");

	http_header_send_file = Text(L"http_header_send_file", L"X-LIGHTTPD-send-file");
	password_min_size = Size(L"password_min_size", 5);
	debug_info = Bool(L"debug_info", false);	

	editors_html_safe_mode = Bool(L"editors_html_safe_mode", true);
	editors_html_safe_mode_skip_root = Bool(L"editors_html_safe_mode_skip_root", true);

	plugins_dir = Text(L"plugins_dir", L"/usr/local/winix/plugins");
	NoLastSlash(plugins_dir);
	parser.ListText(L"plugins", plugin_file);

	time_zone_offset       = Int(L"time_zone_offset", 0);
	time_zone_offset_guest = Int(L"time_zone_offset_guest", 0);

	utf8 = Bool(L"utf8", true);
}


void Config::SetAdditionalVariables()
{
	SetHttpHost(base_url, base_url_http_host);

	if( html_filter_orphans_lang_str == "pl" )
		html_filter_orphans_lang = HTMLFilter::lang_pl;
	else
	if( html_filter_orphans_lang_str == "cz" )
		html_filter_orphans_lang = HTMLFilter::lang_cz;
	else
	if( html_filter_orphans_lang_str == "sk" )
		html_filter_orphans_lang = HTMLFilter::lang_sk;
	else
		html_filter_orphans_lang = HTMLFilter::lang_none;

	if( html_filter_orphans_mode_str == "160" )
		html_filter_orphans_mode = HTMLFilter::orphan_160space;
	else
		html_filter_orphans_mode = HTMLFilter::orphan_nbsp;
}




void Config::SetHttpHost(const std::wstring & in, std::wstring & out)
{
	const char http[]  = "http://";
	const char https[] = "https://";
	size_t http_len    = sizeof(http)  / sizeof(char) - 1;
	size_t https_len   = sizeof(https) / sizeof(char) - 1;

	if( IsSubString(http, in.c_str()) )
		out = in.substr(http_len);	
	else
	if( IsSubString(https, in.c_str()) )
		out = in.substr(https_len);	
	else
		out.clear(); // if empty the RequestController::BaseUrlRedirect() returns false and no redirecting will be done
}


std::wstring Config::Text(const wchar_t * name)
{
	return parser.Text(name);
}


std::wstring Config::Text(const wchar_t * name, const wchar_t * def)
{
	return parser.Text(name, def);
}


std::wstring Config::Text(const std::wstring & name, const std::wstring & def)
{
	return parser.Text(name, def);
}


std::string Config::AText(const wchar_t * name)
{
	return parser.AText(name);
}


std::string Config::AText(const wchar_t * name, const wchar_t * def)
{
	return parser.AText(name, def);
}


std::string Config::AText(const std::wstring & name, const std::wstring & def)
{
	return parser.AText(name, def);
}



int Config::Int(const wchar_t * name)
{
	return parser.Int(name);
}


int Config::Int(const wchar_t * name, int def)
{
	return parser.Int(name, def);
}


int Config::Int(const std::wstring & name, int def)
{
	return parser.Int(name, def);
}


size_t Config::Size(const wchar_t * name)
{
	return parser.Size(name);
}


size_t Config::Size(const wchar_t * name, size_t def)
{
	return parser.Size(name, def);
}


size_t Config::Size(const std::wstring & name, size_t def)
{
	return parser.Size(name, def);
}


bool Config::Bool(const wchar_t * name)
{
	return parser.Bool(name);
}


bool Config::Bool(const wchar_t * name, bool def)
{
	return parser.Bool(name, def);
}


bool Config::Bool(const std::wstring & name, bool def)
{
	return parser.Bool(name, def);
}



void Config::ListText(const wchar_t * name, std::vector<std::wstring> & list)
{
	parser.ListText(name, list);
}


void Config::ListText(const std::wstring & name, std::vector<std::wstring> & list)
{
	parser.ListText(name, list);
}


void Config::Print(std::ostream & out)
{
	parser.Print(out);
}