// http_server.c - Advanced high-performance HTTP server implementation
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <pthread.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <zlib.h>

#define MAX_EVENTS 10000
#define MAX_CONNECTIONS 100000
#define BUFFER_SIZE 8192
#define MAX_REQUEST_SIZE 65536
#define MAX_RESPONSE_SIZE 1048576
#define WORKER_THREADS 8
#define BACKLOG 1024
#define KEEPALIVE_TIMEOUT 30
#define MAX_HEADERS 64
#define MAX_HEADER_SIZE 8192

// HTTP method types
typedef enum {
    HTTP_GET,
    HTTP_POST,
    HTTP_PUT,
    HTTP_DELETE,
    HTTP_HEAD,
    HTTP_OPTIONS,
    HTTP_PATCH,
    HTTP_CONNECT,
    HTTP_TRACE,
    HTTP_UNKNOWN
} http_method_t;

// HTTP status codes
typedef enum {
    HTTP_OK = 200,
    HTTP_CREATED = 201,
    HTTP_ACCEPTED = 202,
    HTTP_NO_CONTENT = 204,
    HTTP_MOVED_PERMANENTLY = 301,
    HTTP_FOUND = 302,
    HTTP_NOT_MODIFIED = 304,
    HTTP_BAD_REQUEST = 400,
    HTTP_UNAUTHORIZED = 401,
    HTTP_FORBIDDEN = 403,
    HTTP_NOT_FOUND = 404,
    HTTP_METHOD_NOT_ALLOWED = 405,
    HTTP_REQUEST_TIMEOUT = 408,
    HTTP_PAYLOAD_TOO_LARGE = 413,
    HTTP_INTERNAL_SERVER_ERROR = 500,
    HTTP_NOT_IMPLEMENTED = 501,
    HTTP_BAD_GATEWAY = 502,
    HTTP_SERVICE_UNAVAILABLE = 503,
    HTTP_GATEWAY_TIMEOUT = 504
} http_status_t;

// Connection states
typedef enum {
    CONN_STATE_READING_REQUEST,
    CONN_STATE_PROCESSING,
    CONN_STATE_WRITING_RESPONSE,
    CONN_STATE_KEEPALIVE,
    CONN_STATE_WEBSOCKET,
    CONN_STATE_CLOSING
} connection_state_t;

// HTTP header structure
typedef struct {
    char name[256];
    char value[2048];
} http_header_t;

// HTTP request structure
typedef struct {
    http_method_t method;
    char uri[2048];
    char version[16];
    char query_string[2048];
    http_header_t headers[MAX_HEADERS];
    int header_count;
    char *body;
    size_t body_length;
    size_t content_length;
    bool keep_alive;
    bool expect_continue;
    bool is_websocket_upgrade;
    char websocket_key[64];
    char websocket_protocol[256];
} http_request_t;

// HTTP response structure
typedef struct {
    http_status_t status;
    char version[16];
    http_header_t headers[MAX_HEADERS];
    int header_count;
    char *body;
    size_t body_length;
    bool keep_alive;
    bool chunked_encoding;
    bool gzip_compressed;
    time_t last_modified;
    char etag[64];
} http_response_t;

// Connection structure
typedef struct connection {
    int socket_fd;
    struct sockaddr_in client_addr;
    connection_state_t state;
    
    // SSL support
    SSL *ssl;
    bool ssl_enabled;
    
    // Request/response data
    char read_buffer[BUFFER_SIZE];
    size_t read_buffer_pos;
    size_t read_buffer_size;
    
    char write_buffer[MAX_RESPONSE_SIZE];
    size_t write_buffer_pos;
    size_t write_buffer_size;
    
    http_request_t request;
    http_response_t response;
    
    // Timing
    time_t last_activity;
    time_t connection_time;
    
    // WebSocket support
    bool websocket_handshake_complete;
    char websocket_frame_buffer[BUFFER_SIZE];
    size_t websocket_frame_pos;
    
    // File serving
    int file_fd;
    off_t file_offset;
    size_t file_size;
    
    // Compression
    z_stream gzip_stream;
    bool gzip_initialized;
    
    // Linked list for connection pool
    struct connection *next;
    struct connection *prev;
    
} connection_t;

// Route handler function type
typedef int (*route_handler_t)(connection_t *conn, http_request_t *request, http_response_t *response);

// Route structure
typedef struct route {
    char pattern[512];
    http_method_t method;
    route_handler_t handler;
    struct route *next;
} route_t;

// Worker thread structure
typedef struct {
    int thread_id;
    pthread_t thread;
    int epoll_fd;
    connection_t *connections;
    int connection_count;
    bool running;
    
    // Statistics
    uint64_t requests_processed;
    uint64_t bytes_sent;
    uint64_t bytes_received;
    
} worker_thread_t;

// HTTP server structure
typedef struct {
    int listen_fd;
    int listen_port;
    char *document_root;
    char *server_name;
    
    // SSL configuration
    SSL_CTX *ssl_ctx;
    bool ssl_enabled;
    char *ssl_cert_file;
    char *ssl_key_file;
    
    // Worker threads
    worker_thread_t workers[WORKER_THREADS];
    int worker_count;
    
    // Route handling
    route_t *routes;
    route_handler_t default_handler;
    
    // Connection pool
    connection_t *connection_pool;
    int max_connections;
    int active_connections;
    
    // Configuration
    bool enable_keepalive;
    int keepalive_timeout;
    bool enable_compression;
    size_t max_request_size;
    
    // Statistics
    uint64_t total_requests;
    uint64_t total_connections;
    uint64_t active_connections_count;
    
    // Control flags
    volatile bool running;
    pthread_mutex_t stats_mutex;
    
} http_server_t;

// Function prototypes
int http_server_init(http_server_t *server, int port, const char *document_root);
int http_server_start(http_server_t *server);
int http_server_stop(http_server_t *server);
int http_server_cleanup(http_server_t *server);

// SSL functions
int init_ssl(http_server_t *server, const char *cert_file, const char *key_file);
void cleanup_ssl(http_server_t *server);

// Worker thread functions
void *worker_thread_function(void *arg);
int handle_new_connection(worker_thread_t *worker, int client_fd);
int handle_client_data(worker_thread_t *worker, connection_t *conn);
int handle_client_write(worker_thread_t *worker, connection_t *conn);

// HTTP protocol functions
int parse_http_request(connection_t *conn, http_request_t *request);
int generate_http_response(connection_t *conn, http_response_t *response);
int send_http_response(connection_t *conn, http_response_t *response);
int send_file_response(connection_t *conn, const char *file_path);
int send_error_response(connection_t *conn, http_status_t status, const char *message);

// WebSocket functions
int handle_websocket_upgrade(connection_t *conn, http_request_t *request);
int handle_websocket_frame(connection_t *conn, const char *data, size_t length);
int send_websocket_frame(connection_t *conn, const char *data, size_t length);
void generate_websocket_accept_key(const char *key, char *accept_key);

// Route handling functions
int add_route(http_server_t *server, const char *pattern, http_method_t method, route_handler_t handler);
route_t *find_route(http_server_t *server, const char *uri, http_method_t method);
int default_file_handler(connection_t *conn, http_request_t *request, http_response_t *response);

// Connection management
connection_t *allocate_connection(http_server_t *server);
void free_connection(http_server_t *server, connection_t *conn);
void cleanup_connection(connection_t *conn);
int set_socket_nonblocking(int fd);
int set_socket_options(int fd);

// Compression functions
int init_gzip_compression(connection_t *conn);
int compress_response_body(connection_t *conn, const char *input, size_t input_size);
void cleanup_gzip_compression(connection_t *conn);

// Utility functions
const char *http_method_to_string(http_method_t method);
const char *http_status_to_string(http_status_t status);
http_method_t string_to_http_method(const char *method);
char *get_mime_type(const char *file_path);
char *url_decode(const char *url);
void parse_query_string(const char *query, http_header_t *params, int *param_count);
bool is_valid_uri(const char *uri);

// Example route handlers
int api_hello_handler(connection_t *conn, http_request_t *request, http_response_t *response);
int api_echo_handler(connection_t *conn, http_request_t *request, http_response_t *response);
int api_status_handler(connection_t *conn, http_request_t *request, http_response_t *response);
int websocket_chat_handler(connection_t *conn, http_request_t *request, http_response_t *response);

// Global server instance
static http_server_t g_server;
static volatile bool g_running = true;

void signal_handler(int signum) {
    g_running = false;
    g_server.running = false;
}

int main(int argc, char *argv[]) {
    int port = 8080;
    char *document_root = "/var/www/html";
    
    // Parse command line arguments
    if (argc > 1) {
        port = atoi(argv[1]);
    }
    if (argc > 2) {
        document_root = argv[2];
    }
    
    // Setup signal handlers
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    signal(SIGPIPE, SIG_IGN);
    
    // Initialize HTTP server
    if (http_server_init(&g_server, port, document_root) != 0) {
        fprintf(stderr, "Failed to initialize HTTP server\n");
        return 1;
    }
    
    // Add example routes
    add_route(&g_server, "/api/hello", HTTP_GET, api_hello_handler);
    add_route(&g_server, "/api/echo", HTTP_POST, api_echo_handler);
    add_route(&g_server, "/api/status", HTTP_GET, api_status_handler);
    add_route(&g_server, "/ws/chat", HTTP_GET, websocket_chat_handler);
    
    // Enable SSL if certificates are available
    if (access("server.crt", F_OK) == 0 && access("server.key", F_OK) == 0) {
        if (init_ssl(&g_server, "server.crt", "server.key") == 0) {
            printf("SSL enabled\n");
        }
    }
    
    // Start server
    if (http_server_start(&g_server) != 0) {
        fprintf(stderr, "Failed to start HTTP server\n");
        http_server_cleanup(&g_server);
        return 1;
    }
    
    printf("HTTP server started on port %d\n", port);
    printf("Document root: %s\n", document_root);
    
    // Main loop
    while (g_running) {
        // Print statistics
        pthread_mutex_lock(&g_server.stats_mutex);
        printf("Stats: Connections=%lu, Requests=%lu, Active=%lu\n",
               g_server.total_connections, g_server.total_requests, g_server.active_connections_count);
        pthread_mutex_unlock(&g_server.stats_mutex);
        
        sleep(10);
    }
    
    // Stop and cleanup
    http_server_stop(&g_server);
    http_server_cleanup(&g_server);
    
    printf("HTTP server stopped\n");
    return 0;
}

int http_server_init(http_server_t *server, int port, const char *document_root) {
    if (!server) return -1;
    
    memset(server, 0, sizeof(http_server_t));
    
    server->listen_port = port;
    server->document_root = strdup(document_root);
    server->server_name = strdup("Advanced-HTTP-Server/1.0");
    server->max_connections = MAX_CONNECTIONS;
    server->enable_keepalive = true;
    server->keepalive_timeout = KEEPALIVE_TIMEOUT;
    server->enable_compression = true;
    server->max_request_size = MAX_REQUEST_SIZE;
    server->worker_count = WORKER_THREADS;
    server->default_handler = default_file_handler;
    server->running = true;
    
    // Initialize statistics mutex
    pthread_mutex_init(&server->stats_mutex, NULL);
    
    // Create listening socket
    server->listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server->listen_fd < 0) {
        perror("socket");
        return -1;
    }
    
    // Set socket options
    set_socket_options(server->listen_fd);
    set_socket_nonblocking(server->listen_fd);
    
    // Bind to port
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(port);
    
    if (bind(server->listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind");
        close(server->listen_fd);
        return -1;
    }
    
    // Listen for connections
    if (listen(server->listen_fd, BACKLOG) < 0) {
        perror("listen");
        close(server->listen_fd);
        return -1;
    }
    
    return 0;
}

int http_server_start(http_server_t *server) {
    if (!server) return -1;
    
    // Create worker threads
    for (int i = 0; i < server->worker_count; i++) {
        worker_thread_t *worker = &server->workers[i];
        worker->thread_id = i;
        worker->running = true;
        
        // Create epoll instance for this worker
        worker->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
        if (worker->epoll_fd < 0) {
            perror("epoll_create1");
            return -1;
        }
        
        // Create worker thread
        if (pthread_create(&worker->thread, NULL, worker_thread_function, worker) != 0) {
            perror("pthread_create");
            return -1;
        }
    }
    
    // Accept connections and distribute to workers
    int worker_index = 0;
    while (server->running) {
        struct sockaddr_in client_addr;
        socklen_t client_len = sizeof(client_addr);
        
        int client_fd = accept(server->listen_fd, (struct sockaddr *)&client_addr, &client_len);
        if (client_fd < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                usleep(1000); // 1ms
                continue;
            }
            perror("accept");
            continue;
        }
        
        // Set client socket options
        set_socket_nonblocking(client_fd);
        set_socket_options(client_fd);
        
        // Distribute connection to worker
        worker_thread_t *worker = &server->workers[worker_index];
        if (handle_new_connection(worker, client_fd) != 0) {
            close(client_fd);
        }
        
        worker_index = (worker_index + 1) % server->worker_count;
        
        // Update statistics
        pthread_mutex_lock(&server->stats_mutex);
        server->total_connections++;
        server->active_connections_count++;
        pthread_mutex_unlock(&server->stats_mutex);
    }
    
    return 0;
}

void *worker_thread_function(void *arg) {
    worker_thread_t *worker = (worker_thread_t *)arg;
    struct epoll_event events[MAX_EVENTS];
    
    // Set thread name
    char thread_name[16];
    snprintf(thread_name, sizeof(thread_name), "http_worker_%d", worker->thread_id);
    pthread_setname_np(pthread_self(), thread_name);
    
    printf("Worker thread %d started\n", worker->thread_id);
    
    while (worker->running) {
        int event_count = epoll_wait(worker->epoll_fd, events, MAX_EVENTS, 1000);
        
        if (event_count < 0) {
            if (errno == EINTR) continue;
            perror("epoll_wait");
            break;
        }
        
        for (int i = 0; i < event_count; i++) {
            connection_t *conn = (connection_t *)events[i].data.ptr;
            
            if (events[i].events & EPOLLERR || events[i].events & EPOLLHUP) {
                // Connection error or hangup
                cleanup_connection(conn);
                free_connection(&g_server, conn);
                continue;
            }
            
            if (events[i].events & EPOLLIN) {
                // Data available for reading
                if (handle_client_data(worker, conn) != 0) {
                    cleanup_connection(conn);
                    free_connection(&g_server, conn);
                    continue;
                }
            }
            
            if (events[i].events & EPOLLOUT) {
                // Socket ready for writing
                if (handle_client_write(worker, conn) != 0) {
                    cleanup_connection(conn);
                    free_connection(&g_server, conn);
                    continue;
                }
            }
        }
        
        // Check for connection timeouts
        time_t current_time = time(NULL);
        connection_t *conn = worker->connections;
        while (conn) {
            connection_t *next = conn->next;
            
            if (current_time - conn->last_activity > g_server.keepalive_timeout) {
                cleanup_connection(conn);
                free_connection(&g_server, conn);
            }
            
            conn = next;
        }
    }
    
    printf("Worker thread %d stopping\n", worker->thread_id);
    return NULL;
}

int handle_new_connection(worker_thread_t *worker, int client_fd) {
    // Allocate connection structure
    connection_t *conn = allocate_connection(&g_server);
    if (!conn) {
        return -1;
    }
    
    conn->socket_fd = client_fd;
    conn->state = CONN_STATE_READING_REQUEST;
    conn->last_activity = time(NULL);
    conn->connection_time = conn->last_activity;
    
    // Add to worker's connection list
    conn->next = worker->connections;
    if (worker->connections) {
        worker->connections->prev = conn;
    }
    worker->connections = conn;
    worker->connection_count++;
    
    // Add to epoll
    struct epoll_event event;
    event.events = EPOLLIN | EPOLLET;
    event.data.ptr = conn;
    
    if (epoll_ctl(worker->epoll_fd, EPOLL_CTL_ADD, client_fd, &event) < 0) {
        perror("epoll_ctl");
        return -1;
    }
    
    return 0;
}

int handle_client_data(worker_thread_t *worker, connection_t *conn) {
    if (!conn) return -1;
    
    ssize_t bytes_read;
    
    if (conn->ssl_enabled && conn->ssl) {
        // SSL read
        bytes_read = SSL_read(conn->ssl, conn->read_buffer + conn->read_buffer_pos,
                             BUFFER_SIZE - conn->read_buffer_pos - 1);
        if (bytes_read <= 0) {
            int ssl_error = SSL_get_error(conn->ssl, bytes_read);
            if (ssl_error == SSL_ERROR_WANT_READ || ssl_error == SSL_ERROR_WANT_WRITE) {
                return 0; // Would block
            }
            return -1; // Error
        }
    } else {
        // Regular read
        bytes_read = read(conn->socket_fd, conn->read_buffer + conn->read_buffer_pos,
                         BUFFER_SIZE - conn->read_buffer_pos - 1);
        if (bytes_read <= 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                return 0; // Would block
            }
            return -1; // Error or EOF
        }
    }
    
    conn->read_buffer_pos += bytes_read;
    conn->read_buffer[conn->read_buffer_pos] = '\0';
    conn->last_activity = time(NULL);
    
    // Update statistics
    worker->bytes_received += bytes_read;
    
    // Process request based on connection state
    switch (conn->state) {
        case CONN_STATE_READING_REQUEST:
            if (strstr(conn->read_buffer, "\r\n\r\n") != NULL) {
                // Complete HTTP request received
                if (parse_http_request(conn, &conn->request) != 0) {
                    send_error_response(conn, HTTP_BAD_REQUEST, "Invalid request");
                    return -1;
                }
                
                conn->state = CONN_STATE_PROCESSING;
                
                // Check for WebSocket upgrade
                if (conn->request.is_websocket_upgrade) {
                    return handle_websocket_upgrade(conn, &conn->request);
                }
                
                // Process HTTP request
                route_t *route = find_route(&g_server, conn->request.uri, conn->request.method);
                if (route && route->handler) {
                    route->handler(conn, &conn->request, &conn->response);
                } else {
                    g_server.default_handler(conn, &conn->request, &conn->response);
                }
                
                conn->state = CONN_STATE_WRITING_RESPONSE;
                
                // Enable EPOLLOUT for writing response
                struct epoll_event event;
                event.events = EPOLLIN | EPOLLOUT | EPOLLET;
                event.data.ptr = conn;
                epoll_ctl(worker->epoll_fd, EPOLL_CTL_MOD, conn->socket_fd, &event);
                
                worker->requests_processed++;
                
                // Update global statistics
                pthread_mutex_lock(&g_server.stats_mutex);
                g_server.total_requests++;
                pthread_mutex_unlock(&g_server.stats_mutex);
            }
            break;
            
        case CONN_STATE_WEBSOCKET:
            return handle_websocket_frame(conn, conn->read_buffer, conn->read_buffer_pos);
            
        default:
            break;
    }
    
    return 0;
}

int handle_client_write(worker_thread_t *worker, connection_t *conn) {
    if (!conn || conn->state != CONN_STATE_WRITING_RESPONSE) return -1;
    
    ssize_t bytes_written;
    
    if (conn->ssl_enabled && conn->ssl) {
        // SSL write
        bytes_written = SSL_write(conn->ssl, conn->write_buffer + conn->write_buffer_pos,
                                 conn->write_buffer_size - conn->write_buffer_pos);
        if (bytes_written <= 0) {
            int ssl_error = SSL_get_error(conn->ssl, bytes_written);
            if (ssl_error == SSL_ERROR_WANT_READ || ssl_error == SSL_ERROR_WANT_WRITE) {
                return 0; // Would block
            }
            return -1; // Error
        }
    } else {
        // Regular write
        bytes_written = write(conn->socket_fd, conn->write_buffer + conn->write_buffer_pos,
                             conn->write_buffer_size - conn->write_buffer_pos);
        if (bytes_written <= 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                return 0; // Would block
            }
            return -1; // Error
        }
    }
    
    conn->write_buffer_pos += bytes_written;
    worker->bytes_sent += bytes_written;
    
    // Check if response is completely sent
    if (conn->write_buffer_pos >= conn->write_buffer_size) {
        if (conn->request.keep_alive && g_server.enable_keepalive) {
            // Reset for next request
            conn->state = CONN_STATE_READING_REQUEST;
            conn->read_buffer_pos = 0;
            conn->write_buffer_pos = 0;
            conn->write_buffer_size = 0;
            memset(&conn->request, 0, sizeof(http_request_t));
            memset(&conn->response, 0, sizeof(http_response_t));
            
            // Disable EPOLLOUT
            struct epoll_event event;
            event.events = EPOLLIN | EPOLLET;
            event.data.ptr = conn;
            epoll_ctl(worker->epoll_fd, EPOLL_CTL_MOD, conn->socket_fd, &event);
        } else {
            // Close connection
            return -1;
        }
    }
    
    return 0;
}

int parse_http_request(connection_t *conn, http_request_t *request) {
    if (!conn || !request) return -1;
    
    memset(request, 0, sizeof(http_request_t));
    
    char *line = strtok(conn->read_buffer, "\r\n");
    if (!line) return -1;
    
    // Parse request line
    char method_str[16], uri[2048], version[16];
    if (sscanf(line, "%15s %2047s %15s", method_str, uri, version) != 3) {
        return -1;
    }
    
    request->method = string_to_http_method(method_str);
    strncpy(request->uri, uri, sizeof(request->uri) - 1);
    strncpy(request->version, version, sizeof(request->version) - 1);
    
    // Parse query string
    char *query_start = strchr(request->uri, '?');
    if (query_start) {
        *query_start = '\0';
        strncpy(request->query_string, query_start + 1, sizeof(request->query_string) - 1);
    }
    
    // Parse headers
    while ((line = strtok(NULL, "\r\n")) != NULL && *line != '\0') {
        char *colon = strchr(line, ':');
        if (!colon) continue;
        
        *colon = '\0';
        char *name = line;
        char *value = colon + 1;
        
        // Skip whitespace
        while (*value == ' ' || *value == '\t') value++;
        
        if (request->header_count < MAX_HEADERS) {
            strncpy(request->headers[request->header_count].name, name, 255);
            strncpy(request->headers[request->header_count].value, value, 2047);
            request->header_count++;
        }
        
        // Check for special headers
        if (strcasecmp(name, "Connection") == 0) {
            request->keep_alive = (strcasecmp(value, "keep-alive") == 0);
        } else if (strcasecmp(name, "Content-Length") == 0) {
            request->content_length = atol(value);
        } else if (strcasecmp(name, "Expect") == 0) {
            request->expect_continue = (strcasecmp(value, "100-continue") == 0);
        } else if (strcasecmp(name, "Upgrade") == 0) {
            request->is_websocket_upgrade = (strcasecmp(value, "websocket") == 0);
        } else if (strcasecmp(name, "Sec-WebSocket-Key") == 0) {
            strncpy(request->websocket_key, value, sizeof(request->websocket_key) - 1);
        } else if (strcasecmp(name, "Sec-WebSocket-Protocol") == 0) {
            strncpy(request->websocket_protocol, value, sizeof(request->websocket_protocol) - 1);
        }
    }
    
    return 0;
}

int send_http_response(connection_t *conn, http_response_t *response) {
    if (!conn || !response) return -1;
    
    // Generate response headers
    char header_buffer[MAX_HEADER_SIZE];
    int header_len = snprintf(header_buffer, sizeof(header_buffer),
                             "%s %d %s\r\n"
                             "Server: %s\r\n"
                             "Date: %s\r\n"
                             "Content-Length: %zu\r\n"
                             "Connection: %s\r\n",
                             response->version,
                             response->status,
                             http_status_to_string(response->status),
                             g_server.server_name,
                             "Thu, 01 Jan 1970 00:00:00 GMT", // TODO: Format current time
                             response->body_length,
                             response->keep_alive ? "keep-alive" : "close");
    
    // Add custom headers
    for (int i = 0; i < response->header_count; i++) {
        header_len += snprintf(header_buffer + header_len, sizeof(header_buffer) - header_len,
                              "%s: %s\r\n",
                              response->headers[i].name,
                              response->headers[i].value);
    }
    
    // End headers
    header_len += snprintf(header_buffer + header_len, sizeof(header_buffer) - header_len, "\r\n");
    
    // Copy headers and body to write buffer
    conn->write_buffer_size = header_len + response->body_length;
    if (conn->write_buffer_size > MAX_RESPONSE_SIZE) {
        return -1; // Response too large
    }
    
    memcpy(conn->write_buffer, header_buffer, header_len);
    if (response->body && response->body_length > 0) {
        memcpy(conn->write_buffer + header_len, response->body, response->body_length);
    }
    
    conn->write_buffer_pos = 0;
    
    return 0;
}

// Example route handlers
int api_hello_handler(connection_t *conn, http_request_t *request, http_response_t *response) {
    const char *hello_msg = "{\"message\": \"Hello, World!\", \"timestamp\": \"2024-01-01T00:00:00Z\"}";
    
    response->status = HTTP_OK;
    strcpy(response->version, "HTTP/1.1");
    response->body = strdup(hello_msg);
    response->body_length = strlen(hello_msg);
    response->keep_alive = request->keep_alive;
    
    // Add JSON content type header
    strcpy(response->headers[0].name, "Content-Type");
    strcpy(response->headers[0].value, "application/json");
    response->header_count = 1;
    
    return send_http_response(conn, response);
}

int api_echo_handler(connection_t *conn, http_request_t *request, http_response_t *response) {
    if (request->method != HTTP_POST) {
        return send_error_response(conn, HTTP_METHOD_NOT_ALLOWED, "Method not allowed");
    }
    
    // Echo the request body
    response->status = HTTP_OK;
    strcpy(response->version, "HTTP/1.1");
    response->body = strdup(request->body ? request->body : "");
    response->body_length = request->body_length;
    response->keep_alive = request->keep_alive;
    
    // Add plain text content type header
    strcpy(response->headers[0].name, "Content-Type");
    strcpy(response->headers[0].value, "text/plain");
    response->header_count = 1;
    
    return send_http_response(conn, response);
}

int api_status_handler(connection_t *conn, http_request_t *request, http_response_t *response) {
    char status_json[1024];
    snprintf(status_json, sizeof(status_json),
             "{"
             "\"server\": \"%s\","
             "\"uptime\": %ld,"
             "\"total_connections\": %lu,"
             "\"total_requests\": %lu,"
             "\"active_connections\": %lu"
             "}",
             g_server.server_name,
             time(NULL) - g_server.total_connections, // Approximate uptime
             g_server.total_connections,
             g_server.total_requests,
             g_server.active_connections_count);
    
    response->status = HTTP_OK;
    strcpy(response->version, "HTTP/1.1");
    response->body = strdup(status_json);
    response->body_length = strlen(status_json);
    response->keep_alive = request->keep_alive;
    
    // Add JSON content type header
    strcpy(response->headers[0].name, "Content-Type");
    strcpy(response->headers[0].value, "application/json");
    response->header_count = 1;
    
    return send_http_response(conn, response);
}

int default_file_handler(connection_t *conn, http_request_t *request, http_response_t *response) {
    if (request->method != HTTP_GET && request->method != HTTP_HEAD) {
        return send_error_response(conn, HTTP_METHOD_NOT_ALLOWED, "Method not allowed");
    }
    
    // Construct file path
    char file_path[2048];
    snprintf(file_path, sizeof(file_path), "%s%s", g_server.document_root, request->uri);
    
    // Check if path is safe
    if (!is_valid_uri(request->uri)) {
        return send_error_response(conn, HTTP_FORBIDDEN, "Access denied");
    }
    
    // Check if file exists
    struct stat file_stat;
    if (stat(file_path, &file_stat) < 0) {
        return send_error_response(conn, HTTP_NOT_FOUND, "File not found");
    }
    
    // Send file
    return send_file_response(conn, file_path);
}

// Utility functions
const char *http_status_to_string(http_status_t status) {
    switch (status) {
        case HTTP_OK: return "OK";
        case HTTP_CREATED: return "Created";
        case HTTP_ACCEPTED: return "Accepted";
        case HTTP_NO_CONTENT: return "No Content";
        case HTTP_BAD_REQUEST: return "Bad Request";
        case HTTP_UNAUTHORIZED: return "Unauthorized";
        case HTTP_FORBIDDEN: return "Forbidden";
        case HTTP_NOT_FOUND: return "Not Found";
        case HTTP_METHOD_NOT_ALLOWED: return "Method Not Allowed";
        case HTTP_INTERNAL_SERVER_ERROR: return "Internal Server Error";
        case HTTP_NOT_IMPLEMENTED: return "Not Implemented";
        case HTTP_BAD_GATEWAY: return "Bad Gateway";
        case HTTP_SERVICE_UNAVAILABLE: return "Service Unavailable";
        default: return "Unknown";
    }
}

http_method_t string_to_http_method(const char *method) {
    if (strcasecmp(method, "GET") == 0) return HTTP_GET;
    if (strcasecmp(method, "POST") == 0) return HTTP_POST;
    if (strcasecmp(method, "PUT") == 0) return HTTP_PUT;
    if (strcasecmp(method, "DELETE") == 0) return HTTP_DELETE;
    if (strcasecmp(method, "HEAD") == 0) return HTTP_HEAD;
    if (strcasecmp(method, "OPTIONS") == 0) return HTTP_OPTIONS;
    if (strcasecmp(method, "PATCH") == 0) return HTTP_PATCH;
    if (strcasecmp(method, "CONNECT") == 0) return HTTP_CONNECT;
    if (strcasecmp(method, "TRACE") == 0) return HTTP_TRACE;
    return HTTP_UNKNOWN;
}

int set_socket_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags < 0) return -1;
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int set_socket_options(int fd) {
    int optval = 1;
    
    // Reuse address
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
        return -1;
    }
    
    // Disable Nagle's algorithm
    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof(optval)) < 0) {
        return -1;
    }
    
    return 0;
}

bool is_valid_uri(const char *uri) {
    if (!uri) return false;
    
    // Check for directory traversal
    if (strstr(uri, "../") != NULL || strstr(uri, "..\\") != NULL) {
        return false;
    }
    
    // Check for null bytes
    for (const char *p = uri; *p; p++) {
        if (*p == '\0') return false;
    }
    
    return true;
}

int send_error_response(connection_t *conn, http_status_t status, const char *message) {
    char error_body[1024];
    snprintf(error_body, sizeof(error_body),
             "<html><head><title>%d %s</title></head>"
             "<body><h1>%d %s</h1><p>%s</p></body></html>",
             status, http_status_to_string(status),
             status, http_status_to_string(status),
             message);
    
    conn->response.status = status;
    strcpy(conn->response.version, "HTTP/1.1");
    conn->response.body = strdup(error_body);
    conn->response.body_length = strlen(error_body);
    conn->response.keep_alive = false;
    
    // Add HTML content type header
    strcpy(conn->response.headers[0].name, "Content-Type");
    strcpy(conn->response.headers[0].value, "text/html");
    conn->response.header_count = 1;
    
    return send_http_response(conn, &conn->response);
}

int http_server_cleanup(http_server_t *server) {
    if (!server) return -1;
    
    // Stop worker threads
    for (int i = 0; i < server->worker_count; i++) {
        server->workers[i].running = false;
        pthread_join(server->workers[i].thread, NULL);
        close(server->workers[i].epoll_fd);
    }
    
    // Close listening socket
    if (server->listen_fd > 0) {
        close(server->listen_fd);
    }
    
    // Cleanup SSL
    if (server->ssl_enabled) {
        cleanup_ssl(server);
    }
    
    // Free resources
    free(server->document_root);
    free(server->server_name);
    
    // Cleanup routes
    route_t *route = server->routes;
    while (route) {
        route_t *next = route->next;
        free(route);
        route = next;
    }
    
    pthread_mutex_destroy(&server->stats_mutex);
    
    printf("HTTP server cleanup completed\n");
    return 0;
}