#include "axl_string.h"

u32 axl_strlen(const i8* s)
{
    if(s == NULL)
    {
        return 0;
    }

    u32 len = 0;

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

    return len;
}

i8* axl_strcpy(i8* dst, const i8* src)
{
    if(dst == NULL || src == NULL)
    {
        return dst;
    }

    i8* start = dst; 

    while((*(dst++) = *(src++)) != '\0');

    return start;
}

i8* axl_strncpy(i8* dst, const i8* src, u32 n)
{
    if(dst == NULL || src == NULL)
    {
        return dst;
    }

    u32 i = 0;

    for(; i < n && src[i] != '\0'; i++)
    {
        dst[i] = src[i];
    }

    for(; i < n; i++)
    {
        dst[i] = '\0';
    }

    return dst;
}

i8* axl_strcat(i8* dst, const i8* src)
{
    if(dst == NULL || src == NULL)
    {
        return dst;
    }

    axl_strcpy(dst + axl_strlen(dst), src);

    return dst;
}

i8* axl_strncat(i8* dst, const i8* src, u32 n) //n actually means "not more than"
{
    if(!dst || !src) 
    {
        return dst;
    }

    i8* p = dst + axl_strlen(dst);
    while (n-- && (*p++ = *src++)); //quick note: '\0' == 0

    *p = '\0';  //in case we copied exactly n without '\0'

    return dst;
}

i32 axl_strcmp(const i8* s1, const i8* s2)
{
    if(!s1 || !s2) 
    {
        return (s1 == s2) ? 0 : (!s1 ? -1 : 1);
    }

    for(;; s1++, s2++) 
    {
        u8 c1 = *(const u8*)s1;
        u8 c2 = *(const u8*)s2;

        if (c1 != c2 || c1 == '\0' || c2 == '\0') 
        {
            return c1 - c2;
        }
    }
    
    return 0;
}

i32 axl_strncmp(const i8* s1, const i8* s2, u32 n)
{
    if(!s1 || !s2) 
    {
        return (s1 == s2) ? 0 : (!s1 ? -1 : 1);
    }

    for(u32 i = 0; i < n; s1++, s2++, i++) 
    {
        u8 c1 = *(const u8*)s1;
        u8 c2 = *(const u8*)s2;

        if(c1 != c2 || c1 == '\0' || c2 == '\0') 
        {
            return c1 - c2;
        }
    }
    
    return 0;
}

const i8* axl_strchr(const i8* str, i8 c)
{
    if(!str) 
    {
        return NULL;
    }
    
    for(; *str != '\0'; ++str) 
    {
        if(*str == c) 
        {
            return str;
        }
    }
    
    return (c == '\0') ? str : NULL;
}

i8* axl_strstr(const i8* str, const i8* substr)
{
    if(!str || !substr)
    {
        return NULL;
    }

    if(*substr == '\0')
    {
        return (i8*)str;
    }

    u32 n = axl_strlen(substr);

    while(*str)
    {
        if(!axl_strncmp(str++, substr, n))
        {
            return (i8*)(str - 1);
        }
    }

    return NULL;
}

i8* axl_strrev(i8* str)
{
    if(!str)
    {
        return NULL;
    }

    i8* start = str;
    i8* end = str + axl_strlen(str) - 1;

    while(start < end)
    {
        i8 tmp = *start;
        *start = *end;
        *end = tmp;
        start++;
        end--;
    }
    
    return str;
}

/*static const char digits_lower[] = "0123456789abcdefghijklmnopqrstuvwxyz";*/
static const char digits_upper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

i8* axl_utoa(u64 val, i8* str, u8 base)
{
    if(!str)
    {
        return NULL;
    }

    if (base < 2 || base > 36) 
    {
        *str = '\0';
        return str;
    }

    i8* head = str;
    const i8* digits = digits_upper;


    if (val == 0) 
    {
        *head++ = '0';
        *head++ = '\0';
        return str;
    }

    while (val != 0) 
    {
        *head++ = digits[val % base];
        val /= base;
    }

    *head = '\0';

    return axl_strrev(str);
}

i8* axl_itoa(i64 val, i8* str, u8 base)
{
    if(!str)
    {
        return NULL;
    }

    if (base < 2 || base > 36) 
    {
        *str = '\0';
        return str;
    }

    i8* head = str;
    u64 uval = val < 0 ? (u64)(-(val)) : (u64)val;

    if (uval == 0) 
    {
        *head++ = '0';
        *head++ = '\0';
        return str;
    }

    while (uval != 0) 
    {
        *head++ = digits_upper[uval % base];
        uval   /= base;
    }

    if (val < 0) 
    {
        *head++ = '-';
        
    } 

    *head = '\0';

    return axl_strrev(str);
}