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




namespace TemplatesFunctions
{
static BBCODEParser bbcode_parser;




void print_user_name(Info & i, const User * puser, const std::string & guest_name)
{
	if( puser )
	{
		HtmlEscape(i.out, puser->name);
	}
	else
	{
		i.out << "~";
		
		if( !guest_name.empty() )
			HtmlEscape(i.out, guest_name);
		else
			i.out << "guest"; // !! dodac do konfiga
	}
}



void item_is(Info & i)
{
	i.res = request->is_item;
}



void item_id(Info & i)
{
	i.out << request->item.id;	
}



void item_subject(Info & i)
{
	HtmlEscape(i.out, request->item.subject);
}


void item_subject_noescape(Info & i)
{
	i.out << request->item.subject;
}



void item_content(Info & i)
{
	HtmlEscape(i.out, request->item.content);
}



void item_content_noescape(Info & i)
{
	i.out << request->item.content;
}


void item_content_type_is(Item & item, Info & i)
{
	i.res = false;

	if( item.content_type == Item::ct_text && i.par == "text" )
		i.res = true;
	else
	if( item.content_type == Item::ct_formatted_text && i.par == "formatted text" )
		i.res = true;
	else
	if( item.content_type == Item::ct_html && i.par == "html" )
		i.res = true;
	else
	if( item.content_type == Item::ct_bbcode && i.par == "bbcode" )
		i.res = true;
	else
	if( item.content_type == Item::ct_raw && i.par == "raw" )
		i.res = true;
}


void item_content_type_is(Info & i)
{
	item_content_type_is(request->item, i);
}


void item_print_content(std::ostringstream & out, const std::string & content, Item::ContentType content_type)
{
	if( content_type == Item::ct_text )
	{
		HtmlEscape(out, content);
	}
	else
	if( content_type == Item::ct_formatted_text )
	{
		HtmlEscapeFormTxt(out, content);
	}
	else
	if( content_type == Item::ct_html || content_type == Item::ct_raw )
	{
		out << content;
	}
	else
	if( content_type == Item::ct_bbcode )
	{
		static std::string out_temp;
		out_temp.clear();
		out_temp.reserve(content.size()*2);

		bbcode_parser.Filter(content.c_str(), out_temp);
		out << out_temp;
	}
}


void item_content_is_empty(Info & i)
{
	i.res = request->item.content.empty();
}

void item_print_content(Info & i)
{
	item_print_content(i.out, request->item.content, request->item.content_type);
}



void item_privileges(Info & i)
{
	i.out << std::setbase(8) << request->item.privileges << std::setbase(10);
}


void item_dir(Info & i)
{
	dir(i);
}


void item_url(Info & i)
{
	HtmlEscape(i.out, request->item.url);
}


void item_url_is(Info & i)
{
	if( !request->is_item )
		return; // default false

    i.res = (request->item.url == i.par);
}


void item_link(Info & i)
{
	HtmlEscape(i.out, config->base_url);
	item_dir(i);
	item_url(i);
}




void item_auth_is_none(Info & i)
{
	i.res = request->item.auth == Item::auth_none;
}


void item_auth_is_image(Info & i)
{
	i.res = request->item.auth == Item::auth_image;
}


void item_can_read(Info & i)
{
	i.res = system->HasReadAccess(request->item);
}


void item_can_write(Info & i)
{
	i.res = system->HasWriteAccess(request->item);
}


void item_can_remove(Info & i)
{
	// !! tutaj trzeba bedzie cos innego zrobic
	// zwlaszcza jak dojdzie sticky bit
	i.res = system->HasWriteAccess(*request->dir_tab.back());
}


void item_info(Info & i)
{
	if( static_cast<size_t>(locale.GetLang()) >= patterns.size() )
		return;

	Ezc::Generator gen(i.out, patterns[locale.GetLang()][pat_item_info], ezc_functions);
	gen.Generate();
}


void item_user(Info & i)
{
	User * puser = system->users.GetUser(request->item.user_id);
	print_user_name(i, puser, request->item.guest_name);
}



void item_modification_user(Info & i)
{
	User * puser = system->users.GetUser(request->item.modification_user_id);
	print_user_name(i, puser, request->item.guest_name);
}


void item_users_different(Info & i)
{
	i.res = (request->item.user_id != request->item.modification_user_id);
}


void item_date_creation(Info & i)
{
	tm * ptm = &request->item.date_creation;
	
	i.out << DateToStr(ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
}


void item_date_modification(Info & i)
{
	tm * ptm = &request->item.date_modification;
	
	i.out << DateToStr(ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
}


void item_date_creation_nice(Info & i)
{
	tm * ptm = &request->item.date_creation;
	print_date_nice(i, ptm);
}


void item_date_modification_nice(Info & i)
{
	tm * ptm = &request->item.date_modification;
	print_date_nice(i, ptm);
}


void item_dates_equal(Info & i)
{
	tm * ptm1 = &request->item.date_creation;
	tm * ptm2 = &request->item.date_modification;
	
	i.res = ptm1->tm_year == ptm2->tm_year &&
			   ptm1->tm_mon  == ptm2->tm_mon  &&
			   ptm1->tm_mday == ptm2->tm_mday && 
			   ptm1->tm_hour == ptm2->tm_hour && 
			   ptm1->tm_min  == ptm2->tm_min  && 
			   ptm1->tm_sec  == ptm2->tm_sec;
}



void item_run(Info & i)
{
	if( !request->is_item )
	{
		i.out << "<!-- there is no an item to run -->";
		return;
	}

	if( !system->HasReadExecAccess(request->item) )
	{
		i.out << "<!-- run: permission denied -->";
		return;
	}
		
	Ezc::Pattern * p = pattern_cacher.GetPattern(request->item);
	std::ostringstream item_run_content;

	Ezc::Generator gen(item_run_content, *p, ezc_functions);
	gen.Generate();

	item_print_content(i.out, item_run_content.str(), request->item.content_type);
}


void item_guest_name(Info & i)
{
	HtmlEscape(i.out, request->item.guest_name);
}







static size_t item_index;


void item_tab(Info & i)
{
	item_index = i.iter;
	i.res   = item_index < request->item_tab.size();
}


void item_tab_id(Info & i)
{
	if( item_index < request->item_tab.size() )
		i.out << request->item_tab[item_index].id;
}


void item_tab_subject(Info & i)
{
	if( item_index < request->item_tab.size() )
		HtmlEscape(i.out, request->item_tab[item_index].subject);
}

void item_tab_subject_noescape(Info & i)
{
	if( item_index < request->item_tab.size() )
		i.out << request->item_tab[item_index].subject;
}


void item_tab_content(Info & i)
{
	if( item_index < request->item_tab.size() )
	    HtmlEscape(i.out, request->item_tab[item_index].content);
}


void item_tab_content_noescape(Info & i)
{
	if( item_index < request->item_tab.size() )
	    i.out << request->item_tab[item_index].content;
}


void item_tab_print_content(Info & i)
{
	if( item_index >= request->item_tab.size() )
		return;
	
	std::string & content  = request->item_tab[item_index].content;
	Item::ContentType type = request->item_tab[item_index].content_type;
	
	item_print_content(i.out, content, type);
}


void item_tab_privileges(Info & i)
{
	if( item_index < request->item_tab.size() )
		i.out << "0" << std::setbase(8) << request->item_tab[item_index].privileges << std::setbase(10);
}



void item_tab_dir(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		std::string path;

		if( system->dirs.MakePath(request->item_tab[item_index].parent_id, path) )
			HtmlEscape(i.out, path);
		else
			i.out << "/the path does not exist/";	
	}
}


void item_tab_url(Info & i)
{
	if( item_index < request->item_tab.size() )
		HtmlEscape(i.out, request->item_tab[item_index].url);
}


void item_tab_link(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		HtmlEscape(i.out, config->base_url);
		item_tab_dir(i);
		item_tab_url(i);
	}
}


void item_tab_link_auth(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		HtmlEscape(i.out, config->base_url_auth);
		item_tab_dir(i);
		item_tab_url(i);
	}
}


void item_tab_can_read(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		if( system->HasReadAccess(request->item_tab[item_index]) )
			i.res = true;
	}
}


void item_tab_can_write(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		if( system->HasWriteAccess(request->item_tab[item_index]) )
			i.res = true;
	}
}


void item_tab_info(Info & i)
{
	if( static_cast<size_t>(locale.GetLang()) >= patterns.size() )
		return;

	Ezc::Generator gen(i.out, patterns[locale.GetLang()][pat_item_tab_info], ezc_functions);
	gen.Generate();
}


void item_tab_user(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		User * puser = system->users.GetUser(request->item_tab[item_index].user_id);
		print_user_name(i, puser, request->item_tab[item_index].guest_name);
	}
}



void item_tab_modification_user(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		User * puser = system->users.GetUser(request->item_tab[item_index].modification_user_id);
		print_user_name(i, puser, request->item_tab[item_index].guest_name);
	}
}



void item_tab_users_different(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		i.res = (request->item_tab[item_index].user_id != request->item_tab[item_index].modification_user_id);
	}
}



void item_tab_group(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		long group_id = request->item_tab[item_index].group_id;
		Group * pgroup = system->groups.GetGroup(group_id);
		
		if( pgroup )
			HtmlEscape(i.out, pgroup->name);
		else
			i.out << group_id;
	}
}


void item_tab_date_creation(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		tm * ptm = &request->item_tab[item_index].date_creation;
		
		i.out << DateToStr(ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
	}
}


void item_tab_date_modification(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		tm * ptm = &request->item_tab[item_index].date_modification;
		
		i.out << DateToStr(ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday, ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
	}
}


void item_tab_date_creation_nice(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		tm * ptm = &request->item_tab[item_index].date_creation;
		print_date_nice(i, ptm);	
	}
}



void item_tab_date_modification_nice(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		tm * ptm = &request->item_tab[item_index].date_modification;
		print_date_nice(i, ptm);
	}
}


void item_tab_dates_equal(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		tm * ptm1 = &request->item_tab[item_index].date_creation;
		tm * ptm2 = &request->item_tab[item_index].date_modification;
		
		i.res = ptm1->tm_year == ptm2->tm_year &&
				ptm1->tm_mon  == ptm2->tm_mon  &&
				ptm1->tm_mday == ptm2->tm_mday && 
				ptm1->tm_hour == ptm2->tm_hour && 
				ptm1->tm_min  == ptm2->tm_min  && 
				ptm1->tm_sec  == ptm2->tm_sec;
	}
}


void item_tab_run(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		if( !system->HasReadExecAccess(request->item) )
		{
			i.out << "<!-- run: permission denied -->";
			return;
		}
			
		Ezc::Pattern * p = pattern_cacher.GetPattern(request->item_tab[item_index]);
		Ezc::Generator gen(i.out, *p, ezc_functions);
		gen.Generate();
	}
}


void item_tab_can_use_emacs(Info & i)
{
	if( item_index < request->item_tab.size() )
	{
		// !!
		//i.res = request->CanUseEmacs(request->item_tab[item_index], true);
	}
}





} // namespace TemplatesFunctions