/*
 * 字符串操作测试文件
 * 用于测试LLM生成的字符串处理和缓冲区安全验证规范
 */

#include <stddef.h>
#include <string.h>
#include <stdbool.h>

// 计算字符串长度
size_t string_length(const char *str) {
    if (str == NULL) {
        return 0;
    }

    size_t len = 0;
    while (str[len] != '\\0') {
        len++;
    }
    return len;
}

// 安全的字符串拷贝
size_t safe_string_copy(char *dest, const char *src, size_t dest_size) {
    if (dest == NULL || src == NULL || dest_size == 0) {
        return 0;
    }

    size_t i;
    for (i = 0; i < dest_size - 1 && src[i] != '\\0'; i++) {
        dest[i] = src[i];
    }
    dest[i] = '\\0'; // 确保字符串正确终止

    return i;
}

// 字符串连接函数
size_t string_concat(char *dest, const char *src, size_t dest_size) {
    if (dest == NULL || src == NULL || dest_size == 0) {
        return 0;
    }

    // 找到目标字符串的结尾
    size_t dest_len = 0;
    while (dest_len < dest_size && dest[dest_len] != '\\0') {
        dest_len++;
    }

    if (dest_len >= dest_size) {
        return 0; // 目标字符串未正确终止
    }

    // 计算可用空间
    size_t available = dest_size - dest_len - 1; // 为终止符留出空间
    size_t copied = 0;

    while (copied < available && src[copied] != '\\0') {
        dest[dest_len + copied] = src[copied];
        copied++;
    }

    dest[dest_len + copied] = '\\0';
    return dest_len + copied;
}

// 字符串比较函数
int string_compare(const char *str1, const char *str2) {
    if (str1 == NULL || str2 == NULL) {
        return -1; // 错误值
    }

    while (*str1 != '\\0' && *str2 != '\\0') {
        if (*str1 != *str2) {
            return *str1 - *str2;
        }
        str1++;
        str2++;
    }

    return *str1 - *str2;
}

// 查找字符在字符串中的位置
char* find_char(const char *str, char c) {
    if (str == NULL) {
        return NULL;
    }

    while (*str != '\\0') {
        if (*str == c) {
            return (char*)str;
        }
        str++;
    }

    return NULL;
}

// 字符串反转函数
void string_reverse(char *str) {
    if (str == NULL) {
        return;
    }

    size_t len = 0;
    while (str[len] != '\\0') {
        len++;
    }

    if (len <= 1) {
        return;
    }

    char *start = str;
    char *end = str + len - 1;

    while (start < end) {
        char temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

// 字符串转整数函数
int string_to_int(const char *str) {
    if (str == NULL) {
        return 0;
    }

    // 跳过空白字符
    while (*str == ' ' || *str == '\\t' || *str == '\\n') {
        str++;
    }

    // 处理符号
    int sign = 1;
    if (*str == '-') {
        sign = -1;
        str++;
    } else if (*str == '+') {
        str++;
    }

    // 转换数字
    int result = 0;
    while (*str >= '0' && *str <= '9') {
        result = result * 10 + (*str - '0');
        str++;
    }

    return sign * result;
}

// 检查字符串是否为数字
bool is_numeric(const char *str) {
    if (str == NULL || *str == '\\0') {
        return false;
    }

    // 跳过符号
    if (*str == '+' || *str == '-') {
        str++;
    }

    // 检查至少有一个数字
    if (*str == '\\0') {
        return false;
    }

    while (*str != '\\0') {
        if (*str < '0' || *str > '9') {
            return false;
        }
        str++;
    }

    return true;
}

// 字符串分割函数
int split_string(const char *str, char delimiter, char **tokens, int max_tokens) {
    if (str == NULL || tokens == NULL || max_tokens <= 0) {
        return 0;
    }

    int token_count = 0;
    const char *start = str;
    const char *end = str;

    while (*end != '\\0' && token_count < max_tokens) {
        if (*end == delimiter) {
            size_t length = end - start;
            if (length > 0) {
                // 分配内存并复制token
                char *token = (char*)malloc(length + 1);
                if (token != NULL) {
                    for (size_t i = 0; i < length; i++) {
                        token[i] = start[i];
                    }
                    token[length] = '\\0';
                    tokens[token_count] = token;
                    token_count++;
                }
            }
            start = end + 1;
        }
        end++;
    }

    // 处理最后一个token
    if (token_count < max_tokens && end > start) {
        size_t length = end - start;
        char *token = (char*)malloc(length + 1);
        if (token != NULL) {
            for (size_t i = 0; i < length; i++) {
                token[i] = start[i];
            }
            token[length] = '\\0';
            tokens[token_count] = token;
            token_count++;
        }
    }

    return token_count;
}

// 字符串修剪函数（去除首尾空白字符）
void trim_string(char *str) {
    if (str == NULL) {
        return;
    }

    // 找到第一个非空白字符
    char *start = str;
    while (*start == ' ' || *start == '\\t' || *start == '\\n' || *start == '\\r') {
        start++;
    }

    // 如果全是空白字符，直接返回
    if (*start == '\\0') {
        *str = '\\0';
        return;
    }

    // 找到最后一个非空白字符
    char *end = str + string_length(str) - 1;
    while (end > start && (*end == ' ' || *end == '\\t' || *end == '\\n' || *end == '\\r')) {
        end--;
    }

    // 移动字符串
    size_t length = end - start + 1;
    if (start != str) {
        for (size_t i = 0; i < length; i++) {
            str[i] = start[i];
        }
    }
    str[length] = '\\0';
}

// 字符串替换函数
int replace_char(char *str, char old_char, char new_char) {
    if (str == NULL) {
        return 0;
    }

    int replacements = 0;
    while (*str != '\\0') {
        if (*str == old_char) {
            *str = new_char;
            replacements++;
        }
        str++;
    }

    return replacements;
}