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

#include <fcgiapp.h>
#include <sstream>
#include <vector>
#include "requesttypes.h"
#include "item.h"
#include "error.h"
#include "config.h"
#include "textstream.h"
#include "templates/htmltextstream.h"
#include "date/date.h"
#include "space/space.h"
#include "space/spacetojson.h"



class FunctionBase;




struct Request
{
	// request id
	// is incremented for each request and is never 0
	// (from -1 will be incremented twice)
	// it's used for some optimalizations e.g. in templates
	size_t id;

	// !! moze pozbyc sie tego none?
	enum Method { get, post, head, none } method;
	enum Role   { responder, authorizer } role;

	// headers, page and debug
	//std::ostringstream headers, page, debug;
	TextStream<std::string>  headers;
	HtmlTextStream page, debug;
	TextStream<std::wstring> ajaxpage;

	// binary page
	BinaryPage binary_page;

	// a compressed page ready to send to the client
	BinaryPage compressed_page;

	// if true then either page or ajaxpage will be sent to the client
	// if false then binary_page is sent
	// default: true
	bool use_text_page;

	// if set to true then the standard template system will not be generated
	// default: false
	bool page_generated;

	// whether or not the html filter should be used
	// default: true
	bool use_html_filter;

	// raw parameters
	PostTab     post_tab;
	PostFileTab post_file_tab;
	CookieTab   cookie_tab;
	
	// html anchor (those part of URI after '#' character)
	std::wstring anchor;

	// environment variables
	// they are not null -- when the server doesn't have such a variable
	// it will be pointing into 'char_empty' which is default '\0'
	const char * env_request_method;
	const char * env_request_uri;
	const char * env_http_cookie;
	const char * env_remote_addr;
	const char * env_http_host;
	const char * env_http_user_agent;
	const char * env_http_accept_encoding;
	const char * env_fcgi_role;
	const char * env_content_type;
	const char * env_https;
	
	// current IP address of the remote host (read from REMOTE_ADDR environment variable)
	// (at the moment only IPv4 are supported)
	int ip;

	// true if the browser is Microsoft Internet Explorer
	bool browser_msie;
	
    // true if the browser is Konqueror
    bool browser_konqueror;

	// true if we are using encrypted connection (SSL)
	bool using_ssl;

	// current directory
	std::vector<Item*> dir_tab;

	// true if a file exists
	bool is_item;
	
	// current file (if exists)
	Item item;

	// current winix function
	// null if there is no a function
	FunctionBase * function;
	
	// parameters (name:value)
	ParamTab param_tab;

	// request status
	Error status;
	
	// usually items in the current directory (depends on the function)
	std::vector<Item> item_tab;

	// if not empty means an address for redirecting to
	// it should be url-encoded
	std::wstring redirect_to;
	std::string aredirect_to;

	// a redirect type
	// following redirect types are supported:
	// 300 Multiple Choices
	// 301 Moved Permanently
	// 302 Found
	// 303 See Other (default)
	// 307 Temporary Redirect
	int redirect_type;

	// send header X-LIGHTTPD-send-file with path to a file
	std::wstring x_sendfile;

	// send as attachment (causes header: content-disposition: attachment)
	bool send_as_attachment;

	// this is a pointer either to the item (if exists) or to the last directory
	Item * last_item;

	// request start time
	// Time() methods are very slow so it is better to directly use those two values
	// they are set when a request starts
	time_t   start_time;
	PT::Date start_date;

	// a subdomain
	// subdomain = HTTP_HOST environment variable - config->base_url
	std::wstring subdomain;

	// used as a JSON output (when ajax_serializer is defined)
	// it will be serialized and have at least:
	// 'content' string - the whole html content
	// 'http_status' integer - http status code (e.g. 200) !! FIXME this is not added at the moment
	PT::Space ajax;

	// if not null then the request will have a JSON as an output
	PT::SpaceToJSON * ajax_serializer;

	// if this variable is true then winix always return 200 OK header
	// when the status would be 404 (not found) or 403 (permission denied)
	// default: false
	bool use_200_status_for_not_found_and_permission_denied;

	// options used by ezc generators
	bool gen_trim_white;
	bool gen_skip_new_line;
	bool gen_use_special_chars;


	Request();
	void SetConfig(Config * pconfig);
	void RequestStarts();
	void Clear();

		

	bool IsParam(const wchar_t * param_name);
	bool IsParam(const std::wstring & param_name);

	const std::wstring & ParamValue(const wchar_t * param_name);      // returns an empty string if there is no such a parameter
	const std::wstring & ParamValue(const std::wstring & param_name); // returns an empty string if there is no such a parameter

	void SetCookie(const char * name, const char * value, PT::Date * expires = 0);
	void SetCookie(const char * name, long value,         PT::Date * expires = 0);

	bool IsPostVar(const wchar_t * var);
	bool IsPostVar(const std::wstring & var);

	const std::wstring & PostVar(const wchar_t * var);				// returns an empty string if there is no such a parameter
	const std::wstring & PostVar(const std::wstring & var);			// returns an empty string if there is no such a parameter


	bool PostVar(const wchar_t * var, std::wstring & result);
	bool PostVar(const std::wstring & var, std::wstring & result);

	std::wstring * PostVarp(const wchar_t * var);
	std::wstring * PostVarp(const std::wstring & var);

	bool AllPostVarEmpty(); // returning true if all post vars are empty

	void SendAll();


private:

	Config * config;

	// contains '\0'
	// used to set env_* pointers to the empty value
	const char char_empty;

	// used in ParamValue() and PostVar() when there is no such a param
	const std::wstring str_empty;

	void ClearAjax();

};







#endif