#if !defined(_RTTI_TYPEINFO_H_)

#define _RTTI_TYPEINFO_H_ 1

#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>

#define var void*

#define SIZE_ROUNDUP(sz)                                                       \
    ((((sz + sizeof(void*) - 1)) / (sizeof(void*))) * sizeof(void*))

#define OBJ_HEADER_SIZE SIZE_ROUNDUP(sizeof(meta_obj_t))

/** Object format
 **
 **  +=====================+===================+===================+
 **  |    <private data>   |   <object header> | <- public data >  |
 **  +=====================+===================+===================+
 **
 **/
#define OBJ_TO_DATA(T, obj) ((T*)(((char*)obj) + OBJ_HEADER_SIZE))
#define DATA_TO_OBJ(v)      ((meta_obj_t*)(((char*)v) - OBJ_HEADER_SIZE))
#define OBJ_TO_PRIV(obj)                                                       \
    ((void*)(((char*)obj) - SIZE_ROUNDUP((obj)->type->privateSize)))

struct meta_obj_;
struct typeinfo_;

typedef struct meta_obj_ meta_obj_t;
typedef struct typeinfo_ typeinfo_t;

/* calculate the size of data */
typedef size_t (*datasize_fn_t)(va_list);

/* object life cycle */
typedef int (*obj_init_fn_t)(typeinfo_t*, va_list);
typedef void (*obj_destroy_fn_t)(var);

/* lock/unlock */
typedef int (*lock_fn_t)(var, uint64_t);
typedef void (*unlock_fn_t)(var);

typedef struct {
    lock_fn_t   lock;
    unlock_fn_t unlock;
} intf_lock_t;

/* convert to string */
typedef char* (*to_string_fn_t)(var, va_list);

typedef struct {
    to_string_fn_t toString;
} intf_tostring_t;

/* iterator function */

#define ITER_NO_DATA (0)
#define ITER_OK      (1)

typedef struct {
    var v;
    var data;
} iterator_t;

typedef int (*iter_make_fn_t)(iterator_t*, var);
typedef int (*iter_next_fn_t)(iterator_t*, void**);
typedef int (*iter_reset_fn_t)(iterator_t*);
typedef void (*iter_destroy_fn_t)(iterator_t*);

typedef struct {
    iter_make_fn_t    make;
    iter_next_fn_t    next;
    iter_reset_fn_t   reset;
    iter_destroy_fn_t destroy;
} intf_iterator_t;

/* reference and deref */
typedef int32_t (*reference_fn_t)(var);
typedef void (*dereference_fn_t)(var);

typedef struct {
    reference_fn_t   reference;
    dereference_fn_t dereference;
} intf_reference_t;

/* hash */

typedef int32_t (*hash_fn_t)(var);

typedef struct {
    hash_fn_t hash;
} intf_hash_t;

/* length */
typedef int64_t (*length_fn_t)(var);

typedef struct {
    length_fn_t length;
} intf_length_t;

typedef struct {
    intf_lock_t*      lock;
    intf_tostring_t*  toString;
    intf_iterator_t*  iter;
    intf_reference_t* reference;
    intf_hash_t*      hash;
    intf_length_t*    length;
} interface_table_t;

struct typeinfo_ {
    char*             name;
    size_t            privateSize;
    datasize_fn_t     dataSize;
    obj_init_fn_t     init;
    obj_destroy_fn_t  destroy;
    interface_table_t interfaces;
};

struct meta_obj_ {
    typeinfo_t* type;
};

extern var     makeInstance(typeinfo_t*, ...);
extern void    destroy(var);
extern int     lock(var, uint64_t);
extern void    unlock(var);
extern char*   toString(var, ...);
extern int     iter_make(iterator_t*, var);
extern int     iter_next(iterator_t*, void**);
extern int     iter_reset(iterator_t*);
extern void    iter_destroy(iterator_t*);
extern int32_t hash(var);
extern int64_t length(var);
extern int32_t reference(var);
extern void    dereference(var);

#endif