#ifndef _kwil_def_H
#define _kwil_def_H

#include <stddef.h>

// Type tag for kwil fields
enum kwil_field_tag_t {
    KWIL_FIELD_FLOAT = 1,           // the field is a float
    KWIL_FIELD_INT = 2,             // the field is an int
    KWIL_FIELD_UNSIGNED = 3,        // the field is an unsigned int
    KWIL_FIELD_CHAR = 4,            // the field is a character
    KWIL_FIELD_CUSTOM = 6,          // the field is a KWIL_STRUCT or KWIL_ENUM
};
extern enum kwil_field_tag_t kwil_field_tag_from_string(const char* str);

enum kwil_type_tag_t {
    KWIL_TYPE_STRUCT,
    KWIL_TYPE_ENUM
};

struct kwil_enum_value_t {
    char name[48];
};

struct kwil_enum_t {
    // an array of strings with the possible enum values
    struct kwil_enum_value_t* enum_values;
    // the length of the enum_values array
    size_t enum_values_len;
    // the capacity of the enum_values array
    size_t enum_values_cap;
};

// Instantiate a new kwil enum with a name and no values yet.
extern void kwil_init_enum(struct kwil_enum_t* self);
// Register an enum value with an enum
extern int kwil_enum_add_value(struct kwil_enum_t* self, const char* name);
// Free all memory related to a kwil enum.
// DOES NOT FREE self*, if the self* was heap-allocated, make sure to free it as well.
extern int kwil_free_enum(struct kwil_enum_t* self);

// Data of a marked field of a marked struct.
struct kwil_field_t {
    // name of the field
    char name_str[48];
    // the type string of the field
    char type_str[48];
    // how to serialize the type
    enum kwil_field_tag_t type_tag;
    // the length of the static sized array, >0 if type_tag is an array
    size_t array_length;
    int array_dynamic;

    // if type_tag is 
    struct kwil_type_t* type_ptr;
};

// Instantiate a new kwil field with a name and type.
extern int kwil_init_field(struct kwil_field_t* self, const char* field_name, const char* type_str);

struct kwil_struct_t {
    // the list of all fields in the type
    struct kwil_field_t* fields;
    // the used length of the fields array
    size_t fields_len;
    // the capacity of the fields array
    size_t fields_cap;
};

// Instantiate new kwil struct data without fields
// NOTE: intended to be used in tandem with kwil_type_t to store the struct's name.
// kwil_init_struct does not store the name of the type.
extern int kwil_init_struct(struct kwil_struct_t* self);
// Register a field to a kwil struct
extern int kwil_struct_add_field(struct kwil_struct_t* self, struct kwil_field_t* new);
// Free all memory allocated for a kwil struct
// DOES NOT FREE self*, if the self* was heap allocated, make sure to free it as well.
extern int kwil_free_struct(struct kwil_struct_t* self);

// A type that can be serialized with kwil
struct kwil_type_t {
    // the declared name of the type
    char type_name[48];
    // the type name switched to a tag
    enum kwil_type_tag_t type_tag;
    union {
        // if type_tag is KWIL_FIELD_ENUM
        struct kwil_enum_t enum_type;
        // if type_tag is KWIL_FIELD_STRUCT
        struct kwil_struct_t struct_type;
    };
};

// Create a new kwil type from an existing kwil struct.
// Copies the contents of the 'from' pointer.
// 'from' pointer only needs to be valid for the duration of the function.
extern int kwil_type_from_struct(struct kwil_type_t* self, struct kwil_struct_t* from, const char* name);
// Create a new type from an existing enum.
// Copies the contents of the 'from' pointer.
// 'from' pointer only needs to be valid for the duration of the function.
extern int kwil_type_from_enum(struct kwil_type_t* self, struct kwil_enum_t* from, const char* name);

// All kwil-serializable data in a header
struct kwil_header_t {
    // name of the header without any other path elements
    char file_name[48];
    // array of kwil types defined in this header
    struct kwil_type_t* types;
    // length of kwil_types
    size_t types_len;
    // capacity of types
    size_t types_cap;
};

// Instantiate a new kwil header with a filename
extern int kwil_init_header(struct kwil_header_t* self, const char* filename);
// Add an existing kwil type to the kwil header.
// Copies the kwil_type_t and inserts it into kwil_types.
// The 'new' pointer only needs to remain valid until the function returns.
extern int kwil_header_add_type(struct kwil_header_t* self, struct kwil_type_t* new);
// Free kwil header data and all associated memory.
// Invalidates all pointers stored in kwil_types.
extern int kwil_free_header(struct kwil_header_t* self);

#endif // _kwil_def_H