Location.cpp

#include "Location.hpp"
#include "Debug.hpp"

Location::Location(void): _get(true),
						_post(true),
						_delete(true),
						_root(""),
						_index(""),
						_return(0),
						_autoindex(false),
						_c_body_limit(1),
						_upload_path(""),
						_cgi_path("")

//_root(DEFAULT_ROOT), _index(DEFAULT_INDEX)
{
	for (int i = 0; i < LOC_VAL_COUNT; i++)
		dir_count[i] = false;
	// check if root exists?
	// if root/index.html exists add to index else throw exception? find another index?
	// std::cout << "Location default constructor called." << std::endl;
}

Location::Location(std::string root, std::string index):_get(true),
						_post(true),
						_delete(true),
						_root(root),
						_index(index),
						_return(0),
						_autoindex(false),
						_c_body_limit(1),
						_upload_path(""),
						_cgi_path("")
{
	for (int i = 0; i < LOC_VAL_COUNT; i++)
		dir_count[i] = false;

	// std::cout << "Location constructor called." << std::endl;
}

/*
	Copy constructor
	usage: for server level error pages
*/
Location::Location(const Location &rhs)
{
	// std::cout << "Location: Copy Constructor called" << std::endl;
	for (int i = 0; i < LOC_VAL_COUNT; i++)
		dir_count[i] = rhs.dir_count[i];
	_get = rhs.get_allowed();
	_post = rhs.post_allowed();
	_delete = rhs.delete_allowed();
	_root = rhs.get_root();
	_index = rhs.get_index();
	if (!_error_pages.empty())
		_error_pages.clear();
	_error_pages = rhs.get_all_error_pages();
	_return = rhs.get_return_type();
	std::pair<int, std::string> ret = rhs.get_return();
	if (ret.first != -1)
	{
		_return_code = ret.first;
		_return_url = ret.second;
	}
	_autoindex = rhs.is_autoindex();
	_c_body_limit = rhs.get_c_body_limit();
	_upload_path = rhs.get_upload_path();
	_cgi_path = rhs.get_cgi_path();
}

/* Copy assignment operator overload */
Location&	Location::operator=(const Location &rhs)
{
	// std::cout << "Location: Copy Assignment Operator called" << std::endl;
	for (int i = 0; i < LOC_VAL_COUNT; i++)
		dir_count[i] = rhs.dir_count[i];
	_get = rhs.get_allowed();
	_post = rhs.post_allowed();
	_delete = rhs.delete_allowed();
	_root = rhs.get_root();
	_index = rhs.get_index();
	if (!_error_pages.empty())
		_error_pages.clear();
	_error_pages = rhs.get_all_error_pages();
	_return = rhs.get_return_type();
	std::pair<int, std::string> ret = rhs.get_return();
	if (ret.first != -1)
	{
		_return_code = ret.first;
		_return_url = ret.second;
	}
	_autoindex = rhs.is_autoindex();
	_c_body_limit = rhs.get_c_body_limit();
	_upload_path = rhs.get_upload_path();
	_cgi_path = rhs.get_cgi_path();
	return (*this);
}

std::string 	Location::get_upload_path(void) const
{
	return (_upload_path);
}

int 	Location::get_c_body_limit(void) const
{
	return (_c_body_limit);
}

void	Location::set_get(bool permission)
{
	_get = permission;
}

void	Location::set_post(bool permission)
{
	_post = permission;
}

void	Location::set_delete(bool permission)
{
	_delete = permission;
}

bool	Location::set_limit_except(bool get, bool post, bool del)
{
	if (dir_count[LIMIT_EXCEPT] == true)
		return (false);
	dir_count[LIMIT_EXCEPT] = true;
	this->set_get(get);
	this->set_post(post); 
	this->set_delete(del);
	return (true);
}

bool	Location::set_upload_path(std::string upload_path)
{
	if (dir_count[UPLOAD_PATH] == true)
		return (false);
	dir_count[UPLOAD_PATH] = true;
	_upload_path = upload_path;
	return (true);

}

bool	Location::set_cgi_path(std::string cgi_path)
{
	if (dir_count[CGI] == true)
		return (false);
	dir_count[CGI] = true;
	_cgi_path = cgi_path;
	return (true);
}

bool	Location::is_cgi(void) const
{
	if (dir_count[CGI] == true)
		return (true);
	return (false);
}

std::string Location::get_cgi_path(void) const
{
	return (_cgi_path);
}

bool	Location::set_root(std::string root)
{
	// check if root exists?
	if (dir_count[ROOT] == true)
		return (false);
	dir_count[ROOT] = true;
	_root = root;
	return (true);

}

int Location::get_return_type(void) const
{
	return (_return);
}

int	Location::set_return(int code, std::string url)
{
	if (dir_count[RETURN] == true)
		return (-1);
	dir_count[RETURN] = true;
	_return_url = url;
	_return_code = code;
	if (url[0] == std::string("\\")[0])
		_return = 2;
	else
		_return = 1;
	return (_return);
}

bool	Location::is_return(void) const
{
	if (_return == 1 || _return == 2)
		return (true);
	return (false);
}

std::pair<int, std::string> Location::get_return(void) const
{
	std::pair<int, std::string> ret;
	if (this->is_return())
		ret = std::pair<int, std::string>(_return_code, _return_url);
	else
		ret = std::pair<int, std::string>(-1, "");
	return (ret);
}

/*
	If error page does not exist, the page is aded to map as key, value pair
	If error page already exists, old page is removed and new one added
*/
bool	Location::set_error_page(std::string key, std::string value)
{
	std::pair<std::map<std::string, std::string>::iterator, bool> ret;
	ret = _error_pages.insert(std::pair<std::string,std::string>(key, value));
	if (ret.second == true)
		return (true);
	else if (ret.first != _error_pages.end())
	{
		_error_pages.erase(ret.first);
		ret = _error_pages.insert(std::pair<std::string,std::string>(key, value));
		if (ret.second == true)
			return (true);
		else
			return (false);
	}
	return (false);
}

bool	Location::set_index(std::string index)
{
	// if index file exists in root or given location?
	if (dir_count[INDEX] == true)
		return (false);
	dir_count[INDEX] = true;
	_index = index;
	return (true);
}

bool	Location::set_c_body_limit(int limit)
{
	if (dir_count[C_BODY_LIMIT] == true)
		return (false);
	else
		dir_count[C_BODY_LIMIT] = true;
	if (limit >= 0 && limit <= INT_MAX)
		_c_body_limit = limit;
	else
		return (false);
	return (true);
}

bool Location::set_autoindex(bool val)
{
	if (dir_count[AUTOINDEX] == true)
		return (false);
	dir_count[AUTOINDEX] = true;
	_autoindex = val;
	return (true);
}

bool	Location::is_autoindex(void) const
{
	if (_autoindex)
		return (true);
	return (false);
}

bool	Location::get_allowed(void) const
{
	if (_get)
		return (true);
	return (false);
}

bool	Location::post_allowed(void) const
{
	if (_post)
		return (true);
	return (false);
}

bool	Location::delete_allowed(void) const
{
	if (_delete)
		return (true);
	return (false); 
}

std::string	Location::get_root(void) const
{
	return (_root);
}

std::string	Location::get_index(void) const
{
	return (_index);
}

/*
	Fist digit match of key
*/

std::pair<std::map<std::string, std::string>::iterator, bool>	find_partial(std::map<std::string, std::string> pages, std::string key)
{
	// std::string gen_code(key[0] + std::string("xx"))
	for (std::map<std::string,std::string>::iterator it = pages.begin();
		it != pages.end();
		it++)
	{
		if (it->first[0] == key[0])
			return (std::pair<std::map<std::string, std::string>::iterator, bool>(it, true));
	}
	return (std::pair<std::map<std::string, std::string>::iterator, bool>(pages.end(), false));
}

/*
	If error code match cannot be found : Look for partial match
		If error code partial match cannot be found:
			return : std::pair<map.end(),false>
		If error code partial match can be found:
			return : std::pair<it,true>
	If error code match can be found
		return : std::pair<it,true>
*/
std::pair<std::map<std::string, std::string>::iterator, bool>	Location::get_error_page(std::string err_no)
{
	std::map<std::string,std::string>::iterator it = _error_pages.find(err_no);
	if (it == _error_pages.end())
	{
		std::pair<std::map<std::string, std::string>::iterator, bool> ret = find_partial(_error_pages, err_no);
		return (ret);
	}
	return (std::pair<std::map<std::string, std::string>::iterator, bool>(it,true));
}

std::map<std::string, std::string>	Location::get_all_error_pages(void) const
{
	return (_error_pages);
	// std::map<std::string, std::string> ret;

	// for (std::map<std::string, std::string>::const_iterator it = _error_pages.begin(); it != _error_pages.end(); it++)
	// {
	// 	ret.insert(std::pair<std::string, std::string>(it->first, it->second));
	// }
	// return (ret);
}

std::map<std::string, std::string> &Location::UNIT_get_error_pages(void)
{
	return (_error_pages);
}


std::ostream&	operator<<(std::ostream& streamRef, const Location& loc)
{
	streamRef << " root: " << loc.get_root();
	streamRef << " index: " << loc.get_index();
	streamRef << " autoindex " <<  loc.is_autoindex();
	streamRef << " c_body_limit " <<  loc.get_c_body_limit();
	streamRef << " upload_path " <<  loc.get_upload_path() << std::endl;
	streamRef << " permissions: (Get Post Delete): ";
	if (loc.get_allowed())
		streamRef << "1";
	else
		streamRef << "0";
	if (loc.post_allowed())
		streamRef << "1";
	else
		streamRef << "0";
	if (loc.delete_allowed())
		streamRef << "1";
	else
		streamRef << "0";
	streamRef << std::endl;
	streamRef << "return: " << loc.get_return_type() << " code: " << loc.get_return().first;
	streamRef << " url: " << loc.get_return().second << std::endl;
	
	streamRef << "Error pages: " << std::endl;
	std::map<std::string, std::string> ret = loc.get_all_error_pages();
	for (std::map<std::string, std::string>::iterator i = ret.begin(); i!= ret.end(); i++)
	{
		streamRef << i->first << " " << i->second << std::endl;
	}
	return (streamRef);
}