/*
 * This file is a part of CMSLU -- Content Management System like Unix
 * and is not publicly distributed
 * 
 * Copyright (c) 2008-2009, Tomasz Sowa
 * All rights reserved.
 * 
 */
 
#include "templates.h"
#include "../core/data.h"
#include "../core/request.h"
#include "../core/misc.h"



namespace TemplatesFunctions
{


void ticket_is(Info & i)
{
	i.result = request.is_ticket;
}




void ticket_can_create(Info & i)
{
	i.result = request.CanCreateTicket(true);	
}



void ticket_type(Info & i)
{
	if( request.ticket.type < data.mounts.pmount->param[Mount::par_ticket_type].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_type].arg[request.ticket.type]);
}


void ticket_status(Info & i)
{
	if( request.ticket.status < data.mounts.pmount->param[Mount::par_ticket_status].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_status].arg[request.ticket.status]);
}

	
void ticket_priority(Info & i)
{
	if( request.ticket.priority < data.mounts.pmount->param[Mount::par_ticket_priority].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_priority].arg[request.ticket.priority]);
}


void ticket_category(Info & i)
{
	if( request.ticket.category < data.mounts.pmount->param[Mount::par_ticket_category].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_category].arg[request.ticket.category]);
}


void ticket_expected(Info & i)
{
	if( request.ticket.expected < data.mounts.pmount->param[Mount::par_ticket_expected].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_expected].arg[request.ticket.expected]);
}



void ticket_progress(Info & i)
{
	i.out << request.ticket.progress;
}



// --------------------------------------------------------------------------------



static size_t ticket_tab_index;



void ticket_tab(Info & i)
{
	ticket_tab_index = i.iter;

	i.result = ticket_tab_index < request.ticket_tab.size();
}


void ticket_tab_url(Info & i)
{
	if( ticket_tab_index < request.ticket_tab.size() )
	{
		Item * dir = data.dirs.GetDir( request.ticket_tab[ticket_tab_index].dir_id );
	
		if( dir )
		{
			HtmlEscape(i.out, dir->url);
		}
		else
		{
			i.out << "<!-- unknown directory -->";	
		}
	}
}


void ticket_tab_subject(Info & i)
{
	if( ticket_tab_index < request.ticket_tab.size() )
	{
		Item * dir = data.dirs.GetDir( request.ticket_tab[ticket_tab_index].dir_id );
	
		if( dir )
		{
			if( !dir->subject.empty() )
				HtmlEscape(i.out, dir->subject);
			else
				HtmlEscape(i.out, dir->url);
		}
		else
		{
			i.out << "<!-- unknown subject -->";	
		}
	}
}


void ticket_tab_subject_empty(Info & i)
{
	i.result = true;

	if( ticket_tab_index < request.ticket_tab.size() )
	{
		Item * dir = data.dirs.GetDir( request.ticket_tab[ticket_tab_index].dir_id );
	
		if( dir )
			i.result = dir->subject.empty();
	}
}


void ticket_tab_author(Info & i)
{
bool unknown = true;
	
	
	if( ticket_tab_index < request.ticket_tab.size() )
	{
		Item * dir = data.dirs.GetDir( request.ticket_tab[ticket_tab_index].dir_id );
	
		if( dir )
		{
			User * puser = data.users.GetUser(dir->user_id);
			unknown = false;
			
			if( puser )
				HtmlEscape(i.out, puser->name);
			else
			{
				i.out << "~";
				
				if( !dir->guest_name.empty() )
					HtmlEscape(i.out, dir->guest_name);
				else
					i.out << "guest"; // !! dodac do konfiga
			}
		}
	}

	
	if( unknown )
	{
		i.out << "<!-- unknown user -->";	
	}
}



void ticket_tab_type(Info & i)
{
	if( ticket_tab_index >= request.ticket_tab.size() )
		return;

	Ticket & t = request.ticket_tab[ticket_tab_index];

	if( t.type < data.mounts.pmount->param[Mount::par_ticket_type].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_type].arg[t.type]);
}


void ticket_tab_status(Info & i)
{
	if( ticket_tab_index >= request.ticket_tab.size() )
		return;

	Ticket & t = request.ticket_tab[ticket_tab_index];

	if( t.status < data.mounts.pmount->param[Mount::par_ticket_status].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_status].arg[t.status]);
}

	
void ticket_tab_priority(Info & i)
{
	if( ticket_tab_index >= request.ticket_tab.size() )
		return;

	Ticket & t = request.ticket_tab[ticket_tab_index];

	if( t.priority < data.mounts.pmount->param[Mount::par_ticket_priority].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_priority].arg[t.priority]);
}


void ticket_tab_category(Info & i)
{
	if( ticket_tab_index >= request.ticket_tab.size() )
		return;

	Ticket & t = request.ticket_tab[ticket_tab_index];

	if( t.category < data.mounts.pmount->param[Mount::par_ticket_category].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_category].arg[t.category]);
}


void ticket_tab_expected(Info & i)
{
	if( ticket_tab_index >= request.ticket_tab.size() )
		return;

	Ticket & t = request.ticket_tab[ticket_tab_index];

	if( t.expected < data.mounts.pmount->param[Mount::par_ticket_expected].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_expected].arg[t.expected]);
}


void ticket_tab_progress(Info & i)
{
	if( ticket_tab_index >= request.ticket_tab.size() )
		return;

	i.out << request.ticket_tab[ticket_tab_index].progress;
}






// --------------------------------------------------------------------------------

static size_t ticket_type_tab_ind;


void ticket_type_tab(Info & i)
{
	ticket_type_tab_ind = i.iter;

	i.result = ticket_type_tab_ind < data.mounts.pmount->param[Mount::par_ticket_type].arg.size();
}


void ticket_type_tab_defined(Info & i)
{
	i.result = data.mounts.pmount->param[Mount::par_ticket_type].defined;
}


void ticket_type_tab_isdefault(Info & i)
{
	if( request.is_ticket )
	{
		i.result = (ticket_type_tab_ind == request.ticket.type);
	}
	else
	{
		Mount::ParamRow & p = data.mounts.pmount->param[Mount::par_ticket_type_default];

		if( !p.defined || p.arg.empty() )
			return; // default false

		size_t value = atoi( p.arg[0].c_str() );
		i.result = (ticket_type_tab_ind == value);
	}
}


void ticket_type_tab_index(Info & i)
{
	i.out << ticket_type_tab_ind;
}


void ticket_type_tab_name(Info & i)
{
	if( ticket_type_tab_ind < data.mounts.pmount->param[Mount::par_ticket_type].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_type].arg[ticket_type_tab_ind]);
}



// --------------------------------------------------------------------------------

static size_t ticket_status_tab_ind;


void ticket_status_tab(Info & i)
{
	ticket_status_tab_ind = i.iter;

	i.result = ticket_status_tab_ind < data.mounts.pmount->param[Mount::par_ticket_status].arg.size();
}


void ticket_status_tab_defined(Info & i)
{
	i.result = data.mounts.pmount->param[Mount::par_ticket_status].defined;
}


void ticket_status_tab_isdefault(Info & i)
{
	if( request.is_ticket )
	{
		i.result = (ticket_status_tab_ind == request.ticket.status);
	}
	else
	{
		Mount::ParamRow & p = data.mounts.pmount->param[Mount::par_ticket_status_default];

		if( !p.defined || p.arg.empty() )
			return; // default false

		size_t value = atoi( p.arg[0].c_str() );
		i.result = (ticket_status_tab_ind == value);
	}
}


void ticket_status_tab_index(Info & i)
{
	i.out << ticket_status_tab_ind;
}


void ticket_status_tab_name(Info & i)
{
	if( ticket_status_tab_ind < data.mounts.pmount->param[Mount::par_ticket_status].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_status].arg[ticket_status_tab_ind]);
}


// --------------------------------------------------------------------------------

static size_t ticket_priority_tab_ind;


void ticket_priority_tab(Info & i)
{
	ticket_priority_tab_ind = i.iter;

	i.result = ticket_priority_tab_ind < data.mounts.pmount->param[Mount::par_ticket_priority].arg.size();
}


void ticket_priority_tab_defined(Info & i)
{
	i.result = data.mounts.pmount->param[Mount::par_ticket_priority].defined;
}


void ticket_priority_tab_isdefault(Info & i)
{
	if( request.is_ticket )
	{
		i.result = (ticket_priority_tab_ind == request.ticket.priority);
	}
	else
	{
		Mount::ParamRow & p = data.mounts.pmount->param[Mount::par_ticket_priority_default];

		if( !p.defined || p.arg.empty() )
			return; // default false

		size_t value = atoi( p.arg[0].c_str() );
		i.result = (ticket_priority_tab_ind == value);
	}
}


void ticket_priority_tab_index(Info & i)
{
	i.out << ticket_priority_tab_ind;
}


void ticket_priority_tab_name(Info & i)
{
	if( ticket_priority_tab_ind < data.mounts.pmount->param[Mount::par_ticket_priority].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_priority].arg[ticket_priority_tab_ind]);
}


// --------------------------------------------------------------------------------

static size_t ticket_category_tab_ind;


void ticket_category_tab(Info & i)
{
	ticket_category_tab_ind = i.iter;

	i.result = ticket_category_tab_ind < data.mounts.pmount->param[Mount::par_ticket_category].arg.size();
}


void ticket_category_tab_defined(Info & i)
{
	i.result = data.mounts.pmount->param[Mount::par_ticket_category].defined;
}


void ticket_category_tab_isdefault(Info & i)
{
	if( request.is_ticket )
	{
		i.result = (ticket_category_tab_ind == request.ticket.category);
	}
	else
	{
		Mount::ParamRow & p = data.mounts.pmount->param[Mount::par_ticket_category_default];

		if( !p.defined || p.arg.empty() )
			return; // default false

		size_t value = atoi( p.arg[0].c_str() );
		i.result = (ticket_category_tab_ind == value);
	}
}


void ticket_category_tab_index(Info & i)
{
	i.out << ticket_category_tab_ind;
}


void ticket_category_tab_name(Info & i)
{
	if( ticket_category_tab_ind < data.mounts.pmount->param[Mount::par_ticket_category].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_category].arg[ticket_category_tab_ind]);
}



// --------------------------------------------------------------------------------

static size_t ticket_expected_tab_ind;


void ticket_expected_tab(Info & i)
{
	ticket_expected_tab_ind = i.iter;

	i.result = ticket_expected_tab_ind < data.mounts.pmount->param[Mount::par_ticket_expected].arg.size();
}


void ticket_expected_tab_defined(Info & i)
{
	i.result = data.mounts.pmount->param[Mount::par_ticket_expected].defined;
}


void ticket_expected_tab_isdefault(Info & i)
{
	if( request.is_ticket )
	{
		i.result = (ticket_expected_tab_ind == request.ticket.expected);
	}
	else
	{
		Mount::ParamRow & p = data.mounts.pmount->param[Mount::par_ticket_expected_default];

		if( !p.defined || p.arg.empty() )
			return; // default false

		size_t value = atoi( p.arg[0].c_str() );
		i.result = (ticket_expected_tab_ind == value);
	}
}


void ticket_expected_tab_index(Info & i)
{
	i.out << ticket_expected_tab_ind;
}


void ticket_expected_tab_name(Info & i)
{
	if( ticket_expected_tab_ind < data.mounts.pmount->param[Mount::par_ticket_expected].arg.size() )
		HtmlEscape(i.out, data.mounts.pmount->param[Mount::par_ticket_expected].arg[ticket_expected_tab_ind]);
}



} // namespace TemplatesFunctions