#include "arc/std/string.h"
#ifdef ARC_DEFAULT_CONFIG

#include "arc/std/defaults/config.h"

#include "arc/std/array.h"
#include "arc/std/config.h"
#include "arc/std/errno.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void ARC_Defaults_ConfigKey_Create(ARC_Config *config){
    
    ARC_Config_AddKeyCString(config, "uint8_t" , 7, ARC_ConfigKey_Read_Uint8_t    , ARC_ConfigKey_Delete_Uint8_t    );
    // ARC_Config_AddKeyCString(config, "int8_t"  , ARC_ConfigKey_Read_Int8_t     , ARC_ConfigKey_Delete_Int8_t     );
    // ARC_Config_AddKeyCString(config, "char"    , ARC_ConfigKey_Read_Char       , ARC_ConfigKey_Delete_Char       );
    // ARC_Config_AddKeyCString(config, "uint16_t", ARC_ConfigKey_Read_Uint16_t   , ARC_ConfigKey_Delete_Uint16_t   );
    // ARC_Config_AddKeyCString(config, "int16_t" , ARC_ConfigKey_Read_Int16_t    , ARC_ConfigKey_Delete_Int16_t    );
    // ARC_Config_AddKeyCString(config, "uint32_t", ARC_ConfigKey_Read_Uint32_t   , ARC_ConfigKey_Delete_Uint32_t   );
    // ARC_Config_AddKeyCString(config, "int32_t" , ARC_ConfigKey_Read_Int32_t    , ARC_ConfigKey_Delete_Int32_t    );
    // ARC_Config_AddKeyCString(config, "int"     , ARC_ConfigKey_Read_Int        , ARC_ConfigKey_Delete_Int        );
    // ARC_Config_AddKeyCString(config, "uint64_t", ARC_ConfigKey_Read_Uint64_t   , ARC_ConfigKey_Delete_Uint64_t   );
    // ARC_Config_AddKeyCString(config, "int64_t" , ARC_ConfigKey_Read_Int64_t    , ARC_ConfigKey_Delete_Int64_t    );
    // ARC_Config_AddKeyCString(config, "long"    , ARC_ConfigKey_Read_Long       , ARC_ConfigKey_Delete_Long       );
    // ARC_Config_AddKeyCString(config, "string"  , ARC_ConfigKey_Read_String     , ARC_ConfigKey_Delete_String     );
    // ARC_Config_AddKeyCString(config, "string[]", ARC_ConfigKey_Read_StringArray, ARC_ConfigKey_Delete_StringArray);
}

uint8_t ARC_ConfigKey_Read_Uint8_t(ARC_Config* config, ARC_String *string, void **value){
    ARC_String *current;
    ARC_String_StripEndsWhitespace(string, &current);

    ARC_Config_Get(config, current, value);
    if(*value){
        ARC_String_Destroy(current);
        return 1;
    }

    *value = (uint8_t *) malloc(sizeof(uint8_t));
    *((uint8_t *)(*value)) = (uint8_t) ARC_String_ToUint64_t(current);
    ARC_String_Destroy(current);
    return 0;
}

/*

void ARC_ConfigKey_Read_Int8_t(ARC_Config* config, ARC_String *string, void **value){
    *value = (int8_t *) malloc(sizeof(int8_t));
    *((int8_t *)(*value)) = (int8_t) ARC_String_ToUint64_t(string);
}

void ARC_ConfigKey_Read_Char(ARC_Config* config, ARC_String *string, void **value){
    *value = (char *) malloc(sizeof(char));
    *((char *)(* value)) = (char) *(data + subdata->index);
}

void ARC_ConfigKey_Read_Uint16_t(ARC_Config* config, ARC_String *string, void **value){
    *value = (uint16_t *) malloc(sizeof(uint16_t));
    *((uint16_t *)(*value)) = (uint16_t) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Int16_t(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (int16_t *) malloc(sizeof(int16_t));
    *((int16_t *)(*value)) = (int16_t) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Uint32_t(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (uint32_t *) malloc(sizeof(uint32_t));
    *((uint32_t *)(*value)) = (uint32_t) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Int32_t(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (int32_t *) malloc(sizeof(int32_t));
    *((int32_t *)(*value)) = (int32_t) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Int(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (int *) malloc(sizeof(int));
    *((int *)(*value)) = (int) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Uint64_t(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (uint64_t *) malloc(sizeof(uint64_t));
    *((uint64_t *)(*value)) = ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Int64_t(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (int64_t *) malloc(sizeof(int64_t));
    *((int64_t *)(*value)) = (int64_t) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_Long(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    *value = (long *) malloc(sizeof(long));
    *((long *)(*value)) = (long) ARC_String_ToUint64_t(data, subdata);
}

void ARC_ConfigKey_Read_String(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    ARC_StringSubstr_StripWhitespaceEnds((char *)data, subdata);
    if(data[subdata->index] != '"' || data[subdata->index + subdata->length - 1] != '"'){
        arc_errno = ARC_ERRNO_DATA;
        return;
    }
    ARC_StringSubstr_StripEnds((char *)data, (char *)"\"", subdata);
    *value = (char *) malloc(sizeof(char) * (subdata->length + 1));
    strncpy((char *)(*value), data + subdata->index, subdata->length);
    ((char *)(*value))[subdata->length] = '\0';
}

void ARC_ConfigKey_Read_StringArray(ARC_Config* config, const char *data, ARC_StringSubstr *subdata, void **value){
    ARC_StringSubstr_StripWhitespaceEnds((char *)data, subdata);
    if(data[subdata->index] != '{' || data[subdata->index + subdata->length - 1] != '}'){ return ARC_ERRNO_DATA; }
    subdata->index++;
    subdata->length -= 2;

    uint32_t arraySize = 1;
    for(uint32_t i = subdata->index; i < subdata->index + subdata->length; i++){
        if(data[i] == ','){
            arraySize++;
        }
    }

    *value = malloc(sizeof(char *));
     ((ARC_Array *) *value)->data = malloc(sizeof(char *) * arraySize);
     ((ARC_Array *) *value)->size = malloc(sizeof(uint32_t));
    *((ARC_Array *) *value)->size = arraySize;

    ARC_StringSubstr temp = { subdata->index, 0 };
    arraySize = 0;
    for(uint64_t i = subdata->index; i < subdata->index + subdata->length; i++){
        if(data[i] != ','){
            continue;
        }

        temp.length = i - temp.index;

        char *tempStr = (char *)ARC_Config_GetReference(config, (char *)data, &temp);
        if(!tempStr){
            ARC_ConfigKey_Read_String(config, data, &temp, (void **) &tempStr);
            if(arc_errno){
                return arc_errno;
            }
        }

        ((char **)((ARC_Array *) *value)->data)[arraySize] = tempStr;

        // ARC_ConfigKey_Delete_String(config, data, &temp, (void *)tempStr);
        // if(arc_errno){
            // return arc_errno;
        // }

        arraySize++;
        temp = (ARC_StringSubstr){ i + 1, 0 };

        if(arraySize == *((ARC_Array *) *value)->size){
            break;
        }
    }

    temp.length = (subdata->index + subdata->length) - temp.index;
    char *tempStr = (char *)ARC_Config_GetReference(config, (char *)data, &temp);
    if(!tempStr){
        ARC_ConfigKey_Read_String(config, data, &temp, (void **) &tempStr);
        if(arc_errno){
            return arc_errno;
        }
    }

    ((char **)((ARC_Array *) *value)->data)[arraySize] = tempStr;

    // ARC_ConfigKey_Delete_String(config, data, &temp, (void *)tempStr);
    // if(arc_errno){
        // return arc_errno;
    // }

    return 0;
}
*/

void ARC_ConfigKey_Delete_Uint8_t(ARC_Config* config, void *value){
    free((uint8_t *)value);
}

// void ARC_ConfigKey_Delete_Int8_t     (ARC_Config* config, void *value){ if((int8_t    *)value){ free((int8_t    *)value); } }
// void ARC_ConfigKey_Delete_Char       (ARC_Config* config, void *value){ if((char      *)value){ free((char      *)value); } }
// void ARC_ConfigKey_Delete_Uint16_t   (ARC_Config* config, void *value){ if((uint16_t  *)value){ free((uint16_t  *)value); } }
// void ARC_ConfigKey_Delete_Int16_t    (ARC_Config* config, void *value){ if((int16_t   *)value){ free((int16_t   *)value); } }
// void ARC_ConfigKey_Delete_Uint32_t   (ARC_Config* config, void *value){ if((uint32_t  *)value){ free((uint32_t  *)value); } }
// void ARC_ConfigKey_Delete_Int32_t    (ARC_Config* config, void *value){ if((int32_t   *)value){ free((int32_t   *)value); } }
// void ARC_ConfigKey_Delete_Int        (ARC_Config* config, void *value){ if((int       *)value){ free((int       *)value); } }
// void ARC_ConfigKey_Delete_Uint64_t   (ARC_Config* config, void *value){ if((uint64_t  *)value){ free((uint64_t  *)value); } }
// void ARC_ConfigKey_Delete_Int64_t    (ARC_Config* config, void *value){ if((int64_t   *)value){ free((int64_t   *)value); } }
// void ARC_ConfigKey_Delete_Long       (ARC_Config* config, void *value){ if((long      *)value){ free((long      *)value); } }
// void ARC_ConfigKey_Delete_String     (ARC_Config* config, void *value){ if((char      *)value){ free((char      *)value); } }
// void ARC_ConfigKey_Delete_StringArray(ARC_Config* config, void *value){ if((ARC_Array *)value){ free((ARC_Array *)value); } }

#endif //ARC_DEFAULT_CONFIG