erlang_python

/*
 * Copyright 2026 Benoit Chesneau
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * @file py_wsgi.c
 * @brief WSGI marshalling optimizations implementation
 * @author Benoit Chesneau
 *
 * This file implements optimized WSGI request/response handling:
 * - Interned Python string keys for environ dicts
 * - Pre-built constant values reused across requests
 * - Direct WSGI NIF for maximum performance
 *
 * @note This file is included from py_nif.c (single compilation unit)
 */

/* ============================================================================
 * Per-Interpreter State Management
 * ============================================================================ */

/* Storage for per-interpreter states */
static wsgi_interp_state_t *g_wsgi_interp_states[WSGI_MAX_INTERPRETERS];
static int g_wsgi_interp_state_count = 0;
static pthread_mutex_t g_wsgi_interp_state_mutex = PTHREAD_MUTEX_INITIALIZER;

/* Flag: WSGI subsystem is initialized (not per-interpreter) */
static bool g_wsgi_initialized = false;

/**
 * @brief Initialize a single interpreter state for WSGI
 */
static int init_wsgi_interp_state(wsgi_interp_state_t *state) {
    /* CGI/1.1 environ keys */
    state->key_request_method = PyUnicode_InternFromString("REQUEST_METHOD");
    if (!state->key_request_method) return -1;
    state->key_script_name = PyUnicode_InternFromString("SCRIPT_NAME");
    if (!state->key_script_name) return -1;
    state->key_path_info = PyUnicode_InternFromString("PATH_INFO");
    if (!state->key_path_info) return -1;
    state->key_query_string = PyUnicode_InternFromString("QUERY_STRING");
    if (!state->key_query_string) return -1;
    state->key_content_type = PyUnicode_InternFromString("CONTENT_TYPE");
    if (!state->key_content_type) return -1;
    state->key_content_length = PyUnicode_InternFromString("CONTENT_LENGTH");
    if (!state->key_content_length) return -1;
    state->key_server_name = PyUnicode_InternFromString("SERVER_NAME");
    if (!state->key_server_name) return -1;
    state->key_server_port = PyUnicode_InternFromString("SERVER_PORT");
    if (!state->key_server_port) return -1;
    state->key_server_protocol = PyUnicode_InternFromString("SERVER_PROTOCOL");
    if (!state->key_server_protocol) return -1;
    state->key_remote_host = PyUnicode_InternFromString("REMOTE_HOST");
    if (!state->key_remote_host) return -1;
    state->key_remote_addr = PyUnicode_InternFromString("REMOTE_ADDR");
    if (!state->key_remote_addr) return -1;

    /* WSGI environ keys */
    state->key_wsgi_version = PyUnicode_InternFromString("wsgi.version");
    if (!state->key_wsgi_version) return -1;
    state->key_wsgi_url_scheme = PyUnicode_InternFromString("wsgi.url_scheme");
    if (!state->key_wsgi_url_scheme) return -1;
    state->key_wsgi_input = PyUnicode_InternFromString("wsgi.input");
    if (!state->key_wsgi_input) return -1;
    state->key_wsgi_errors = PyUnicode_InternFromString("wsgi.errors");
    if (!state->key_wsgi_errors) return -1;
    state->key_wsgi_multithread = PyUnicode_InternFromString("wsgi.multithread");
    if (!state->key_wsgi_multithread) return -1;
    state->key_wsgi_multiprocess = PyUnicode_InternFromString("wsgi.multiprocess");
    if (!state->key_wsgi_multiprocess) return -1;
    state->key_wsgi_run_once = PyUnicode_InternFromString("wsgi.run_once");
    if (!state->key_wsgi_run_once) return -1;

    /* WSGI extensions */
    state->key_wsgi_file_wrapper = PyUnicode_InternFromString("wsgi.file_wrapper");
    if (!state->key_wsgi_file_wrapper) return -1;
    state->key_wsgi_input_terminated = PyUnicode_InternFromString("wsgi.input_terminated");
    if (!state->key_wsgi_input_terminated) return -1;
    state->key_wsgi_early_hints = PyUnicode_InternFromString("wsgi.early_hints");
    if (!state->key_wsgi_early_hints) return -1;

    /* HTTP protocol constants */
    state->http_10 = PyUnicode_InternFromString("HTTP/1.0");
    if (!state->http_10) return -1;
    state->http_11 = PyUnicode_InternFromString("HTTP/1.1");
    if (!state->http_11) return -1;

    /* Scheme constants */
    state->scheme_http = PyUnicode_InternFromString("http");
    if (!state->scheme_http) return -1;
    state->scheme_https = PyUnicode_InternFromString("https");
    if (!state->scheme_https) return -1;

    /* HTTP methods */
    state->method_get = PyUnicode_InternFromString("GET");
    if (!state->method_get) return -1;
    state->method_post = PyUnicode_InternFromString("POST");
    if (!state->method_post) return -1;
    state->method_put = PyUnicode_InternFromString("PUT");
    if (!state->method_put) return -1;
    state->method_delete = PyUnicode_InternFromString("DELETE");
    if (!state->method_delete) return -1;
    state->method_head = PyUnicode_InternFromString("HEAD");
    if (!state->method_head) return -1;
    state->method_options = PyUnicode_InternFromString("OPTIONS");
    if (!state->method_options) return -1;
    state->method_patch = PyUnicode_InternFromString("PATCH");
    if (!state->method_patch) return -1;

    /* WSGI version tuple (1, 0) */
    state->wsgi_version_tuple = PyTuple_Pack(2, PyLong_FromLong(1), PyLong_FromLong(0));
    if (!state->wsgi_version_tuple) return -1;

    /* Boolean constants */
    state->py_true = Py_True;
    Py_INCREF(state->py_true);
    state->py_false = Py_False;
    Py_INCREF(state->py_false);

    /* Empty values */
    state->empty_string = PyUnicode_InternFromString("");
    if (!state->empty_string) return -1;
    state->empty_bytes = PyBytes_FromStringAndSize("", 0);
    if (!state->empty_bytes) return -1;

    /* Import io.BytesIO for wsgi.input */
    PyObject *io_module = PyImport_ImportModule("io");
    if (!io_module) return -1;
    state->bytesio_class = PyObject_GetAttrString(io_module, "BytesIO");
    Py_DECREF(io_module);
    if (!state->bytesio_class) return -1;

    /* HTTP header prefix */
    state->http_prefix = PyUnicode_InternFromString("HTTP_");
    if (!state->http_prefix) return -1;

    state->initialized = true;
    return 0;
}

/**
 * @brief Clean up a single interpreter state for WSGI
 */
static void cleanup_wsgi_interp_state_internal(wsgi_interp_state_t *state) {
    if (!state || !state->initialized) return;

    Py_XDECREF(state->key_request_method);
    Py_XDECREF(state->key_script_name);
    Py_XDECREF(state->key_path_info);
    Py_XDECREF(state->key_query_string);
    Py_XDECREF(state->key_content_type);
    Py_XDECREF(state->key_content_length);
    Py_XDECREF(state->key_server_name);
    Py_XDECREF(state->key_server_port);
    Py_XDECREF(state->key_server_protocol);
    Py_XDECREF(state->key_remote_host);
    Py_XDECREF(state->key_remote_addr);
    Py_XDECREF(state->key_wsgi_version);
    Py_XDECREF(state->key_wsgi_url_scheme);
    Py_XDECREF(state->key_wsgi_input);
    Py_XDECREF(state->key_wsgi_errors);
    Py_XDECREF(state->key_wsgi_multithread);
    Py_XDECREF(state->key_wsgi_multiprocess);
    Py_XDECREF(state->key_wsgi_run_once);
    Py_XDECREF(state->key_wsgi_file_wrapper);
    Py_XDECREF(state->key_wsgi_input_terminated);
    Py_XDECREF(state->key_wsgi_early_hints);
    Py_XDECREF(state->http_10);
    Py_XDECREF(state->http_11);
    Py_XDECREF(state->scheme_http);
    Py_XDECREF(state->scheme_https);
    Py_XDECREF(state->method_get);
    Py_XDECREF(state->method_post);
    Py_XDECREF(state->method_put);
    Py_XDECREF(state->method_delete);
    Py_XDECREF(state->method_head);
    Py_XDECREF(state->method_options);
    Py_XDECREF(state->method_patch);
    Py_XDECREF(state->wsgi_version_tuple);
    Py_XDECREF(state->py_true);
    Py_XDECREF(state->py_false);
    Py_XDECREF(state->empty_string);
    Py_XDECREF(state->empty_bytes);
    Py_XDECREF(state->bytesio_class);
    Py_XDECREF(state->http_prefix);

    /* Clean up callable cache */
    if (state->cached_module_name) {
        enif_free(state->cached_module_name);
        state->cached_module_name = NULL;
    }
    if (state->cached_callable_name) {
        enif_free(state->cached_callable_name);
        state->cached_callable_name = NULL;
    }
    Py_XDECREF(state->cached_callable);
    state->cached_callable = NULL;

    if (state->cached_runner_name) {
        enif_free(state->cached_runner_name);
        state->cached_runner_name = NULL;
    }
    Py_XDECREF(state->cached_runner);
    state->cached_runner = NULL;
    Py_XDECREF(state->cached_run_func);
    state->cached_run_func = NULL;

    state->initialized = false;
}

/**
 * @brief Get or create per-interpreter state for WSGI
 */
wsgi_interp_state_t *get_wsgi_interp_state(void) {
    PyInterpreterState *interp = PyInterpreterState_Get();

    /* Fast path: check existing states without lock */
    for (int i = 0; i < g_wsgi_interp_state_count; i++) {
        if (g_wsgi_interp_states[i] && g_wsgi_interp_states[i]->interp == interp) {
            return g_wsgi_interp_states[i];
        }
    }

    /* Slow path: acquire lock and create new state */
    pthread_mutex_lock(&g_wsgi_interp_state_mutex);

    /* Double-check after acquiring lock */
    for (int i = 0; i < g_wsgi_interp_state_count; i++) {
        if (g_wsgi_interp_states[i] && g_wsgi_interp_states[i]->interp == interp) {
            pthread_mutex_unlock(&g_wsgi_interp_state_mutex);
            return g_wsgi_interp_states[i];
        }
    }

    /* Check capacity */
    if (g_wsgi_interp_state_count >= WSGI_MAX_INTERPRETERS) {
        pthread_mutex_unlock(&g_wsgi_interp_state_mutex);
        PyErr_SetString(PyExc_RuntimeError, "Too many Python interpreters for WSGI");
        return NULL;
    }

    /* Allocate and initialize new state */
    wsgi_interp_state_t *state = enif_alloc(sizeof(wsgi_interp_state_t));
    if (!state) {
        pthread_mutex_unlock(&g_wsgi_interp_state_mutex);
        PyErr_NoMemory();
        return NULL;
    }

    memset(state, 0, sizeof(wsgi_interp_state_t));
    state->interp = interp;

    if (init_wsgi_interp_state(state) < 0) {
        cleanup_wsgi_interp_state_internal(state);
        enif_free(state);
        pthread_mutex_unlock(&g_wsgi_interp_state_mutex);
        return NULL;
    }

    g_wsgi_interp_states[g_wsgi_interp_state_count++] = state;
    pthread_mutex_unlock(&g_wsgi_interp_state_mutex);

    return state;
}

/**
 * @brief Clean up state for a specific interpreter
 */
void cleanup_wsgi_interp_state(PyInterpreterState *interp) {
    if (!interp) {
        interp = PyInterpreterState_Get();
    }

    pthread_mutex_lock(&g_wsgi_interp_state_mutex);

    for (int i = 0; i < g_wsgi_interp_state_count; i++) {
        if (g_wsgi_interp_states[i] && g_wsgi_interp_states[i]->interp == interp) {
            cleanup_wsgi_interp_state_internal(g_wsgi_interp_states[i]);
            enif_free(g_wsgi_interp_states[i]);

            /* Shift remaining states down */
            for (int j = i; j < g_wsgi_interp_state_count - 1; j++) {
                g_wsgi_interp_states[j] = g_wsgi_interp_states[j + 1];
            }
            g_wsgi_interp_states[--g_wsgi_interp_state_count] = NULL;
            break;
        }
    }

    pthread_mutex_unlock(&g_wsgi_interp_state_mutex);
}

/**
 * @brief Clean up all interpreter states
 */
void cleanup_all_wsgi_interp_states(void) {
    pthread_mutex_lock(&g_wsgi_interp_state_mutex);

    for (int i = 0; i < g_wsgi_interp_state_count; i++) {
        if (g_wsgi_interp_states[i]) {
            cleanup_wsgi_interp_state_internal(g_wsgi_interp_states[i]);
            enif_free(g_wsgi_interp_states[i]);
            g_wsgi_interp_states[i] = NULL;
        }
    }
    g_wsgi_interp_state_count = 0;

    pthread_mutex_unlock(&g_wsgi_interp_state_mutex);
}

/* ============================================================================
 * Callable Caching
 * ============================================================================
 * Cache module imports and callable lookups to avoid per-request overhead.
 * Most WSGI apps use a single module/callable, so a simple last-used cache
 * provides excellent hit rates.
 */

/**
 * @brief Get cached runner function or import and cache it
 *
 * Returns a borrowed reference to the cached _run_wsgi_sync function.
 */
static PyObject *get_cached_wsgi_runner(wsgi_interp_state_t *state,
                                        const char *runner_name) {
    /* Check if cached */
    if (state->cached_runner_name &&
        strcmp(state->cached_runner_name, runner_name) == 0 &&
        state->cached_run_func != NULL) {
        return state->cached_run_func;  /* Cache hit - borrowed reference */
    }

    /* Cache miss - import and cache */
    PyObject *runner = PyImport_ImportModule(runner_name);
    if (!runner) return NULL;

    PyObject *run_func = PyObject_GetAttrString(runner, "_run_wsgi_sync");
    if (!run_func) {
        Py_DECREF(runner);
        return NULL;
    }

    /* Update cache */
    if (state->cached_runner_name) {
        enif_free(state->cached_runner_name);
    }
    Py_XDECREF(state->cached_runner);
    Py_XDECREF(state->cached_run_func);

    state->cached_runner_name = enif_alloc(strlen(runner_name) + 1);
    if (!state->cached_runner_name) {
        Py_DECREF(run_func);
        Py_DECREF(runner);
        return NULL;
    }
    strcpy(state->cached_runner_name, runner_name);
    state->cached_runner = runner;      /* Takes ownership */
    state->cached_run_func = run_func;  /* Takes ownership */

    return run_func;  /* Borrowed reference */
}

/* ============================================================================
 * Initialization / Cleanup
 * ============================================================================ */

static int wsgi_scope_init(void) {
    if (g_wsgi_initialized) {
        return 0;
    }

    wsgi_interp_state_t *state = get_wsgi_interp_state();
    if (!state) {
        return -1;
    }

    g_wsgi_initialized = true;
    return 0;
}

static void wsgi_scope_cleanup(void) {
    if (!g_wsgi_initialized) {
        return;
    }

    cleanup_all_wsgi_interp_states();
    g_wsgi_initialized = false;
}

/* ============================================================================
 * Helper Functions
 * ============================================================================ */

static PyObject *wsgi_get_method(const char *method, size_t len) {
    /* Check common methods - return new reference */
    switch (len) {
        case 3:
            if (memcmp(method, "GET", 3) == 0) {
                Py_INCREF(WSGI_METHOD_GET);
                return WSGI_METHOD_GET;
            }
            if (memcmp(method, "PUT", 3) == 0) {
                Py_INCREF(WSGI_METHOD_PUT);
                return WSGI_METHOD_PUT;
            }
            break;
        case 4:
            if (memcmp(method, "POST", 4) == 0) {
                Py_INCREF(WSGI_METHOD_POST);
                return WSGI_METHOD_POST;
            }
            if (memcmp(method, "HEAD", 4) == 0) {
                Py_INCREF(WSGI_METHOD_HEAD);
                return WSGI_METHOD_HEAD;
            }
            break;
        case 5:
            if (memcmp(method, "PATCH", 5) == 0) {
                Py_INCREF(WSGI_METHOD_PATCH);
                return WSGI_METHOD_PATCH;
            }
            break;
        case 6:
            if (memcmp(method, "DELETE", 6) == 0) {
                Py_INCREF(WSGI_METHOD_DELETE);
                return WSGI_METHOD_DELETE;
            }
            break;
        case 7:
            if (memcmp(method, "OPTIONS", 7) == 0) {
                Py_INCREF(WSGI_METHOD_OPTIONS);
                return WSGI_METHOD_OPTIONS;
            }
            break;
    }

    /* Uncommon method - create new string */
    return PyUnicode_FromStringAndSize(method, len);
}

/**
 * @brief Get cached key for an environ key term
 */
static PyObject *wsgi_get_key_for_term(ErlNifEnv *env, ERL_NIF_TERM term) {
    char key_buf[128];
    ErlNifBinary key_bin;

    if (enif_is_atom(env, term)) {
        if (enif_get_atom(env, term, key_buf, sizeof(key_buf), ERL_NIF_LATIN1)) {
            /* Map to cached keys */
            if (strcmp(key_buf, "REQUEST_METHOD") == 0) return WSGI_KEY_REQUEST_METHOD;
            if (strcmp(key_buf, "SCRIPT_NAME") == 0) return WSGI_KEY_SCRIPT_NAME;
            if (strcmp(key_buf, "PATH_INFO") == 0) return WSGI_KEY_PATH_INFO;
            if (strcmp(key_buf, "QUERY_STRING") == 0) return WSGI_KEY_QUERY_STRING;
            if (strcmp(key_buf, "CONTENT_TYPE") == 0) return WSGI_KEY_CONTENT_TYPE;
            if (strcmp(key_buf, "CONTENT_LENGTH") == 0) return WSGI_KEY_CONTENT_LENGTH;
            if (strcmp(key_buf, "SERVER_NAME") == 0) return WSGI_KEY_SERVER_NAME;
            if (strcmp(key_buf, "SERVER_PORT") == 0) return WSGI_KEY_SERVER_PORT;
            if (strcmp(key_buf, "SERVER_PROTOCOL") == 0) return WSGI_KEY_SERVER_PROTOCOL;
            if (strcmp(key_buf, "REMOTE_HOST") == 0) return WSGI_KEY_REMOTE_HOST;
            if (strcmp(key_buf, "REMOTE_ADDR") == 0) return WSGI_KEY_REMOTE_ADDR;
        }
    } else if (enif_inspect_binary(env, term, &key_bin)) {
        /* Check for binary keys */
        if (key_bin.size < sizeof(key_buf)) {
            memcpy(key_buf, key_bin.data, key_bin.size);
            key_buf[key_bin.size] = '\0';

            /* Check common keys */
            if (strcmp(key_buf, "REQUEST_METHOD") == 0) return WSGI_KEY_REQUEST_METHOD;
            if (strcmp(key_buf, "SCRIPT_NAME") == 0) return WSGI_KEY_SCRIPT_NAME;
            if (strcmp(key_buf, "PATH_INFO") == 0) return WSGI_KEY_PATH_INFO;
            if (strcmp(key_buf, "QUERY_STRING") == 0) return WSGI_KEY_QUERY_STRING;
            if (strcmp(key_buf, "CONTENT_TYPE") == 0) return WSGI_KEY_CONTENT_TYPE;
            if (strcmp(key_buf, "CONTENT_LENGTH") == 0) return WSGI_KEY_CONTENT_LENGTH;
            if (strcmp(key_buf, "SERVER_NAME") == 0) return WSGI_KEY_SERVER_NAME;
            if (strcmp(key_buf, "SERVER_PORT") == 0) return WSGI_KEY_SERVER_PORT;
            if (strcmp(key_buf, "SERVER_PROTOCOL") == 0) return WSGI_KEY_SERVER_PROTOCOL;
            if (strcmp(key_buf, "REMOTE_HOST") == 0) return WSGI_KEY_REMOTE_HOST;
            if (strcmp(key_buf, "REMOTE_ADDR") == 0) return WSGI_KEY_REMOTE_ADDR;
            if (strcmp(key_buf, "wsgi.version") == 0) return WSGI_KEY_WSGI_VERSION;
            if (strcmp(key_buf, "wsgi.url_scheme") == 0) return WSGI_KEY_WSGI_URL_SCHEME;
            if (strcmp(key_buf, "wsgi.input") == 0) return WSGI_KEY_WSGI_INPUT;
            if (strcmp(key_buf, "wsgi.errors") == 0) return WSGI_KEY_WSGI_ERRORS;
            if (strcmp(key_buf, "wsgi.multithread") == 0) return WSGI_KEY_WSGI_MULTITHREAD;
            if (strcmp(key_buf, "wsgi.multiprocess") == 0) return WSGI_KEY_WSGI_MULTIPROCESS;
            if (strcmp(key_buf, "wsgi.run_once") == 0) return WSGI_KEY_WSGI_RUN_ONCE;
        }
    }

    return NULL;
}

/**
 * @brief Convert WSGI environ map from Erlang to Python dict
 */
static PyObject *wsgi_environ_from_map(ErlNifEnv *env, ERL_NIF_TERM environ_map) {
    if (!g_wsgi_initialized) {
        PyErr_SetString(PyExc_RuntimeError, "WSGI cache not initialized");
        return NULL;
    }

    if (!enif_is_map(env, environ_map)) {
        PyErr_SetString(PyExc_TypeError, "expected map for WSGI environ");
        return NULL;
    }

    PyObject *environ = PyDict_New();
    if (environ == NULL) {
        return NULL;
    }

    ERL_NIF_TERM key, value;
    ErlNifMapIterator iter;

    enif_map_iterator_create(env, environ_map, &iter, ERL_NIF_MAP_ITERATOR_FIRST);

    while (enif_map_iterator_get_pair(env, &iter, &key, &value)) {
        PyObject *py_key = wsgi_get_key_for_term(env, key);
        bool key_borrowed = (py_key != NULL);

        if (py_key == NULL) {
            /* Unknown key - create new Python string */
            py_key = term_to_py(env, key);
            if (py_key == NULL) {
                enif_map_iterator_destroy(env, &iter);
                Py_DECREF(environ);
                return NULL;
            }
        }

        /* Convert value with optimizations for known keys */
        PyObject *py_value = NULL;

        if (py_key == WSGI_KEY_REQUEST_METHOD) {
            ErlNifBinary method_bin;
            if (enif_inspect_binary(env, value, &method_bin)) {
                py_value = wsgi_get_method((char *)method_bin.data, method_bin.size);
            }
        } else if (py_key == WSGI_KEY_SERVER_PROTOCOL) {
            ErlNifBinary proto_bin;
            if (enif_inspect_binary(env, value, &proto_bin)) {
                if (proto_bin.size == 8 && memcmp(proto_bin.data, "HTTP/1.1", 8) == 0) {
                    Py_INCREF(WSGI_HTTP_11);
                    py_value = WSGI_HTTP_11;
                } else if (proto_bin.size == 8 && memcmp(proto_bin.data, "HTTP/1.0", 8) == 0) {
                    Py_INCREF(WSGI_HTTP_10);
                    py_value = WSGI_HTTP_10;
                }
            }
        } else if (py_key == WSGI_KEY_WSGI_URL_SCHEME) {
            ErlNifBinary scheme_bin;
            if (enif_inspect_binary(env, value, &scheme_bin)) {
                if (scheme_bin.size == 4 && memcmp(scheme_bin.data, "http", 4) == 0) {
                    Py_INCREF(WSGI_SCHEME_HTTP);
                    py_value = WSGI_SCHEME_HTTP;
                } else if (scheme_bin.size == 5 && memcmp(scheme_bin.data, "https", 5) == 0) {
                    Py_INCREF(WSGI_SCHEME_HTTPS);
                    py_value = WSGI_SCHEME_HTTPS;
                }
            }
        } else if (py_key == WSGI_KEY_SCRIPT_NAME || py_key == WSGI_KEY_PATH_INFO ||
                   py_key == WSGI_KEY_QUERY_STRING) {
            ErlNifBinary str_bin;
            if (enif_inspect_binary(env, value, &str_bin) && str_bin.size == 0) {
                Py_INCREF(WSGI_EMPTY_STRING);
                py_value = WSGI_EMPTY_STRING;
            }
        } else if (py_key == WSGI_KEY_WSGI_VERSION) {
            /* Always use cached version tuple */
            Py_INCREF(WSGI_VERSION_TUPLE);
            py_value = WSGI_VERSION_TUPLE;
        } else if (py_key == WSGI_KEY_WSGI_MULTITHREAD ||
                   py_key == WSGI_KEY_WSGI_MULTIPROCESS) {
            /* These are typically true */
            if (enif_is_atom(env, value)) {
                char atom_buf[16];
                if (enif_get_atom(env, value, atom_buf, sizeof(atom_buf), ERL_NIF_LATIN1)) {
                    if (strcmp(atom_buf, "true") == 0) {
                        Py_INCREF(WSGI_PY_TRUE);
                        py_value = WSGI_PY_TRUE;
                    } else if (strcmp(atom_buf, "false") == 0) {
                        Py_INCREF(WSGI_PY_FALSE);
                        py_value = WSGI_PY_FALSE;
                    }
                }
            }
        } else if (py_key == WSGI_KEY_WSGI_RUN_ONCE) {
            /* Typically false */
            if (enif_is_atom(env, value)) {
                char atom_buf[16];
                if (enif_get_atom(env, value, atom_buf, sizeof(atom_buf), ERL_NIF_LATIN1)) {
                    if (strcmp(atom_buf, "false") == 0) {
                        Py_INCREF(WSGI_PY_FALSE);
                        py_value = WSGI_PY_FALSE;
                    } else if (strcmp(atom_buf, "true") == 0) {
                        Py_INCREF(WSGI_PY_TRUE);
                        py_value = WSGI_PY_TRUE;
                    }
                }
            }
        } else if (py_key == WSGI_KEY_WSGI_INPUT) {
            /* Create BytesIO from binary body */
            ErlNifBinary body_bin;
            if (enif_inspect_binary(env, value, &body_bin)) {
                PyObject *body_bytes = PyBytes_FromStringAndSize(
                    (char *)body_bin.data, body_bin.size);
                if (body_bytes) {
                    py_value = PyObject_CallFunctionObjArgs(
                        WSGI_BYTESIO_CLASS, body_bytes, NULL);
                    Py_DECREF(body_bytes);
                }
            }
        }

        /* Generic conversion if no optimization applied */
        if (py_value == NULL) {
            py_value = term_to_py(env, value);
            if (py_value == NULL) {
                if (!key_borrowed) {
                    Py_DECREF(py_key);
                }
                enif_map_iterator_destroy(env, &iter);
                Py_DECREF(environ);
                return NULL;
            }
        }

        /* Use interned key reference */
        if (key_borrowed) {
            Py_INCREF(py_key);
        }

        int set_result = PyDict_SetItem(environ, py_key, py_value);
        Py_DECREF(py_key);
        Py_DECREF(py_value);

        if (set_result < 0) {
            enif_map_iterator_destroy(env, &iter);
            Py_DECREF(environ);
            return NULL;
        }

        enif_map_iterator_next(env, &iter);
    }

    enif_map_iterator_destroy(env, &iter);
    return environ;
}

/* ============================================================================
 * NIF Function
 * ============================================================================ */

static ERL_NIF_TERM nif_wsgi_run(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
    if (argc < 4) {
        return make_error(env, "badarg");
    }

    if (!runtime_is_running()) {
        return make_error(env, "python_not_initialized");
    }

    if (!g_wsgi_initialized) {
        /* Initialize lazily */
        PyGILState_STATE init_gstate = PyGILState_Ensure();
        int init_result = wsgi_scope_init();
        PyGILState_Release(init_gstate);
        if (init_result < 0) {
            return make_error(env, "wsgi_init_failed");
        }
    }

    ErlNifBinary runner_bin, module_bin, callable_bin;

    if (!enif_inspect_binary(env, argv[0], &runner_bin)) {
        return make_error(env, "invalid_runner");
    }
    if (!enif_inspect_binary(env, argv[1], &module_bin)) {
        return make_error(env, "invalid_module");
    }
    if (!enif_inspect_binary(env, argv[2], &callable_bin)) {
        return make_error(env, "invalid_callable");
    }

    PyGILState_STATE gstate = PyGILState_Ensure();

    ERL_NIF_TERM result;

    /* Convert names */
    char *runner_name = binary_to_string(&runner_bin);
    char *module_name = binary_to_string(&module_bin);
    char *callable_name = binary_to_string(&callable_bin);
    if (runner_name == NULL || module_name == NULL || callable_name == NULL) {
        enif_free(runner_name);
        enif_free(module_name);
        enif_free(callable_name);
        PyGILState_Release(gstate);
        return make_error(env, "alloc_failed");
    }

    /* Get per-interpreter state for callable caching */
    wsgi_interp_state_t *state = get_wsgi_interp_state();
    if (state == NULL) {
        result = make_py_error(env);
        goto cleanup;
    }

    /* Build optimized environ dict from Erlang map */
    PyObject *environ = wsgi_environ_from_map(env, argv[3]);
    if (environ == NULL) {
        result = make_py_error(env);
        goto cleanup;
    }

    /* Get cached runner function (avoids per-request import) */
    PyObject *run_func = get_cached_wsgi_runner(state, runner_name);
    if (run_func == NULL) {
        Py_DECREF(environ);
        result = make_py_error(env);
        goto cleanup;
    }

    /* Create Python strings for module/callable names (for runner call) */
    PyObject *py_module_name = PyUnicode_FromString(module_name);
    PyObject *py_callable_name = PyUnicode_FromString(callable_name);
    if (py_module_name == NULL || py_callable_name == NULL) {
        Py_XDECREF(py_module_name);
        Py_XDECREF(py_callable_name);
        Py_DECREF(environ);
        result = make_py_error(env);
        goto cleanup;
    }

    /* Call _run_wsgi_sync(module_name, callable_name, environ) using cached function */
    PyObject *run_result = PyObject_CallFunctionObjArgs(
        run_func, py_module_name, py_callable_name, environ, NULL);

    Py_DECREF(py_module_name);
    Py_DECREF(py_callable_name);
    Py_DECREF(environ);
    /* Note: run_func is borrowed reference from cache - don't decref */

    if (run_result == NULL) {
        result = make_py_error(env);
        goto cleanup;
    }

    /* Convert result to Erlang term */
    ERL_NIF_TERM term_result = py_to_term(env, run_result);
    Py_DECREF(run_result);

    result = enif_make_tuple2(env, ATOM_OK, term_result);

cleanup:
    enif_free(runner_name);
    enif_free(module_name);
    enif_free(callable_name);
    PyGILState_Release(gstate);

    return result;
}