#include "arc/std/string.h"

#include "arc/std/errno.h"
#include <stdint.h>
#include <string.h>
#include <stdlib.h>

void ARC_String_Create(ARC_String **string, char *data, uint64_t length){
    *string           = (ARC_String *)malloc(sizeof(ARC_String));
    (*string)->data   = (char       *)malloc(length + 1);
    (*string)->length = length;

    strncpy((*string)->data, data, length);
    (*string)->data[length] = '\0';
}

void ARC_String_Destroy(ARC_String *string){
    free(string->data);
    free(string);
}

void ARC_String_Copy(ARC_String **copy, ARC_String *original){
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *copy = NULL;
        return;
    }

    ARC_String_Create(copy, original->data, original->length);
}

void ARC_String_CopySubstring(ARC_String **substring, ARC_String *original, uint64_t start, uint64_t length){
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *substring = NULL;
        return;
    }

    if(length == 0){
        *substring = NULL;
        return;
    }

    if(start + length > original->length){
        arc_errno = ARC_ERRNO_DATA;
        *substring = NULL;
        return;
    }

    char data[length];
    for(uint32_t i = 0; i < length; i++){
        data[i] = 0;
    }

    strncpy(data, original->data + start, length);

    ARC_String_Create(substring, data, length);
}

void ARC_String_RemoveSubstring(ARC_String **newString, ARC_String *original, ARC_String *substring){
    uint64_t index = ARC_String_Find(original, substring);
    if(arc_errno){
        newString = NULL;
        return;
    }

    ARC_String_RemoveSection(newString, original, index, original->length);
}

uint8_t ARC_String_Equals(ARC_String *first, ARC_String *second){
    if(first->length != second->length){
        return 0;
    }

    if(strncmp(first->data, second->data, first->length)){
        return 0;
    }

    return 1;
}

uint8_t ARC_String_EqualsCString(ARC_String *string, const char *cstring, uint64_t length){
    if(string->length != length){
        return 0;
    }

    if(strncmp(string->data, cstring, string->length)){
        return 0;
    }

    return 1;
}

uint8_t ARC_String_Alpha(ARC_String *string){
    for(uint64_t length = string->length; length; length--){
        if(string->data[length - 1] >= 'a' && string->data[length - 1] <= 'z'){
            continue;
        }

        if(string->data[length - 1] >= 'A' && string->data[length - 1] <= 'Z'){
            continue;
        }

        return 1;
    }

    return 0;
}

uint64_t ARC_String_ToUint64_t(ARC_String *string){
    char temp[string->length + 1];
    strncpy(temp, string->data, string->length);
    temp[string->length] = '\0';

    return (uint64_t) strtoul(temp, NULL, 10);
}

uint64_t ARC_String_Find(ARC_String *string, ARC_String *substring){
    if(!string || !substring){
        arc_errno = ARC_ERRNO_NULL;
        return ~(uint64_t)0;
    }

    if(substring->length > string->length){
        return ~(uint64_t)0;
    }

    uint64_t max = string->length - (substring->length - 1);
    for(uint64_t i = 0; max; i++, max--){
        if(!strncmp(string->data + i, substring->data, substring->length)){
            return i + 1;
        }
    }

    return ~(uint64_t)0;
}

uint64_t ARC_String_FindCString(ARC_String *string, const char *cstring, uint64_t length){
    if(!string || !cstring){
        arc_errno = ARC_ERRNO_NULL;
        return ~(uint64_t)0;
    }

    if(string->length < length){
        return ~(uint64_t)0;
    }

    uint64_t max = string->length - (length - 1);
    for(uint64_t i = 0; i < max; i++){
        if(!strncmp(string->data + i, cstring, length)){
            return i + 1;
        }
    }

    return ~(uint64_t)0;
}

uint64_t ARC_String_FindBack(ARC_String *string, ARC_String *substring){
    if(!string || !substring){
        arc_errno = ARC_ERRNO_NULL;
        return ~(uint64_t)0;
    }

    if(substring->length > string->length){
        return ~(uint64_t)0;
    }

    uint64_t max = string->length - (substring->length - 1);
    for(; max; max--){
        if(!strncmp(string->data + (max - 1), substring->data, substring->length)){
            return max;
        }
    }

    return ~(uint64_t)0;
}

void ARC_String_StripEnds(ARC_String *original, ARC_String **stripped, char charToStrip){
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *stripped = NULL;
        return;
    }

    if(!original->length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }

    uint64_t length = original->length - 1;
    for(; length; length--){
        if(strncmp(original->data + (length - 1), &charToStrip, 1)){
            break;
        }
    }

    if(!length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }

    uint64_t start = 0;
    for(; start <= length; start++){
        if(strncmp(original->data + start, &charToStrip, 1)){
            break;
        }
    }

    if(start == length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }

    length -= start;
    ARC_String_Create(stripped, original->data + start, length);
}

void ARC_String_StripWhitespace(ARC_String *original, ARC_String **stripped){
    if(!original){
        arc_errno = ARC_ERRNO_NULL;
        *stripped = NULL;
        return;
    }

    if(!original->length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }

    uint64_t length = 0;
    for(uint64_t i = 0; i < original->length; i++){
        if(original->data[i] == ' '){
            continue;
        }

        if(original->data[i] == '\n'){
            continue;
        }

        if(original->data[i] == '\t'){
            continue;
        }

        if(original->data[i] == '\r'){
            continue;
        }

        length++;
    }

    if(!length){
        arc_errno = ARC_ERRNO_DATA;
        *stripped = NULL;
        return;
    }

    length++;
    char data[length];
    for(uint32_t i = 0; i < length; i++){
        data[i] = 0;
    }

    uint64_t start = 0;
    for(uint64_t i = 0; i < length; i++){
        if(original->data[i] == ' '){
            continue;
        }

        if(original->data[i] == '\n'){
            continue;
        }

        if(original->data[i] == '\t'){
            continue;
        }

        if(original->data[i] == '\r'){
            continue;
        }

        data[start] = original->data[i];
        start++;
    }

    ARC_String_Create(stripped, data, length);
}


void ARC_String_StripEndsWhitespace(ARC_String *original, ARC_String **stripped){
    uint64_t index;
    for(uint64_t i = 0; i < original->length; i++){
        if(original->data[i] == ' '){
            continue;
        }

        if(original->data[i] == '\n'){
            continue;
        }

        if(original->data[i] == '\t'){
            continue;
        }

        if(original->data[i] == '\r'){
            continue;
        }

        index = i;
        break;
    }

    uint64_t endIndex;
    for(uint64_t i = original->length; i > 0; i--){
        if(original->data[i - 1] == ' '){
            continue;
        }

        if(original->data[i - 1] == '\n'){
            continue;
        }

        if(original->data[i - 1] == '\t'){
            continue;
        }

        if(original->data[i - 1] == '\r'){
            continue;
        }

        endIndex = i;
        break;
    }

    ARC_String_CopySubstring(stripped, original, index, endIndex - index);
}

void ARC_String_Merge(ARC_String *first, ARC_String *second, ARC_String **combined){
    char data[first->length + second->length];
    for(uint32_t i = 0; i < first->length; i++){
        data[i] = first->data[i];
    }

    for(uint32_t i = 0; i < second->length; i++){
        data[i + first->length] = second->data[i];
    }

    ARC_String_Create(combined, data, first->length + second->length);
}


void ARC_String_RemoveSection(ARC_String **newString, ARC_String *original, uint64_t removeIndex, uint64_t removeLength){
    if(removeIndex == 0 && removeIndex + removeLength >= original->length){
        ARC_String_Copy(newString, original);
        return;
    }

    if(removeIndex == 0){
        ARC_String_CopySubstring(newString, original, removeLength, original->length - removeLength);
        return;
    }

    if(removeIndex + removeLength >= original->length){
        ARC_String_CopySubstring(newString, original, 0, removeIndex);
        return;
    }

    ARC_String *first, *second;
    ARC_String_CopySubstring(&first , original, 0                         , removeIndex                                    );
    ARC_String_CopySubstring(&second, original, removeIndex + removeLength, original->length - (removeIndex + removeLength));

    ARC_String_Merge(first, second, newString);

    ARC_String_Destroy(first );
    ARC_String_Destroy(second);
}