Config.cpp

#include "Config.hpp"

Config::Config(void):temp_index(""), temp_root(""),
					_port(DEFAULT_PORT),
					_c_body_limit(1),
					_ip(DEFAULT_IP),
					_server_name(DEFAULT_SERVERNAME)
{
	for (int i = 0; i < SERV_VAL_COUNT; i++)
		dir_count[i] = false;
	// std::cout << "Config constructor called" << std::endl;
}

Config::Config(const Config& other)
    : temp_index(other.temp_index),
	  temp_root(other.temp_root),
	  _port(other._port),
	  _c_body_limit(other._c_body_limit),
	  _ip(other._ip),
      _server_name(other._server_name)
{
	// std::cout << "Config: Copy Constructor called" << std::endl;
	for (int i = 0; i < SERV_VAL_COUNT; i++)
		dir_count[i] = other.dir_count[i];
    // Deep copy the error pages map
    if (!temp_error_pages.empty())
    	temp_error_pages.clear();
    temp_error_pages = other.temp_error_pages;

    // //Create clean copies of all Location objects
    // std::map<std::string, Location> sourceLocations = other.get_all_Locations();

    // clear it just to be safe
    if (!_locations.empty())
    	_locations.clear();

    _locations = other.get_all_Locations();

    // // Create fresh copies of all locations using the copy constructor
    // for (std::map<std::string, Location>::const_iterator it = sourceLocations.begin();
    //      it != sourceLocations.end(); ++it) {
    //     Location locCopy(it->second);
    //     // Insert directly
    //     _locations[it->first] = locCopy;
    // }

}

Config& Config::operator=(const Config& other) {
	// std::cout << "Config: Copy Assignment Operator called" << std::endl;
    // Defensive self-assignment check
    if (this != &other) {
        // Explicit deep copy of ALL members
        _port = other._port;
        _c_body_limit = other._c_body_limit;
        _ip = other._ip;
        _server_name = other._server_name;

        // Deep copy temporary elements
        temp_index = other.temp_index;
        temp_root = other.temp_root;

        for (int i = 0; i < SERV_VAL_COUNT; i++)
			dir_count[i] = other.dir_count[i];

		// Deep copy the error pages map
		if (!temp_error_pages.empty())
			temp_error_pages.clear();

		temp_error_pages = other.temp_error_pages;

        // // Deep copy error pages
        // temp_error_pages.clear();
        // for (std::map<std::string, std::string>::const_iterator it =
        //      other.temp_error_pages.begin();
        //      it != other.temp_error_pages.end(); ++it) {
        //     temp_error_pages[it->first] = it->second;
        // }

        // clear it just to be safe
        //_locations.clear();

        // // Deep copy locations
        // const std::map<std::string, Location>& srcLocations = other.get_all_Locations();
        // for (std::map<std::string, Location>::const_iterator it = srcLocations.begin();
        //      it != srcLocations.end(); ++it) {
        //     // Explicit deep copy of each location
        //     Location locCopy(it->second);
        //     _locations[it->first] = locCopy;
        // }

        // clear it just to be safe
		if (!_locations.empty())
			_locations.clear();

		_locations = other.get_all_Locations();
    }
    return *this;
}

bool is_ipv4(std::string ip)
{
	std::stringstream 	ss(ip);
	std::string 		block;
	int 				blocks = 0;

	while(std::getline(ss,block,'.'))
	{
		if (block.empty() || std::atoi(block.c_str()) < 0 || std::atoi(block.c_str()) > 255)
			return (false);
		blocks++;
	}
	if (blocks != 4)
		return (false);
	return (true);
}

//LISTEN
void	Config::set_port(int port)
{
	// min max values?
	if (dir_count[LISTEN] == true)
		return;
	_port = port;
	dir_count[LISTEN] = true;
}

//HOST
bool	Config::set_ip(std::string ip)
{
	if (dir_count[HOST] == true)
		return (false);
	if (ip == std::string("localhost"))
		_ip = DEFAULT_IP;
	else if (ip.empty())
		return (false);
	else if (!is_ipv4(ip))
		return (false);
	else
		_ip = ip;
	dir_count[HOST] = true;
	return (true);

}

//C_BODY_LIM
bool	Config::set_c_body_limit(int limit)
{
	//min max values
	if (dir_count[C_BODY_LIM] == true)
		return (false);
	if (limit >= 0 && limit <= INT_MAX)
		_c_body_limit = limit;
	else
		return (false);
	dir_count[C_BODY_LIM] = true;
	return (true);
}

//SERVER_NAME
void	Config::set_server_name(std::string server_name)
{
	if (dir_count[SERVER_NAME] == true)
		return;
	_server_name = server_name;
	dir_count[SERVER_NAME] = true;
}

std::map<std::string, Location> &Config::UNIT_get_locations(void)
{
	return (_locations);
}

bool	Config::add_location(std::string path, Location loc)
{
	std::pair< std::map<std::string, Location>::iterator, bool > ret;

	// if path is not already in _locations
	// Assume Location loc was able to initialize because everything in the location exists and works
	std::map<std::string, Location>::iterator it = _locations.find(path);
	if (it == _locations.end())
	{
			ret = _locations.insert(std::pair<std::string, Location>(path, loc));
			if (ret.second)
				return (true);
			else
				std::cerr << "_locations: map insertion error" << std::endl;
	}
	std::cout << path << " already exists" << std::endl;
	return (false);
}

int		Config::get_port(void) const
{
	return (_port);
}

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

std::string		Config::get_ip(void) const
{
	return (_ip);
}

std::string		Config::get_server_name(void) const
{
	return (_server_name);
}

bool	Config::location_exists(std::string path)
{
	std::map<std::string, Location>::iterator it = _locations.find(path);
	if (it != _locations.end())
		return (true);
	// std::cout << "not end" << std::endl;
	return (false);
}

/*
Always use find_location() if location exists == true ONLY
*/
Location 	Config::find_location(std::string	path)
{
	std::map<std::string, Location>::iterator it = _locations.find(path);
	// +++++++ add debugging and a proper alternative here ++++++++++++
	// if (it == _locations.end()) {
	// 	debug("[find_location]: No such location");
	// 	return _locations[0];
	// }
	return (it->second);
}

std::map<std::string, Location>	Config::get_all_Locations(void) const
{
	return (_locations);
}

bool	Config::update_location(Location loc, std::string path, std::string new_path)
{
	if (!location_exists(path))
	{
		std::cout << path << "is not in map, add location instead.\n";
		return (false);
	}
	std::pair< std::map<std::string, Location>::iterator, bool > ret;
	if (_locations.erase(path) != 1)
		return (false);
	ret = _locations.insert(std::pair<std::string, Location>(new_path, loc));
	return (ret.second);
}

/*
	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	Config::set_temp_error_page(std::string key, std::string value)
{
	std::pair<std::map<std::string, std::string>::iterator, bool> ret;
	ret = temp_error_pages.insert(std::pair<std::string,std::string>(key, value));
	if (ret.second == true)
		return (true);
	else if (ret.first != temp_error_pages.end())
	{
		temp_error_pages.erase(ret.first);
		ret = temp_error_pages.insert(std::pair<std::string,std::string>(key, value));
		if (ret.second == true)
			return (true);
		else
			return (false);
	}
	return (false);
}


std::ostream&	operator<<(std::ostream& streamRef, const Config& conf)
{
	streamRef << "host: " << conf.get_ip() << "port: " << conf.get_port() << "\tserver_name: " << conf.get_server_name();
	streamRef << "\ttemp root: " << conf.temp_root << "\ttemp index: " << conf.temp_index << std::endl;
	int i = 1;
	std::map<std::string, Location> loc = conf.get_all_Locations();
	std::map<std::string, Location>::iterator it;

	for (it = loc.begin(); it != loc.end(); it++)
	{
		streamRef << "Loc "<< i << ": " << it->first << it->second << std::endl;
		i++;
	}
	return (streamRef);
}