FileManager.cpp

#include "FileManager.hpp"
#include "Utils.hpp"
#include <cstring>
#include <ctime>
#include <limits.h>
#include <unistd.h>
#include <errno.h>
#include <set>


FileManager::FileManager(Config& config) : config(config) {
    importantExtensions.push_back(".conf");
    importantExtensions.push_back(".key");
    importantExtensions.push_back(".cert");
    importantExtensions.push_back(".db");

    initializeMimeTypes();

    try {
        cachedLocations = config.get_all_Locations();

        // Debug: print out all cached locations
        debug("[FileManager]: Cached " + Utils::to_string(cachedLocations.size()) + " locations");

        // Print out the locations for verification
        for (std::map<std::string, Location>::const_iterator it = cachedLocations.begin();
             it != cachedLocations.end(); ++it) {
            debug("Cached Location: " + it->first + ", Root: " + it->second.get_root());
        }
    } catch (const std::exception& e) {
        debug("[FileManager]: Error caching locations: " + std::string(e.what()));
    }
}

FileManager::~FileManager() {
    // No resources to clean up
}

void FileManager::initializeMimeTypes() {
    // Common MIME types
    mimeTypes[".html"] = "text/html";
    mimeTypes[".htm"] = "text/html";
    mimeTypes[".css"] = "text/css";
    mimeTypes[".js"] = "application/javascript";
    mimeTypes[".json"] = "application/json";
    mimeTypes[".txt"] = "text/plain";
    mimeTypes[".jpg"] = "image/jpeg";
    mimeTypes[".jpeg"] = "image/jpeg";
    mimeTypes[".png"] = "image/png";
    mimeTypes[".gif"] = "image/gif";
    mimeTypes[".svg"] = "image/svg+xml";
    mimeTypes[".ico"] = "image/x-icon";
    mimeTypes[".pdf"] = "application/pdf";
    mimeTypes[".xml"] = "application/xml";
}

std::string FileManager::findBestLocationMatch(const std::string& path) const {
    // Defensive checks
    if (path.empty()) {
        return "/";
    }

    if (cachedLocations.empty()) {
        return "/";
    }

    // Normalize the request path
    std::string normalizedPath = path;
    // Ensure path starts with '/'
    if (normalizedPath[0] != '/') {
        normalizedPath = "/" + normalizedPath;
    }
    
    // Remove trailing slash for comparison purposes
    if (normalizedPath.length() > 1 && normalizedPath[normalizedPath.length() - 1] == '/') {
        normalizedPath = normalizedPath.substr(0, normalizedPath.length() - 1);
    }
    
    debug("[findBestLocationMatch]: Normalized path: " + normalizedPath);

    // First try exact match
    if (cachedLocations.find(normalizedPath) != cachedLocations.end()) {
        return normalizedPath;
    }

    // Try with trailing slash variant
    std::string pathWithSlash = normalizedPath + '/';
    if (cachedLocations.find(pathWithSlash) != cachedLocations.end()) {
        return pathWithSlash;
    }

    // Try with path without trailing slash
    if (normalizedPath[normalizedPath.length() - 1] == '/') {
        std::string pathWithoutSlash = normalizedPath.substr(0, normalizedPath.length() - 1);
        if (cachedLocations.find(pathWithoutSlash) != cachedLocations.end()) {
            return pathWithoutSlash;
        }
    }

    // If still no match, find the best prefix match
    std::string bestMatch = "/";
    size_t longestMatchLength = 0;

    for (std::map<std::string, Location>::const_iterator it = cachedLocations.begin();
         it != cachedLocations.end(); ++it) {
        std::string locationPath = it->first;

        // Ensure location path starts with '/'
        if (locationPath[0] != '/') {
            locationPath = "/" + locationPath;
        }
        
        // Remove trailing slash for comparison
        if (locationPath.length() > 1 && locationPath[locationPath.length() - 1] == '/') {
            locationPath = locationPath.substr(0, locationPath.length() - 1);
        }

        // Simple prefix matching
        if (normalizedPath == locationPath ||
            (normalizedPath.find(locationPath) == 0 &&
             (locationPath == "/" ||
              normalizedPath.length() == locationPath.length() ||
              normalizedPath[locationPath.length()] == '/'))) {

            if (locationPath.length() > longestMatchLength) {
                bestMatch = it->first; // Use the original key
                longestMatchLength = locationPath.length();
                debug("[findBestLocationMatch]: New best match: " + bestMatch + 
                      " (length: " + Utils::to_string(longestMatchLength) + ")");
            }
        }
    }

    debug("[findBestLocationMatch]: Best match for " + path + " is " + bestMatch);
    return bestMatch;
}

// Non-const version - simply calls the const version
std::string FileManager::findBestLocationMatch(const std::string& path) {
    // Call the const version using const_cast to avoid code duplication
    return const_cast<const FileManager*>(this)->findBestLocationMatch(path);
}

bool FileManager::createDirectory(const std::string& path) {
    debug("[createDirectory]: Attempting to create directory: " + path);

    // Create directory with 0755 permissions (user: rwx, group: r-x, others: r-x)
    if (mkdir(path.c_str(), 0755) == 0) {
        debug("[createDirectory]: Directory created successfully: " + path);
        return true;
    }

    // Check if directory already exists
    if (errno == EEXIST) {
        bool isDir = isDirectory(path);
        debug("[createDirectory]: Directory already exists: " + path + ", isDir: " + (isDir ? "true" : "false"));
        return isDir;
    }

    debug("[createDirectory]: Failed to create directory: " + path);
    return false;
}

void FileManager::updateConfig(const Config& newConfig) {
    debug("[FileManager]: Updating configuration to " + newConfig.get_server_name());

    try {
        // First, make a deep copy of the new config to work with
        Config tempConfig(newConfig);
        
        // Clear all cached locations before changing anything
        cachedLocations.clear();
        
        // Now assign the new config
        config = tempConfig;
        
        // Get a fresh reference to all locations from the updated config
        const std::map<std::string, Location>& locations = config.get_all_Locations();
        
        // Copy each location using a safer approach
        for (std::map<std::string, Location>::const_iterator it = locations.begin();
             it != locations.end(); ++it) {
            // Create a new location and insert it into the map
            cachedLocations.insert(std::make_pair(it->first, Location(it->second)));
        }
        
        debug("[FileManager]: Updated configuration with " +
              Utils::to_string(cachedLocations.size()) + " locations");
    }
    catch (const std::exception& e) {
        debug("[FileManager]: Exception updating configuration: " + std::string(e.what()));
    }
}

std::string FileManager::resolveFilePath(const std::string& requestUri, const std::string& method) {
    debug("[resolveFilePath]: Resolving path for: " + requestUri + " (Method: " + method + ")");

    // Prevent path traversal attacks
    if (detectPathTraversal(requestUri)) {
        debug("[resolveFilePath]: Potential path traversal detected");
        return "?forbidden";
    }

    // Normalize the path
    std::string normalizedUri = normalizePath(requestUri);

    // Find the best matching location
    std::string bestMatch = findBestLocationMatch(normalizedUri);

    if (bestMatch.empty()) {
        debug("[resolveFilePath]: No location match found");
        return "?notfound";
    }

    // Retrieve the location
    std::map<std::string, Location>::const_iterator locIt = cachedLocations.find(bestMatch);
    if (locIt == cachedLocations.end()) {
        debug("[resolveFilePath]: Location not found in cache");
        return "?notfound";
    }
    const Location& location = locIt->second;

    // Check if this location has an upload path
    bool hasUploadPath = !location.get_upload_path().empty();
    //debug("[resolveFilePath]: Location has upload_path: " + (hasUploadPath ? "yes" : "no"));
    
    // Handle upload locations specifically for POST and DELETE
    if (hasUploadPath) {
        //debug("[resolveFilePath]: Location has upload_path configured: " + location.get_upload_path());
        
        // For POST requests, just return the URI for special handling
        if (method == "POST") {
            debug("[resolveFilePath]: POST request to upload location");
            return requestUri;
        }
        
        // For DELETE requests, handle file deletion
        if (method == "DELETE") {
            std::string uploadPath = location.get_upload_path();
            std::string filename = normalizedUri.substr(normalizedUri.find_last_of("/") + 1);
            std::string specificPath = uploadPath + "/" + filename;
            debug("[resolveFilePath]: DELETE request for uploaded file: " + specificPath);
            return specificPath;
        }
    }

    // For GET requests and other methods, use the location's root path
    std::string rootPath = location.get_root();
    debug("[resolveFilePath]: Root path from location: " + rootPath);

    if (!rootPath.empty() && rootPath[0] != '/') {
        char cwd[PATH_MAX];
        if (getcwd(cwd, sizeof(cwd)) != NULL) {
            rootPath = std::string(cwd) + "/" + rootPath;
            debug("[resolveFilePath]: Converted relative root to: " + rootPath);
        }
    }

    if (!rootPath.empty() && rootPath[rootPath.length() - 1] != '/') {
        rootPath += '/';
    }

    std::string relativePath = "";
    // Handle special location blocks first
    if (bestMatch != "/" && bestMatch.length() > 1) {
        // For specific location blocks like "/css", "/js", etc.
        debug("[resolveFilePath]: Found specific location match: " + bestMatch);
        
        // Check if the request URI exactly matches the location or contains additional path components
        if (normalizedUri.length() > bestMatch.length()) {
            // Extract the part after the location path (e.g., for "/js/script.js", extract "script.js")
            relativePath = normalizedUri.substr(bestMatch.length());
            if (relativePath[0] == '/') {
                relativePath = relativePath.substr(1); // Remove leading slash
            }
        } else {
            // The URI exactly matches the location path (e.g., "/js" matches "/js")
            relativePath = ""; // Empty relative path
        }
    } else {
        // For the root location ("/"), try to find specialized locations first
        bool foundSpecialized = false;
        
        // Check if the URI starts with a path that matches a more specific location
        for (std::map<std::string, Location>::const_iterator it = cachedLocations.begin();
             it != cachedLocations.end(); ++it) {
            
            std::string locPath = it->first;
            
            // Skip the root location
            if (locPath == "/") {
                continue;
            }
            
            // Check if this location is a prefix of the request URI
            if (normalizedUri.find(locPath) == 0) {
                // If we have /js as location and /js/script.js as URI, use the js location
                debug("[resolveFilePath]: Found specialized location for URI: " + locPath);
                
                // Get the corresponding location block
                const Location& specLocation = it->second;
                
                // Use this location's root path instead
                rootPath = specLocation.get_root();
                debug("[resolveFilePath]: Using specialized root path: " + rootPath);
                
                // Make it absolute if needed
                if (!rootPath.empty() && rootPath[0] != '/') {
                    char cwd[PATH_MAX];
                    if (getcwd(cwd, sizeof(cwd)) != NULL) {
                        rootPath = std::string(cwd) + "/" + rootPath;
                        debug("[resolveFilePath]: Converted specialized root to: " + rootPath);
                    }
                }
                
                // Ensure it ends with a slash
                if (!rootPath.empty() && rootPath[rootPath.length() - 1] != '/') {
                    rootPath += '/';
                }
                
                // Get the part after the location path
                if (normalizedUri.length() > locPath.length()) {
                    relativePath = normalizedUri.substr(locPath.length());
                    if (relativePath[0] == '/') {
                        relativePath = relativePath.substr(1);
                    }
                }
                
                foundSpecialized = true;
                break;
            }
        }
        
        // If no specialized location found, handle as regular root location
        if (!foundSpecialized) {
            // For the root location, preserve the original path structure but strip any prefixes
            // like "/webserv/websites/var/www/html" that might match the root path
            
            // Skip the leading slash
            relativePath = normalizedUri.substr(1);
            
            // Check if the URI starts with a prefix that matches the root path
            std::string rootDir = rootPath;
            if (!rootDir.empty() && rootDir[rootDir.size() - 1] == '/') {
            rootDir.erase(rootDir.size() - 1); // Remove trailing slash for comparison
            }           

            
            // Get just the directory name from the root path
            std::string rootDirName = rootDir;
            size_t lastSlash = rootDirName.find_last_of('/');
            if (lastSlash != std::string::npos) {
                rootDirName = rootDirName.substr(lastSlash + 1);
            }
            
            // If the URI starts with the root dir name (e.g., "chihuahua" or "webserv"), strip it
            if (relativePath.find(rootDirName) == 0) {
                debug("[resolveFilePath]: Stripping root dir name from path: " + rootDirName);
                relativePath = relativePath.substr(rootDirName.length());
                if (!relativePath.empty() && relativePath[0] == '/') {
                    relativePath = relativePath.substr(1);
                }
            }
        }
    }
    debug("[resolveFilePath]: Relative path: " + relativePath);

    std::string fullPath = rootPath + relativePath;
    fullPath = normalizePath(fullPath);
    debug("[resolveFilePath]: Full normalized path: " + fullPath);

    // Special case: For locations with upload_path, check if we're trying to access an uploaded file
    if (hasUploadPath && method == "GET") {
        std::string uploadPath = location.get_upload_path();
        
        // Make upload path absolute if needed
        if (!uploadPath.empty() && uploadPath[0] != '/') {
            char cwd[PATH_MAX];
            if (getcwd(cwd, sizeof(cwd)) != NULL) {
                uploadPath = std::string(cwd) + "/" + uploadPath;
            }
        }
        
        // If there's a relative path, check if it exists in the upload directory
        if (!relativePath.empty()) {
            std::string uploadFilePath = uploadPath + "/" + relativePath;
            debug("[resolveFilePath]: Checking for file in upload directory: " + uploadFilePath);
            
            if (fileExists(uploadFilePath)) {
                debug("[resolveFilePath]: File found in upload directory");
                return uploadFilePath;
            }
        }
        
        // If we're accessing exactly the upload location (e.g., /uploads with no subpath)
        // and we want to list the directory, check if upload_path exists as a directory
        if (relativePath.empty() && isDirectory(uploadPath)) {
            debug("[resolveFilePath]: Checking upload directory for autoindex: " + uploadPath);
            
            // If autoindex is enabled, return the upload directory for listing
            if (location.is_autoindex()) {
                debug("[resolveFilePath]: Autoindex enabled for upload directory");
                return uploadPath + "?directory";
            }
        }
    }

    // Check for CGI requests
    bool isCgiRequest = false;
    for (std::map<std::string, Location>::const_iterator it = cachedLocations.begin(); 
         it != cachedLocations.end(); ++it) {
        const Location& loc = it->second;
        if (requestUri.find(it->first) == 0 && loc.is_cgi()) {
            isCgiRequest = true;
            debug("[resolveFilePath]: CGI request detected for location: " + it->first);
            break;
        }
    }

    if (isCgiRequest) {
        debug("[resolveFilePath]: CGI request, using full path");
        std::string cgiPath = rootPath + requestUri;
        cgiPath = normalizePath(cgiPath);
        debug("[resolveFilePath]: Returning full path for CGI: " + cgiPath);
        return cgiPath;
    }

    if (!isPathSafe(fullPath)) {
        debug("[resolveFilePath]: Unsafe path detected");
        return "?forbidden";
    }

    if (isDirectory(fullPath)) {
        debug("[resolveFilePath]: Path is a directory: " + fullPath);
        //debug("[resolveFilePath]: Location autoindex: " + (location.is_autoindex() ? "on" : "off"));

        if (method == "DELETE") {
            debug("[resolveFilePath]: DELETE request on directory - checking if deletion is allowed");
            return fullPath;
        }

        if (fullPath[fullPath.length() - 1] != '/') {
            fullPath += '/';
        }

        std::vector<std::string> indexFiles;
        if (!location.get_index().empty()) {
            indexFiles.push_back(location.get_index());
        }
        indexFiles.push_back("index.html");
        indexFiles.push_back("index.htm");

        for (std::vector<std::string>::iterator it = indexFiles.begin(); it != indexFiles.end(); ++it) {
            std::string indexPath = fullPath + *it;
            if (fileExists(indexPath) && !isDirectory(indexPath)) {
                debug("[resolveFilePath]: Found index file: " + indexPath);
                return indexPath;
            }
        }

        if (location.is_autoindex()) {
            debug("[resolveFilePath]: Autoindex is enabled, returning directory marker");
            return fullPath + "?directory";
        } else {
            debug("[resolveFilePath]: Autoindex is disabled, access forbidden");
            return "?forbidden";
        }
    }

    return fullPath;
}

bool FileManager::isPathSafe(const std::string& filePath) {
    debug("[isPathSafe]: Checking path safety for: " + filePath);

    // Check if the path is empty
    if (filePath.empty()) {
        debug("[isPathSafe]: Path is empty");
        return false;
    }

    // Normalize the path
    std::string normalizedPath = normalizePath(filePath);
    debug("[isPathSafe]: Normalized path to check: " + normalizedPath);

    // make sure that normalizedPath doesn't end with a slash
    if (normalizedPath.length() > 1 && normalizedPath[normalizedPath.length() - 1] == '/') {
        normalizedPath = normalizedPath.substr(0, normalizedPath.length() - 1);
        debug("[isPathSafe]: Corrected trailing slash in normalized path: " + normalizedPath);
    }

    // Use an static array for suspicious patterns
    static const char* suspiciousPatterns[] = {
        "..", "./", "//", "\\", "~", "$", "|", ">", "<", "&", ";", "?", "*", "[", "]", "'", "\"", "`"
    };
    static const size_t numPatterns = sizeof(suspiciousPatterns) / sizeof(suspiciousPatterns[0]);

    // Look for suspicious patterns
    for (size_t i = 0; i < numPatterns; ++i) {
        if (normalizedPath.find(suspiciousPatterns[i]) != std::string::npos) {
            debug("[isPathSafe]: Suspicious pattern found: " + std::string(suspiciousPatterns[i]));
            // don't return, some patterns are legitimate in certain contexts
        }
    }

    // Check if the path is inside a root directory
    bool foundMatch = false;
    std::string matchedRoot;

    // Check all the cached locations
    for (std::map<std::string, Location>::const_iterator it = cachedLocations.begin();
         it != cachedLocations.end(); ++it) {
        std::string rootPath = it->second.get_root();
        if (!rootPath.empty()) {
            if (rootPath[0] != '/') {
                char cwd[PATH_MAX];
                if (getcwd(cwd, sizeof(cwd)) != NULL) {
                    std::string currentDir(cwd);
                    rootPath = currentDir + "/" + rootPath;
                    debug("[isPathSafe]: Converted relative path to absolute: " + rootPath);
                }
            }

            std::string normalizedRoot = normalizePath(rootPath);

            // ELiminate slash if exists
            if (normalizedRoot.length() > 1 && normalizedRoot[normalizedRoot.length() - 1] == '/') {
                normalizedRoot = normalizedRoot.substr(0, normalizedRoot.length() - 1);
                debug("[isPathSafe]: Corrected trailing slash in normalized root: " + normalizedRoot);
            }

            debug("[isPathSafe]: Checking with normalized root: " + normalizedRoot);

            // Check if the path starts with the normalized root
            if (normalizedPath == normalizedRoot ||
                (normalizedPath.length() > normalizedRoot.length() &&
                 normalizedPath.substr(0, normalizedRoot.length()) == normalizedRoot &&
                 normalizedPath[normalizedRoot.length()] == '/')) {
                foundMatch = true;
                matchedRoot = normalizedRoot;
                debug("[isPathSafe]: Path is within root directory: " + matchedRoot);
                break;
            }
        }
    }

    if (!foundMatch) {
        debug("[isPathSafe]: Path is not within any configured root directory");
        return false;
    }

    // Verify if the file exists
    if (access(normalizedPath.c_str(), F_OK) != 0) {
        debug("[isPathSafe]: File does not exist: " + normalizedPath);
        return true;  // Allow non-existent files in safe paths
    }

    // Additional checks can be added here
    if (isImportantFile(normalizedPath)) {
        debug("[isPathSafe]: Important file requested: " + normalizedPath);
        // Maybe more checks in the future
    }
    debug("[isPathSafe]: Path is safe: " + normalizedPath);
    return true;
}

bool FileManager::createBackup(const std::string& filePath) {
    std::string backupPath = filePath + ".backup." + getCurrentTimestamp();
    debug("[createBackup]: Attempting to create backup: " + backupPath);

    // Check if source file exists
    if (access(filePath.c_str(), F_OK) != 0) {
        debug("[createBackup]: Source file does not exist: " + filePath);
        return false;
    }

    // Get file size
    struct stat fileStat;
    if (stat(filePath.c_str(), &fileStat) != 0) {
        debug("[createBackup]: Cannot stat source file: " + filePath);
        return false;
    }
    
    size_t fileSize = static_cast<size_t>(fileStat.st_size);
    debug("[createBackup]: Source file size: " + Utils::to_string(fileSize) + " bytes");

    // Handle empty files
    if (fileSize == 0) {
        debug("[createBackup]: Source file is empty, creating empty backup");
        std::ofstream backupFile(backupPath.c_str(), std::ios::binary);
        if (!backupFile.is_open()) {
            debug("[createBackup]: Failed to create empty backup file");
            return false;
        }
        backupFile.close();
        return access(backupPath.c_str(), F_OK) == 0;
    }

    // For non-empty files, use the most robust method
    std::ifstream src(filePath.c_str(), std::ios::binary);
    if (!src.is_open()) {
        debug("[createBackup]: Failed to open source file: " + filePath);
        return false;
    }

    std::ofstream dst(backupPath.c_str(), std::ios::binary);
    if (!dst.is_open()) {
        debug("[createBackup]: Failed to create backup file: " + backupPath);
        src.close();
        return false;
    }

    // Method 1: Try the simple rdbuf() method first (works for most files)
    bool success = false;
    try {
        dst << src.rdbuf();
        
        // Check if streams are still good
        if (!src.bad() && !dst.bad()) {
            success = true;
            debug("[createBackup]: Backup created using rdbuf() method");
        } else {
            debug("[createBackup]: rdbuf() method failed, trying chunked copy");
            success = false;
        }
    } catch (const std::exception& e) {
        debug("[createBackup]: Exception with rdbuf(): " + std::string(e.what()));
        success = false;
    }

    // Method 2: If rdbuf() fails, try chunked copy (more reliable for problematic files)
    if (!success) {
        // Reset file streams
        src.close();
        dst.close();
        
        src.open(filePath.c_str(), std::ios::binary);
        dst.open(backupPath.c_str(), std::ios::binary | std::ios::trunc);
        
        if (!src.is_open() || !dst.is_open()) {
            debug("[createBackup]: Failed to reopen files for chunked copy");
            unlink(backupPath.c_str());
            return false;
        }

        // Copy in chunks for better reliability
        const size_t CHUNK_SIZE = 8192; // 8KB chunks
        char buffer[CHUNK_SIZE];
        size_t totalCopied = 0;
        
        while (src.read(buffer, CHUNK_SIZE) || src.gcount() > 0) {
            std::streamsize bytesRead = src.gcount();
            dst.write(buffer, bytesRead);
            
            if (dst.fail()) {
                debug("[createBackup]: Write failed during chunked copy");
                src.close();
                dst.close();
                unlink(backupPath.c_str());
                return false;
            }
            
            totalCopied += bytesRead;
        }
        
        debug("[createBackup]: Chunked copy completed, " + Utils::to_string(totalCopied) + " bytes copied");
        success = (totalCopied == fileSize);
    }

    src.close();
    dst.close();

    if (!success) {
        debug("[createBackup]: Both copy methods failed");
        unlink(backupPath.c_str());
        return false;
    }

    // Verify backup file size matches original
    struct stat backupStat;
    if (stat(backupPath.c_str(), &backupStat) == 0) {
        if (static_cast<size_t>(backupStat.st_size) == fileSize) {
            debug("[createBackup]: Backup verified successfully: " + 
                  Utils::to_string(backupStat.st_size) + " bytes");
            return true;
        } else {
            debug("[createBackup]: Size mismatch - original: " + Utils::to_string(fileSize) + 
                  ", backup: " + Utils::to_string(backupStat.st_size));
            unlink(backupPath.c_str());
            return false;
        }
    }

    debug("[createBackup]: Cannot verify backup file");
    unlink(backupPath.c_str());
    return false;
}

std::string FileManager::getFileTypeDescription(const std::string& filePath) const {
    std::string extension = "";
    size_t dotPos = filePath.find_last_of(".");
    if (dotPos != std::string::npos) {
        extension = filePath.substr(dotPos + 1);
        
        // Convert to lowercase for comparison
        for (size_t i = 0; i < extension.size(); i++) {
            extension[i] = tolower(extension[i]);
        }
    }
    
    // Categorize file types
    if (extension == "txt" || extension == "md" || extension == "log") {
        return "text file";
    } else if (extension == "jpg" || extension == "jpeg" || extension == "png" || 
               extension == "gif" || extension == "bmp" || extension == "svg") {
        return "image file";
    } else if (extension == "pdf" || extension == "doc" || extension == "docx") {
        return "document file";
    } else if (extension == "html" || extension == "css" || extension == "js") {
        return "web file";
    } else if (extension == "zip" || extension == "tar" || extension == "gz") {
        return "archive file";
    } else if (extension == "exe" || extension == "bin") {
        return "executable file";
    } else if (extension.empty()) {
        return "file with no extension";
    } else {
        return "file (." + extension + ")";
    }
}

void FileManager::logDeletion(const std::string& filePath, const std::string& clientIp) {
    std::ofstream logFile("deletion_log.txt", std::ios::app);
    if (logFile.is_open()) {
        std::string fileType = getFileTypeDescription(filePath);
        logFile << getCurrentTimestamp() << " - " << fileType << " deleted: " << filePath
                << " by client: " << clientIp << std::endl;
        logFile.close();
    }
}

bool FileManager::isImportantFile(const std::string& filePath) {
    for (std::vector<std::string>::const_iterator it = importantExtensions.begin(); 
         it != importantExtensions.end(); ++it) {
        if (filePath.length() >= it->length() &&
            filePath.substr(filePath.length() - it->length()) == *it) {
            return true;
        }
    }
    return false;
}

std::string FileManager::getCurrentTimestamp() {
    time_t now = time(NULL);
    char timestamp[20];
    strftime(timestamp, sizeof(timestamp), "%Y%m%d_%H%M%S", localtime(&now));
    return std::string(timestamp);
}

std::string FileManager::generateHttpResponse(const std::string& path) {
    std::string rootDirectory;
    std::string contentType = "text/plain";
    std::string filePath;

    // Find best location match
    std::map<std::string, Location> locations = config.get_all_Locations();
    std::string bestLocation = findBestLocationMatch(path);
    rootDirectory = config.find_location(bestLocation).get_root();

    filePath = rootDirectory + path;

    // Get content type based on file extension
    contentType = getMimeType(filePath);

    std::ifstream file(filePath.c_str(), std::ios::binary);
    if (!file.is_open()) {
        std::ifstream errorFile("public/404.html");
        std::stringstream errorBuffer;

        if (errorFile.is_open()) {
            errorBuffer << errorFile.rdbuf(); // Load the 404.html file
        } else {
            errorBuffer << "<h1>404 Not Found</h1>"; // Default hardcoded error message
        }

        std::string errorContent = errorBuffer.str();
        std::ostringstream errorResponse;
        errorResponse << "HTTP/1.1 404 Not Found\r\n"
                      << "Content-Type: text/html\r\n"
                      << "Content-Length: " << errorContent.size() << "\r\n"
                      << "Connection: close\r\n"
                      << "\r\n"
                      << errorContent;
        return errorResponse.str();
    }

    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string fileContent = buffer.str();
    file.close();

    std::ostringstream response;
    response << "HTTP/1.1 200 OK\r\n"
             << "Content-Type: " << contentType << "\r\n"
             << "Content-Length: " << fileContent.size() << "\r\n"
             << "\r\n"
             << fileContent;

    return response.str();
}

std::string FileManager::getMimeType(const std::string& filePath) {
    // Get file extension
    size_t dotPos = filePath.find_last_of('.');
    if (dotPos == std::string::npos) {
        return "text/plain";  // Default to text/plain if no extension
    }

    std::string extension = filePath.substr(dotPos);

    // Look up extension in the MIME types map
    std::map<std::string, std::string>::const_iterator it = mimeTypes.find(extension);
    if (it != mimeTypes.end()) {
        return it->second;
    }

    // Default content type if not found
    return "application/octet-stream";
}

bool FileManager::fileExists(const std::string& filePath) {
    struct stat fileStat;
    return (stat(filePath.c_str(), &fileStat) == 0);
}

bool FileManager::isDirectory(const std::string& filePath) {
    struct stat fileStat;
    if (stat(filePath.c_str(), &fileStat) != 0) {
        return false;
    }
    return S_ISDIR(fileStat.st_mode);
}

std::string FileManager::readFile(const std::string& filePath) {
    std::ifstream file(filePath.c_str(), std::ios::binary);
    if (!file.is_open()) {
        return "";
    }

    // Get file size
    file.seekg(0, std::ios::end);
    std::streamsize size = file.tellg();
    file.seekg(0, std::ios::beg);

    // Use a vector for binary data handling
    std::vector<char> buffer(size);
    if (size > 0) {
        file.read(&buffer[0], size);
    }

    return std::string(buffer.begin(), buffer.end());
}

bool FileManager::writeFile(const std::string& filePath, const std::string& content) {
    std::ofstream file(filePath.c_str(), std::ios::binary);
    if (!file.is_open()) {
        return false;
    }

    file << content;
    return !file.fail();
}

bool FileManager::deleteFile(const std::string& filePath) {
    debug("[deleteFile]: Attempting to delete file: " + filePath);
    
    // Check if file exists first
    if (!fileExists(filePath)) {
        debug("[deleteFile]: File does not exist: " + filePath);
        return false;
    }
    
    // Check write permissions on the file
    if (access(filePath.c_str(), W_OK) != 0) {
        debug("[deleteFile]: No write permission for file: " + filePath);
        return false;
    }
    
    // Check write permissions on the parent directory
    std::string parentDir = filePath.substr(0, filePath.find_last_of('/'));
    if (!parentDir.empty() && access(parentDir.c_str(), W_OK) != 0) {
        debug("[deleteFile]: No write permission for parent directory: " + parentDir);
        return false;
    }
    
    // Create backup before deleting (your existing backup logic)
    if (!createBackup(filePath)) {
        debug("[deleteFile]: Backup creation failed, aborting deletion");
        return false;
    }
    
    // Try to delete the file
    int result = unlink(filePath.c_str());  // Use unlink() instead of remove()
    
    if (result == 0) {
        debug("[deleteFile]: File deleted successfully: " + filePath);
        return true;
    } else {
        debug("[deleteFile]: Failed to delete file: " + filePath + 
              ", errno: " + Utils::to_string(errno) + " (" + strerror(errno) + ")");
        
        switch (errno) {
            case EACCES:
                debug("[deleteFile]: Permission denied");
                break;
            case EBUSY:
                debug("[deleteFile]: File is busy or in use");
                break;
            case ENOENT:
                debug("[deleteFile]: File not found");
                break;
            case EPERM:
                debug("[deleteFile]: Operation not permitted");
                break;
            case EROFS:
                debug("[deleteFile]: Read-only file system");
                break;
            default:
                debug("[deleteFile]: Unknown error: " + Utils::to_string(errno));
                break;
        }
        return false;
    }
}


std::string FileManager::normalizePath(const std::string& path) {
    debug("[normalizePath]: Normalizing path: " + path);

    if (path.empty()) {
        return path;
    }

    // Convert backslashes to forward slashes
    std::string result = path;
    size_t i = 0;
    while ((i = result.find('\\', i)) != std::string::npos) {
        result[i] = '/';
    }

    // Eliminate double slashes
    i = 0;
    while ((i = result.find("//", i)) != std::string::npos) {
        result.erase(i, 1);
    }

    // Manual implementation to handle './' and '../'
    std::string simplified;
    bool isAbsolute = (result[0] == '/');

    // Separate the path into components
    std::string::size_type start = 0;
    std::string::size_type end = 0;
    std::vector<std::string> components;

    while ((end = result.find('/', start)) != std::string::npos) {
        std::string component = result.substr(start, end - start);
        if (!component.empty() && component != "." && component != "..") {
            simplified += "/" + component;
        } else if (component == "..") {
            // Eliminate the last component if there is one
            std::string::size_type lastSlash = simplified.rfind('/');
            if (lastSlash != std::string::npos && simplified.length() > 1) {
                simplified.erase(lastSlash);
            }
        }
        start = end + 1;
    }

    // Handle the last component
    std::string lastComponent = result.substr(start);
    if (!lastComponent.empty() && lastComponent != "." && lastComponent != "..") {
        simplified += "/" + lastComponent;
    } else if (lastComponent == "..") {
        // Eliminate the last component if there is one
        std::string::size_type lastSlash = simplified.rfind('/');
        if (lastSlash != std::string::npos && simplified.length() > 1) {
            simplified.erase(lastSlash);
        }
    }

    // If the rout was absolute, add the leading '/'
    if (isAbsolute && (simplified.empty() || simplified[0] != '/')) {
        simplified = "/" + simplified;
    } else if (simplified.empty()) {
        simplified = "/";
    }

    // Handle the special case where the resulting path is empty
    if (simplified.empty()) {
        simplified = isAbsolute ? "/" : ".";
    }

    // If the original path ended with a '/', keep this
    if (!path.empty() && path[path.length() - 1] == '/' &&
        simplified[simplified.length() - 1] != '/') {
        simplified += "/";
    }

    debug("[normalizePath]: Normalized path: " + simplified);
    return simplified;
}

/*
std::string FileManager::generateDirectoryListing(const std::string& dirPath, const std::string& requestUri) {
    debug("[generateDirectoryListing]: Generating listing for " + dirPath + " (URI: " + requestUri + ")");

    // Try to open the directory
    DIR* dir = opendir(dirPath.c_str());
    if (!dir) {
        debug("[generateDirectoryListing]: Failed to open directory");
        return "";
    }

    // Start building the HTML for the directory listing
    std::ostringstream html;
    html << "<!DOCTYPE html>\n"
         << "<html>\n"
         << "<head>\n"
         << "    <title>Index of " << requestUri << "</title>\n"
         << "    <style>\n"
         << "        body { font-family: Arial, sans-serif; margin: 40px; }\n"
         << "        h1 { border-bottom: 1px solid #c0c0c0; margin-bottom: 20px; padding-bottom: 10px; }\n"
         << "        table { border-collapse: collapse; width: 100%; }\n"
         << "        th, td { text-align: left; padding: 8px; }\n"
         << "        tr:nth-child(even) { background-color: #f2f2f2; }\n"
         << "        a { text-decoration: none; color: #0366d6; }\n"
         << "        a:hover { text-decoration: underline; }\n"
         << "        .size { text-align: right; }\n"
         << "        .date { color: #6a737d; }\n"
         << "    </style>\n"
         << "</head>\n"
         << "<body>\n"
         << "    <h1>Index of " << requestUri << "</h1>\n"
         << "    <table>\n"
         << "        <tr>\n"
         << "            <th>Name</th>\n"
         << "            <th>Last Modified</th>\n"
         << "            <th>Size</th>\n"
         << "        </tr>\n"
         << "        <tr>\n"
         << "            <td><a href=\"../"<<"\">Parent Directory</a></td>\n"
         << "            <td></td>\n"
         << "            <td></td>\n"
         << "        </tr>\n";

    // Collect all directory entries
    std::vector<dirent*> entries;
    struct dirent* entry;

    while ((entry = readdir(dir)) != NULL) {
        std::string name = entry->d_name;
        if (name != "." && name != "..") {
            entries.push_back(entry);
        }
    }

    // Sort entries (directories first, then files, both alphabetically)
    // C++98 compatible sorting using a custom comparator function
    std::sort(entries.begin(), entries.end(),
    FileManager::dirEntryCompare);

    // Generate table rows for each entry
    for (std::vector<dirent*>::iterator it = entries.begin(); it != entries.end(); ++it) {
        entry = *it;
        std::string name = entry->d_name;
        if (name != "." && name != "..") {
            std::string fullPath = dirPath + "/" + name;
            bool isDir = entry->d_type == DT_DIR;

            // Get file stats for size and modification time
            struct stat st;
            stat(fullPath.c_str(), &st);

            // Format the modification time
            char timeStr[100];
            strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", localtime(&st.st_mtime));

            html << "        <tr>\n"
                 << "            <td><a href=\"" << name << (isDir ? "/" : "") << "\">" << name << (isDir ? "/" : "") << "</a></td>\n"
                 << "            <td class=\"date\">" << timeStr << "</td>\n";

            if (isDir) {
                html << "            <td class=\"size\">-</td>\n";
            } else {
                // Format size in human-readable format
                std::string sizeStr;
                if (st.st_size < 1024) {
                    sizeStr = Utils::to_string(st.st_size) + " B";
                } else if (st.st_size < 1024 * 1024) {
                    sizeStr = Utils::to_string(st.st_size / 1024) + " KB";
                } else if (st.st_size < 1024 * 1024 * 1024) {
                    sizeStr = Utils::to_string(st.st_size / (1024 * 1024)) + " MB";
                } else {
                    sizeStr = Utils::to_string(st.st_size / (1024 * 1024 * 1024)) + " GB";
                }
                html << "            <td class=\"size\">" << sizeStr << "</td>\n";
            }

            html << "        </tr>\n";
        }
    }

    // Finish the HTML
    html << "    </table>\n"
         << "    <hr>\n"
         << "    <p>Generated by webserv on " << getFormattedTime() << "</p>\n"
         << "</body>\n"
         << "</html>";

    closedir(dir);
    return html.str();
}
*/

bool FileManager::dirEntryCompare(const dirent* a, const dirent* b) {
    bool a_is_dir = a->d_type == DT_DIR;
    bool b_is_dir = b->d_type == DT_DIR;

    if (a_is_dir && !b_is_dir) return true;
    if (!a_is_dir && b_is_dir) return false;

    return std::string(a->d_name) < std::string(b->d_name);
}

// Helper function to get the current time formatted
std::string FileManager::getFormattedTime() {
    time_t now = time(NULL);
    struct tm* tm_info = localtime(&now);
    char buf[100];
    strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm_info);
    return std::string(buf);
}

bool FileManager::detectPathTraversal(const std::string& rawPath) {
    debug("[detectPathTraversal]: Analyzing possible attack in: " + rawPath);

    // Common path traversal patterns, including encoded versions
    std::vector<std::string> traversalPatterns;
    traversalPatterns.push_back("../");
    traversalPatterns.push_back("..\\");
    traversalPatterns.push_back("%2e%2e%2f");   // ../ URL encoded
    traversalPatterns.push_back("%2e%2e/");     // ../ partial URL encoded
    traversalPatterns.push_back("..%2f");       // ../ partial URL encoded
    traversalPatterns.push_back("%2e%2e%5c");   // ..\ URL encoded
    traversalPatterns.push_back("..%5c");       // ..\ partial URL encoded
    traversalPatterns.push_back("%252e%252e%252f"); // ../ double URL encoded
    traversalPatterns.push_back("..%c0%af");    // ../ UTF-8 encoded
    traversalPatterns.push_back("..%c1%9c");    // ..\ UTF-8 encoded

    for (std::vector<std::string>::const_iterator it = traversalPatterns.begin();
         it != traversalPatterns.end(); ++it) {
        if (rawPath.find(*it) != std::string::npos) {
            debug("[detectPathTraversal]: Traversal pattern detected: " + *it);
            return true; // Attack detected
        }
    }

    // Look for path traversal sequences combined with encoding or obfuscation
    std::string lowerPath = rawPath;
    std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(), ::tolower);

    // Common obfuscation and encoding patterns
    if (lowerPath.find("%c0%ae") != std::string::npos ||  // Another encoding for .
        lowerPath.find("%e0%80%ae") != std::string::npos ||  // Over-long UTF-8
        lowerPath.find("%c0%af") != std::string::npos) {  // Another encoding for /
        debug("[detectPathTraversal]: Suspicious character encoding detected");
        return true;
    }

    // Double URL encoding patterns that might bypass simple filters
    if (lowerPath.find("%25") != std::string::npos) {  // % encoded as %25
        debug("[detectPathTraversal]: Possible double encoding detected");
    }

    debug("[detectPathTraversal]: No traversal patterns detected");
    return false;
}

size_t FileManager::getFileSize(const std::string& path) const {
    struct stat fileStat;
    if (stat(path.c_str(), &fileStat) < 0) {
        throw std::runtime_error("Cannot stat file: " + path);
    }
    return static_cast<size_t>(fileStat.st_size);
}

std::string FileManager::generateDirectoryListing(const std::string& dirPath, const std::string& requestUri) {
    debug("[generateDirectoryListing]: Generating directory listing for: " + dirPath);

    DIR* dir;
    struct dirent* entry;
    std::stringstream htmlOutput;

    // Open the directory
    dir = opendir(dirPath.c_str());
    if (dir == NULL) {
        debug("[generateDirectoryListing]: Failed to open directory: " + dirPath);
        return "";
    }

    // Build HTML output
    htmlOutput << "<!DOCTYPE html>\n"
               << "<html>\n"
               << "<head>\n"
               << "    <title>Index of " << requestUri << "</title>\n"
               << "    <style>\n"
               << "        body { font-family: Arial, sans-serif; margin: 40px; }\n"
               << "        h1 { border-bottom: 1px solid #ccc; padding-bottom: 10px; }\n"
               << "        table { border-collapse: collapse; width: 100%; }\n"
               << "        th, td { text-align: left; padding: 8px; }\n"
               << "        tr:nth-child(even) { background-color: #f2f2f2; }\n"
               << "        a { text-decoration: none; color: #0066cc; }\n"
               << "        a:hover { text-decoration: underline; }\n"
               << "        .name { width: 50%; }\n"
               << "        .size { width: 20%; }\n"
               << "        .date { width: 30%; }\n"
               << "    </style>\n"
               << "</head>\n"
               << "<body>\n"
               << "    <h1>Index of " << requestUri << "</h1>\n"
               << "    <table>\n"
               << "        <tr>\n"
               << "            <th class=\"name\">Name</th>\n"
               << "            <th class=\"size\">Size</th>\n"
               << "            <th class=\"date\">Last Modified</th>\n"
               << "        </tr>\n";

    // Add link to parent directory if not root
    if (requestUri != "/") {
        std::string parentUri = requestUri;
        
        if (parentUri[parentUri.length() - 1] == '/') {
            parentUri = parentUri.substr(0, parentUri.length() - 1);
        }
        
        size_t lastSlash = parentUri.find_last_of('/');
        if (lastSlash != std::string::npos) {
            parentUri = parentUri.substr(0, lastSlash + 1);
        } else {
            parentUri = "/";
        }
        
        htmlOutput << "        <tr>\n"
                   << "            <td class=\"name\"><a href=\"" << parentUri << "\">..</a></td>\n"
                   << "            <td class=\"size\">-</td>\n"
                   << "            <td class=\"date\">-</td>\n"
                   << "        </tr>\n";
    }

    std::vector<std::string> dirEntries;
    std::vector<std::string> fileEntries;

    // Read the directory entries
    while ((entry = readdir(dir)) != NULL) {
        std::string name = entry->d_name;

        // Hide hidden files and directories except for . and ..
        if (name[0] == '.' && name != "..") {
            continue;
        }

        // for the case of .., we don't want to show it
        if (name == "..") {
            continue;
        }

        std::string fullPath = dirPath + "/" + name;
        struct stat fileStat;

        if (stat(fullPath.c_str(), &fileStat) < 0) {
            continue;  // Skip if we can't stat the file
        }

        // Separate directories from files
        if (S_ISDIR(fileStat.st_mode)) {
            dirEntries.push_back(name);
        } else {
            fileEntries.push_back(name);
        }
    }

    // Sort entries alphabetically
    std::sort(dirEntries.begin(), dirEntries.end());
    std::sort(fileEntries.begin(), fileEntries.end());

    std::string baseUri = requestUri;
    if (!baseUri.empty() && baseUri[baseUri.length() - 1] != '/') {
        baseUri += '/';
    }

    // First show the directories
    for (std::vector<std::string>::const_iterator it = dirEntries.begin(); it != dirEntries.end(); ++it) {
        std::string name = *it;
        std::string fullPath = dirPath + "/" + name;
        struct stat fileStat;

        if (stat(fullPath.c_str(), &fileStat) < 0) {
            continue;
        }

        char timeStr[80];
        strftime(timeStr, sizeof(timeStr), "%d-%b-%Y %H:%M", localtime(&fileStat.st_mtime));

        htmlOutput << "        <tr>\n"
                   << "            <td class=\"name\"><a href=\"" << baseUri << name << "/\">" << name << "/</a></td>\n"
                   << "            <td class=\"size\">-</td>\n"
                   << "            <td class=\"date\">" << timeStr << "</td>\n"
                   << "        </tr>\n";
    }

    // Then show the files
    for (std::vector<std::string>::const_iterator it = fileEntries.begin(); it != fileEntries.end(); ++it) {
        std::string name = *it;
        std::string fullPath = dirPath + "/" + name;
        struct stat fileStat;

        if (stat(fullPath.c_str(), &fileStat) < 0) {
            continue;
        }

        char timeStr[80];
        strftime(timeStr, sizeof(timeStr), "%d-%b-%Y %H:%M", localtime(&fileStat.st_mtime));

        // Format that are easier to read
        std::string sizeStr;
        if (fileStat.st_size < 1024) {
            sizeStr = Utils::to_string(fileStat.st_size) + " B";
        } else if (fileStat.st_size < 1024 * 1024) {
            sizeStr = Utils::to_string(fileStat.st_size / 1024) + " KB";
        } else {
            sizeStr = Utils::to_string(fileStat.st_size / (1024 * 1024)) + " MB";
        }

        htmlOutput << "        <tr>\n"
                   << "            <td class=\"name\"><a href=\"" << baseUri << name << "\">" << name << "</a></td>\n"
                   << "            <td class=\"size\">" << sizeStr << "</td>\n"
                   << "            <td class=\"date\">" << timeStr << "</td>\n"
                   << "        </tr>\n";
    }

    htmlOutput << "    </table>\n"
               << "    <hr>\n"
               << "    <p>webserv server at " << config.get_ip() << ":" << config.get_port() << "</p>\n"
               << "</body>\n"
               << "</html>";

    closedir(dir);
    return htmlOutput.str();
}

/*
bool FileManager::detectPathTraversal(const std::string& rawPath) {
    debug("[detectPathTraversal]: Analyzing possible attack in: " + rawPath);

    // Common path traversal patterns, including encoded versions
    std::vector<std::string> traversalPatterns;
    traversalPatterns.push_back("../");
    traversalPatterns.push_back("..\\");
    traversalPatterns.push_back("%2e%2e%2f");   // ../ URL encoded
    traversalPatterns.push_back("%2e%2e/");     // ../ partial URL encoded
    traversalPatterns.push_back("..%2f");       // ../ partial URL encoded
    traversalPatterns.push_back("%2e%2e%5c");   // ..\ URL encoded
    traversalPatterns.push_back("..%5c");       // ..\ partial URL encoded
    traversalPatterns.push_back("%252e%252e%252f"); // ../ double URL encoded
    traversalPatterns.push_back("..%c0%af");    // ../ UTF-8 encoded
    traversalPatterns.push_back("..%c1%9c");    // ..\ UTF-8 encoded

    for (std::vector<std::string>::const_iterator it = traversalPatterns.begin();
         it != traversalPatterns.end(); ++it) {
        if (rawPath.find(*it) != std::string::npos) {
            debug("[detectPathTraversal]: Traversal pattern detected: " + *it);
            return true; // Attack detected
        }
    }

    // Look for path traversal sequences combined with encoding or obfuscation
    std::string lowerPath = rawPath;
    std::transform(lowerPath.begin(), lowerPath.end(), lowerPath.begin(), ::tolower);

    // Common obfuscation and encoding patterns
    if (lowerPath.find("%c0%ae") != std::string::npos ||  // Another encoding for .
        lowerPath.find("%e0%80%ae") != std::string::npos ||  // Over-long UTF-8
        lowerPath.find("%c0%af") != std::string::npos) {  // Another encoding for /
        debug("[detectPathTraversal]: Suspicious character encoding detected");
        return true;
    }

    // Double URL encoding patterns that might bypass simple filters
    if (lowerPath.find("%25") != std::string::npos) {  // % encoded as %25
        debug("[detectPathTraversal]: Possible double encoding detected");
    }

    debug("[detectPathTraversal]: No traversal patterns detected");
    return false;
}
*/