Client.cpp

#include "Client.hpp"
#include "Utils.hpp"
#include "Server.hpp"
#include <iostream>
#include <sys/socket.h>
#include <errno.h>

// Constructor
Client::Client(const Server &passiveServer, int clientFD) 
    : passiveServer(passiveServer), 
      clientFD(clientFD),
      currentRequest(NULL),
      state(STATE_IDLE),           // Start in IDLE state, not READING_REQUEST
      lastChunkSize(0),
      lastActivityTime(time(NULL)),
      responseBytesSent(0),
      isMultiPart(false),
      hasBeenServed(false),
      keepAliveConnection(true),   // Default to keep-alive
      errorHasOccurred(false),
      bodyComplete(false),
      firstChunkProcessed(false),
      location(NULL),
      rawRequestData(""),
      needFilenameExtraction(false)
      {

    debug("[Client]: Created new client with fd " + Utils::to_string(clientFD));
}

// Destructor - ensure proper cleanup
Client::~Client() {
    debug("[Client]: Destroying client with fd " + Utils::to_string(clientFD));
    
    // Clean up request if it exists
    if (currentRequest) {
        delete currentRequest;
        currentRequest = NULL;
    }
    
    // Note: we don't close clientFD here as that's handled by ConnectionHandler
    if (location) {
        delete location;
        location = NULL;
    }
}

std::string Client::extractFilenameFromRawData(const std::string& rawData) {
    debug("[Client]: Extracting filename from raw request data, size: " + Utils::to_string(rawData.size()));
    
    // Show a preview of what we're working with (first 200 chars, cleaned)
    std::string preview = rawData.substr(0, std::min(rawData.size(), static_cast<size_t>(200)));
    debug("[Client]: Raw data preview: " + Utils::cleanForDebug(preview));
    
    if (rawData.find("multipart/form-data") == std::string::npos) {
        debug("[Client]: Not a multipart form data request");
        return "uploaded_file";
    }

    // Look for filename in Content-Disposition header
    size_t dispPos = rawData.find("filename=\"");
    if (dispPos != std::string::npos) {
        dispPos += 10; // Skip 'filename="'
        size_t endPos = rawData.find("\"", dispPos);
        
        if (endPos != std::string::npos && endPos > dispPos) {
            std::string filename = rawData.substr(dispPos, endPos - dispPos);
            debug("[Client]: Found quoted filename: '" + filename + "'");
            
            // Clean the filename
            filename = cleanFilename(filename);
            if (!filename.empty() && filename != "uploaded_file") {
                debug("[Client]: Successfully extracted filename: '" + filename + "'");
                return filename;
            }
        }
    }
    
    // Try without quotes
    dispPos = rawData.find("filename=");
    if (dispPos != std::string::npos) {
        dispPos += 9; // Skip 'filename='
        
        // Find the end - could be semicolon, newline, or carriage return
        size_t endPos = rawData.find_first_of(";\r\n ", dispPos);
        if (endPos == std::string::npos) {
            endPos = rawData.size();
        }
        
        if (endPos > dispPos) {
            std::string filename = rawData.substr(dispPos, endPos - dispPos);
            
            // Remove quotes if present
            if (!filename.empty() && filename[0] == '"') {
                filename = filename.substr(1);
                if (!filename.empty() && filename[filename.size() - 1] == '"') {
                    filename = filename.substr(0, filename.size() - 1);
                }
            }
            
            debug("[Client]: Found unquoted filename: '" + filename + "'");
            
            filename = cleanFilename(filename);
            if (!filename.empty() && filename != "uploaded_file") {
                debug("[Client]: Successfully extracted filename: '" + filename + "'");
                return filename;
            }
        }
    }

    // Look for Content-Disposition in the body
    size_t bodyStart = rawData.find("\r\n\r\n");
    if (bodyStart != std::string::npos) {
        bodyStart += 4;
        
        // Look for Content-Disposition in the body
        size_t dispPosInBody = rawData.find("Content-Disposition:", bodyStart);
        if (dispPosInBody != std::string::npos) {
            // Look for filename in this Content-Disposition
            size_t filenamePos = rawData.find("filename=\"", dispPosInBody);
            if (filenamePos != std::string::npos && filenamePos < dispPosInBody + 500) {
                filenamePos += 10;
                size_t endPos = rawData.find("\"", filenamePos);
                
                if (endPos != std::string::npos && endPos > filenamePos) {
                    std::string filename = rawData.substr(filenamePos, endPos - filenamePos);
                    debug("[Client]: Found filename in body: '" + filename + "'");
                    
                    filename = cleanFilename(filename);
                    if (!filename.empty() && filename != "uploaded_file") {
                        debug("[Client]: Successfully extracted filename from body: '" + filename + "'");
                        return filename;
                    }
                }
            }
        }
    }
    
    // If we still don't have a filename, we might need to extract it later when we have more data
    extractedFilename = "uploaded_file"; // Use default for now
    
    // Keep track of the fact that we need to try again later with more data
    needFilenameExtraction = true;
    
    debug("[Client]: No filename found, using default");
    return "uploaded_file";
}

std::string Client::cleanFilename(const std::string& filename) {
    if (filename.empty()) return "uploaded_file";
    
    std::string cleaned = filename;
    
    // Remove leading/trailing whitespace
    while (!cleaned.empty() && (cleaned[0] == ' ' || cleaned[0] == '\t' || 
                               cleaned[0] == '\r' || cleaned[0] == '\n')) {
        cleaned = cleaned.substr(1);
    }
    
    while (!cleaned.empty() && (cleaned[cleaned.size() - 1] == ' ' || 
                               cleaned[cleaned.size() - 1] == '\t' ||
                               cleaned[cleaned.size() - 1] == '\r' || 
                               cleaned[cleaned.size() - 1] == '\n')) {
        cleaned = cleaned.substr(0, cleaned.size() - 1);
    }
    
    // Remove path separators (security)
    size_t lastSlash = cleaned.find_last_of("/\\");
    if (lastSlash != std::string::npos) {
        cleaned = cleaned.substr(lastSlash + 1);
    }
    
    // Replace dangerous characters
    std::string safeFilename;
    for (size_t i = 0; i < cleaned.size(); i++) {
        char c = cleaned[i];
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || 
            (c >= '0' && c <= '9') || c == '.' || c == '_' || c == '-') {
            safeFilename += c;
        } else {
            safeFilename += '_';
        }
    }
    
    // Ensure filename isn't empty and has reasonable length
    if (safeFilename.empty() || safeFilename == "." || safeFilename == "_") {
        return "uploaded_file";
    }
    
    if (safeFilename.length() > 255) {
        safeFilename = safeFilename.substr(0, 255);
    }
    
    return safeFilename;
}

// Reset client for next request (preserving connection)
int Client::resetForNextRequest() {
    debug("[Client]: Resetting client for next request, fd " + Utils::to_string(clientFD));
    
    // Clean up previous request
    if (currentRequest) {
        delete currentRequest;
        currentRequest = NULL;
    }
    
    // Reset buffers
    totalBody.clear();
    responseBuffer.clear();
    responseBytesSent = 0;
    rawRequestData.clear();
    
    // Reset flags
    isMultiPart = false;
    bodyComplete = false;
    hasBeenServed = false;
    errorHasOccurred = false;
    firstChunkProcessed = false;  // Reset the flag
    
    if (location) {
        delete location;
        location = NULL;
    }
    
    setState(STATE_IDLE);
    return 0;
}

void Client::updateLastActivityTime() {
    lastActivityTime = time(NULL);
}

// State management
void Client::setState(ClientState newState) {
    debug("[Client]: State transition: " + stateToString(state) + " -> " + stateToString(newState) + 
          " (fd: " + Utils::to_string(clientFD) + ")");
    state = newState;
}

ClientState Client::getState() const {
    return state;
}

// Helper method to convert state to string for debugging
std::string Client::stateToString(ClientState state) const {
    switch (state) {
        case STATE_READING_REQUEST: return "READING_REQUEST";
        case STATE_PROCESSING: return "PROCESSING";
        case STATE_SENDING_RESPONSE: return "SENDING_RESPONSE";
        case STATE_IDLE: return "IDLE";
        case STATE_ERROR: return "ERROR";
        default: return "UNKNOWN";
    }
}

int Client::receiveRequest() {
    debug("[Client]: Receiving data for client fd " + Utils::to_string(clientFD));
    
    if (state == STATE_IDLE) {
        setState(STATE_READING_REQUEST);
    }
    
    if (state != STATE_READING_REQUEST) {
        debug("[Client]: receiveRequest called in incorrect state: " + stateToString(state));
        return 0;
    }
    
    // Use a reasonably sized buffer for receiving
    char buffer[16384];
    
    // Non-blocking receive
    ssize_t bytes_read = recv(clientFD, buffer, sizeof(buffer), MSG_DONTWAIT);
    
    // Handle receive errors
    if (bytes_read < 0) {
        lastActivityTime = time(NULL);
        lastChunkSize = bytes_read;

        debug("[Client]: Error reading from socket: " + Utils::to_string(errno));
        setError();
        return 0;
        
        // if (errno == EAGAIN || errno == EWOULDBLOCK) {
        //     debug("[Client]: No data available at the moment (EAGAIN/EWOULDBLOCK)");
        //     return 0;
        // } else {
        //     debug("[Client]: Error reading from socket: " + Utils::to_string(errno));
        //     setError();
        //     return -1;
        // }
    }
    
    // Handle zero-length reads (connection closed by peer)
    if (bytes_read == 0) {
        debug("[Client]: Connection closed by client");
        
        // If we were in the middle of receiving a complete request, try to process it
        if (currentRequest && isRequestComplete()) {
            debug("[Client]: Connection closed but request appears complete, processing");
            setState(STATE_PROCESSING);
            return 1;
        }
        
        setError();
        return -1;
    }
    
    // Add newly received data to our buffer
    rawRequestData.append(buffer, bytes_read);
    lastActivityTime = time(NULL);
    lastChunkSize = bytes_read;
    
    // Now process the data we have
    if (!currentRequest) {
        debug("[Client]: Creating new Request object");
        
        // If we can't validate the headers yet, wait for more data
        if (rawRequestData.find("\r\n\r\n") == std::string::npos) {
            // Check if this is potentially an invalid request
            if (rawRequestData.size() > 4096 || 
                rawRequestData.find("\n\n") != std::string::npos || 
                rawRequestData.find("\r\n\n") != std::string::npos) {
                
                debug("[Client]: Likely invalid request format, sending 400 Bad Request");
                
                ResponseBuilder builder;
                builder.setStatus(400, "Bad Request");
                builder.setContentType("text/plain");
                builder.setBody("Invalid request format");
                
                std::string response = builder.build();
                setResponseBuffer(response);
                setState(STATE_SENDING_RESPONSE);
                return 0;
            }
            return(0);
        }

        std::string method, path, version;
        HttpHeaders requestHeaders;
        int errorCode = 0;
        std::string errorMessage;
        
        // Use validateHttpHeadersNoSend to check headers without sending
        if (!passiveServer.validateHttpHeadersNoSend(rawRequestData.c_str(), 
                                                 rawRequestData.length(),
                                                 method, path, version, 
                                                 requestHeaders, errorCode, errorMessage)) {
            // Validation failed, prepare error response
            debug("[Client]: HTTP header validation failed: " + errorMessage);
            
            // Create error response
            ResponseBuilder builder;
            if (errorCode == 405) {
                builder.setHeader("Allow", "GET, POST, DELETE");
            }
            builder.setStatus(errorCode, errorMessage);
            builder.setContentType("text/plain");
            builder.setBody(errorMessage);
            
            std::string response = builder.build();
            setResponseBuffer(response);
            setState(STATE_SENDING_RESPONSE);
            
            return 0;
        }
        
        // Extract multipart filename if present
        if (rawRequestData.find("multipart/form-data") != std::string::npos) {
            extractedFilename = extractFilenameFromRawData(rawRequestData);
            debug("[Client]: Extracted filename from multipart data: " + extractedFilename);
        }
        
        // Create Request object and validate headers
        currentRequest = new Request(rawRequestData);
        
        int result = currentRequest->preProcessRequest();
        if (result != 0) {
            debug("[Client]: Error preprocessing request headers");
            return 0;
        }
        
        // Validate request method and other requirements
        result = currentRequest->validateRequest();
        if (result != 0) {
        debug("[Client]: Request validation failed");
        
        // Check if it's because of an unsupported method
        std::string method = currentRequest->getMethod();
        if (method != "GET" && method != "POST" && method != "DELETE") {
            debug("[Client]: Unsupported method: " + method);
            
            // Create and send 405 Method Not Allowed response
            ResponseBuilder builder;
            builder.setStatus(405, "Method Not Allowed");
            builder.setHeader("Allow", "GET, POST, DELETE");
            builder.setContentType("text/plain");
            builder.setBody("Method " + method + " is not allowed");
            
            std::string response = builder.build();
            setResponseBuffer(response);
            setState(STATE_SENDING_RESPONSE);
            return 0;
        }
        
        // Other validation error
        ResponseBuilder builder;
        builder.setStatus(400, "Bad Request");
        builder.setContentType("text/plain");
        builder.setBody("Invalid request format");
        
        std::string response = builder.build();
        setResponseBuffer(response);
        setState(STATE_SENDING_RESPONSE);
        return 0;
    }
        
        // Request is valid, configure client
        setParams();
        
        // Extract the body from the raw request data
        size_t headerEnd = rawRequestData.find("\r\n\r\n");
        if (headerEnd != std::string::npos) {
            headerEnd += 4;  // Skip
            if (headerEnd < rawRequestData.length()) {
                // There's body data after the headers
                totalBody = rawRequestData.substr(headerEnd);
                debug("[Client]: Extracted body from request, size: " + Utils::to_string(totalBody.size()));
            } else {
                totalBody = ""; // Empty string
                debug("[Client]: No body data in request yet");
            }
        }
        
        // For multipart requests, we need special handling
        if (isMultiPart) {
            debug("[Client]: Request is multipart, need to handle body specially");
            int multipartStatus = handleMultiPartBody();
            
            if (multipartStatus == 0) {
                // Body complete
                debug("[Client]: Multipart body complete in first chunk");
                setState(STATE_PROCESSING);
                return 1; // Ready to process
            } else if (multipartStatus < 0) {
                // Error in multipart
                debug("[Client]: Error in multipart body");
                return 0;
            } else {
                // Need more data
                debug("[Client]: Multipart body incomplete, waiting for more data");
                return 0;
            }
        } else {
            // Check if we've received the full request for non-multipart requests
            if (isRequestComplete()) {
                debug("[Client]: Non-multipart request complete, ready for processing");
                setState(STATE_PROCESSING);
                return 1; // Ready
            } else {
                debug("[Client]: Non-multipart request incomplete, waiting for more data");
                return 0;
            }
        }
    } else {
        // Continui
        size_t headerEnd = rawRequestData.find("\r\n\r\n");
        if (headerEnd != std::string::npos) {
            headerEnd += 4;  // Skip
            
            // Update body
            totalBody = rawRequestData.substr(headerEnd);
            debug("[Client]: Updated total body, new size: " + Utils::to_string(totalBody.size()));
        }
        
        // For multipart request
        if (isMultiPart) {
            debug("[Client]: Continuing multipart request, handling body");
            int multipartStatus = handleMultiPartBody();
            
            if (multipartStatus == 0) {
                // Body complete
                debug("[Client]: Multipart body complete after more data");
                setState(STATE_PROCESSING);
                return 1; // Ready
            } else if (multipartStatus < 0) {
                // Error
                debug("[Client]: Error in multipart body");
                return 0;
            } else {
                // Need more data
                debug("[Client]: Multipart body still incomplete, waiting for more data");
                return 0;
            }
        } else {
            // For normal requests, check if complete
            if (isRequestComplete()) {
                debug("[Client]: Request now complete after more data, ready for processing");
                setState(STATE_PROCESSING);
                return 1; 
            } else {
                debug("[Client]: Request still incomplete, waiting for more data");
                return 0;
            }
        }
    }
    
    return 0;
}

bool Client::isRequestComplete() {
    if (!currentRequest) {
        return false;
    }
    
    if (currentRequest->getMethod() == "POST") {
        HttpHeaders headers = currentRequest->getHeaders();
        std::string contentLengthStr = headers.get("Content-Length");
        
        if (!contentLengthStr.empty()) {
            int contentLength = std::atoi(contentLengthStr.c_str());
            
            debug("[Client]: Checking if request is complete: " + 
                  Utils::to_string(totalBody.size()) + "/" + 
                  Utils::to_string(contentLength) + " bytes");
                  
            return totalBody.size() >= static_cast<size_t>(contentLength);
        }
    }
    
    return true;
}

// Non-blocking send method
int Client::sendResponse() {
    if (state != STATE_SENDING_RESPONSE) {
        debug("[Client]: sendResponse called in wrong state: " + stateToString(state));
        return 0;
    }
    
    if (responseBuffer.empty()) {
        debug("[Client]: No response buffer to send");
        return 0;
    }
    
    if (responseBytesSent >= responseBuffer.size()) {
        debug("[Client]: Response already fully sent");
        
        // Response is complete
        hasBeenServed = true;
        
        // If keep-alive connection, reset for next request but keep connection open
        if (keepAliveConnection) {
            debug("[Client]: Connection is keep-alive, resetting for next request");
            resetForNextRequest(); // This also sets state to IDLE
            return 0; // Don't close the connection
        } else {
            // Not keep-alive, signal that we're done with this client
            debug("[Client]: Connection is not keep-alive, can be closed");
            return 1; // Signal to close connection
        }
    }
    
    // Calculate what's left to send
    const char* buffer = responseBuffer.c_str() + responseBytesSent;
    size_t bytesRemaining = responseBuffer.size() - responseBytesSent;
    
    // Try to send non-blockingly
    ssize_t bytesSent = send(clientFD, buffer, bytesRemaining, MSG_DONTWAIT);
    
    // Check for errors
    if (bytesSent < 0) {
        debug("[Client]: Error sending response: " + Utils::to_string(errno));
        setError();
        return 0;
        // if (errno == EAGAIN || errno == EWOULDBLOCK) {
        //     // Would block, try again later
        //     debug("[Client]: Send would block, try again later");
        //     return 0;
        // } else {
        //     // Actual error
        //     debug("[Client]: Error sending response: " + Utils::to_string(errno));
        //     setError();
        //     return -1;
        // }
    }
    
    // Update bytes sent
    responseBytesSent += bytesSent;
    debug("[Client]: Sent " + Utils::to_string(bytesSent) + " bytes, " + 
          Utils::to_string(responseBytesSent) + "/" + Utils::to_string(responseBuffer.size()) + " total");
    
    // Check if we're done
    if (responseBytesSent >= responseBuffer.size()) {
        debug("[Client]: Response fully sent");
        hasBeenServed = true;
        
        // If keep-alive connection, reset for next request but keep connection open
        if (keepAliveConnection) {
            debug("[Client]: Connection is keep-alive, resetting for next request");
            resetForNextRequest(); // This also sets state to IDLE
            return 0; // Don't close the connection
        } else {
            // Not keep-alive, signal that we're done with this client
            debug("[Client]: Connection is not keep-alive, can be closed");
            return 1; // Signal to close connection
        }
    }
    
    // Still have more to send
    return 0;
}

// Set response buffer for sending
void Client::setResponseBuffer(const std::string& response) {
    responseBuffer = response;
    responseBytesSent = 0;
    debug("[Client]: Response buffer set, size: " + Utils::to_string(responseBuffer.size()) + " bytes");
    
    // Update state to SENDING_RESPONSE
    setState(STATE_SENDING_RESPONSE);
}

// Diagnostic version of setBody to understand what's happening

void Client::setBody(std::string buffer) {
    debug("[Client]: Adding data to request body, buffer size: " + Utils::to_string(buffer.size()));
    
    lastChunkSize = buffer.size();
    
    if (!currentRequest) {
        debug("[Client]: Cannot set body, no current request");
        return;
    }
    
    // Special handling for binary data
    bool hasBinaryBytes = false;
    for (size_t i = 0; i < buffer.size(); i++) {
        if (buffer[i] == '\0') {
            hasBinaryBytes = true;
            debug("[Client]: Buffer contains binary data with null bytes");
            break;
        }
    }
    
    if (!firstChunkProcessed) {
        // **FIRST CHUNK ONLY** - Process HTTP headers
        debug("[Client]: === FIRST CHUNK DIAGNOSTIC ===");
        debug("[Client]: Buffer size: " + Utils::to_string(buffer.size()));
        
        // Clean the buffer content for debug display
        std::string bufferSample = buffer.substr(0, std::min(buffer.size(), static_cast<size_t>(300)));
        debug("[Client]: Raw buffer content: " + Utils::cleanForDebug(bufferSample));
        
        // Look for the header separator
        size_t headerEnd = buffer.find("\r\n\r\n");
        if (headerEnd != std::string::npos) {
            debug("[Client]: Found header separator at position: " + Utils::to_string(headerEnd));
            
            // Show what's before the separator (cleaned)
            std::string httpHeaders = buffer.substr(0, headerEnd);
            debug("[Client]: HTTP headers part: " + Utils::cleanForDebug(httpHeaders));
            
            size_t bodyStart = headerEnd + 4;
            if (bodyStart < buffer.size()) {
                std::string bodyPartSample = buffer.substr(bodyStart, std::min(static_cast<size_t>(200), buffer.size() - bodyStart));
                debug("[Client]: Body part starts with: " + Utils::cleanForDebug(bodyPartSample));
                
                // Extract whatever body data we have in this first chunk
                if (hasBinaryBytes) {
                    totalBody.clear();
                    for (size_t i = bodyStart; i < buffer.size(); i++) {
                        totalBody.push_back(buffer[i]);
                    }
                    debug("[Client]: Extracted binary body after headers, size: " + Utils::to_string(totalBody.size()));
                } else {
                    totalBody = buffer.substr(bodyStart);
                    debug("[Client]: Extracted text body after headers, size: " + Utils::to_string(totalBody.size()));
                }
            } else {
                debug("[Client]: Headers end at chunk boundary, no body data in first chunk");
                // **CRITICAL**: Even if no body data, we need to initialize totalBody to indicate first chunk processed
                totalBody = "";  // Initialize as empty string, not uninitialized
            }
        } else {
            debug("[Client]: No header end marker found in first chunk, waiting for more data");
            return;
        }
        
        // **CRITICAL**: Mark that we've processed the first chunk
        firstChunkProcessed = true;
        debug("[Client]: === END DIAGNOSTIC ===");
    } else {
        // **SUBSEQUENT CHUNKS** - All data is multipart body content
        debug("[Client]: Subsequent chunk - appending raw multipart data (size: " + Utils::to_string(buffer.size()) + ")");
        
        // Show what we're appending for debugging
        std::string chunkPreview = buffer.substr(0, std::min(buffer.size(), static_cast<size_t>(100)));
        debug("[Client]: Appending chunk preview: " + Utils::cleanForDebug(chunkPreview));
        
        // Just append the raw data - NO header processing!
        if (hasBinaryBytes) {
            for (size_t i = 0; i < buffer.size(); i++) {
                totalBody.push_back(buffer[i]);
            }
        } else {
            totalBody.append(buffer);
        }
        
        debug("[Client]: Appended data to body, new total size: " + Utils::to_string(totalBody.size()));
    }
    
    // IMPROVED filename extraction - do this whenever we have enough data
    if (isMultiPart && rawRequestData.size() > 200) {
        std::string newFilename = extractFilenameFromRawData(rawRequestData);
        if (newFilename != "uploaded_file" && newFilename != extractedFilename) {
            debug("[Client]: Updated filename from '" + extractedFilename + "' to '" + newFilename + "'");
            extractedFilename = newFilename;
        }
    }
    
    debug("[Client]: Current extracted filename: '" + extractedFilename + "'");
}

bool Client::hasUploadTimedOut() const {
    time_t currentTime = time(NULL);
    time_t idleTime = currentTime - lastActivityTime;
    return (idleTime > UPLOAD_TIMEOUT_SECONDS);
}

void Client::forceCompleteMultipartUpload() {
    if (isMultiPart && !bodyComplete) {
        debug("[Client]: Forcing completion of multipart upload");
        bodyComplete = true;
        setState(STATE_PROCESSING);
    }
}

// Set client parameters based on request
void Client::setParams() {
    if (!currentRequest) {
        debug("[Client]: Cannot set params, no request object");
        return;
    }
    
    // Get headers from the request
    HttpHeaders headers = currentRequest->getHeaders();
    
    // Check content type for multipart
    std::string contentType = headers.get("Content-Type");
    isMultiPart = (contentType.find("multipart/form-data") != std::string::npos);
    
    // Extract boundary if multipart
if (isMultiPart) {
    size_t boundaryPos = contentType.find("boundary=");
    if (boundaryPos != std::string::npos) {
        std::string boundaryValue = contentType.substr(boundaryPos + 9);
        // Remove any trailing whitespace or quotes
        boundaryValue.erase(boundaryValue.find_last_not_of(" \n\r\t\"") + 1);
        // Remove any leading whitespace or quotes
        boundaryValue.erase(0, boundaryValue.find_first_not_of(" \n\r\t\""));
        
        // Store the boundary both with and without the prefix
        //boundary = boundaryValue;
        //boundaryWithPrefix = "--" + boundaryValue;
        
        //debug("[Client]: Extracted boundary: '" + boundary + "' and prefix form: '" + boundaryWithPrefix + "'");
    } else {
        debug("[Client]: Multipart content type without boundary parameter");
        isMultiPart = false; // Can't process multipart without boundary
    }
}

    // Check connection type for keep-alive
    std::string connection = headers.get("Connection");
    bool isHttp11 = (currentRequest->getVersion() == "HTTP/1.1");
    
    // Set keep-alive property based on Connection header and HTTP version
    // HTTP/1.1 defaults to keep-alive unless "Connection: close" is specified
    // HTTP/1.0 defaults to close unless "Connection: keep-alive" is specified
    if (isHttp11) {
        keepAliveConnection = (connection.find("close") == std::string::npos);
    } else {
        keepAliveConnection = (connection.find("keep-alive") != std::string::npos);
    }
    
    // Find matching location for request
    std::string requestUri = currentRequest->getUri();
    std::cout << "[Client]: Finding best location match for URI: " << requestUri << std::endl;
    std::string bestMatch = passiveServer.getFileManager().findBestLocationMatch(requestUri);
    
    if (!bestMatch.empty()) {
        std::cout << "[Client]: Best location match found: " << bestMatch << std::endl;
        const std::map<std::string, Location>& locations = passiveServer.getConfig().get_all_Locations();
        std::cout << "[Client]: Total locations available: " << locations.size() << std::endl;
        
        std::map<std::string, Location>::const_iterator it = locations.find(bestMatch);
        
        if (it != locations.end()) {
            std::cout << "[Client]: Setting location for path: " << bestMatch << std::endl;
            
            // Make a complete copy instead of using a pointer
            if (location) {
                delete location; // Delete any existing location
            }
            try {
                // Create a deep copy of the location
                location = new Location();
                *location = it->second; // Use assignment operator instead of copy constructor
                
                std::cout << "[Client]: Location permissions after copy - GET: " 
                          << (location->get_allowed() ? "yes" : "no")
                          << ", POST: " << (location->post_allowed() ? "yes" : "no")
                          << ", DELETE: " << (location->delete_allowed() ? "yes" : "no") << std::endl;
            } catch (const std::exception& e) {
                std::cout << "[Client]: Exception copying location: " << e.what() << std::endl;
                location = NULL; // Ensure we don't have a dangling pointer
            }
        } else {
            std::cout << "[Client]: Location not found in config: " << bestMatch << std::endl;
        }
    } else {
        std::cout << "[Client]: No location match found for: " << requestUri << std::endl;
    }
    
    debug("[Client]: Params set - MultiPart: " + std::string(isMultiPart ? "yes" : "no") +
          ", KeepAlive: " + std::string(keepAliveConnection ? "yes" : "no") +
          ", Location: " + (location ? bestMatch : "none"));
}

// Handle error state
void Client::setError() {
    debug("[Client]: Setting error state for client fd " + Utils::to_string(clientFD));
    errorHasOccurred = true;
    setState(STATE_ERROR);
}

// Handle multipart body data
int Client::handleMultiPartBody() {
    if (!currentRequest) {
        debug("[Client]: Cannot handle multipart body, no request object");
        return -1;
    }
    
    // Get content length from headers
    HttpHeaders headers = currentRequest->getHeaders();
    std::string contentLengthStr = headers.get("Content-Length");
    
    if (contentLengthStr.empty()) {
        debug("[Client]: No Content-Length header for multipart request");
        setError();
        return -1;
    }
    
    // Parse content length
    int contentLength = std::atoi(contentLengthStr.c_str());
    
    // Calculate actual body size
    size_t bodySize = totalBody.size();
    
    debug("[Client]: Checking multipart body: " + Utils::to_string(bodySize) + "/" + 
          Utils::to_string(contentLength) + " bytes");
    
    // If filename is still the default and we have enough data, try to extract it again
    if (extractedFilename == "uploaded_file" && bodySize > 1000) {
        // Look for Content-Disposition in the body
        size_t dispPos = totalBody.find("Content-Disposition:");
        if (dispPos != std::string::npos) {
            // Look for filename in this Content-Disposition
            size_t filenamePos = totalBody.find("filename=\"", dispPos);
            if (filenamePos != std::string::npos && filenamePos < dispPos + 500) {
                filenamePos += 10; // Skip 'filename="'
                size_t endPos = totalBody.find("\"", filenamePos);
                
                if (endPos != std::string::npos && endPos > filenamePos) {
                    std::string filename = totalBody.substr(filenamePos, endPos - filenamePos);
                    debug("[Client]: Found filename in multipart body: '" + filename + "'");
                    
                    filename = cleanFilename(filename);
                    if (!filename.empty() && filename != "uploaded_file") {
                        debug("[Client]: Successfully extracted filename from body: '" + filename + "'");
                        extractedFilename = filename;
                    }
                }
            }
        }
    }
    
    // Check if we've been waiting too long
    time_t currentTime = time(NULL);
    time_t idleTime = currentTime - lastActivityTime;
    
    // Check for boundary markers
    std::string boundary = "--" + currentRequest->getBoundary();
    
    // Check if the last part of the buffer is a partial boundary
    if (bodySize >= boundary.size() && 
        totalBody.substr(totalBody.size() - boundary.size()) == boundary) {
        debug("[Client]: Found potential partial boundary at end of buffer, waiting for more data");
        return 1; // Need more data
    }
    
    // Check for end boundary patterns
    std::string endBoundary1 = boundary + "--";
    std::string endBoundary2 = boundary + "--\r\n";
    std::string endBoundary3 = boundary + "--\n";
    std::string endBoundary4 = "\r\n" + boundary + "--";
    std::string endBoundary5 = "\n" + boundary + "--";

    if (totalBody.find(endBoundary1) != std::string::npos ||
        totalBody.find(endBoundary2) != std::string::npos ||
        totalBody.find(endBoundary3) != std::string::npos ||
        totalBody.find(endBoundary4) != std::string::npos ||
        totalBody.find(endBoundary5) != std::string::npos) {
        debug("[Client]: Found end boundary marker, body is complete!");
        bodyComplete = true;
        return 0;
    }
    
    // Check if we've received the full content length
    if (bodySize >= static_cast<size_t>(contentLength)) {
        debug("[Client]: Received full content length, marking as complete");
        bodyComplete = true;
        return 0;
    }

    // Add a check for binary data with potential null bytes
    bool hasBinaryData = false;
    for (size_t i = 0; i < std::min(totalBody.size(), static_cast<size_t>(1024)); i++) {
        if (totalBody[i] == '\0') {
            hasBinaryData = true;
            debug("[Client]: Binary data detected with null bytes - using lenient checks");
            break;
        }
    }

    static size_t lastCheckedSize = 0;
    if (bodySize > lastCheckedSize + 10240) {  // 10KB progress
        debug("[Client]: Upload progressing steadily, resetting idle timer");
        lastActivityTime = currentTime;  // Reset the idle timer
        lastCheckedSize = bodySize;
    }

    if (lastChunkSize > 0 && idleTime < 10) {  // Recently received data
        debug("[Client]: Still receiving data actively, continuing upload");
        return 1;  // Need more data
    }
    
    if (hasBinaryData || idleTime > 10) {
        if (bodySize >= static_cast<size_t>(contentLength * 0.98)) {
            debug("[Client]: Nearly complete, accepting upload");
            bodyComplete = true;
            return 0;
        }
    }
    
    // If we've been waiting for more than UPLOAD_TIMEOUT_SECONDS and have at least 95% of the data
    if (idleTime > UPLOAD_TIMEOUT_SECONDS && bodySize >= static_cast<size_t>(contentLength * 0.95)) {
        debug("[Client]: Upload timed out after " + Utils::to_string(idleTime) + 
              " seconds, but we have " + Utils::to_string(bodySize) + " of " + 
              Utils::to_string(contentLength) + " bytes, accepting as complete");
        bodyComplete = true;
        return 0;
    }
    
    if (lastChunkSize < 1000 && bodySize >= static_cast<size_t>(contentLength * 0.95)) {
        debug("[Client]: Last chunk was small (" + Utils::to_string(lastChunkSize) + 
              " bytes) and we've received " + Utils::to_string(bodySize) + " out of " + 
              Utils::to_string(contentLength) + ", marking as complete");
        bodyComplete = true;
        return 0; // Body complete, ready to process
    }
    
    // For very slow uploads that might hit timeout but are still making progress
    if (idleTime > UPLOAD_TIMEOUT_SECONDS/2 && lastChunkSize > 0) {
        debug("[Client]: Slow upload in progress, extending timeout");
        lastActivityTime = currentTime - UPLOAD_TIMEOUT_SECONDS/4;  // Reset to 1/4 of timeout
    }
    
    debug("[Client]: Multipart body incomplete: " + Utils::to_string(bodySize) + "/" + 
          Utils::to_string(contentLength) + " bytes, waiting for more data");
    
    return 1; // Need more data
}

// Get client status
int Client::getClientStatus() {
    if (errorHasOccurred) {
        return -1; // Error
    }
    
    if (isMultiPart && !bodyComplete && state == STATE_READING_REQUEST) {
        return 1; // Incomplete, waiting for more data
    }
    
    return 0; // Ready to be processed
}

// Getters
int Client::getClientFD() const {
    return clientFD;
}

Request* Client::getCurrentRequest() const {
    return currentRequest;
}

const std::string& Client::getTotalBody() const {
    if (totalBody.empty() && currentRequest) {
        debug("[Client]: Warning: getTotalBody returning empty body but request exists");
    }
    return totalBody;
}

bool Client::isKeepAliveConnection() const {
    return keepAliveConnection;
}

void Client::setKeepAliveConnection(bool keepAlive) {
    keepAliveConnection = keepAlive;
}

Location* Client::getLocation() const {
    return location;
}

const Server& Client::getServer() const {
    return passiveServer;
}

std::string Client::getVersion() const {
    return currentRequest ? currentRequest->getVersion() : "";
}

void Client::setLocation(Location* loc) {
    // Delete existing location if any
    if (location) {
        delete location;
        location = NULL;
    }
    
    // Create a brand new Location object as a deep copy if loc is not NULL
    if (loc) {
        try {
            location = new Location(*loc); // Use copy constructor
            debug("[Client]: Location set using deep copy");
        } catch (const std::exception& e) {
            debug("[Client]: Exception setting location: " + std::string(e.what()));
            location = NULL;
        }
    }
}