/*
 * This file is a part of Winix
 * and is not publicly distributed
 * 
 * Copyright (c) 2008-2011, Tomasz Sowa
 * All rights reserved.
 * 
 */
 
#include "config.h"
#include "log.h"
#include "plugin.h"
#include "misc.h"
#include "crypt.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_save_each_line = Bool(L"log_save_each_line", false);
	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);
	log_post_value_size = Size(L"log_post_value_size", 80);

	post_file_max      = Size(L"post_file_max", 8388608); // 8 MB

	upload_dir         = Text(L"upload_dir");
	common_dir         = Text(L"common_dir");
	NoLastSlash(upload_dir);
	NoLastSlash(common_dir);

	upload_dirs_chmod  = Int(L"upload_dirs_chmod", 0750);
	upload_files_chmod = Int(L"upload_files_chmod", 0640);
	ListText(L"static_dirs", static_dirs);
	dont_use_static_dirs = Bool(L"dont_use_static_dirs", false);
	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");

	url_proto             = Text(L"url_proto", L"http://");
	url_ssl_proto         = Text(L"url_ssl_proto", L"https://");

	use_ssl                       = Bool(L"use_ssl", false);
	use_ssl_static                = Bool(L"use_ssl_static", false);
	use_ssl_common                = Bool(L"use_ssl_common", false);
	use_ssl_only_for_logged_users = Bool(L"use_ssl_only_for_logged_users", true);

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

	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 = Size(L"compression_page_min_size", 512);
	compression_encoding      = Int(L"compression_encoding", 20);

	html_filter             = Bool(L"html_filter", true);
	html_filter_trim_white  = Bool(L"html_filter_trim_white", true);
	html_filter_break_word  = Int(L"html_filter_break_word", 60);
	html_filter_wrap_line   = Int(L"html_filter_wrap_line", 110);
	html_filter_tabs        = Size(L"html_filter_tabs", 2);
	html_filter_orphans		= Bool(L"html_filter_orphans", true);
	html_filter_orphans_mode_str = AText(L"html_filter_orphans_mode_str", L"nbsp");

	locale_dir         = Text(L"locale_dir");
	locale_dir_default = Text(L"locale_dir_default");
	locale_default     = Text(L"locale_default");
	ListText(L"locale_files", locale_files);

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

	http_header_send_file = Text(L"http_header_send_file", L"X-LIGHTTPD-send-file");
	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);
	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);
	symlinks_follow_max = Size(L"symlinks_follow_max", 20);

	ticket_form_prefix = Text(L"ticket_form_prefix", L"ticketparam");

	pass_min_size        = Size(L"pass_min_size", 5);
	pass_type            = Int(L"pass_type", 12);
	pass_hash_use_salt   = Bool(L"pass_hash_use_salt", false);
	pass_hash_salt       = Text(L"pass_hash_salt");
	pass_use_rsa         = Bool(L"pass_use_rsa", false);
	pass_rsa_private_key = Text(L"pass_rsa_private_key");

	opensll_path = Text(L"opensll_path", L"/usr/bin/openssl");

	pattern_cacher_when_delete     = Size(L"pattern_cacher_when_delete", 130);
	pattern_cacher_how_many_delete = Size(L"pattern_cacher_how_many_delete", 30);
}





void Config::SetAdditionalVariables()
{
	if( html_filter_orphans_mode_str == "160" )
		html_filter_orphans_mode = HTMLFilter::orphan_160space;
	else
		html_filter_orphans_mode = HTMLFilter::orphan_nbsp;

	for(size_t i=0 ; i<static_dirs.size() ; ++i)
		NoLastSlash(static_dirs[i]);

	CheckLocale();
	CheckPasswd();
}



void Config::CheckLocale()
{
bool found = false;

	if( locale_files.empty() )
		locale_files.push_back(L"en");

	if( locale_default.empty() )
		locale_default = locale_files[0];

	for(size_t i=0 ; i<locale_files.size() ; ++i)
	{
		if( locale_files[i] == locale_default )
		{
			locale_default_index = i;
			found = true;
			break;
		}
	}

	if( !found )
	{
		// we have at least one item
		locale_default = locale_files[0];
		locale_default_index = 0;
	}
}


void Config::CheckPasswd()
{
	switch(pass_type)
	{
		case WINIX_CRYPT_HASH_NONE:
		case WINIX_CRYPT_HASH_MD4:
		case WINIX_CRYPT_HASH_MD5:
		case WINIX_CRYPT_HASH_SHA1:
		case WINIX_CRYPT_HASH_SHA224:
		case WINIX_CRYPT_HASH_SHA256:
		case WINIX_CRYPT_HASH_SHA384:
		case WINIX_CRYPT_HASH_SHA512:
		break;

		default:
		pass_type = WINIX_CRYPT_HASH_SHA256;
	}
}




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);
}