/*
 * axl_string_tests.c — Unit tests for axl_string.h
 */

#include "axl_string.h"
#include "axl_koan.h"
#include "axl_memory.h"

KOAN(strlen_empty)
{
    i8* s = (i8*)"";
    ASSERT_UINT_EQ(0, axl_strlen(s));
}

KOAN(strlen_simple)
{
    i8* s = (i8*)"hello";
    ASSERT_UINT_EQ(5, axl_strlen(s));
}

KOAN(strlen_with_special_chars)
{
    i8* s = (i8*)"hello\n\tworld";
    ASSERT_UINT_EQ(12, axl_strlen(s));
}

KOAN(strlen_null)
{
    ASSERT_UINT_EQ(0, axl_strlen(NULL));
}

KOAN(strcpy_basic)
{
    i8* src = (i8*)"test";
    i8* dst = (i8*)axl_malloc(10);
    ASSERT_NOT_NULL(dst);
    
    i8* result = axl_strcpy(dst, src);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("test", dst);
    
    axl_free(dst);
}

KOAN(strcpy_empty)
{
    i8* src = (i8*)"";
    i8* dst = (i8*)axl_malloc(10);
    ASSERT_NOT_NULL(dst);
    axl_memset(dst, 0xFF, 10);
    
    i8* result = axl_strcpy(dst, src);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("", dst);
    
    axl_free(dst);
}

KOAN(strcpy_null_dst)
{
    i8 buf[10];
    ASSERT_PTR_EQ(buf, axl_strcpy(buf, NULL));
}

KOAN(strcpy_null_src)
{
    ASSERT_NULL(axl_strcpy(NULL, "test"));
}

KOAN(strncpy_exact)
{
    i8* src = (i8*)"hello";
    i8* dst = (i8*)axl_malloc(10);
    ASSERT_NOT_NULL(dst);
    
    i8* result = axl_strncpy(dst, src, 5);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_TRUE(memcmp(dst, "hello", 5) == 0);
    
    axl_free(dst);
}

KOAN(strncpy_truncates)
{
    i8* src = (i8*)"hello world";
    i8* dst = (i8*)axl_malloc(10);
    ASSERT_NOT_NULL(dst);
    
    i8* result = axl_strncpy(dst, src, 5);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_TRUE(memcmp(dst, "hello", 5) == 0);
    
    axl_free(dst);
}

KOAN(strncpy_pads_with_nulls)
{
    i8* src = (i8*)"hi";
    i8* dst = (i8*)axl_malloc(10);
    ASSERT_NOT_NULL(dst);
    axl_memset(dst, 0xFF, 10);
    
    i8* result = axl_strncpy(dst, src, 5);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_TRUE(memcmp(dst, "hi\0\0\0", 5) == 0);
    
    axl_free(dst);
}

KOAN(strncpy_zero_n)
{
    i8 dst[10] = {'w'};
    axl_strncpy(dst, (const i8*)"test", 0);
    ASSERT_INT_EQ('w', dst[0]);
}

KOAN(strncpy_embedded_null)
{
    i8* dst = (i8*)axl_malloc(10);
    i8* src = (i8*)"ab\0cde";
    axl_strncpy(dst, src, 5);
    ASSERT_TRUE(memcmp(dst, "ab\0\0\0", 5) == 0);
    axl_free(dst);
}

KOAN(strcat_basic)
{
    i8* dst = (i8*)axl_malloc(20);
    ASSERT_NOT_NULL(dst);
    axl_strcpy(dst, (i8*)"hello ");
    
    i8* result = axl_strcat(dst, (i8*)"world");
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("hello world", dst);
    
    axl_free(dst);
}

KOAN(strcat_to_empty)
{
    i8* dst = (i8*)axl_malloc(20);
    ASSERT_NOT_NULL(dst);
    axl_strcpy(dst, (i8*)"");
    
    i8* result = axl_strcat(dst, (i8*)"test");
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("test", dst);
    
    axl_free(dst);
}

KOAN(strncat_full)
{
    i8* dst = (i8*)axl_malloc(20);
    ASSERT_NOT_NULL(dst);
    axl_strcpy(dst, (i8*)"hello ");
    
    i8* result = axl_strncat(dst, (i8*)"world", 5);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("hello world", dst);
    
    axl_free(dst);
}

KOAN(strncat_partial)
{
    i8* dst = (i8*)axl_malloc(20);
    ASSERT_NOT_NULL(dst);
    axl_strcpy(dst, (i8*)"hello ");
    
    i8* result = axl_strncat(dst, (i8*)"worldwide", 5);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("hello world", dst);
    
    axl_free(dst);
}

KOAN(strncat_always_null_terminates)
{
    i8* dst = (i8*)axl_malloc(20);
    ASSERT_NOT_NULL(dst);
    axl_strcpy(dst, (i8*)"test");
    
    i8* result = axl_strncat(dst, (i8*)"123456789", 3);
    ASSERT_PTR_EQ(dst, result);
    ASSERT_STR_EQ("test123", dst);
    ASSERT_INT_EQ(0, (int)dst[7]);
    
    axl_free(dst);
}

KOAN(strncat_zero_n)
{
    i8 dst[10] = "hi";
    axl_strncat(dst, (const i8*)"world", 0);
    ASSERT_STR_EQ("hi", dst);
}

KOAN(strcmp_equal)
{
    i8* s1 = (i8*)"hello";
    i8* s2 = (i8*)"hello";
    ASSERT_INT_EQ(0, axl_strcmp(s1, s2));
}

KOAN(strcmp_less)
{
    i8* s1 = (i8*)"abc";
    i8* s2 = (i8*)"def";
    ASSERT_TRUE(axl_strcmp(s1, s2) < 0);
}

KOAN(strcmp_greater)
{
    i8* s1 = (i8*)"xyz";
    i8* s2 = (i8*)"abc";
    ASSERT_TRUE(axl_strcmp(s1, s2) > 0);
}

KOAN(strcmp_prefix)
{
    i8* s1 = (i8*)"test";
    i8* s2 = (i8*)"testing";
    ASSERT_TRUE(axl_strcmp(s1, s2) < 0);
}

KOAN(strcmp_both_empty)
{
    i8* s1 = (i8*)"";
    i8* s2 = (i8*)"";
    ASSERT_INT_EQ(0, axl_strcmp(s1, s2));
}

KOAN(strcmp_first_empty)
{
    i8* s1 = (i8*)"";
    i8* s2 = (i8*)"hello";
    ASSERT_TRUE(axl_strcmp(s1, s2) < 0);
}

KOAN(strncmp_equal_shorter_n)
{
    i8* s1 = (i8*)"hello";
    i8* s2 = (i8*)"help!";
    ASSERT_INT_EQ(0, axl_strncmp(s1, s2, 3));
}

KOAN(strncmp_equal_longer_n)
{
    i8* s1 = (i8*)"test";
    i8* s2 = (i8*)"test";
    ASSERT_INT_EQ(0, axl_strncmp(s1, s2, 10));
}

KOAN(strncmp_differs_at_n)
{
    i8* s1 = (i8*)"hello";
    i8* s2 = (i8*)"helma";
    ASSERT_TRUE(axl_strncmp(s1, s2, 5) < 0);
}

KOAN(strncmp_zero_n)
{
    i8* s1 = (i8*)"hello";
    i8* s2 = (i8*)"world";
    ASSERT_INT_EQ(0, axl_strncmp(s1, s2, 0));
}

KOAN(strncmp_null_ptrs)
{
    ASSERT_INT_EQ(0, axl_strncmp(NULL, NULL, 5));
    ASSERT_TRUE(axl_strncmp(NULL, (i8*)"test", 5) < 0);
    ASSERT_TRUE(axl_strncmp((i8*)"test", NULL, 5) > 0);
}

KOAN(strchr_null)
{
    ASSERT_NULL(axl_strchr(NULL, 'a'));
}

KOAN(strchr_empty)
{
    i8 str[] = "";
    ASSERT_NULL(axl_strchr(str, 'a'));
}

KOAN(strchr_not_found)
{
    i8 str[] = "hello";
    ASSERT_NULL(axl_strchr(str, 'x'));
}

KOAN(strchr_first_char)
{
    i8 str[] = "hello";
    ASSERT_PTR_EQ(str, axl_strchr(str, 'h'));
}

KOAN(strchr_last_char)
{
    i8 str[] = "hello";
    ASSERT_PTR_EQ(str + 4, axl_strchr(str, 'o'));
}

KOAN(strchr_null_terminator)
{
    i8 str[] = "hello";
    ASSERT_PTR_EQ(str + 5, axl_strchr(str, '\0'));
}

KOAN(strchr_returns_proper_ptr)
{
    i8 str[] = "hi Mark";
    ASSERT_PTR_EQ(str + 0, axl_strchr(str, 'h'));
    ASSERT_PTR_EQ(str + 1, axl_strchr(str, 'i'));
    ASSERT_PTR_EQ(str + 2, axl_strchr(str, ' '));
    ASSERT_PTR_EQ(str + 3, axl_strchr(str, 'M'));
    ASSERT_PTR_EQ(str + 4, axl_strchr(str, 'a'));
    ASSERT_PTR_EQ(str + 5, axl_strchr(str, 'r'));
    ASSERT_PTR_EQ(str + 6, axl_strchr(str, 'k'));
    ASSERT_NULL(axl_strchr(str, 'm'));
    ASSERT_PTR_EQ(str + 7, axl_strchr(str, '\0'));
}

KOAN(strstr_null_pointer)
{
    ASSERT_NULL(axl_strstr(NULL, "test"));
    ASSERT_NULL(axl_strstr("test", NULL));
    ASSERT_NULL(axl_strstr(NULL, NULL));
}

KOAN(strstr_empty_string)
{
    i8 str[] = "";
    ASSERT_NULL(axl_strstr(str, "test"));
    ASSERT_PTR_EQ(str, axl_strstr(str, ""));
}

KOAN(strstr_empty_substring)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str, axl_strstr(str, ""));
}

KOAN(strstr_exact_match)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str, axl_strstr(str, "hello world"));
}

KOAN(strstr_prefix_match)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str, axl_strstr(str, "hello"));
}

KOAN(strstr_suffix_match)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str + 6, axl_strstr(str, "world"));
}

KOAN(strstr_middle_match)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str + 2, axl_strstr(str, "llo"));
}

KOAN(strstr_single_char_match)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str + 4, axl_strstr(str, "o"));
}

KOAN(strstr_multiple_occurrences)
{
    i8 str[] = "hello world";
    ASSERT_PTR_EQ(str + 4, axl_strstr(str, "o"));
}

KOAN(strstr_not_found)
{
    i8 str[] = "hello world";
    ASSERT_NULL(axl_strstr(str, "xyz"));
    ASSERT_NULL(axl_strstr(str, "hello!"));
    ASSERT_NULL(axl_strstr(str, "world!"));
}

KOAN(strstr_partial_match_but_not_full)
{
    i8 str[] = "hello world";
    ASSERT_NULL(axl_strstr(str, "helloo"));
    ASSERT_NULL(axl_strstr(str, "worldd"));
}

KOAN(strstr_case_sensitive)
{
    i8 str[] = "Hello World";
    ASSERT_NULL(axl_strstr(str, "hello"));
    ASSERT_NULL(axl_strstr(str, "world"));
    ASSERT_PTR_EQ(str, axl_strstr(str, "Hello"));
    ASSERT_PTR_EQ(str + 6, axl_strstr(str, "World"));
}

KOAN(strstr_with_null_bytes)
{
    i8 str[] = "ab\0cde";
    ASSERT_PTR_EQ(str, axl_strstr(str, "ab"));
    ASSERT_NULL(axl_strstr(str, "cde"));
}

KOAN(strstr_longer_substring_than_string)
{
    i8 str[] = "short";
    ASSERT_NULL(axl_strstr(str, "longer string"));
}

KOAN(strstr_repeated_pattern)
{
    i8 str[] = "ababab";
    ASSERT_PTR_EQ(str, axl_strstr(str, "ab"));
    ASSERT_PTR_EQ(str + 1, axl_strstr(str, "baba"));
}

KOAN(strstr_overlapping_match)
{
    i8 str[] = "aaaaa";
    ASSERT_PTR_EQ(str, axl_strstr(str, "aa"));
    ASSERT_PTR_EQ(str, axl_strstr(str, "aaa"));
    ASSERT_PTR_EQ(str, axl_strstr(str, "aaaa"));
    ASSERT_PTR_EQ(str, axl_strstr(str, "aaaaa"));
}

KOAN(strstr_special_chars)
{
    i8 str[] = "hello\tworld\n";
    ASSERT_PTR_EQ(str, axl_strstr(str, "hello"));
    ASSERT_PTR_EQ(str + 6, axl_strstr(str, "world"));
    ASSERT_PTR_EQ(str + 5, axl_strstr(str, "\t"));
    ASSERT_PTR_EQ(str + 11, axl_strstr(str, "\n"));
}

KOAN(strrev_null)
{
    ASSERT_NULL(axl_strrev(NULL));
}

KOAN(strrev_empty)
{
    i8 str[] = "";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("", str);
}

KOAN(strrev_single_char)
{
    i8 str[] = "a";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("a", str);
}

KOAN(strrev_two_chars)
{
    i8 str[] = "ab";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("ba", str);
}

KOAN(strrev_odd_length)
{
    i8 str[] = "hello";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("olleh", str);
}

KOAN(strrev_even_length)
{
    i8 str[] = "world";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("dlrow", str);
}

KOAN(strrev_palindrome)
{
    i8 str[] = "racecar";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("racecar", str);
}

KOAN(strrev_with_spaces)
{
    i8 str[] = "hello world";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("dlrow olleh", str);
}

KOAN(strrev_with_special_chars)
{
    i8 str[] = "a\nb\tc";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("c\tb\na", str);
}

KOAN(strrev_numbers)
{
    i8 str[] = "123456789";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("987654321", str);
}

KOAN(strrev_mixed)
{
    i8 str[] = "a1b2c3";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("3c2b1a", str);
}

KOAN(strrev_long_string)
{
    i8 str[] = "abcdefghijklmnopqrstuvwxyz";
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(str, result);
    ASSERT_STR_EQ("zyxwvutsrqponmlkjihgfedcba", str);
}

KOAN(strrev_in_place)
{
    i8 str[] = "test";
    i8* original_ptr = str;
    i8* result = axl_strrev(str);
    ASSERT_PTR_EQ(original_ptr, result);
    ASSERT_STR_EQ("tset", str);
    
    // Reverse again to get back original
    result = axl_strrev(str);
    ASSERT_PTR_EQ(original_ptr, result);
    ASSERT_STR_EQ("test", str);
}

KOAN(utoa_decimal_zero)
{
    i8 buffer[32];
    i8* result = axl_utoa(0, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("0", buffer);
}

KOAN(utoa_decimal_small)
{
    i8 buffer[32];
    i8* result = axl_utoa(42, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("42", buffer);
}

KOAN(utoa_decimal_large)
{
    i8 buffer[32];
    i8* result = axl_utoa(4294967295U, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("4294967295", buffer);
}

KOAN(utoa_binary)
{
    i8 buffer[32];
    i8* result = axl_utoa(10, buffer, 2);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("1010", buffer);
}

KOAN(utoa_octal)
{
    i8 buffer[32];
    i8* result = axl_utoa(255, buffer, 8);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("377", buffer);
}

KOAN(utoa_hexadecimal_lowercase)
{
    i8 buffer[32];
    i8* result = axl_utoa(0xDEADBEEF, buffer, 16);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("DEADBEEF", buffer);
}

KOAN(utoa_hexadecimal_uppercase)
{
    i8 buffer[32];
    i8* result = axl_utoa(0xCAFEBABE, buffer, 16);
    ASSERT_PTR_EQ(buffer, result);
    // Note: implementation should produce lowercase by default
    // If uppercase is needed, we'd need a separate function
    ASSERT_STR_EQ("CAFEBABE", buffer);
}

KOAN(utoa_base_36)
{
    i8 buffer[32];
    i8* result = axl_utoa(123456789, buffer, 36);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("21I3V9", buffer);
}

KOAN(utoa_max_base)
{
    i8 buffer[32];
    i8* result = axl_utoa(35, buffer, 36);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("Z", buffer);
}

KOAN(itoa_positive)
{
    i8 buffer[32];
    i8* result = axl_itoa(12345, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("12345", buffer);
}

KOAN(itoa_negative)
{
    i8 buffer[32];
    i8* result = axl_itoa(-12345, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("-12345", buffer);
}

KOAN(itoa_zero)
{
    i8 buffer[32];
    i8* result = axl_itoa(0, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("0", buffer);
}

KOAN(itoa_min_int)
{
    i8 buffer[32];
    i8* result = axl_itoa(-9223372036854775807LL - 1, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("-9223372036854775808", buffer);
}

KOAN(itoa_max_int)
{
    i8 buffer[32];
    i8* result = axl_itoa(9223372036854775807LL, buffer, 10);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("9223372036854775807", buffer);
}

KOAN(itoa_negative_binary)
{
    i8 buffer[32];
    i8* result = axl_itoa(-10, buffer, 2);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("-1010", buffer);
}

KOAN(itoa_negative_hex)
{
    i8 buffer[32];
    i8* result = axl_itoa(-0xDEAD, buffer, 16);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("-DEAD", buffer);
}

KOAN(itoa_positive_octal)
{
    i8 buffer[32];
    i8* result = axl_itoa(511, buffer, 8);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("777", buffer);
}

KOAN(itoa_negative_octal)
{
    i8 buffer[32];
    i8* result = axl_itoa(-511, buffer, 8);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("-777", buffer);
}

KOAN(itoa_base_36_positive)
{
    i8 buffer[32];
    i8* result = axl_itoa(123456789, buffer, 36);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("21I3V9", buffer);
}

KOAN(itoa_base_36_negative)
{
    i8 buffer[32];
    i8* result = axl_itoa(-123456789, buffer, 36);
    ASSERT_PTR_EQ(buffer, result);
    ASSERT_STR_EQ("-21I3V9", buffer);
}

KOAN(utoa_buffer_reuse)
{
    i8 buffer[32];
    i8* result1 = axl_utoa(123, buffer, 10);
    ASSERT_PTR_EQ(buffer, result1);
    ASSERT_STR_EQ("123", buffer);
    
    i8* result2 = axl_utoa(456, buffer, 10);
    ASSERT_PTR_EQ(buffer, result2);
    ASSERT_STR_EQ("456", buffer);
}

KOAN(itoa_buffer_reuse)
{
    i8 buffer[32];
    i8* result1 = axl_itoa(-123, buffer, 10);
    ASSERT_PTR_EQ(buffer, result1);
    ASSERT_STR_EQ("-123", buffer);
    
    i8* result2 = axl_itoa(456, buffer, 10);
    ASSERT_PTR_EQ(buffer, result2);
    ASSERT_STR_EQ("456", buffer);
}

KOAN(utoa_edge_cases)
{
    i8 buffer[32];
    
    // Test with base 2 (binary)
    i8* result1 = axl_utoa(42, buffer, 2);
    ASSERT_PTR_EQ(buffer, result1);
    ASSERT_STR_EQ("101010", buffer);
    
    // Test with base 8 (octal)
    i8* result2 = axl_utoa(777, buffer, 8);
    ASSERT_PTR_EQ(buffer, result2);
    ASSERT_STR_EQ("1411", buffer);
    
    // Test with base 16 (hex)
    i8* result3 = axl_utoa(0xABCD, buffer, 16);
    ASSERT_PTR_EQ(buffer, result3);
    ASSERT_STR_EQ("ABCD", buffer);
}

KOAN(itoa_edge_cases)
{
    i8 buffer[32];
    
    // Test positive to negative transition
    i8* result1 = axl_itoa(1, buffer, 10);
    ASSERT_PTR_EQ(buffer, result1);
    ASSERT_STR_EQ("1", buffer);
    
    i8* result2 = axl_itoa(-1, buffer, 10);
    ASSERT_PTR_EQ(buffer, result2);
    ASSERT_STR_EQ("-1", buffer);
    
    // Test zero stays zero
    i8* result3 = axl_itoa(0, buffer, 10);
    ASSERT_PTR_EQ(buffer, result3);
    ASSERT_STR_EQ("0", buffer);
}

int main(void)
{
    axl_init();
    return koan_run_all();
}