/*
 * =====================================================================================
 *
 * Filename:  proxy.c
 *
 * Description:  High-performance Reverse Proxy with Real-time Monitoring Dashboard.
 * Single-file C implementation using epoll - PRODUCTION READY VERSION
 *
 * Version:   1.5 (Compiler Warnings Fixed)
 * Created:   2024
 * Compiler:  gcc
 *
 * Author:    Fixed Version
 *
 * To Compile:
 * gcc -Wall -Wextra -O2 -g -pthread cJSON.c proxy.c -o rproxy -lssl -lcrypto -lsqlite3 -lm
 *
 * =====================================================================================
 */


// --- Standard Library Includes ---
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <sqlite3.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <stdarg.h>
#include <signal.h>
#include <errno.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/sysinfo.h>
#include <math.h>
#include <ctype.h>
#include <netdb.h>

// --- Local Includes ---
#include "cJSON.h"

// --- Constants ---
#define MAX_EVENTS 1024
#define MAX_FDS 65536
#define CHUNK_SIZE 65536
#define HISTORY_SECONDS 300
#define MAX_HEADER_SIZE 8192
#define MAX_REQUEST_LINE_SIZE 4096
#define MAX_URI_SIZE 2048

// --- Enums and Structs ---

typedef enum {
    CONN_TYPE_UNUSED,
    CONN_TYPE_LISTENER,
    CONN_TYPE_CLIENT,
    CONN_TYPE_UPSTREAM
} conn_type_t;

typedef enum {
    CLIENT_STATE_READING_REQUEST_LINE, // Initial state, reading headers
    CLIENT_STATE_READING_HEADERS,      // Legacy, handled by above
    CLIENT_STATE_READING_BODY,         // New state for handling request bodies
    CLIENT_STATE_CONNECTING_UPSTREAM,
    CLIENT_STATE_TUNNELING,            // Full-duplex forwarding state
    CLIENT_STATE_DONE,
    CLIENT_STATE_ERROR
} client_state_t;

struct connection_s;
struct vhost_stats_s;

typedef struct {
    char hostname[256];
    char upstream_host[256];
    int upstream_port;
    int use_ssl;
    int rewrite_host;
} route_config_t;

typedef struct {
    int port;
    route_config_t *routes;
    int route_count;
} app_config_t;

typedef struct {
    char *data;
    size_t size;
    size_t capacity;
} buffer_t;

typedef struct {
    char method[16];
    char uri[MAX_URI_SIZE];
    char version[16];
    char host[256];
    int content_length;
    int is_websocket;
    int keep_alive;
    int connection_upgrade;
} http_request_t;

typedef struct connection_s {
    conn_type_t type;
    client_state_t state;
    int fd;
    struct connection_s *pair;
    struct vhost_stats_s *vhost_stats;
    buffer_t read_buf;
    buffer_t write_buf;
    SSL *ssl;
    int ssl_handshake_done;
    http_request_t request;
    char *http_body_start;
    long http_content_length;
    long http_body_read;
    int is_websocket;
    int keep_alive;
    double request_start_time;
    time_t last_activity;
} connection_t;

typedef struct {
    double time;
    double value;
} history_point_t;

typedef struct {
    history_point_t *points;
    int capacity;
    int head;
    int count;
} history_deque_t;

typedef struct {
    double time;
    double rx_kbps;
    double tx_kbps;
} network_history_point_t;

typedef struct {
    network_history_point_t *points;
    int capacity;
    int head;
    int count;
} network_history_deque_t;

typedef struct request_time_s {
    double *times;
    int capacity;
    int head;
    int count;
} request_time_deque_t;

typedef struct vhost_stats_s {
    char vhost_name[256];
    long long http_requests;
    long long websocket_requests;
    long long total_requests;
    long long bytes_sent;
    long long bytes_recv;
    double avg_request_time_ms;
    long long last_bytes_sent;
    long long last_bytes_recv;
    double last_update;
    history_deque_t throughput_history;
    request_time_deque_t request_times;
    struct vhost_stats_s *next;
} vhost_stats_t;

typedef struct {
    time_t start_time;
    int active_connections;
    history_deque_t cpu_history;
    history_deque_t memory_history;
    network_history_deque_t network_history;
    history_deque_t throughput_history;
    long long last_net_sent;
    long long last_net_recv;
    double last_net_update_time;
    vhost_stats_t *vhost_stats_head;
    sqlite3 *db;
} system_monitor_t;

// --- Global State ---
connection_t connections[MAX_FDS];
app_config_t config;
system_monitor_t monitor;
int epoll_fd;
SSL_CTX *ssl_ctx;
static int g_debug_mode = 0;


// --- Function Prototypes ---
void log_error(const char *msg);
void log_info(const char *format, ...);
void log_debug(const char *format, ...);
int load_config(const char *filename);
void free_config();
route_config_t *find_route(const char *hostname);
void setup_listener_socket(int port);
void accept_new_connection(int listener_fd);
void close_connection(int fd);
void handle_connection_event(struct epoll_event *event);
void connect_to_upstream(connection_t *client_conn, route_config_t *route);
void handle_client_data(connection_t *conn);
void handle_client_body(connection_t *conn);
int parse_http_request_line(const char *line, http_request_t *request);
int parse_http_headers(const char *headers, http_request_t *request);
int find_header_value(const char *headers, const char *header_name, char *value, size_t value_size);
void monitor_init(const char *db_file);
void monitor_update();
void monitor_cleanup();
void monitor_record_request_start(vhost_stats_t *stats, int is_websocket);
void monitor_record_request_end(vhost_stats_t *stats, double start_time);
vhost_stats_t* monitor_get_or_create_vhost_stats(const char *vhost_name);
void serve_dashboard(connection_t *conn);
void serve_stats_api(connection_t *conn);
void send_error_response(connection_t *conn, int code, const char* status, const char* body);


// --- Buffer Helpers ---
static inline int buffer_init(buffer_t *buf, size_t capacity) {
    buf->data = malloc(capacity);
    if (!buf->data) {
        log_error("Failed to allocate buffer");
        return -1;
    }
    buf->capacity = capacity;
    buf->size = 0;
    return 0;
}

static inline void buffer_free(buffer_t *buf) {
    if (buf->data) {
        free(buf->data);
        buf->data = NULL;
    }
    buf->capacity = 0;
    buf->size = 0;
}

static inline int buffer_ensure_capacity(buffer_t *buf, size_t required) {
    if (buf->capacity >= required) return 0;

    size_t new_capacity = buf->capacity;
    while (new_capacity < required) {
        new_capacity *= 2;
    }

    char *new_data = realloc(buf->data, new_capacity);
    if (!new_data) {
        log_error("Failed to reallocate buffer");
        return -1;
    }
    buf->data = new_data;
    buf->capacity = new_capacity;
    return 0;
}

// --- String Utilities ---
static char* safe_strdup(const char *str, size_t max_len) {
    if (!str) return NULL;
    size_t len = strnlen(str, max_len);
    char *dup = malloc(len + 1);
    if (!dup) return NULL;
    memcpy(dup, str, len);
    dup[len] = '\0';
    return dup;
}

static void trim_whitespace(char *str) {
    if (!str) return;

    // Trim leading whitespace
    char *start = str;
    while (isspace((unsigned char)*start)) start++;

    if (start != str) {
        memmove(str, start, strlen(start) + 1);
    }

    // Trim trailing whitespace
    char *end = str + strlen(str) - 1;
    while (end >= str && isspace((unsigned char)*end)) {
        *end = '\0';
        end--;
    }
}

static int is_valid_http_method(const char *method) {
    const char *valid_methods[] = {"GET", "POST", "PUT", "DELETE", "HEAD", 
                                     "OPTIONS", "PATCH", "TRACE", "CONNECT", NULL};
    for (int i = 0; valid_methods[i]; i++) {
        if (strcmp(method, valid_methods[i]) == 0) return 1;
    }
    return 0;
}

static int is_valid_http_version(const char *version) {
    return (strcmp(version, "HTTP/1.0") == 0 || strcmp(version, "HTTP/1.1") == 0);
}

// =================================================================================================
//
//                                         Logging Implementation
//
// =================================================================================================

void log_error(const char *msg) {
    perror(msg);
}

void log_message(const char *level, const char *format, va_list args) {
    time_t now;
    time(&now);
    char buf[32];
    strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&now));
    printf("%s - %-5s - ", buf, level);
    vprintf(format, args);
    printf("\n");
    fflush(stdout);
}

void log_info(const char *format, ...) {
    va_list args;
    va_start(args, format);
    log_message("INFO", format, args);
    va_end(args);
}

void log_debug(const char *format, ...) {
    if (!g_debug_mode) return;
    va_list args;
    va_start(args, format);
    log_message("DEBUG", format, args);
    va_end(args);
}


// =================================================================================================
//
//                                       Configuration Implementation
//
// =================================================================================================

static char* read_file_to_string(const char *filename) {
    FILE *f = fopen(filename, "rb");
    if (!f) return NULL;

    fseek(f, 0, SEEK_END);
    long length = ftell(f);
    if (length < 0 || length > 1024*1024) { // Max 1MB config
        fclose(f);
        return NULL;
    }

    fseek(f, 0, SEEK_SET);
    char *buffer = malloc(length + 1);
    if (buffer) {
        size_t read_len = fread(buffer, 1, length, f);
        buffer[read_len] = '\0';
    }
    fclose(f);
    return buffer;
}

int load_config(const char *filename) {
    log_info("Loading configuration from %s", filename);
    char *json_string = read_file_to_string(filename);
    if (!json_string) {
        log_error("Could not read config file");
        return 0;
    }

    cJSON *root = cJSON_Parse(json_string);
    free(json_string);
    if (!root) {
        fprintf(stderr, "JSON parse error: %s\n", cJSON_GetErrorPtr());
        return 0;
    }

    cJSON *port_item = cJSON_GetObjectItem(root, "port");
    config.port = cJSON_IsNumber(port_item) ? port_item->valueint : 8080;

    if (config.port < 1 || config.port > 65535) {
        fprintf(stderr, "Invalid port number: %d\n", config.port);
        cJSON_Delete(root);
        return 0;
    }

    cJSON *proxy_array = cJSON_GetObjectItem(root, "reverse_proxy");
    if (cJSON_IsArray(proxy_array)) {
        config.route_count = cJSON_GetArraySize(proxy_array);
        if (config.route_count <= 0) {
            cJSON_Delete(root);
            return 0;
        }

        config.routes = malloc(config.route_count * sizeof(route_config_t));
        if (!config.routes) {
            log_error("Failed to allocate memory for routes");
            cJSON_Delete(root);
            return 0;
        }

        int i = 0;
        cJSON *route_item;
        cJSON_ArrayForEach(route_item, proxy_array) {
            route_config_t *route = &config.routes[i];
            memset(route, 0, sizeof(route_config_t));

            cJSON *hostname = cJSON_GetObjectItem(route_item, "hostname");
            cJSON *upstream_host = cJSON_GetObjectItem(route_item, "upstream_host");
            cJSON *upstream_port = cJSON_GetObjectItem(route_item, "upstream_port");

            if (!cJSON_IsString(hostname) || !cJSON_IsString(upstream_host) || !cJSON_IsNumber(upstream_port)) {
                fprintf(stderr, "Invalid route configuration at index %d\n", i);
                continue;
            }

            strncpy(route->hostname, hostname->valuestring, sizeof(route->hostname) - 1);
            strncpy(route->upstream_host, upstream_host->valuestring, sizeof(route->upstream_host) - 1);
            route->upstream_port = upstream_port->valueint;

            if (route->upstream_port < 1 || route->upstream_port > 65535) {
                fprintf(stderr, "Invalid upstream port for %s: %d\n", route->hostname, route->upstream_port);
                continue;
            }

            route->use_ssl = cJSON_IsTrue(cJSON_GetObjectItem(route_item, "use_ssl"));
            route->rewrite_host = cJSON_IsTrue(cJSON_GetObjectItem(route_item, "rewrite_host"));

            log_info("Route configured: %s -> %s:%d (SSL: %s, Rewrite Host: %s)", 
                     route->hostname, route->upstream_host, route->upstream_port,
                     route->use_ssl ? "yes" : "no", route->rewrite_host ? "yes" : "no");
            i++;
        }
    }
    cJSON_Delete(root);
    log_info("Loaded %d routes from %s", config.route_count, filename);
    return 1;
}

void free_config() {
    if (config.routes) {
        free(config.routes);
        config.routes = NULL;
    }
    config.route_count = 0;
}

route_config_t *find_route(const char *hostname) {
    if (!hostname) return NULL;
    for (int i = 0; i < config.route_count; i++) {
        if (strcasecmp(hostname, config.routes[i].hostname) == 0) {
            return &config.routes[i];
        }
    }
    return NULL;
}

// =================================================================================================
//
//                                         Monitor Implementation
//
// =================================================================================================
static void history_deque_init(history_deque_t *dq, int capacity) {
    dq->points = malloc(sizeof(history_point_t) * capacity);
    dq->capacity = capacity;
    dq->head = 0;
    dq->count = 0;
}

static void history_deque_push(history_deque_t *dq, double time, double value) {
    dq->points[dq->head] = (history_point_t){ .time = time, .value = value };
    dq->head = (dq->head + 1) % dq->capacity;
    if (dq->count < dq->capacity) dq->count++;
}

static void network_history_deque_init(network_history_deque_t *dq, int capacity) {
    dq->points = malloc(sizeof(network_history_point_t) * capacity);
    dq->capacity = capacity;
    dq->head = 0;
    dq->count = 0;
}

static void network_history_deque_push(network_history_deque_t *dq, double time, double rx, double tx) {
    dq->points[dq->head] = (network_history_point_t){ .time = time, .rx_kbps = rx, .tx_kbps = tx };
    dq->head = (dq->head + 1) % dq->capacity;
    if (dq->count < dq->capacity) dq->count++;
}

static void request_time_deque_init(request_time_deque_t *dq, int capacity) {
    dq->times = malloc(sizeof(double) * capacity);
    dq->capacity = capacity;
    dq->head = 0;
    dq->count = 0;
}

static void request_time_deque_push(request_time_deque_t *dq, double time_ms) {
    dq->times[dq->head] = time_ms;
    dq->head = (dq->head + 1) % dq->capacity;
    if (dq->count < dq->capacity) dq->count++;
}

static void init_db() {
    if (!monitor.db) return;

    char *err_msg = 0;
    const char *sql_create_table = 
        "CREATE TABLE IF NOT EXISTS vhost_stats ("
        "  id INTEGER PRIMARY KEY AUTOINCREMENT,"
        "  vhost TEXT NOT NULL,"
        "  timestamp REAL NOT NULL,"
        "  http_requests INTEGER DEFAULT 0,"
        "  websocket_requests INTEGER DEFAULT 0,"
        "  total_requests INTEGER DEFAULT 0,"
        "  bytes_sent INTEGER DEFAULT 0,"
        "  bytes_recv INTEGER DEFAULT 0,"
        "  avg_request_time_ms REAL DEFAULT 0,"
        "  UNIQUE(vhost, timestamp)"
        ");";
    const char *sql_create_index = 
        "CREATE INDEX IF NOT EXISTS idx_vhost_timestamp ON vhost_stats(vhost, timestamp);";

    if (sqlite3_exec(monitor.db, sql_create_table, 0, 0, &err_msg) != SQLITE_OK ||
        sqlite3_exec(monitor.db, sql_create_index, 0, 0, &err_msg) != SQLITE_OK) {
        fprintf(stderr, "SQL error: %s\n", err_msg);
        sqlite3_free(err_msg);
    }
}

static void load_stats_from_db() {
    if (!monitor.db) return;

    sqlite3_stmt *res;
    const char *sql = 
        "SELECT vhost, http_requests, websocket_requests, total_requests, "
        "bytes_sent, bytes_recv, avg_request_time_ms "
        "FROM vhost_stats v1 WHERE timestamp = ("
        "  SELECT MAX(timestamp) FROM vhost_stats v2 WHERE v2.vhost = v1.vhost"
        ")";

    if (sqlite3_prepare_v2(monitor.db, sql, -1, &res, 0) != SQLITE_OK) {
        fprintf(stderr, "Failed to execute statement: %s\n", sqlite3_errmsg(monitor.db));
        return;
    }

    int vhost_count = 0;
    while (sqlite3_step(res) == SQLITE_ROW) {
        vhost_stats_t *stats = monitor_get_or_create_vhost_stats((const char*)sqlite3_column_text(res, 0));
        if (stats) {
            stats->http_requests = sqlite3_column_int64(res, 1);
            stats->websocket_requests = sqlite3_column_int64(res, 2);
            stats->total_requests = sqlite3_column_int64(res, 3);
            stats->bytes_sent = sqlite3_column_int64(res, 4);
            stats->bytes_recv = sqlite3_column_int64(res, 5);
            stats->avg_request_time_ms = sqlite3_column_double(res, 6);
            vhost_count++;
        }
    }
    sqlite3_finalize(res);
    log_info("Loaded statistics for %d vhosts from database", vhost_count);
}

void monitor_init(const char *db_file) {
    memset(&monitor, 0, sizeof(system_monitor_t));
    monitor.start_time = time(NULL);

    history_deque_init(&monitor.cpu_history, HISTORY_SECONDS);
    history_deque_init(&monitor.memory_history, HISTORY_SECONDS);
    network_history_deque_init(&monitor.network_history, HISTORY_SECONDS);
    history_deque_init(&monitor.throughput_history, HISTORY_SECONDS);

    if (sqlite3_open(db_file, &monitor.db) != SQLITE_OK) {
        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(monitor.db));
        if (monitor.db) {
            sqlite3_close(monitor.db);
            monitor.db = NULL;
        }
    } else {
        init_db();
        load_stats_from_db();
    }
    monitor_update();
}

void monitor_cleanup() {
    if (monitor.db) {
        sqlite3_close(monitor.db);
        monitor.db = NULL;
    }

    vhost_stats_t *current = monitor.vhost_stats_head;
    while (current) {
        vhost_stats_t *next = current->next;
        if (current->throughput_history.points) free(current->throughput_history.points);
        if (current->request_times.times) free(current->request_times.times);
        free(current);
        current = next;
    }
    monitor.vhost_stats_head = NULL;

    if (monitor.cpu_history.points) free(monitor.cpu_history.points);
    if (monitor.memory_history.points) free(monitor.memory_history.points);
    if (monitor.network_history.points) free(monitor.network_history.points);
    if (monitor.throughput_history.points) free(monitor.throughput_history.points);
}

static void save_stats_to_db() {
    if (!monitor.db) return;

    sqlite3_stmt *stmt;
    const char *sql = 
        "INSERT OR REPLACE INTO vhost_stats "
        "(vhost, timestamp, http_requests, websocket_requests, total_requests, "
        "bytes_sent, bytes_recv, avg_request_time_ms) "
        "VALUES (?, ?, ?, ?, ?, ?, ?, ?);";

    if (sqlite3_prepare_v2(monitor.db, sql, -1, &stmt, NULL) != SQLITE_OK) return;

    double current_time = (double)time(NULL);
    for (vhost_stats_t *s = monitor.vhost_stats_head; s != NULL; s = s->next) {
        if (s->request_times.count > 0) {
            double total_time = 0;
            for(int i = 0; i < s->request_times.count; i++) {
                total_time += s->request_times.times[i];
            }
            s->avg_request_time_ms = total_time / s->request_times.count;
        }

        sqlite3_bind_text(stmt, 1, s->vhost_name, -1, SQLITE_STATIC);
        sqlite3_bind_double(stmt, 2, current_time);
        sqlite3_bind_int64(stmt, 3, s->http_requests);
        sqlite3_bind_int64(stmt, 4, s->websocket_requests);
        sqlite3_bind_int64(stmt, 5, s->total_requests);
        sqlite3_bind_int64(stmt, 6, s->bytes_sent);
        sqlite3_bind_int64(stmt, 7, s->bytes_recv);
        sqlite3_bind_double(stmt, 8, s->avg_request_time_ms);
        sqlite3_step(stmt);
        sqlite3_reset(stmt);
    }
    sqlite3_finalize(stmt);
}

static double get_cpu_usage() {
    static long long prev_user = 0, prev_nice = 0, prev_system = 0, prev_idle = 0;
    long long user, nice, system, idle, iowait, irq, softirq;

    FILE *f = fopen("/proc/stat", "r");
    if (!f) return 0.0;

    if (fscanf(f, "cpu %lld %lld %lld %lld %lld %lld %lld", 
             &user, &nice, &system, &idle, &iowait, &irq, &softirq) != 7) {
        fclose(f);
        return 0.0;
    }
    fclose(f);

    long long prev_total = prev_user + prev_nice + prev_system + prev_idle;
    long long total = user + nice + system + idle;
    long long totald = total - prev_total;
    long long idled = idle - prev_idle;

    prev_user = user; prev_nice = nice; prev_system = system; prev_idle = idle;
    return totald == 0 ? 0.0 : (double)(totald - idled) * 100.0 / totald;
}

static void get_memory_usage(double *used_gb) {
    struct sysinfo info;
    if (sysinfo(&info) != 0) {
        *used_gb = 0;
        return;
    }
    *used_gb = (double)(info.totalram - info.freeram) * info.mem_unit / (1024.0 * 1024.0 * 1024.0);
}

static void get_network_stats(long long *bytes_sent, long long *bytes_recv) {
    FILE *f = fopen("/proc/net/dev", "r");
    if (!f) { 
        *bytes_sent = 0; 
        *bytes_recv = 0; 
        return; 
    }

    char line[256];
    if (!fgets(line, sizeof(line), f) || !fgets(line, sizeof(line), f)) { // Skip headers
        fclose(f);
        *bytes_sent = 0; 
        *bytes_recv = 0;
        return;
    }

    long long total_recv = 0, total_sent = 0;
    while (fgets(line, sizeof(line), f)) {
        char iface[32];
        long long r, t;
        if (sscanf(line, "%31[^:]: %lld %*d %*d %*d %*d %*d %*d %*d %lld", iface, &r, &t) == 3) {
            if (strncmp(iface, " lo", 3) != 0) { 
                total_recv += r; 
                total_sent += t; 
            }
        }
    }
    fclose(f);
    *bytes_sent = total_sent; 
    *bytes_recv = total_recv;
}

void monitor_update() {
    double current_time = time(NULL);

    history_deque_push(&monitor.cpu_history, current_time, get_cpu_usage());

    double mem_used_gb;
    get_memory_usage(&mem_used_gb);
    history_deque_push(&monitor.memory_history, current_time, mem_used_gb);

    long long net_sent, net_recv;
    get_network_stats(&net_sent, &net_recv);
    double time_delta = current_time - monitor.last_net_update_time;
    if (time_delta > 0 && monitor.last_net_update_time > 0) {
        double rx = (net_recv - monitor.last_net_recv) / time_delta / 1024.0;
        double tx = (net_sent - monitor.last_net_sent) / time_delta / 1024.0;
        network_history_deque_push(&monitor.network_history, current_time, fmax(0, rx), fmax(0, tx));
        history_deque_push(&monitor.throughput_history, current_time, fmax(0, rx + tx));
    }
    monitor.last_net_sent = net_sent;
    monitor.last_net_recv = net_recv;
    monitor.last_net_update_time = current_time;

    for (vhost_stats_t *s = monitor.vhost_stats_head; s != NULL; s = s->next) {
        double vhost_delta = current_time - s->last_update;
        if (vhost_delta >= 1.0) {
            double kbps = 0;
            if (s->last_update > 0) {
                long long bytes_diff = (s->bytes_sent - s->last_bytes_sent) + (s->bytes_recv - s->last_bytes_recv);
                kbps = bytes_diff / vhost_delta / 1024.0;
            }
            history_deque_push(&s->throughput_history, current_time, fmax(0, kbps));
            s->last_bytes_sent = s->bytes_sent; 
            s->last_bytes_recv = s->bytes_recv; 
            s->last_update = current_time;
        }
    }

    static time_t last_db_save = 0;
    if (current_time - last_db_save >= 10) {
        save_stats_to_db();
        last_db_save = current_time;
    }
}

vhost_stats_t* monitor_get_or_create_vhost_stats(const char *vhost_name) {
    if (!vhost_name || strlen(vhost_name) == 0) return NULL;

    for (vhost_stats_t *curr = monitor.vhost_stats_head; curr; curr = curr->next) {
        if (strcmp(curr->vhost_name, vhost_name) == 0) return curr;
    }

    vhost_stats_t *new_stats = calloc(1, sizeof(vhost_stats_t));
    if (!new_stats) return NULL;

    strncpy(new_stats->vhost_name, vhost_name, sizeof(new_stats->vhost_name) - 1);
    new_stats->last_update = time(NULL);
    history_deque_init(&new_stats->throughput_history, 60);
    request_time_deque_init(&new_stats->request_times, 100);
    new_stats->next = monitor.vhost_stats_head;
    monitor.vhost_stats_head = new_stats;
    return new_stats;
}

void monitor_record_request_start(vhost_stats_t *stats, int is_websocket) {
    if (!stats) return;
    if (is_websocket) {
        stats->websocket_requests++;
    } else {
        stats->http_requests++;
    }
    stats->total_requests++;
}

void monitor_record_request_end(vhost_stats_t *stats, double start_time) {
    if (!stats) return;
    struct timespec end_time;
    clock_gettime(CLOCK_MONOTONIC, &end_time);
    double duration_ms = ((end_time.tv_sec + end_time.tv_nsec / 1e9) - start_time) * 1000.0;
    if (duration_ms >= 0) {
        request_time_deque_push(&stats->request_times, duration_ms);
    }
}

// =================================================================================================
//
//                                       Dashboard Implementation
//
// =================================================================================================
const char *DASHBOARD_HTML =
"<!DOCTYPE html>\n"
"<html>\n"
"<head>\n"
"  <title>Reverse Proxy Monitor</title>\n"
"  <style>\n"
"    * { margin: 0; padding: 0; box-sizing: border-box; }\n"
"    body { font-family: -apple-system, system-ui, sans-serif; background: #1a1e2e; color: #fff; padding: 20px; }\n"
"    .header { display: flex; justify-content: space-around; margin-bottom: 30px; gap: 20px; }\n"
"    .metric { text-align: center; flex: 1; }\n"
"    .metric-value { font-size: 48px; font-weight: 300; }\n"
"    .metric-label { font-size: 24px; opacity: 0.7; text-transform: uppercase; }\n"
"    .chart-container { background: #0f1419; border-radius: 8px; padding: 20px; margin-bottom: 20px; height: 250px; position: relative; }\n"
"    .chart-title { position: absolute; top: 10px; left: 20px; font-size: 14px; opacity: 0.7; }\n"
"    canvas { width: 100% !important; height: 100% !important; }\n"
"    .process-table { background: #0f1419; border-radius: 8px; padding: 20px; }\n"
"    table { width: 100%; border-collapse: collapse; }\n"
"    th, td { padding: 10px; text-align: left; border-bottom: 1px solid #2a2e3e; }\n"
"    th { font-weight: 500; opacity: 0.7; }\n"
"    .legend { position: absolute; top: 10px; right: 20px; display: flex; gap: 20px; font-size: 12px; }\n"
"    .legend-item { display: flex; align-items: center; gap: 5px; }\n"
"    .legend-color { width: 12px; height: 12px; border-radius: 2px; }\n"
"    .vhost-chart-container { height: 250px; background: #0f1419; border-radius: 8px; position: relative; padding: 20px; margin-bottom: 10px; }\n"
"  </style>\n"
"  <script src=\"https://cdn.jsdelivr.net/npm/chart.js\"></script>\n"
"</head>\n"
"<body>\n"
"  <div class=\"header\">\n"
"    <div class=\"metric\">\n"
"      <div class=\"metric-value\" id=\"connections\">0</div>\n"
"      <div class=\"metric-label\">Connections</div>\n"
"    </div>\n"
"    <div class=\"metric\">\n"
"      <div class=\"metric-value\" id=\"memory\">0</div>\n"
"      <div class=\"metric-label\">Memory</div>\n"
"    </div>\n"
"    <div class=\"metric\">\n"
"      <div class=\"metric-value\" id=\"cpu\">0</div>\n"
"      <div class=\"metric-label\">CPU %</div>\n"
"    </div>\n"
"  </div>\n"
"\n"
"  <div class=\"chart-container\">\n"
"    <div class=\"chart-title\">CPU Usage</div>\n"
"    <canvas id=\"cpuChart\"></canvas>\n"
"  </div>\n"
"\n"
"  <div class=\"chart-container\">\n"
"    <div class=\"chart-title\">Memory Usage</div>\n"
"    <canvas id=\"memChart\"></canvas>\n"
"  </div>\n"
"\n"
"  <div class=\"chart-container\">\n"
"    <div class=\"chart-title\">Network I/O</div>\n"
"    <div class=\"legend\">\n"
"        <div class=\"legend-item\"><div class=\"legend-color\" style=\"background: #3498db\"></div><span>RX</span></div>\n"
"        <div class=\"legend-item\"><div class=\"legend-color\" style=\"background: #2ecc71\"></div><span>TX</span></div>\n"
"    </div>\n"
"    <canvas id=\"netChart\"></canvas>\n"
"  </div>\n"
"\n"
"  <div class=\"process-table\">\n"
"    <table>\n"
"      <thead>\n"
"        <tr>\n"
"          <th>Virtual Host</th>\n"
"          <th>HTTP Req</th>\n"
"          <th>WS Req</th>\n"
"          <th>Total Req</th>\n"
"          <th>Avg Resp (ms)</th>\n"
"          <th>Sent</th>\n"
"          <th>Received</th>\n"
"        </tr>\n"
"      </thead>\n"
"      <tbody id=\"processTable\"></tbody>\n"
"    </table>\n"
"  </div>\n"
"\n"
"  <script>\n"
"    const formatTimeTick = (value) => {\n"
"        const seconds = Math.abs(Math.round(value / 1000));\n"
"        if (seconds === 0) return 'now';\n"
"        const m = Math.floor(seconds / 60);\n"
"        const s = seconds % 60;\n"
"        return `-${m > 0 ? `${m}m ` : ''}${s}s`;\n"
"    };\n"
"\n"
"    const formatSizeTick = (value) => {\n"
"        if (value >= 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(1)} GB/s`;\n"
"        if (value >= 1024) return `${(value / 1024).toFixed(1)} MB/s`;\n"
"        return `${value.toFixed(0)} KB/s`;\n"
"    };\n"
"\n"
"    const formatBytes = (bytes) => {\n"
"        if (bytes === 0) return '0 B';\n"
"        const k = 1024;\n"
"        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];\n"
"        const i = Math.floor(Math.log(bytes) / Math.log(k));\n"
"        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];\n"
"    };\n"
"\n"
"    const createBaseChartOptions = (historySeconds) => ({\n"
"        responsive: true,\n"
"        maintainAspectRatio: false,\n"
"        animation: false,\n"
"        layout: { padding: { top: 30 } },\n"
"        interaction: { mode: 'nearest', axis: 'x', intersect: false },\n"
"        scales: {\n"
"            x: { type: 'linear', display: true, grid: { color: '#2a2e3e' }, ticks: { color: '#666', maxTicksLimit: 7, callback: formatTimeTick }, min: -historySeconds * 1000, max: 0 },\n"
"            y: { display: true, grid: { color: '#2a2e3e' }, ticks: { color: '#666', beginAtZero: true } }\n"
"        },\n"
"        plugins: { legend: { display: false }, tooltip: { displayColors: false } },\n"
"        elements: { point: { radius: 0 }, line: { borderWidth: 2, tension: 0.4, fill: true } }\n"
"    });\n"
"\n"
"    const cpuChart = new Chart(document.getElementById('cpuChart'), {\n"
"        type: 'line',\n"
"        data: { datasets: [{ label: 'CPU %', data: [], borderColor: '#f39c12', backgroundColor: 'rgba(243, 156, 18, 0.1)' }] },\n"
"        options: { ...createBaseChartOptions(300), scales: { ...createBaseChartOptions(300).scales, y: { ...createBaseChartOptions(300).scales.y, max: 100, ticks: { ...createBaseChartOptions(300).scales.y.ticks, callback: v => `${v}%` } } } }\n"
"    });\n"
"\n"
"    const memChart = new Chart(document.getElementById('memChart'), {\n"
"        type: 'line',\n"
"        data: { datasets: [{ label: 'Memory GB', data: [], borderColor: '#e74c3c', backgroundColor: 'rgba(231, 76, 60, 0.1)' }] },\n"
"        options: { ...createBaseChartOptions(300), scales: { ...createBaseChartOptions(300).scales, y: { ...createBaseChartOptions(300).scales.y, ticks: { ...createBaseChartOptions(300).scales.y.ticks, callback: v => `${v.toFixed(2)} GiB` } } } }\n"
"    });\n"
"\n"
"    const netChart = new Chart(document.getElementById('netChart'), {\n"
"        type: 'line',\n"
"        data: {\n"
"            datasets: [\n"
"                { label: 'RX KB/s', data: [], borderColor: '#3498db', backgroundColor: 'rgba(52, 152, 219, 0.1)' },\n"
"                { label: 'TX KB/s', data: [], borderColor: '#2ecc71', backgroundColor: 'rgba(46, 204, 113, 0.1)' }\n"
"            ]\n"
"        },\n"
"        options: { ...createBaseChartOptions(300), scales: { ...createBaseChartOptions(300).scales, y: { ...createBaseChartOptions(300).scales.y, ticks: { ...createBaseChartOptions(300).scales.y.ticks, callback: formatSizeTick } } } }\n"
"    });\n"
"\n"
"    window.vhostCharts = {};\n"
"    let prevProcessNames = [];\n"
"\n"
"    async function updateStats() {\n"
"        try {\n"
"            const response = await fetch('/api/stats');\n"
"            const data = await response.json();\n"
"\n"
"            document.getElementById('connections').textContent = data.current.active_connections;\n"
"            document.getElementById('memory').textContent = data.current.memory_gb + ' GiB';\n"
"            document.getElementById('cpu').textContent = data.current.cpu_percent + '%';\n"
"\n"
"            cpuChart.data.datasets[0].data = data.cpu_history;\n"
"            memChart.data.datasets[0].data = data.memory_history;\n"
"            netChart.data.datasets[0].data = data.network_rx_history;\n"
"            netChart.data.datasets[1].data = data.network_tx_history;\n"
"            cpuChart.update('none');\n"
"            memChart.update('none');\n"
"            netChart.update('none');\n"
"\n"
"            const tbody = document.getElementById('processTable');\n"
"            const processNames = data.processes.map(p => p.name).join(',');\n"
"            if (processNames !== prevProcessNames.join(',')) {\n"
"                Object.values(window.vhostCharts).forEach(chart => chart.destroy());\n"
"                window.vhostCharts = {};\n"
"                tbody.innerHTML = '';\n"
"                data.processes.forEach((p, index) => {\n"
"                    const colors = ['#3498db', '#2ecc71', '#f39c12', '#e74c3c', '#9b59b6', '#1abc9c'];\n"
"                    const chartColor = colors[index % colors.length];\n"
"                    const mainRow = document.createElement('tr');\n"
"                    mainRow.innerHTML = `<td style='color: ${chartColor}'>${p.name}</td><td>${p.http_requests}</td><td>${p.websocket_requests}</td><td>${p.total_requests}</td><td>${p.avg_request_time_ms.toFixed(2)}</td><td>${formatBytes(p.bytes_sent)}</td><td>${formatBytes(p.bytes_recv)}</td>`;\n"
"                    tbody.appendChild(mainRow);\n"
"                    \n"
"                    const chartRow = document.createElement('tr');\n"
"                    chartRow.innerHTML = `<td colspan='7' style='padding: 10px 0; border: none;'><div class='vhost-chart-container'><div class='chart-title'>Live Throughput - ${p.name}</div><canvas id='vhostChart${index}'></canvas></div></td>`;\n"
"                    tbody.appendChild(chartRow);\n"
"                });\n"
"                prevProcessNames = data.processes.map(p => p.name);\n"
"            }\n"
"\n"
"            data.processes.forEach((p, index) => {\n"
"                const chartId = `vhostChart${index}`;\n"
"                const canvas = document.getElementById(chartId);\n"
"                if (!canvas) return;\n"
"                if (!window.vhostCharts[chartId]) {\n"
"                   const colors = [\n"
"                      { border: '#3498db', bg: 'rgba(52, 152, 219, 0.1)' }, { border: '#2ecc71', bg: 'rgba(46, 204, 113, 0.1)' },\n"
"                      { border: '#f39c12', bg: 'rgba(243, 156, 18, 0.1)' }, { border: '#e74c3c', bg: 'rgba(231, 76, 60, 0.1)' },\n"
"                      { border: '#9b59b6', bg: 'rgba(155, 89, 182, 0.1)' }, { border: '#1abc9c', bg: 'rgba(26, 188, 156, 0.1)' }\n"
"                    ];\n"
"                    const color = colors[index % colors.length];\n"
"                    const options = { ...createBaseChartOptions(60), scales: { ...createBaseChartOptions(60).scales, y: { ...createBaseChartOptions(60).scales.y, ticks: { ...createBaseChartOptions(60).scales.y.ticks, callback: formatSizeTick } } } };\n"
"                    window.vhostCharts[chartId] = new Chart(canvas.getContext('2d'), {\n"
"                        type: 'line',\n"
"                        data: { datasets: [{ label: 'Throughput KB/s', data: p.throughput_history || [], borderColor: color.border, backgroundColor: color.bg }] },\n"
"                        options: options\n"
"                    });\n"
"                } else {\n"
"                    window.vhostCharts[chartId].data.datasets[0].data = p.throughput_history || [];\n"
"                    window.vhostCharts[chartId].update('none');\n"
"                }\n"
"            });\n"
"        } catch (e) {\n"
"            console.error('Failed to fetch stats:', e);\n"
"        }\n"
"    }\n"
"\n"
"    updateStats();\n"
"    setInterval(updateStats, 1000);\n"
"  </script>\n"
"</body>\n"
"</html>\n"
;
void serve_dashboard(connection_t *conn) {
    if (!conn) return;

    char header[512];
    int len = snprintf(header, sizeof(header), 
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: text/html; charset=utf-8\r\n"
        "Content-Length: %zu\r\n"
        "Connection: keep-alive\r\n"
        "Cache-Control: no-cache\r\n"
        "\r\n", strlen(DASHBOARD_HTML));

    if (buffer_ensure_capacity(&conn->write_buf, conn->write_buf.size + len + strlen(DASHBOARD_HTML)) < 0) {
        send_error_response(conn, 500, "Internal Server Error", "Memory allocation failed");
        return;
    }

    memcpy(conn->write_buf.data + conn->write_buf.size, header, len);
    conn->write_buf.size += len;
    memcpy(conn->write_buf.data + conn->write_buf.size, DASHBOARD_HTML, strlen(DASHBOARD_HTML));
    conn->write_buf.size += strlen(DASHBOARD_HTML);

    struct epoll_event event = { .data.fd = conn->fd, .events = EPOLLIN | EPOLLOUT };
    epoll_ctl(epoll_fd, EPOLL_CTL_MOD, conn->fd, &event);
    conn->read_buf.size = 0;
    conn->keep_alive = 1;
}

static cJSON* format_history(history_deque_t *dq, int window_seconds) {
    cJSON *arr = cJSON_CreateArray();
    if (!arr || !dq || !dq->points || dq->count == 0) return arr;

    double current_time = time(NULL);
    int start_index = (dq->head - dq->count + dq->capacity) % dq->capacity;

    for (int i = 0; i < dq->count; ++i) {
        int current_index = (start_index + i) % dq->capacity;
        history_point_t *p = &dq->points[current_index];
        if ((current_time - p->time) <= window_seconds) {
            cJSON *pt = cJSON_CreateObject();
            if (pt) {
                cJSON_AddNumberToObject(pt, "x", (long)((p->time - current_time) * 1000));
                cJSON_AddNumberToObject(pt, "y", p->value);
                cJSON_AddItemToArray(arr, pt);
            }
        }
    }
    return arr;
}

static cJSON* format_network_history(network_history_deque_t *dq, int window_seconds, const char *key) {
    cJSON *arr = cJSON_CreateArray();
    if (!arr || !dq || !dq->points || !key || dq->count == 0) return arr;

    double current_time = time(NULL);
    int start_index = (dq->head - dq->count + dq->capacity) % dq->capacity;

    for (int i = 0; i < dq->count; ++i) {
        int current_index = (start_index + i) % dq->capacity;
        network_history_point_t *p = &dq->points[current_index];
        if ((current_time - p->time) <= window_seconds) {
            cJSON *pt = cJSON_CreateObject();
            if (pt) {
                cJSON_AddNumberToObject(pt, "x", (long)((p->time - current_time) * 1000));
                cJSON_AddNumberToObject(pt, "y", strcmp(key, "rx_kbps") == 0 ? p->rx_kbps : p->tx_kbps);
                cJSON_AddItemToArray(arr, pt);
            }
        }
    }
    return arr;
}

void serve_stats_api(connection_t *conn) {
    if (!conn) return;

    cJSON *root = cJSON_CreateObject();
    if (!root) {
        send_error_response(conn, 500, "Internal Server Error", "JSON creation failed");
        return;
    }

    cJSON *current = cJSON_CreateObject();
    if (!current) {
        cJSON_Delete(root);
        send_error_response(conn, 500, "Internal Server Error", "JSON creation failed");
        return;
    }
    cJSON_AddItemToObject(root, "current", current);

    char buffer[64];
    double last_cpu = 0, last_mem = 0;

    if (monitor.cpu_history.count > 0) {
        int last_idx = (monitor.cpu_history.head - 1 + monitor.cpu_history.capacity) % monitor.cpu_history.capacity;
        last_cpu = monitor.cpu_history.points[last_idx].value;
    }

    if (monitor.memory_history.count > 0) {
        int last_idx = (monitor.memory_history.head - 1 + monitor.memory_history.capacity) % monitor.memory_history.capacity;
        last_mem = monitor.memory_history.points[last_idx].value;
    }

    snprintf(buffer, sizeof(buffer), "%.2f", last_cpu); 
    cJSON_AddStringToObject(current, "cpu_percent", buffer);
    snprintf(buffer, sizeof(buffer), "%.2f", last_mem); 
    cJSON_AddStringToObject(current, "memory_gb", buffer);
    cJSON_AddNumberToObject(current, "active_connections", monitor.active_connections);

    cJSON_AddItemToObject(root, "cpu_history", format_history(&monitor.cpu_history, HISTORY_SECONDS));
    cJSON_AddItemToObject(root, "memory_history", format_history(&monitor.memory_history, HISTORY_SECONDS));
    cJSON_AddItemToObject(root, "network_rx_history", format_network_history(&monitor.network_history, HISTORY_SECONDS, "rx_kbps"));
    cJSON_AddItemToObject(root, "network_tx_history", format_network_history(&monitor.network_history, HISTORY_SECONDS, "tx_kbps"));
    cJSON_AddItemToObject(root, "throughput_history", format_history(&monitor.throughput_history, HISTORY_SECONDS));

    cJSON *processes = cJSON_CreateArray();
    if (processes) {
        cJSON_AddItemToObject(root, "processes", processes);
        for (vhost_stats_t *s = monitor.vhost_stats_head; s; s = s->next) {
            cJSON *p = cJSON_CreateObject();
            if (p) {
                cJSON_AddStringToObject(p, "name", s->vhost_name);
                cJSON_AddNumberToObject(p, "http_requests", s->http_requests);
                cJSON_AddNumberToObject(p, "websocket_requests", s->websocket_requests);
                cJSON_AddNumberToObject(p, "total_requests", s->total_requests);
                cJSON_AddNumberToObject(p, "avg_request_time_ms", s->avg_request_time_ms);
                cJSON_AddNumberToObject(p, "bytes_sent", s->bytes_sent);
                cJSON_AddNumberToObject(p, "bytes_recv", s->bytes_recv);
                cJSON_AddItemToObject(p, "throughput_history", format_history(&s->throughput_history, 60));
                cJSON_AddItemToArray(processes, p);
            }
        }
    }

    char *json_string = cJSON_PrintUnformatted(root);
    if (!json_string) {
        cJSON_Delete(root);
        send_error_response(conn, 500, "Internal Server Error", "JSON serialization failed");
        return;
    }

    char header[512];
    int hlen = snprintf(header, sizeof(header), 
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: application/json; charset=utf-8\r\n"
        "Content-Length: %zu\r\n"
        "Connection: keep-alive\r\n"
        "Cache-Control: no-cache\r\n"
        "\r\n", strlen(json_string));

    if (buffer_ensure_capacity(&conn->write_buf, conn->write_buf.size + hlen + strlen(json_string)) < 0) {
        free(json_string);
        cJSON_Delete(root);
        send_error_response(conn, 500, "Internal Server Error", "Memory allocation failed");
        return;
    }

    memcpy(conn->write_buf.data + conn->write_buf.size, header, hlen); 
    conn->write_buf.size += hlen;
    memcpy(conn->write_buf.data + conn->write_buf.size, json_string, strlen(json_string)); 
    conn->write_buf.size += strlen(json_string);

    struct epoll_event event = { .data.fd = conn->fd, .events = EPOLLIN | EPOLLOUT };
    epoll_ctl(epoll_fd, EPOLL_CTL_MOD, conn->fd, &event);

    cJSON_Delete(root); 
    free(json_string);
    conn->read_buf.size = 0;
    conn->keep_alive = 1;
}


// =================================================================================================
//
//                                         HTTP Implementation
//
// =================================================================================================

int find_header_value(const char *headers, const char *header_name, char *value, size_t value_size) {
    if (!headers || !header_name || !value || value_size == 0) return 0;

    size_t header_name_len = strlen(header_name);
    const char *line_start = headers;

    while (*line_start) {
        const char *line_end = strstr(line_start, "\r\n");
        if (!line_end) {
            line_end = line_start + strlen(line_start);
        }

        size_t line_len = line_end - line_start;
        if (line_len > header_name_len + 1) {
            if (strncasecmp(line_start, header_name, header_name_len) == 0 && 
                line_start[header_name_len] == ':') {

                const char *value_start = line_start + header_name_len + 1;
                while (value_start < line_end && isspace((unsigned char)*value_start)) {
                    value_start++;
                }

                size_t value_len = line_end - value_start;
                if (value_len >= value_size) {
                    value_len = value_size - 1;
                }

                memcpy(value, value_start, value_len);
                value[value_len] = '\0';
                trim_whitespace(value);
                return 1;
            }
        }

        if (*line_end == '\r') {
            line_start = line_end + 2;
        } else if (*line_end == '\0') {
            break;
        } else {
            line_start = line_end + 1;
        }
    }

    return 0;
}

int parse_http_request_line(const char *line, http_request_t *request) {
    if (!line || !request) return 0;

    memset(request, 0, sizeof(http_request_t));

    char *line_copy = safe_strdup(line, MAX_REQUEST_LINE_SIZE);
    if (!line_copy) return 0;

    trim_whitespace(line_copy);

    char *method = strtok(line_copy, " ");
    char *uri = strtok(NULL, " ");
    char *version = strtok(NULL, " ");

    if (!method || !uri || !version) {
        free(line_copy);
        return 0;
    }

    if (!is_valid_http_method(method) || !is_valid_http_version(version)) {
        free(line_copy);
        return 0;
    }

    if (strlen(uri) >= sizeof(request->uri)) {
        free(line_copy);
        return 0;
    }

    strncpy(request->method, method, sizeof(request->method) - 1);
    request->method[sizeof(request->method) - 1] = '\0'; // Fix: Ensure null termination

    strncpy(request->uri, uri, sizeof(request->uri) - 1);
    request->uri[sizeof(request->uri) - 1] = '\0'; // Fix: Ensure null termination

    strncpy(request->version, version, sizeof(request->version) - 1);
    request->version[sizeof(request->version) - 1] = '\0'; // Fix: Ensure null termination

    free(line_copy);
    return 1;
}

int parse_http_headers(const char *headers, http_request_t *request) {
    if (!headers || !request) return 0;

    char value[256];

    // Parse Host header
    if (find_header_value(headers, "Host", value, sizeof(value))) {
        char *colon = strchr(value, ':');
        if (colon) {
            *colon = '\0'; // Remove port from hostname
        }
        strncpy(request->host, value, sizeof(request->host) - 1);
        request->host[sizeof(request->host) - 1] = '\0'; // Fix: [-Wstringop-truncation] Ensure null termination
    }

    // Parse Content-Length
    request->content_length = -1; // Default to unknown
    if (find_header_value(headers, "Content-Length", value, sizeof(value))) {
        request->content_length = atoi(value);
        if (request->content_length < 0) {
            request->content_length = 0;
        }
    }

    // Parse Connection header
    if (find_header_value(headers, "Connection", value, sizeof(value))) {
        if (strcasecmp(value, "keep-alive") == 0) {
            request->keep_alive = 1;
        } else if (strcasecmp(value, "upgrade") == 0) {
            request->connection_upgrade = 1;
        }
    }

    // Parse Upgrade header for WebSocket
    if (find_header_value(headers, "Upgrade", value, sizeof(value))) {
        if (strcasecmp(value, "websocket") == 0) {
            request->is_websocket = 1;
        }
    }

    return 1;
}

void send_error_response(connection_t *conn, int code, const char* status, const char* body) {
    if (!conn || !status || !body) return;

    char response[2048];
    int len = snprintf(response, sizeof(response), 
        "HTTP/1.1 %d %s\r\n"
        "Content-Type: text/plain; charset=utf-8\r\n"
        "Content-Length: %zu\r\n"
        "Connection: close\r\n"
        "Server: ReverseProxy/1.1\r\n"
        "\r\n"
        "%s", 
        code, status, strlen(body), body);

    if (len > 0 && len < (int)sizeof(response)) { // Fix: [-Wsign-compare] Cast sizeof to int
        if (buffer_ensure_capacity(&conn->write_buf, conn->write_buf.size + len) == 0) {
            memcpy(conn->write_buf.data + conn->write_buf.size, response, len);
            conn->write_buf.size += len;

            struct epoll_event event = { .data.fd = conn->fd, .events = EPOLLIN | EPOLLOUT };
            epoll_ctl(epoll_fd, EPOLL_CTL_MOD, conn->fd, &event);
        }
    }

    conn->keep_alive = 0;
    conn->state = CLIENT_STATE_ERROR;
}

void handle_client_data(connection_t *conn) {
    if (!conn) return;

    // Update last activity time
    conn->last_activity = time(NULL);

    int bytes_read = read(conn->fd, conn->read_buf.data + conn->read_buf.size, 
                          conn->read_buf.capacity - conn->read_buf.size - 1);

    if (bytes_read <= 0) {
        if (bytes_read < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
            return;
        }
        close_connection(conn->fd);
        return;
    }

    conn->read_buf.size += bytes_read;
    conn->read_buf.data[conn->read_buf.size] = '\0';

    // Check for complete headers
    char *headers_end = strstr(conn->read_buf.data, "\r\n\r\n");
    if (!headers_end) {
        // Check if we've exceeded max header size
        if (conn->read_buf.size >= MAX_HEADER_SIZE) {
            send_error_response(conn, 413, "Request Header Too Large", "Request headers too large");
        }
        return;
    }

    // Mark request start time
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    conn->request_start_time = ts.tv_sec + ts.tv_nsec / 1e9;

    // Extract request line
    char *first_line_end = strstr(conn->read_buf.data, "\r\n");
    if (!first_line_end) {
        send_error_response(conn, 400, "Bad Request", "Invalid request line");
        return;
    }

    *first_line_end = '\0';

    // Parse request line
    if (!parse_http_request_line(conn->read_buf.data, &conn->request)) {
        send_error_response(conn, 400, "Bad Request", "Invalid request line format");
        *first_line_end = '\r'; // restore
        return;
    }

    *first_line_end = '\r'; // restore

    // Parse headers
    char *headers_start = first_line_end + 2;
    *headers_end = '\0';

    if (!parse_http_headers(headers_start, &conn->request)) {
        send_error_response(conn, 400, "Bad Request", "Invalid headers");
        *headers_end = '\r'; // restore
        return;
    }

    *headers_end = '\r'; // restore

    // Handle special dashboard/API routes
    if (strcmp(conn->request.method, "GET") == 0) {
        if (strncmp(conn->request.uri, "/dashboard", 10) == 0) {
            serve_dashboard(conn);
            return;
        }
        if (strncmp(conn->request.uri, "/api/stats", 10) == 0) {
            serve_stats_api(conn);
            return;
        }
    }

    // Validate Host header
    if (strlen(conn->request.host) == 0) {
        send_error_response(conn, 400, "Bad Request", "Host header is required");
        return;
    }

    // Find route configuration
    route_config_t *route = find_route(conn->request.host);
    if (!route) {
        char body[512];
        snprintf(body, sizeof(body), "Host not configured: %s", conn->request.host);
        send_error_response(conn, 404, "Not Found", body);
        return;
    }

    // Get or create vhost stats
    conn->vhost_stats = monitor_get_or_create_vhost_stats(route->hostname);
    conn->is_websocket = conn->request.is_websocket;
    conn->keep_alive = conn->request.keep_alive;
    
    // **FIX**: Store content length and how much body we've already read
    conn->http_content_length = conn->request.content_length;
    conn->http_body_read = conn->read_buf.size - ((headers_end + 4) - conn->read_buf.data);
    if (conn->http_content_length < 0) conn->http_content_length = 0; // Treat unknown length as 0 for this stage

    // Record request start
    monitor_record_request_start(conn->vhost_stats, conn->is_websocket);

    // Rewrite Host header if needed
    if (route->rewrite_host) {
        char new_host_header[320];
        snprintf(new_host_header, sizeof(new_host_header), "Host: %s:%d\r\n", 
               route->upstream_host, route->upstream_port);

        char host_search[] = "Host:";
        char *host_start = strcasestr(conn->read_buf.data, host_search);
        if (host_start) {
            char *host_line_end = strstr(host_start, "\r\n");
            if (host_line_end) {
                size_t old_len = (host_line_end + 2) - host_start;
                size_t new_len = strlen(new_host_header);
                size_t tail_len = conn->read_buf.size - (host_start - conn->read_buf.data) - old_len;

                if (new_len != old_len) {
                    if (buffer_ensure_capacity(&conn->read_buf, conn->read_buf.size - old_len + new_len + 1) < 0) {
                        send_error_response(conn, 500, "Internal Server Error", "Memory allocation failed");
                        return;
                    }
                    // Recalculate pointer after potential realloc
                    host_start = strcasestr(conn->read_buf.data, host_search);
                    memmove(host_start + new_len, host_start + old_len, tail_len);
                    conn->read_buf.size = conn->read_buf.size - old_len + new_len;
                }
                memcpy(host_start, new_host_header, new_len);
                conn->read_buf.data[conn->read_buf.size] = '\0';
            }
        }
    }

    // Transition to connecting upstream
    conn->state = CLIENT_STATE_CONNECTING_UPSTREAM;
    connect_to_upstream(conn, route);
}

// =================================================================================================
//
//                                         Proxy Implementation
//
// =================================================================================================

static void set_non_blocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    if (flags >= 0) {
        fcntl(fd, F_SETFL, flags | O_NONBLOCK);
    }
}

static void add_to_epoll(int fd, uint32_t events) {
    struct epoll_event event = { .data.fd = fd, .events = events };
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event) == -1) {
        log_error("epoll_ctl_add failed");
        close(fd);
    }
}

static void modify_epoll(int fd, uint32_t events) {
    struct epoll_event event = { .data.fd = fd, .events = events };
    if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) == -1) {
        close_connection(fd);
    }
}

void setup_listener_socket(int port) {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        log_error("socket failed");
        exit(EXIT_FAILURE);
    }

    int reuse = 1;
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
        log_error("setsockopt SO_REUSEADDR failed");
        close(fd);
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in addr = { 
        .sin_family = AF_INET, 
        .sin_port = htons(port), 
        .sin_addr.s_addr = htonl(INADDR_ANY) 
    };

    if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
        log_error("bind failed");
        close(fd);
        exit(EXIT_FAILURE);
    }

    if (listen(fd, SOMAXCONN) == -1) {
        log_error("listen failed");
        close(fd);
        exit(EXIT_FAILURE);
    }

    set_non_blocking(fd);
    add_to_epoll(fd, EPOLLIN);

    connections[fd].type = CONN_TYPE_LISTENER;
    connections[fd].fd = fd;

    log_info("Listening on port %d (fd=%d)", port, fd);
}

void accept_new_connection(int listener_fd) {
    struct sockaddr_in client_addr;
    socklen_t client_len = sizeof(client_addr);

    int client_fd = accept(listener_fd, (struct sockaddr*)&client_addr, &client_len);
    if (client_fd == -1) {
        if (errno != EAGAIN && errno != EWOULDBLOCK) {
            log_error("accept failed");
        }
        return;
    }

    if (client_fd >= MAX_FDS) {
        log_error("Connection fd too high, closing");
        close(client_fd);
        return;
    }

    set_non_blocking(client_fd);
    add_to_epoll(client_fd, EPOLLIN);

    connection_t *conn = &connections[client_fd];
    memset(conn, 0, sizeof(connection_t));
    conn->type = CONN_TYPE_CLIENT;
    conn->state = CLIENT_STATE_READING_REQUEST_LINE;
    conn->fd = client_fd;
    conn->last_activity = time(NULL);

    if (buffer_init(&conn->read_buf, CHUNK_SIZE) < 0 ||
        buffer_init(&conn->write_buf, CHUNK_SIZE) < 0) {
        close_connection(client_fd);
        return;
    }

    monitor.active_connections++;
    log_debug("New connection on fd %d from %s, total: %d", 
              client_fd, inet_ntoa(client_addr.sin_addr), monitor.active_connections);
}

void close_connection(int fd) {
    if (fd < 0 || fd >= MAX_FDS || connections[fd].type == CONN_TYPE_UNUSED) return;

    connection_t *conn = &connections[fd];

    // Close paired connection if exists
    if (conn->pair) {
        conn->pair->pair = NULL;
        close_connection(conn->pair->fd);
    }

    // Record request end if needed
    if (conn->vhost_stats && conn->request_start_time > 0) {
        monitor_record_request_end(conn->vhost_stats, conn->request_start_time);
    }

    // Remove from epoll
    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, NULL);

    // Clean up SSL
    if (conn->ssl) {
        SSL_shutdown(conn->ssl);
        SSL_free(conn->ssl);
        conn->ssl = NULL;
    }

    // Close socket
    close(fd);

    // Free buffers
    buffer_free(&conn->read_buf);
    buffer_free(&conn->write_buf);

    // Update connection count
    if (conn->type == CONN_TYPE_CLIENT) {
        monitor.active_connections--;
    }

    log_debug("Closed connection on fd %d, remaining: %d", fd, monitor.active_connections);

    // Reset connection structure
    memset(conn, 0, sizeof(connection_t));
    conn->type = CONN_TYPE_UNUSED;
}

void connect_to_upstream(connection_t *client, route_config_t *route) {
    if (!client || !route) return;

    int up_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (up_fd < 0) {
        send_error_response(client, 502, "Bad Gateway", "Failed to create upstream socket");
        return;
    }

    if (up_fd >= MAX_FDS) {
        close(up_fd);
        send_error_response(client, 502, "Bad Gateway", "Connection limit exceeded");
        return;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(route->upstream_port);

    // Try to resolve hostname
    if (inet_pton(AF_INET, route->upstream_host, &addr.sin_addr) <= 0) {
        struct hostent *he = gethostbyname(route->upstream_host);
        if (!he) {
            close(up_fd);
            send_error_response(client, 502, "Bad Gateway", "Cannot resolve upstream hostname");
            return;
        }
        memcpy(&addr.sin_addr, he->h_addr_list[0], he->h_length);
    }

    set_non_blocking(up_fd);

    int connect_result = connect(up_fd, (struct sockaddr*)&addr, sizeof(addr));
    if (connect_result < 0 && errno != EINPROGRESS) {
        close(up_fd);
        send_error_response(client, 502, "Bad Gateway", "Failed to connect to upstream");
        return;
    }

    add_to_epoll(up_fd, EPOLLIN | EPOLLOUT);

    connection_t *up = &connections[up_fd];
    memset(up, 0, sizeof(connection_t));
    up->type = CONN_TYPE_UPSTREAM;
    up->fd = up_fd;
    up->last_activity = time(NULL);

    client->pair = up;
    up->pair = client;
    up->vhost_stats = client->vhost_stats;

    if (buffer_init(&up->read_buf, CHUNK_SIZE) < 0 ||
        buffer_init(&up->write_buf, CHUNK_SIZE) < 0) {
        close_connection(up_fd);
        send_error_response(client, 502, "Bad Gateway", "Memory allocation failed");
        return;
    }

    if (route->use_ssl) {
        up->ssl = SSL_new(ssl_ctx);
        if (!up->ssl) {
            close_connection(up_fd);
            send_error_response(client, 502, "Bad Gateway", "SSL initialization failed");
            return;
        }
        SSL_set_fd(up->ssl, up_fd);
        SSL_set_connect_state(up->ssl);
    }

    log_debug("Connecting to upstream %s:%d on fd %d", 
              route->upstream_host, route->upstream_port, up_fd);
}

static int do_read(connection_t *conn) {
    if (!conn) return -1;

    if (buffer_ensure_capacity(&conn->read_buf, conn->read_buf.size + CHUNK_SIZE) < 0) {
        return -1;
    }

    int bytes_read;
    if (conn->ssl && conn->ssl_handshake_done) {
        bytes_read = SSL_read(conn->ssl, conn->read_buf.data + conn->read_buf.size, CHUNK_SIZE);
        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) {
                errno = EAGAIN;
            }
        }
    } else {
        bytes_read = read(conn->fd, conn->read_buf.data + conn->read_buf.size, CHUNK_SIZE);
    }

    return bytes_read;
}

static int do_write(connection_t *conn) {
    if (!conn || conn->write_buf.size == 0) return 0;

    int written;
    if (conn->ssl && conn->ssl_handshake_done) {
        written = SSL_write(conn->ssl, conn->write_buf.data, conn->write_buf.size);
        if (written <= 0) {
            int ssl_error = SSL_get_error(conn->ssl, written);
            if (ssl_error == SSL_ERROR_WANT_READ || ssl_error == SSL_ERROR_WANT_WRITE) {
                errno = EAGAIN;
                return 0;
            }
        }
    } else {
        written = write(conn->fd, conn->write_buf.data, conn->write_buf.size);
    }

    if (written > 0) {
        memmove(conn->write_buf.data, conn->write_buf.data + written, 
                conn->write_buf.size - written);
        conn->write_buf.size -= written;
    }

    return written;
}

void handle_client_body(connection_t *conn) {
    if (!conn || !conn->pair) {
        close_connection(conn->fd);
        return;
    }
    
    connection_t *upstream = conn->pair;
    conn->last_activity = time(NULL);

    long remaining_to_read_total = conn->http_content_length - conn->http_body_read;
    if (remaining_to_read_total <= 0) {
        conn->state = CLIENT_STATE_TUNNELING;
        return;
    }

    size_t can_read_now = conn->read_buf.capacity - conn->read_buf.size;
    if (can_read_now > (size_t)remaining_to_read_total) { // Fix: [-Wsign-compare] Cast to size_t
        can_read_now = remaining_to_read_total;
    }
    
    if(can_read_now == 0) return;

    int bytes = read(conn->fd, conn->read_buf.data, can_read_now);

    if (bytes > 0) {
        conn->http_body_read += bytes;

        if (buffer_ensure_capacity(&upstream->write_buf, upstream->write_buf.size + bytes) < 0) {
            close_connection(conn->fd);
            return;
        }

        memcpy(upstream->write_buf.data + upstream->write_buf.size, conn->read_buf.data, bytes);
        upstream->write_buf.size += bytes;
        modify_epoll(upstream->fd, EPOLLIN | EPOLLOUT);

        if (conn->http_body_read >= conn->http_content_length) {
            log_debug("Finished reading body for fd %d, transitioning to TUNNELING", conn->fd);
            conn->state = CLIENT_STATE_TUNNELING;
        }
    } else if (bytes == 0) {
        close_connection(conn->fd);
    } else if (errno != EAGAIN && errno != EWOULDBLOCK) {
        close_connection(conn->fd);
    }
}

static void handle_tunneling(connection_t *conn) {
    if (!conn || !conn->pair) {
        close_connection(conn->fd);
        return;
    }

    conn->last_activity = time(NULL);

    int bytes = do_read(conn);
    if (bytes > 0) {
        conn->read_buf.size += bytes;
        connection_t *pair = conn->pair;

        if (buffer_ensure_capacity(&pair->write_buf, 
                                     pair->write_buf.size + conn->read_buf.size) < 0) {
            close_connection(conn->fd);
            return;
        }

        memcpy(pair->write_buf.data + pair->write_buf.size, 
               conn->read_buf.data, conn->read_buf.size);
        pair->write_buf.size += conn->read_buf.size;

        // Update stats
        if (conn->vhost_stats) {
            if (conn->type == CONN_TYPE_CLIENT) {
                conn->vhost_stats->bytes_recv += bytes;
            } else {
                conn->vhost_stats->bytes_sent += bytes;
            }
        }

        conn->read_buf.size = 0;
        modify_epoll(pair->fd, EPOLLIN | EPOLLOUT);
    } else if (bytes == 0) {
        close_connection(conn->fd);
    } else if (errno != EAGAIN && errno != EWOULDBLOCK) {
        close_connection(conn->fd);
    }
}

static void handle_write_event(connection_t *conn) {
    if (!conn) return;

    conn->last_activity = time(NULL);

    if (conn->type == CONN_TYPE_UPSTREAM && !conn->ssl_handshake_done) {
        // Check if connection is established
        int err = 0;
        socklen_t len = sizeof(err);
        if (getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &err, &len) != 0 || err != 0) {
            close_connection(conn->fd);
            return;
        }

        // Handle SSL handshake if needed
        if (conn->ssl) {
            int ret = SSL_do_handshake(conn->ssl);
            if (ret == 1) {
                conn->ssl_handshake_done = 1;
            } else {
                int ssl_error = SSL_get_error(conn->ssl, ret);
                if (ssl_error != SSL_ERROR_WANT_READ && ssl_error != SSL_ERROR_WANT_WRITE) {
                    close_connection(conn->fd);
                    return;
                }
                // Continue handshake later
                return;
            }
        } else {
            conn->ssl_handshake_done = 1; // No SSL, consider "handshake" done
        }

        // Connection established, forward client request
        if (conn->ssl_handshake_done && conn->pair) {
            connection_t *client = conn->pair;
            if (buffer_ensure_capacity(&conn->write_buf, 
                                         conn->write_buf.size + client->read_buf.size) < 0) {
                close_connection(conn->fd);
                return;
            }

            memcpy(conn->write_buf.data + conn->write_buf.size, 
                   client->read_buf.data, client->read_buf.size);
            conn->write_buf.size += client->read_buf.size;
            client->read_buf.size = 0;

            // **FIX**: Transition to the correct state based on Content-Length
            if (client->http_body_read >= client->http_content_length) {
                client->state = CLIENT_STATE_TUNNELING;
                log_debug("Request has no body or was already read, tunneling fd %d", client->fd);
            } else {
                client->state = CLIENT_STATE_READING_BODY;
                log_debug("Request has body, reading body for fd %d", client->fd);
            }

            // Record WebSocket request end immediately after connection
            if (client->is_websocket && client->vhost_stats) {
                monitor_record_request_end(client->vhost_stats, client->request_start_time);
            }
        }
    }

    // Write data if available
    int written = do_write(conn);
    if (written > 0) {
        // Update stats
        if(conn->vhost_stats) {
            if(conn->type == CONN_TYPE_CLIENT) {
                conn->vhost_stats->bytes_sent += written;
            } else {
                conn->vhost_stats->bytes_recv += written; // This seems reversed, but from perspective of vhost, upstream sends to it.
            }
        }
    }
    
    if (written < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
        close_connection(conn->fd);
        return;
    }

    // Adjust epoll events
    if (conn->write_buf.size == 0) {
        modify_epoll(conn->fd, EPOLLIN);
    }
}

void handle_connection_event(struct epoll_event *event) {
    int fd = event->data.fd;

    if (event->events & (EPOLLERR | EPOLLHUP)) {
        close_connection(fd);
        return;
    }

    if (fd < 0 || fd >= MAX_FDS) {
        return;
    }

    connection_t *conn = &connections[fd];

    if (conn->type == CONN_TYPE_LISTENER) {
        if (event->events & EPOLLIN) {
            accept_new_connection(fd);
        }
    } else {
        if (event->events & EPOLLOUT) {
            handle_write_event(conn);
        }

        if ((event->events & EPOLLIN) && conn->type != CONN_TYPE_UNUSED) {
            if (conn->type == CONN_TYPE_CLIENT) {
                // **FIX**: Dispatch based on the more detailed state machine
                switch (conn->state) {
                    case CLIENT_STATE_READING_REQUEST_LINE:
                        handle_client_data(conn);
                        break;
                    case CLIENT_STATE_READING_BODY:
                        handle_client_body(conn);
                        break;
                    case CLIENT_STATE_TUNNELING:
                        handle_tunneling(conn);
                        break;
                    default:
                        // Do nothing for other states like CONNECTING, DONE, ERROR
                        break;
                }
            } else { // It's an upstream connection
                handle_tunneling(conn);
            }
        }
    }
}

// =================================================================================================
//
//                                         Main Implementation
//
// =================================================================================================

void create_default_config_if_not_exists(const char* filename) {
    FILE *f = fopen(filename, "r");
    if (f) {
        fclose(f);
        return;
    }

    f = fopen(filename, "w");
    if (!f) {
        log_error("Cannot create default config file");
        return;
    }

    fprintf(f, "{\n"
               "  \"port\": 8080,\n"
               "  \"reverse_proxy\": [\n"
               "    {\n"
               "      \"hostname\": \"localhost\",\n"
               "      \"upstream_host\": \"127.0.0.1\",\n"
               "      \"upstream_port\": 3000,\n"
               "      \"use_ssl\": false,\n"
               "      \"rewrite_host\": true\n"
               "    },\n"
               "    {\n"
               "      \"hostname\": \"example.com\",\n"
               "      \"upstream_host\": \"127.0.0.1\",\n"
               "      \"upstream_port\": 5000,\n"
               "      \"use_ssl\": false,\n"
               "      \"rewrite_host\": false\n"
               "    }\n"
               "  ]\n"
               "}\n");
    fclose(f);
    log_info("Created default config file: %s", filename);
}

void init_ssl() {
    SSL_load_error_strings();
    OpenSSL_add_ssl_algorithms();
    ssl_ctx = SSL_CTX_new(TLS_client_method());
    if (!ssl_ctx) {
        log_error("Failed to create SSL context");
        exit(EXIT_FAILURE);
    }

    // Set verification options
    SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_NONE, NULL);
    SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
}

void cleanup() {
    log_info("Shutting down proxy...");

    // Close all connections
    for (int i = 0; i < MAX_FDS; i++) {
        if (connections[i].type != CONN_TYPE_UNUSED) {
            close_connection(i);
        }
    }

    free_config();
    monitor_cleanup();

    if (epoll_fd >= 0) {
        close(epoll_fd);
    }

    if (ssl_ctx) {
        SSL_CTX_free(ssl_ctx);
    }

    EVP_cleanup();
}

void cleanup_idle_connections() {
    static time_t last_cleanup = 0;
    time_t current_time = time(NULL);

    // Run cleanup every 60 seconds
    if (current_time - last_cleanup < 60) {
        return;
    }

    last_cleanup = current_time;
    const time_t timeout = 300; // 5 minutes timeout

    for (int i = 0; i < MAX_FDS; i++) {
        connection_t *conn = &connections[i];
        if (conn->type != CONN_TYPE_UNUSED && conn->type != CONN_TYPE_LISTENER) {
            if (current_time - conn->last_activity > timeout) {
                log_debug("Closing idle connection fd=%d", i);
                close_connection(i);
            }
        }
    }
}

int main(int argc, char *argv[]) {
    signal(SIGPIPE, SIG_IGN);

    if (getenv("DEBUG")) {
        g_debug_mode = 1;
        log_info("Debug mode enabled");
    }

    const char *config_file = (argc > 1) ? argv[1] : "proxy_config.json";
    create_default_config_if_not_exists(config_file);

    if (!load_config(config_file)) {
        fprintf(stderr, "Failed to load configuration\n");
        return 1;
    }

    init_ssl();
    monitor_init("proxy_stats.db");

    epoll_fd = epoll_create1(EPOLL_CLOEXEC);
    if (epoll_fd == -1) {
        log_error("epoll_create1 failed");
        return 1;
    }

    // Initialize connections array
    for (int i = 0; i < MAX_FDS; i++) {
        connections[i].type = CONN_TYPE_UNUSED;
    }

    setup_listener_socket(config.port);

    log_info("Reverse proxy running on 0.0.0.0:%d", config.port);
    log_info("Dashboard available at http://localhost:%d/dashboard", config.port);

    atexit(cleanup);

    struct epoll_event events[MAX_EVENTS];
    struct timespec last_monitor_update = {0, 0};

    while (1) {
        int n = epoll_wait(epoll_fd, events, MAX_EVENTS, 1000);
        if (n == -1) {
            if (errno == EINTR) {
                continue;
            }
            log_error("epoll_wait failed");
            break;
        }

        for (int i = 0; i < n; i++) {
            handle_connection_event(&events[i]);
        }

        struct timespec current_time;
        clock_gettime(CLOCK_MONOTONIC, &current_time);
        if (current_time.tv_sec > last_monitor_update.tv_sec) {
            monitor_update();
            cleanup_idle_connections();
            last_monitor_update = current_time;
        }
    }

    return 0;
}