// string_backend.c
#include "wren.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>

// Helper to validate that the value in a slot is a string.
static bool validateString(WrenVM* vm, int slot, const char* name) {
    if (wrenGetSlotType(vm, slot) == WREN_TYPE_STRING) return true;
    wrenSetSlotString(vm, 0, "Argument must be a string.");
    wrenAbortFiber(vm, 0);
    return false;
}

// Helper to validate that the value in a slot is a number.
static bool validateNumber(WrenVM* vm, int slot, const char* name) {
    if (wrenGetSlotType(vm, slot) == WREN_TYPE_NUM) return true;
    wrenSetSlotString(vm, 0, "Argument must be a number.");
    wrenAbortFiber(vm, 0);
    return false;
}

// Implements String.endsWith(_).
void stringEndsWith(WrenVM* vm) {
    if (!validateString(vm, 1, "Suffix")) return;

    int stringLength, suffixLength;
    const char* string = wrenGetSlotBytes(vm, 0, &stringLength);
    const char* suffix = wrenGetSlotBytes(vm, 1, &suffixLength);

    if (suffixLength > stringLength) {
        wrenSetSlotBool(vm, 0, false);
        return;
    }

    wrenSetSlotBool(vm, 0, memcmp(string + stringLength - suffixLength, suffix, suffixLength) == 0);
}

// Implements String.startsWith(_).
void stringStartsWith(WrenVM* vm) {
    if (!validateString(vm, 1, "Prefix")) return;

    int stringLength, prefixLength;
    const char* string = wrenGetSlotBytes(vm, 0, &stringLength);
    const char* prefix = wrenGetSlotBytes(vm, 1, &prefixLength);

    if (prefixLength > stringLength) {
        wrenSetSlotBool(vm, 0, false);
        return;
    }

    wrenSetSlotBool(vm, 0, memcmp(string, prefix, prefixLength) == 0);
}

// Implements String.replace(_, _).
void stringReplace(WrenVM* vm) {
    if (!validateString(vm, 1, "From")) return;
    if (!validateString(vm, 2, "To")) return;

    int haystackLen, fromLen, toLen;
    const char* haystack = wrenGetSlotBytes(vm, 0, &haystackLen);
    const char* from = wrenGetSlotBytes(vm, 1, &fromLen);
    const char* to = wrenGetSlotBytes(vm, 2, &toLen);

    if (fromLen == 0) {
        wrenSetSlotString(vm, 0, haystack);
        return;
    }

    size_t resultCapacity = haystackLen * (toLen > fromLen ? toLen / fromLen + 1 : 1) + 1;
    char* result = (char*)malloc(resultCapacity);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }

    char* dest = result;
    const char* p = haystack;
    const char* end = haystack + haystackLen;

    while (p < end) {
        const char* found = strstr(p, from);
        if (found) {
            size_t len = found - p;
            memcpy(dest, p, len);
            dest += len;
            memcpy(dest, to, toLen);
            dest += toLen;
            p = found + fromLen;
        } else {
            size_t len = end - p;
            memcpy(dest, p, len);
            dest += len;
            p = end;
        }
    }
    *dest = '\0';

    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.split(_).
void stringSplit(WrenVM* vm) {
    if (!validateString(vm, 1, "Delimiter")) return;

    int haystackLen, delimLen;
    const char* haystack = wrenGetSlotBytes(vm, 0, &haystackLen);
    const char* delim = wrenGetSlotBytes(vm, 1, &delimLen);

    if (delimLen == 0) {
        wrenSetSlotString(vm, 0, "Delimiter cannot be empty.");
        wrenAbortFiber(vm, 0);
        return;
    }

    wrenSetSlotNewList(vm, 0);

    const char* p = haystack;
    const char* end = haystack + haystackLen;
    while (p < end) {
        const char* found = strstr(p, delim);
        if (found) {
            wrenSetSlotBytes(vm, 1, p, found - p);
            wrenInsertInList(vm, 0, -1, 1);
            p = found + delimLen;
        } else {
            wrenSetSlotBytes(vm, 1, p, end - p);
            wrenInsertInList(vm, 0, -1, 1);
            p = end;
        }
    }
    
    if (haystackLen > 0 && (haystackLen >= delimLen) &&
        memcmp(haystack + haystackLen - delimLen, delim, delimLen) == 0) {
        wrenSetSlotBytes(vm, 1, "", 0);
        wrenInsertInList(vm, 0, -1, 1);
    }
}

// Implements String.toUpper().
void stringToUpper(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        result[i] = toupper((unsigned char)str[i]);
    }
    result[len] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.toLower().
void stringToLower(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        result[i] = tolower((unsigned char)str[i]);
    }
    result[len] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.trim().
void stringTrim(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    int start = 0;
    int end = len - 1;
    
    while (start < len && isspace((unsigned char)str[start])) start++;
    while (end >= 0 && isspace((unsigned char)str[end])) end--;
    
    if (start > end) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    wrenSetSlotBytes(vm, 0, str + start, end - start + 1);
}

// Implements String.trimStart().
void stringTrimStart(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    int start = 0;
    while (start < len && isspace((unsigned char)str[start])) start++;
    
    wrenSetSlotBytes(vm, 0, str + start, len - start);
}

// Implements String.trimEnd().
void stringTrimEnd(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    int end = len - 1;
    while (end >= 0 && isspace((unsigned char)str[end])) end--;
    
    wrenSetSlotBytes(vm, 0, str, end + 1);
}

// Implements String.count(_).
void stringCount(WrenVM* vm) {
    if (!validateString(vm, 1, "Substring")) return;
    
    int haystackLen, needleLen;
    const char* haystack = wrenGetSlotBytes(vm, 0, &haystackLen);
    const char* needle = wrenGetSlotBytes(vm, 1, &needleLen);
    
    if (needleLen == 0) {
        wrenSetSlotDouble(vm, 0, 0);
        return;
    }
    
    int count = 0;
    const char* p = haystack;
    const char* end = haystack + haystackLen;
    
    while (p < end) {
        const char* found = strstr(p, needle);
        if (found) {
            count++;
            p = found + needleLen;
        } else {
            break;
        }
    }
    
    wrenSetSlotDouble(vm, 0, count);
}

// Implements String.indexOf(_).
void stringIndexOf(WrenVM* vm) {
    if (!validateString(vm, 1, "Substring")) return;
    
    int haystackLen, needleLen;
    const char* haystack = wrenGetSlotBytes(vm, 0, &haystackLen);
    const char* needle = wrenGetSlotBytes(vm, 1, &needleLen);
    
    if (needleLen == 0) {
        wrenSetSlotDouble(vm, 0, 0);
        return;
    }
    
    const char* found = strstr(haystack, needle);
    if (found) {
        wrenSetSlotDouble(vm, 0, found - haystack);
    } else {
        wrenSetSlotDouble(vm, 0, -1);
    }
}

// Implements String.lastIndexOf(_).
void stringLastIndexOf(WrenVM* vm) {
    if (!validateString(vm, 1, "Substring")) return;
    
    int haystackLen, needleLen;
    const char* haystack = wrenGetSlotBytes(vm, 0, &haystackLen);
    const char* needle = wrenGetSlotBytes(vm, 1, &needleLen);
    
    if (needleLen == 0 || needleLen > haystackLen) {
        wrenSetSlotDouble(vm, 0, -1);
        return;
    }
    
    const char* lastFound = NULL;
    const char* p = haystack;
    
    while ((p = strstr(p, needle)) != NULL) {
        lastFound = p;
        p++;
    }
    
    if (lastFound) {
        wrenSetSlotDouble(vm, 0, lastFound - haystack);
    } else {
        wrenSetSlotDouble(vm, 0, -1);
    }
}

// Implements String.contains(_).
void stringContains(WrenVM* vm) {
    if (!validateString(vm, 1, "Substring")) return;
    
    int haystackLen, needleLen;
    const char* haystack = wrenGetSlotBytes(vm, 0, &haystackLen);
    const char* needle = wrenGetSlotBytes(vm, 1, &needleLen);
    
    if (needleLen == 0) {
        wrenSetSlotBool(vm, 0, true);
        return;
    }
    
    wrenSetSlotBool(vm, 0, strstr(haystack, needle) != NULL);
}

// Implements String.toInt().
void stringToInt(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* endptr;
    errno = 0;
    long value = strtol(str, &endptr, 10);
    
    if (errno != 0 || endptr == str || *endptr != '\0') {
        wrenSetSlotNull(vm, 0);
    } else {
        wrenSetSlotDouble(vm, 0, (double)value);
    }
}

// Implements String.toNum().
void stringToNum(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* endptr;
    errno = 0;
    double value = strtod(str, &endptr);
    
    if (errno != 0 || endptr == str || *endptr != '\0') {
        wrenSetSlotNull(vm, 0);
    } else {
        wrenSetSlotDouble(vm, 0, value);
    }
}

// Implements String.reverse().
void stringReverse(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        result[i] = str[len - 1 - i];
    }
    result[len] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.repeat(_).
void stringRepeat(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Count")) return;
    
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    int count = (int)wrenGetSlotDouble(vm, 1);
    
    if (count < 0) {
        wrenSetSlotString(vm, 0, "Count must be non-negative.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    if (count == 0 || len == 0) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    size_t resultLen = len * count;
    char* result = (char*)malloc(resultLen + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    for (int i = 0; i < count; i++) {
        memcpy(result + (i * len), str, len);
    }
    result[resultLen] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.padStart(_, _).
void stringPadStart(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Length")) return;
    if (!validateString(vm, 2, "PadString")) return;
    
    int strLen;
    const char* str = wrenGetSlotBytes(vm, 0, &strLen);
    int targetLen = (int)wrenGetSlotDouble(vm, 1);
    int padLen;
    const char* padStr = wrenGetSlotBytes(vm, 2, &padLen);
    
    if (targetLen <= strLen || padLen == 0) {
        wrenSetSlotString(vm, 0, str);
        return;
    }
    
    int padNeeded = targetLen - strLen;
    char* result = (char*)malloc(targetLen + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    int pos = 0;
    while (pos < padNeeded) {
        int copyLen = (padNeeded - pos < padLen) ? (padNeeded - pos) : padLen;
        memcpy(result + pos, padStr, copyLen);
        pos += copyLen;
    }
    
    memcpy(result + padNeeded, str, strLen);
    result[targetLen] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.padEnd(_, _).
void stringPadEnd(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Length")) return;
    if (!validateString(vm, 2, "PadString")) return;
    
    int strLen;
    const char* str = wrenGetSlotBytes(vm, 0, &strLen);
    int targetLen = (int)wrenGetSlotDouble(vm, 1);
    int padLen;
    const char* padStr = wrenGetSlotBytes(vm, 2, &padLen);
    
    if (targetLen <= strLen || padLen == 0) {
        wrenSetSlotString(vm, 0, str);
        return;
    }
    
    int padNeeded = targetLen - strLen;
    char* result = (char*)malloc(targetLen + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    memcpy(result, str, strLen);
    
    int pos = strLen;
    while (pos < targetLen) {
        int copyLen = (targetLen - pos < padLen) ? (targetLen - pos) : padLen;
        memcpy(result + pos, padStr, copyLen);
        pos += copyLen;
    }
    
    result[targetLen] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.charAt(_).
void stringCharAt(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Index")) return;
    
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    int index = (int)wrenGetSlotDouble(vm, 1);
    
    if (index < 0 || index >= len) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    char result[2] = { str[index], '\0' };
    wrenSetSlotString(vm, 0, result);
}

// Implements String.charCodeAt(_).
void stringCharCodeAt(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Index")) return;
    
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    int index = (int)wrenGetSlotDouble(vm, 1);
    
    if (index < 0 || index >= len) {
        wrenSetSlotNull(vm, 0);
        return;
    }
    
    wrenSetSlotDouble(vm, 0, (unsigned char)str[index]);
}

// Implements String.isNumeric().
void stringIsNumeric(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    if (len == 0) {
        wrenSetSlotBool(vm, 0, false);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        if (!isdigit((unsigned char)str[i])) {
            wrenSetSlotBool(vm, 0, false);
            return;
        }
    }
    
    wrenSetSlotBool(vm, 0, true);
}

// Implements String.isAlpha().
void stringIsAlpha(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    if (len == 0) {
        wrenSetSlotBool(vm, 0, false);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        if (!isalpha((unsigned char)str[i])) {
            wrenSetSlotBool(vm, 0, false);
            return;
        }
    }
    
    wrenSetSlotBool(vm, 0, true);
}

// Implements String.isAlphaNumeric().
void stringIsAlphaNumeric(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    if (len == 0) {
        wrenSetSlotBool(vm, 0, false);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        if (!isalnum((unsigned char)str[i])) {
            wrenSetSlotBool(vm, 0, false);
            return;
        }
    }
    
    wrenSetSlotBool(vm, 0, true);
}

// Implements String.isEmpty().
void stringIsEmpty(WrenVM* vm) {
    int len;
    wrenGetSlotBytes(vm, 0, &len);
    wrenSetSlotBool(vm, 0, len == 0);
}

// Implements String.isWhitespace().
void stringIsWhitespace(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    if (len == 0) {
        wrenSetSlotBool(vm, 0, true);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        if (!isspace((unsigned char)str[i])) {
            wrenSetSlotBool(vm, 0, false);
            return;
        }
    }
    
    wrenSetSlotBool(vm, 0, true);
}

// Implements String.capitalize().
void stringCapitalize(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    if (len == 0) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    result[0] = toupper((unsigned char)str[0]);
    for (int i = 1; i < len; i++) {
        result[i] = tolower((unsigned char)str[i]);
    }
    result[len] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.toCamelCase().
void stringToCamelCase(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    int j = 0;
    bool capitalizeNext = false;
    
    for (int i = 0; i < len; i++) {
        if (str[i] == '_' || str[i] == '-' || isspace((unsigned char)str[i])) {
            capitalizeNext = true;
        } else {
            if (capitalizeNext && j > 0) {
                result[j++] = toupper((unsigned char)str[i]);
                capitalizeNext = false;
            } else {
                result[j++] = (j == 0) ? tolower((unsigned char)str[i]) : str[i];
            }
        }
    }
    result[j] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.toSnakeCase().
void stringToSnakeCase(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    // Allocate extra space for underscores
    char* result = (char*)malloc(len * 2 + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    int j = 0;
    for (int i = 0; i < len; i++) {
        if (isupper((unsigned char)str[i]) && i > 0 && !isupper((unsigned char)str[i-1])) {
            result[j++] = '_';
        }
        if (str[i] == '-' || isspace((unsigned char)str[i])) {
            result[j++] = '_';
        } else {
            result[j++] = tolower((unsigned char)str[i]);
        }
    }
    result[j] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.toKebabCase().
void stringToKebabCase(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    // Allocate extra space for hyphens
    char* result = (char*)malloc(len * 2 + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    int j = 0;
    for (int i = 0; i < len; i++) {
        if (isupper((unsigned char)str[i]) && i > 0 && !isupper((unsigned char)str[i-1])) {
            result[j++] = '-';
        }
        if (str[i] == '_' || isspace((unsigned char)str[i])) {
            result[j++] = '-';
        } else {
            result[j++] = tolower((unsigned char)str[i]);
        }
    }
    result[j] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.toPascalCase().
void stringToPascalCase(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    int j = 0;
    bool capitalizeNext = true;
    
    for (int i = 0; i < len; i++) {
        if (str[i] == '_' || str[i] == '-' || isspace((unsigned char)str[i])) {
            capitalizeNext = true;
        } else {
            if (capitalizeNext) {
                result[j++] = toupper((unsigned char)str[i]);
                capitalizeNext = false;
            } else {
                result[j++] = str[i];
            }
        }
    }
    result[j] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.swapCase().
void stringSwapCase(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    char* result = (char*)malloc(len + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    for (int i = 0; i < len; i++) {
        if (isupper((unsigned char)str[i])) {
            result[i] = tolower((unsigned char)str[i]);
        } else if (islower((unsigned char)str[i])) {
            result[i] = toupper((unsigned char)str[i]);
        } else {
            result[i] = str[i];
        }
    }
    result[len] = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Implements String.substring(_, _).
void stringSubstring(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Start")) return;
    if (!validateNumber(vm, 2, "End")) return;
    
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    int start = (int)wrenGetSlotDouble(vm, 1);
    int end = (int)wrenGetSlotDouble(vm, 2);
    
    // Handle negative indices
    if (start < 0) start = 0;
    if (end < 0) end = 0;
    if (start > len) start = len;
    if (end > len) end = len;
    
    // Swap if start > end
    if (start > end) {
        int temp = start;
        start = end;
        end = temp;
    }
    
    wrenSetSlotBytes(vm, 0, str + start, end - start);
}

// Implements String.slice(_, _).
void stringSlice(WrenVM* vm) {
    if (!validateNumber(vm, 1, "Start")) return;
    
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    int start = (int)wrenGetSlotDouble(vm, 1);
    int end = len;
    
    // Check if end parameter is provided
    if (wrenGetSlotCount(vm) > 2 && wrenGetSlotType(vm, 2) == WREN_TYPE_NUM) {
        end = (int)wrenGetSlotDouble(vm, 2);
    }
    
    // Handle negative indices
    if (start < 0) start = len + start;
    if (end < 0) end = len + end;
    
    // Clamp values
    if (start < 0) start = 0;
    if (end < 0) end = 0;
    if (start > len) start = len;
    if (end > len) end = len;
    
    if (start >= end) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    wrenSetSlotBytes(vm, 0, str + start, end - start);
}

// Implements String.toBytes().
void stringToBytes(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    
    wrenSetSlotNewList(vm, 0);
    
    for (int i = 0; i < len; i++) {
        wrenSetSlotDouble(vm, 1, (unsigned char)str[i]);
        wrenInsertInList(vm, 0, -1, 1);
    }
}

// Implements String.fromCharCode(_).
void stringFromCharCode(WrenVM* vm) {
    if (!validateNumber(vm, 1, "CharCode")) return;
    
    int code = (int)wrenGetSlotDouble(vm, 1);
    
    if (code < 0 || code > 255) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    char result[2] = { (char)code, '\0' };
    wrenSetSlotString(vm, 0, result);
}

// Implements String.length().
void stringLength(WrenVM* vm) {
    int len;
    const char* str = wrenGetSlotBytes(vm, 0, &len);
    wrenSetSlotDouble(vm, 0, (double)len);
}

// Static method: String.join(_, _).
void stringJoin(WrenVM* vm) {
    // First argument should be a list
    if (wrenGetSlotType(vm, 1) != WREN_TYPE_LIST) {
        wrenSetSlotString(vm, 0, "First argument must be a list.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    if (!validateString(vm, 2, "Separator")) return;
    
    int sepLen;
    const char* separator = wrenGetSlotBytes(vm, 2, &sepLen);
    
    int count = wrenGetListCount(vm, 1);
    if (count == 0) {
        wrenSetSlotString(vm, 0, "");
        return;
    }
    
    // Calculate total length needed
    size_t totalLen = 0;
    for (int i = 0; i < count; i++) {
        wrenGetListElement(vm, 1, i, 0);
        if (wrenGetSlotType(vm, 0) == WREN_TYPE_STRING) {
            int itemLen;
            wrenGetSlotBytes(vm, 0, &itemLen);
            totalLen += itemLen;
        }
    }
    totalLen += (count - 1) * sepLen;
    
    char* result = (char*)malloc(totalLen + 1);
    if (!result) {
        wrenSetSlotString(vm, 0, "Memory allocation failed.");
        wrenAbortFiber(vm, 0);
        return;
    }
    
    char* p = result;
    for (int i = 0; i < count; i++) {
        wrenGetListElement(vm, 1, i, 0);
        if (wrenGetSlotType(vm, 0) == WREN_TYPE_STRING) {
            int itemLen;
            const char* item = wrenGetSlotBytes(vm, 0, &itemLen);
            memcpy(p, item, itemLen);
            p += itemLen;
            
            if (i < count - 1) {
                memcpy(p, separator, sepLen);
                p += sepLen;
            }
        }
    }
    *p = '\0';
    
    wrenSetSlotString(vm, 0, result);
    free(result);
}

// Binds the foreign methods for the String class.
WrenForeignMethodFn bindStringForeignMethod(WrenVM* vm, const char* module, const char* className, bool isStatic, const char* signature) {
    if (strcmp(module, "main") != 0 && strcmp(module, "core") != 0) return NULL;
    if (strcmp(className, "String") != 0) return NULL;
    
    // Instance methods
    if (!isStatic) {
        if (strcmp(signature, "endsWith(_)") == 0) return stringEndsWith;
        if (strcmp(signature, "startsWith(_)") == 0) return stringStartsWith;
        if (strcmp(signature, "replace(_,_)") == 0) return stringReplace;
        if (strcmp(signature, "split(_)") == 0) return stringSplit;
        if (strcmp(signature, "toUpper()") == 0) return stringToUpper;
        if (strcmp(signature, "toLower()") == 0) return stringToLower;
        if (strcmp(signature, "trim()") == 0) return stringTrim;
        if (strcmp(signature, "trimStart()") == 0) return stringTrimStart;
        if (strcmp(signature, "trimEnd()") == 0) return stringTrimEnd;
        if (strcmp(signature, "count(_)") == 0) return stringCount;
        if (strcmp(signature, "indexOf(_)") == 0) return stringIndexOf;
        if (strcmp(signature, "lastIndexOf(_)") == 0) return stringLastIndexOf;
        if (strcmp(signature, "contains(_)") == 0) return stringContains;
        if (strcmp(signature, "toInt()") == 0) return stringToInt;
        if (strcmp(signature, "toNum()") == 0) return stringToNum;
        if (strcmp(signature, "reverse()") == 0) return stringReverse;
        if (strcmp(signature, "repeat(_)") == 0) return stringRepeat;
        if (strcmp(signature, "padStart(_,_)") == 0) return stringPadStart;
        if (strcmp(signature, "padEnd(_,_)") == 0) return stringPadEnd;
        if (strcmp(signature, "charAt(_)") == 0) return stringCharAt;
        if (strcmp(signature, "charCodeAt(_)") == 0) return stringCharCodeAt;
        if (strcmp(signature, "isNumeric()") == 0) return stringIsNumeric;
        if (strcmp(signature, "isAlpha()") == 0) return stringIsAlpha;
        if (strcmp(signature, "isAlphaNumeric()") == 0) return stringIsAlphaNumeric;
        if (strcmp(signature, "isEmpty()") == 0) return stringIsEmpty;
        if (strcmp(signature, "isWhitespace()") == 0) return stringIsWhitespace;
        if (strcmp(signature, "capitalize()") == 0) return stringCapitalize;
        if (strcmp(signature, "toCamelCase()") == 0) return stringToCamelCase;
        if (strcmp(signature, "toSnakeCase()") == 0) return stringToSnakeCase;
        if (strcmp(signature, "toKebabCase()") == 0) return stringToKebabCase;
        if (strcmp(signature, "toPascalCase()") == 0) return stringToPascalCase;
        if (strcmp(signature, "swapCase()") == 0) return stringSwapCase;
        if (strcmp(signature, "substring(_,_)") == 0) return stringSubstring;
        if (strcmp(signature, "slice(_,_)") == 0) return stringSlice;
        if (strcmp(signature, "slice(_)") == 0) return stringSlice;
        if (strcmp(signature, "toBytes()") == 0) return stringToBytes;
        if (strcmp(signature, "length()") == 0) return stringLength; // Added length method
    }
    
    // Static methods
    if (isStatic) {
        if (strcmp(signature, "join(_,_)") == 0) return stringJoin;
        if (strcmp(signature, "fromCharCode(_)") == 0) return stringFromCharCode;
    }
    
    return NULL;
}