/*
 * This file is a part of Winix
 * and is not publicly distributed
 * 
 * Copyright (c) 2010-2013, Tomasz Sowa
 * All rights reserved.
 * 
 */
 
#include <algorithm>
#include <ctime>
#include "ticketinfo.h"
#include "core/error.h"
#include "core/log.h"
#include "core/misc.h"
#include "core/plugin.h"
#include "pluginmsg.h"
#include "sessiondata.h"



namespace Ticket
{



TicketInfo::TicketInfo()
{
	Clear();
}


void TicketInfo::SetTDb(TDb * ptdb)
{
	tdb = ptdb;
}


void TicketInfo::SetDb(Db * pdb)
{
	db = pdb;
}


void TicketInfo::SetConfig(Config * pconfig)
{
	config = pconfig;
}


void TicketInfo::SetSystem(System * psystem)
{
	system = psystem;
}


void TicketInfo::SetCur(Cur * pcur)
{
	cur = pcur;
}


void TicketInfo::SetFunctions(Functions * pfunctions)
{
	functions = pfunctions;
}



void TicketInfo::Clear()
{
	ticket = &ticket_empty;
	item   = &item_empty;
	ticket->Clear();
	item->Clear();
	// we use meta from item which should not be const

	cur_conf_wrap = &cur_conf_wrap_empty;
	cur_conf      = &cur_conf_empty;
	cur_conf->Clear();

	item_tab.clear();
	ticket_tab.clear();
	item_sort_tab.clear();

	create_new_ticket = false;
}



void TicketInfo::MarkAllConfToDelete()
{
	ConfTab::iterator i = conf_tab.begin();

	for( ; i!=conf_tab.end() ; ++i)
		i->second.to_delete = true;
}


void TicketInfo::DeleteAllMarkedConf()
{
	ConfTab::iterator inext;
	ConfTab::iterator i = conf_tab.begin();

	while( i != conf_tab.end() )
	{
		inext = i;
		++inext;

		if( i->second.to_delete )
		{
			log << log3 << "Ticket: deleting ticket conf for dir id: " << i->first << logend;
			conf_tab.erase(i);
		}

		i = inext;
	}
}


bool TicketInfo::GetConfContent(const std::wstring & path)
{
	int status = system->FollowAllLinks(path, config_dir_tab, config_file, false, false, false);

	if( status != 1 )
	{
		log << log1 << "Ticket: problem with reading a config file: " << path << ", status: " << status << logend;
		return false;
	}

return true;
}


bool TicketInfo::ParseTicketConf(long mount_dir_id, const std::wstring & path)
{
	log << log3 << "Ticket: parsing conf file: " << path << logend;

	conf_tab[mount_dir_id].file_name = path;
	conf_parser.UTF8(true);
	conf_parser.SetSpace(conf_tab[mount_dir_id].conf);
	conf_parser.SplitSingle(true);
	conf_tab[mount_dir_id].conf.Clear();

return (conf_parser.ParseString(config_file.content) == PT::SpaceParser::ok);
}


void TicketInfo::ReadTicketConf(const Mount & mount, bool skip_existing_configs)
{
	if( mount.param[mount_par_ticket_conf].defined &&
		mount.param[mount_par_ticket_conf].arg.size() == 1 )
	{	
		const std::wstring & file_name = mount.param[mount_par_ticket_conf].arg[0];
		ConfTab::iterator c = conf_tab.find(mount.dir_id);
		bool exists = (c != conf_tab.end() && c->second.file_name == file_name);

		if( exists )
			c->second.to_delete = false;

		if( !(skip_existing_configs && exists) )
		{
			if( GetConfContent(file_name) )
			{
				if( !ParseTicketConf(mount.dir_id, file_name) )
					conf_tab[mount.dir_id].to_delete = true;
			}
			else
			{
				if( exists )
					c->second.to_delete = true;
			}
		}
	}
}


// if skip_existing_configs is true then only new config files will be parsed
void TicketInfo::ReadTicketConf(Mounts & mounts, bool skip_existing_configs)
{
	Mounts::MountTab::const_iterator i;
	const Mounts::MountTab * mtab = mounts.GetMountTab();

	// loop through all mount points
	for(i=mtab->begin() ; i!=mtab->end() ; ++i)
	{
		const Mount & mount = i->second;
		ReadTicketConf(mount, skip_existing_configs);
	}
}



// if skip_existing_configs is true then only new config files will be parsed
void TicketInfo::ReadTicketConf(bool skip_existing_configs)
{
	MarkAllConfToDelete();
	ReadTicketConf(system->mounts, skip_existing_configs);
	DeleteAllMarkedConf();
}


void TicketInfo::FindCurrentConf(long dir_id)
{
	Mount * mount = system->mounts.CalcMount(dir_id);

	if( mount )
	{
		// long dir_id = cur->mount->dir_id;
		ConfTab::iterator i = conf_tab.find(mount->dir_id);

		if( i != conf_tab.end() )
		{
			cur_conf_wrap = &i->second;
			cur_conf      = &i->second.conf;
		}
		else
		{
			log << log1 << "Ticket: there is no a ticket_conf parameter in the mount point (an empty config used)" << logend;
		}
	}
	else
	{
		log << log1 << "Ticket: I cannot find the mount point for dir id: " << dir_id << logend;
	}
}


void TicketInfo::FindCurrentConf()
{
	if( !cur->request->dir_tab.empty() )
		FindCurrentConf(cur->request->dir_tab.back()->id);
}




void TicketInfo::CheckMinMaxValue(PT::Space & space, Ticket::TicketParam & par)
{
	if( space.Text(L"type") == L"integer" )
	{
		std::wstring * min_str = space.GetValue(L"min");
		std::wstring * max_str = space.GetValue(L"min");

		if( min_str )
		{
			long minv = Tol(*min_str);

			if( par.intv < minv )
				par.intv = minv;
		}

		if( max_str )
		{
			long maxv = Tol(*max_str);

			if( par.intv > maxv )
				par.intv = maxv;
		}
	}
	else
	if( space.Text(L"type") == L"progress" )
	{
		// !! dodac tez min/max
		if( par.intv < 0 )
			par.intv = 0;

		if( par.intv > 100 )
			par.intv = 100;
	}	
	else
	if( space.Text(L"type") == L"select" ) 
	{
		for(size_t a=0 ; a<space.spaces.size() ; ++a)
		{
			PT::Space & sp = *space.spaces[a];

			if( sp.name == L"option" && sp.Long(L"id") == par.intv )
				return;
		}

		par.intv = Tol(space.Text(L"default"));
	}
}


PT::Space & TicketInfo::FindAddMetaByParam(PT::Space & meta, long param)
{
	for(size_t i=0 ; i<meta.spaces.size() ; ++i)
	{
		PT::Space & sp = *meta.spaces[i];

		if( sp.name == L"param" && sp.Long(L"id") == param )
			return sp;
	}

	PT::Space & sp = meta.AddSpace(L"param");
	sp.Add(L"id", param);

return sp;
}



bool TicketInfo::ReadTicketValue(PT::Space & space, long param_id, Ticket::TicketParam & par, const std::wstring & value, PT::Space & meta)
{
	if( space.Text(L"type") == L"integer"	||
		space.Text(L"type") == L"progress"	||
		space.Text(L"type") == L"select" ) 
	{
		par.intv = Tol(value);
		par.decv.clear();
		CheckMinMaxValue(space, par);
		return true;
	}
	else
	if( space.Text(L"type") == L"string" ||
		space.Text(L"type") == L"multistring" )
	{
		// !! dodac cos co sprawdzi czy string nie zawiera znakow konca linii
		PT::Space & sp = FindAddMetaByParam(meta, param_id);
		sp.Add(L"value", value);
		return false;
	}
	if(	space.Text(L"type") == L"images"	||
		space.Text(L"type") == L"files"		)
	{
		if( !value.empty() )
		{
			log << log1 << "Ticket: images or files should be added only by a specific html tag (ignored)" << logend;
		}
		else
		{
			// an empty field from the html form (ignoring)
		}

		return false;
	}
	else
	{
		// !! dodac obsluge komunikatow
		// niech zostanie wyslany komunikat o dodawaniu nieznanego parametru
		// i jesli nic nie odpowie na ten komunikat to wtedy zglaszamy blad
		log << log1 << "Ticket: incorrect parameter, param: " << par.param << ", value: " << value << " (ignored)" << logend;
	}

return false;
}



void TicketInfo::ReadTicketValue(PT::Space & space,
								 long param_id,
								 const PostFile & value,
								 PT::Space & meta,
								 Item & upload_dir)
{
	file.Clear(); // clearing and setting date
	file.parent_id  = upload_dir.id;
	file.type       = Item::file;
	file.privileges = system->NewFilePrivileges();
	file.file_type  = SelectFileType(value.filename);
	file.url        = value.filename;
	functions->PrepareUrl(file);
	functions->SetUser(file);
	functions->fun_upload.UploadFile(file, value.tmp_filename);

	if( cur->request->status == WINIX_ERR_OK )
	{
		PT::Space & space = FindAddMetaByParam(meta, param_id);
		PT::Space & file_space = space.AddSpace(L"file");

		if( file.file_type == WINIX_ITEM_FILETYPE_IMAGE )
			file_space.Add(L"type", L"image");
		else
			file_space.Add(L"type", L"file");

		file_space.Add(L"itemid", file.id);
		system->MakePath(file, file_path);
		file_space.Add(L"path", file_path);
	}
	else
	{
		log << log1 << "Ticket: problem with uploading" << logend;
	}
}


void TicketInfo::ReadTicketValue(PT::Space & space,
								 long param_id, const PostFile & value, PT::Space & meta)
{
	if( space.Text(L"type") == L"images" || space.Text(L"type") == L"files" )
	{
		std::wstring & upload_path = space.Text(L"upload_dir");

		if( !upload_path.empty() )
		{
			Item * upload_dir = system->dirs.GetDir(upload_path);

			if( upload_dir )
				ReadTicketValue(space, param_id, value, meta, *upload_dir);
			else
				log << log1 << "Ticket: there is no an upload directory: " << upload_path << logend;
		}
		else
		{
			log << log1 << "Ticket: you must set 'upload_dir' directory in the config" << logend;
		}
	}
}



// adding a new parameter only if it not exists in ticket.par_tab
void TicketInfo::ReadTicketParam(PT::Space & space, Ticket & ticket, long param_id, const std::wstring & value, PT::Space & meta)
{
	ticket_param.param = param_id;

	for(size_t i2=0 ; i2<ticket.par_tab.size() ; ++i2)
	{
		if( ticket.par_tab[i2].param == param_id )
		{
			// parameter param_id already exists in ticket.par_tab
			// (overwritting)

			if( ReadTicketValue(space, param_id, ticket_param, value, meta) )
				ticket.par_tab[i2] = ticket_param;

			return;
		}
	}

	// adding a new parameter param_id
	if( ReadTicketValue(space, param_id, ticket_param, value, meta) )
		ticket.par_tab.push_back(ticket_param);
}



void TicketInfo::ReadTicketParam(Ticket & ticket, long param_id, const std::wstring & value, PT::Space & meta)
{
	ticket_param.Clear();

	for(size_t i=0 ; i<cur_conf->spaces.size() ; ++i)
	{
		PT::Space & space = *cur_conf->spaces[i];

		if( space.name == L"param" && Tol(space.Text(L"id")) == param_id )
		{
			ReadTicketParam(space, ticket, param_id, value, meta);
			return;
		}
	}

	log << log1 << "Ticket: skipped incorrect parameter: " << param_id << " (not defined in the config)" << logend;
}


// always adds a new parameter
void TicketInfo::ReadTicketParam(long param_id, const PostFile & value, PT::Space & meta)
{
	for(size_t i=0 ; i<cur_conf->spaces.size() ; ++i)
	{
		PT::Space & space = *cur_conf->spaces[i];

		if( space.name == L"param" && space.Long(L"id") == param_id )
		{
			ReadTicketValue(space, param_id, value, meta);
			return;
		}
	}

	log << log1 << "Ticket: skipped incorrect parameter: " << param_id << " (not defined in the config)" << logend;
}





bool TicketInfo::DeleteTicketFile(Ticket & ticket, long file_id, PT::Space & meta)
{
	for(size_t i=0 ; i<meta.spaces.size() ; ++i)
	{
		PT::Space & param = *meta.spaces[i];

		if( param.name == L"param" )
		{
			for(size_t z=0 ; z<param.spaces.size() ; ++z)
			{
				PT::Space & file = *param.spaces[z];

				if( file.name == L"file" )
				{
					if( file.Long(L"itemid") == file_id )
					{
						param.RemoveSpace(z);

						// !! IMPROVE ME
						// temporarily we delete the file here
						// but it should be really deleted when the user will press
						// the submit button
						//functions->fun_rm.RemoveFileOrSymlink(file_id, true);

						return true;
					}
				}
			}
		}
	}

return false;
}



void TicketInfo::ReadTicketParams(Ticket & ticket, bool clear_ticket, PT::Space & meta, bool & file_was_deleted)
{
PostTab::iterator i;
PostFileTab::iterator i2;

	file_was_deleted = false;

	if( clear_ticket )
		ticket.Clear();

	// !! IMPROVE ME move me somewhere
	std::wstring ticket_delete_prefix = L"ticketdeletefile_";

	for(i=cur->request->post_tab.begin() ; i!=cur->request->post_tab.end() ; ++i)
	{
		// !! CHECKME why ticket_form_prefix is in the global config?
		// (this is a plugin variable)
		if( IsSubString(config->ticket_form_prefix, i->first) )
		{
			long param_id = Tol(i->first.c_str() + config->ticket_form_prefix.size());
			ReadTicketParam(ticket, param_id, i->second, meta);
		}

		if( IsSubString(ticket_delete_prefix, i->first) )
		{
			long file_id = Tol(i->first.c_str() + ticket_delete_prefix.size());

			if( DeleteTicketFile(ticket, file_id, meta) )
			{
				file_was_deleted = true;
			}
		}
	}

	for(i2=cur->request->post_file_tab.begin() ; i2!=cur->request->post_file_tab.end() ; ++i2)
	{
		if( IsSubString(config->ticket_form_prefix, i2->first) )
			ReadTicketParam(Tol(i2->first.c_str() + config->ticket_form_prefix.size()), i2->second, meta);
	}

	ticket.SortParTab();
}




void TicketInfo::RemoveTicket(long file_id)
{
	/*
	 * IMPROVEME
	 * we should also remove some files (images) for a ticket
	 * may when 'rm' function is displayed we should show some checkboxes
	 * 'remove static files etc.' and if they are checked then the files are removed?
	 *
	 */

	if( tdb->GetTicket(file_id, rm_ticket) == WINIX_ERR_OK )
	{
		tdb->RemoveTicket(file_id);
	}
}


void TicketInfo::CopyTicketSpace(PT::Space & ticket_space, Item & item)
{
	PT::Space & ticket_meta = item.meta.FindAddSpace(L"ticket");
	ticket_meta             = ticket_space;
	ticket_meta.name        = L"ticket";
}



void TicketInfo::MakeRedirectIfPossible(const Item & item)
{
	PluginRes res = plugin.Call(WINIX_PL_TICKET_CAN_MAKE_REDIRECT);

	if( res.res_false > 0 )
	{
		log << log4 << "Ticket: redirect prevented" << logend;
		return;
	}

	system->RedirectTo(item);
}



} // namespace