/*
 * This file is a part of Winix
 * and is not publicly distributed
 * 
 * Copyright (c) 2008-2011, Tomasz Sowa
 * All rights reserved.
 * 
 */
 
#ifndef headerfile_winix_core_config
#define headerfile_winix_core_config

#include <string>
#include "confparser.h"
#include "htmlfilter.h"




class Config
{
public:

	// name of the config file
	// this is the parameter passed to winix programm
	std::string config_file;

	// start as a demon (in the background)
	// default: true
	bool demonize;

	// system user name (to which drop privileges)
	// used only if winix is started as the root
	std::string user;

	// system group name (to which drop privileges)
	// used only if winix is started as the root
	std::string group;

	// setting additional effective groups from /etc/group
	// by using initgroups()
	// used only if winix is started as the root
	// default: true
	bool additional_groups;

	// log file name, log file name for notifications (sending emails, etc)
	std::string log_file, log_notify_file;
	
	// 1 - minimum
	// 2 - (default)
	// 3 - maximum - all logs
	int log_level;

	// logging to stdout too
	// only if demonize is 'false'
	// default: false
	bool log_stdout;

	// how many requests should be saved in the same time
	// default: 1
	int log_request;

	// whether to save each line of the config (use it for debug purposes)
	// default: false
	bool log_save_each_line;

	// logging db queries
	// default: false
	bool log_db_query;

	// logging when a plugin function is called
	// default: false
	bool log_plugin_call;

	// how many characters in values should be logged from POST parameters
	// default: 80
	// set to 0 to turn off
	size_t log_post_value_size;

	// request delimiter in the log file, default "---------"
	std::wstring log_delimiter;

	// fast cgi: socket (unix domain)
	std::string fcgi_socket;

	// fast cgi: socket permissions
	int fcgi_socket_chmod;

	// fast cgi: owner of the socket
	std::string fcgi_socket_user;
	
	// fast cgi: group of the socket
	std::string fcgi_socket_group;

	std::wstring templates_dir;
	std::wstring templates_dir_default; // html templates from winix

	std::wstring txt_templates_dir;
	std::wstring txt_templates_dir_default; // txt (notifications) templates from winix

	// prefix and postfix for functions templates
	// default: 
	// prefix:  "fun_"
	// postfix: ".html"
	std::wstring templates_fun_prefix;
	std::wstring templates_fun_postfix;

	// main html template
	// default: index.html
	std::wstring templates_index;

	// if true then only root can use 'template' function
	// default: false
	bool template_only_root_use_template_fun;

	std::string db_database;
	std::string db_user;
	std::string db_pass;

	std::string http_session_id_name;

	// when the HOST_HTTP environment variable doesn't point into 'base_url' (the part 'http://' and the last slash is removed)
	// the server will redirect into 'base_url' + 'REQUEST_URI'
	// it's useful when you want to redirect from 'mydomain.tld' into 'www.mydomain.tld' etc.
	bool base_url_redirect;

	// string used in a place where is a user (or group) selected
	std::wstring priv_no_user;
	std::wstring priv_no_group;

	// time in seconds when the user will be automatically logged out (iddle time)
	int session_max_idle;
	
	// time in seconds when the user will be automatically logged out (when he selected 'remember me' option)
	// this time is usually greater than session_max_idle
	int session_remember_max_idle;

	// this file is used when the program is starting and ending
	std::string session_file;

	// how many sessions can be (zero turn off this checking)
	// default: 1000000 (one milion)
	size_t session_max;

	// allow the html output to be compressed
	// default: true
	bool compression;

	// if the output is shorter than this value then it will not be compressed
	// default: 512 bytes
	size_t compression_page_min_size;

	// 1  - use deflate if available (or raw deflate for Internet Explorer) or don't compress
	// 2  - use gzip if available or don't compress
	// 10 - prefer deflate -- use deflate (or raw deflate for IE) if both deflate and gzip are available
	// 20 - prefer gzip    -- use gzip if both deflate and gzip are available
	// default: 20
	int compression_encoding;
	
	// plugins directory
	// default: /usr/local/winix/plugins
	std::wstring plugins_dir;

	// plugins
	// you can provide either a relative path (plugins_dir will be used) 
	// or a full path to a plugin
	std::vector<std::wstring> plugin_file;

	// should the html code be cleaned by the html filter
	bool html_filter;

	// should white characters be trimmed
	bool html_filter_trim_white;

	// when long words should be broken (a space will be inserted)
	// default: after 60 non white characters will be put a space
	// set zero to turn off
	size_t html_filter_break_word;

	// when long lines should be broken (a new line character will be inserted)
	// default: 80
	// set zero to turn off
	size_t html_filter_wrap_line;

	// how many spaces will be put at one tree level
	// default: 2
	size_t html_filter_tabs;

	// use checking for 'orphans' for a specicic language
	// default: true
	bool html_filter_orphans;

	// orphans mode
	// either: "nbsp" or "160"
	// default: "nbsp"
	std::string html_filter_orphans_mode_str;
	HTMLFilter::OrphanMode html_filter_orphans_mode;

	// the url of a new empty item (if there is not the subject too)
	std::wstring item_url_empty;

	// maximum length of a file send by post multipart form
	// 0 - not used
	size_t post_file_max;

	// directory for static files
	std::wstring upload_dir;

	// chmod of newly created directories (under upload_dir)
	// default: 0750
	int upload_dirs_chmod;

	// chmod of newly created files (under upload_dir)
	// default: 0640
	int upload_files_chmod;

	// create a thumbnail from an image
	// default: true
	bool create_thumb;

	// the mode of creating a thumbnail
	// width means thumb_cx, height means thumb_cy
	// 1: Width given, height automagically selected to preserve aspect ratio.
	// 2: Height given, width automagically selected to preserve aspect ratio.
	// 3: Maximum values of height and width given, aspect ratio preserved.
	// 4: Minimum values of width and height given, aspect ratio preserved.
	// 5: Width and height emphatically given, original aspect ratio ignored.
	// 6: Change as per widthxheight (3) but only if an image dimension exceeds a specified dimension.
	// 7: Change dimensions only if both image dimensions are less than specified dimensions.
	// default: 2
	int thumb_mode;

	// width of thumbnails
	// default: 150
	size_t thumb_cx;

	// height of thumbnails
	// default: 150
	size_t thumb_cy;

	// the convert program
	// default: /usr/local/bin/convert
	std::wstring convert_cmd;

	// directory with locale files
	std::wstring locale_dir;

	// directory with default locale files (those from winix)
	std::wstring locale_dir_default;

	// locale files (e.g. "en", "pl")
	// default: only one item: en
	std::vector<std::wstring> locale_files;

	// default locale
	// default: the first item from locale_files
	std::wstring locale_default;

	// default locale - index to locale_files
	// not available in config -- set automatically based on locale_default
	size_t locale_default_index;

	// the main address of the server (e.g. someserver.com) (without the 'www' part etc)
	std::wstring base_server;

	// the main address of the site (e.g. http://www.someserver.com)
	std::wstring base_url;

	// static content not authorized by winix
	std::wstring base_url_static;

	// additional static server for common content (not authorized)
	std::wstring base_url_common;

	// separator used in <title> html tag
	std::wstring title_separator;

	// http header recognized by www server as a file to send back
	// default: X-LIGHTTPD-send-file
	std::wstring http_header_send_file;

	// prints additional information (in the end of the html page as a commentary)
	bool debug_info;

	// in editors (emacs, ckeditor,...) the html will be filtered and unsafe tags
	// will be dropped (script, frame, etc.)
	// default: true;
	bool editors_html_safe_mode;

	// don't filter the html code for root
	// default: true
	// (if true the html code for root is not filtered)
	bool editors_html_safe_mode_skip_root;

	// temporarily we do not support time zones per user
	// there is one offset for all users
	// default: 0
	int time_zone_offset;

	// time zone offset for guests (not logged users)
	// default: 0
	int time_zone_offset_guest;

	// charset used in templates, locales, logs etc.
	// default: true (UTF-8)
	// if false it means 8-bit ASCII
	bool utf8;

	// how many maximum symlinks can be followed
	// (symlinks on directories as well)
	// default: 20
	size_t symlinks_follow_max;

	// the prefix of a name of html form controls used in the ticket plugin
	// default: ticketparam
	std::wstring ticket_form_prefix;

	// the minimal size of a user's password
	// default: 5
	size_t pass_min_size;

	// how passwords should be stored
	// 0  - plain text
	// 1  - md4 hash
	// 2  - md5 hash
	// 10 - sha1 hash
	// 11 - sha224 hash
	// 12 - sha256 hash (default)
	// 13 - sha384 hash
	// 14 - sha512 hash
	int pass_type;

	// whether the passwords' hashes should be salted or not
	// this affects newly created accounts
	// default: false
	bool pass_hash_use_salt;

	// salt to a password's hash
	// default empty
	// !! once you set this salt don't change it any more (people wouldn't be allowed to login)
	std::wstring pass_hash_salt;

	// whether the passwords' hashes should be encrypted
	// this affects newly created accounts
	// default: false
	bool pass_use_rsa;

	// path to a RSA private key
	// this is actually private + public key in one file
	// generated by "openssl genrsa"
	// default empty which means encryption will not be used
	// !! once you set these keys don't change it any more (people wouldn't be allowed to login)
	std::wstring pass_rsa_private_key;


	// path to 'openssl'
	// default: /usr/bin/openssl
	std::wstring opensll_path;

	/*
	*/

	// based on base_url
	// set by SetAdditionalVariables()
	// without the first part http:// (or https://) or the whole string is empty
	std::wstring base_url_http_host;


	Config();
	bool ReadConfig(bool errors_to_stdout_, bool stdout_is_closed = true);

	std::wstring Text(const wchar_t * name);
	std::wstring Text(const wchar_t * name, const wchar_t * def);
	std::wstring Text(const std::wstring & name, const std::wstring & def);
	std::string AText(const wchar_t * name);
	std::string AText(const wchar_t * name, const wchar_t * def);
	std::string AText(const std::wstring & name, const std::wstring & def);

	int Int(const wchar_t *);
	int Int(const wchar_t * name, int def);
	int Int(const std::wstring & name, int def);
	size_t Size(const wchar_t *);
	size_t Size(const wchar_t * name, size_t def);
	size_t Size(const std::wstring & name, size_t def);
	bool Bool(const wchar_t *);
	bool Bool(const wchar_t * name, bool def);
	bool Bool(const std::wstring & name, bool def);
	void ListText(const wchar_t * name, std::vector<std::wstring> & list);
	void ListText(const std::wstring & name, std::vector<std::wstring> & list);

	// for debug
	void Print(std::ostream & out);

private:
	void ShowError();
	void AssignValues(bool stdout_is_closed);
	void SetHttpHost(const std::wstring & in, std::wstring & out);
	void SetAdditionalVariables();
	void CheckLocale();
	void CheckPasswd();

	ConfParser parser;

	std::string default_str;
	int  default_int;
	bool default_bool;
	
	bool errors_to_stdout;

};






#endif