AUTOTEST {
    test_obj_core();
}

// ----------------------------------------------------------------------------

typedef struct orc { OBJ
    char name[8];
} orc;

//#pragma pack(push, 1)
typedef struct boy { OBJ
    char name[8];
    float hp;
} boy;
//#pragma pack(pop)

OBJTYPEDEF(orc,100)
int   orc_ctor(orc* self) { strcpy(self->name, "orc!"); printf("i'm orc %p\n", self); return 0; }
int   orc_tick(orc* self) { printf("%p orc tick\n", self); return 0; }
char* orc_save(orc *self) { return obj_saveini(self); } // PACKMSG("ss", "orc_v1", self->name); }

OBJTYPEDEF(boy,101)
int   boy_ctor(boy* self) { strcpy(self->name, "boy!"); printf("i'm boy %p\n", self); self->hp = 0x80; return 0; }
int   boy_tick(boy* self) { printf("%p boy tick, hp:%f\n", self, self->hp); return 0; }
char* boy_save(boy *self) { return obj_saveini(self); } // PACKMSG("ssf", "boy_v1", self->name, self->hp); }

AUTOTEST {
    obj_extend(orc, ctor);
    obj_extend(orc, tick);
    obj_extend(orc, save);

    obj_extend(boy, ctor);
    obj_extend(boy, tick);
    obj_extend(boy, save);

    // instance gameobjs

    boy *obj1 = obj_new(boy, "boy", 123);
    orc *obj2 = obj_new(orc, "orc");
    orc *obj3 = obj_new(orc, "orc");

    printf("%p\n", obj_datac(obj1));
    printf("%d vs %d vs %d\n", (int)sizeof(boy), obj_sizeof(obj1), obj_size(obj1));

    // generics
    obj_tick(obj1);
    obj_tick(obj2);
    obj_tick(obj3);

    obj_hexdump(obj1);

    obj_free(obj1); // will free

    obj_ref(obj2);
    obj_unref(obj2); // will free

    obj_ref(obj3);
    obj_free(obj3); // will do nothing
    obj_unref(obj3); // will free

    // make a dangling reference. this will be printed at end of program.
    static int dangling;
    obj1 = obj_new(boy, "boy", 123);
    obj_ref(obj1);
}

// --- scene

AUTOTEST {
    test_obj_scene();
}

// --- comps

struct WorldTravellerComponent {
    unsigned world_source;
    unsigned world_target;
};

struct TransformComponent {
    vec3 position;
    quat rotation;
    vec3 scale;
};

struct VelocityComponent {
    float speed;
};

struct LookComponent {
    float sensitivity; // _and_polarity;
    vec2 rotation;
};

struct PhysicsComponent {
    float gravity;
    vec3 velocity;
    vec3 acceleration;
    vec3 rotationVelocity;
    vec3 rotationAcceleration;
};

struct RenderComponent {
    aabb box;
    mesh_t mesh;
    texture_t texture;
};

AUTOTEST {
    test_obj_ecs();
}

// generics

// --- example: new class

// declare new object

TYPEDEF_STRUCT(box,102,
    int x,y,w,h;
);

// /* same as: */
// typedef struct box { OBJ
//     int x,y,w,h;
// } box;
// OBJTYPEDEF(box,102)

// implement a few built-in interfaces

#define box(...)         obj(box, __VA_ARGS__)
char*   box_save(const box *b) { return obj_saveini(b); } // PACKMSG("siiii", "box_v1", b->x, b->y, b->w, b->h); }
bool    box_load(box *b, const char* s) { return !!obj_loadini(b, s); } // char *header; return UNPACKMSG(s, "siiii", &header, &b->x, &b->y, &b->w, &b->h) && !strcmp(header, "box_v1"); }
int     box_test(box *b) { return b->w > 0 && b->h > 0; }
void    box_dtor(box *b) { puts("bye box!"); }

// create a new obj interface (not only for box! valid for every other obj that would extend on this)

obj_vtable(area, float, { return 0; });

#define obj_area(o,...) obj_method(area, o, ##__VA_ARGS__)

// implement area interface for box object

float   box_area(box *b) { return b->w * b->h; }

AUTOTEST {
    // reflect
    STRUCT(box,int,x);
    STRUCT(box,int,y);
    STRUCT(box,int,w);
    STRUCT(box,int,h);

    // extend
    obj_extend(box,save);
    obj_extend(box,load);
    obj_extend(box,test);
    obj_extend(box,dtor);
    obj_extend(box,area);

    // -- example

    box b = box(0,0,2,3);
    box *c = obj_new(box, 1,1,3,4);

    test( obj_test(&b) );
    test( obj_test(c) );

    test( obj_area(&b) == 6 );
    test( obj_area(c) == 12 );

    // serialization tests
    test_obj_serialization(&b, c);

    test_obj_similarity(&b, c);
    char *sav = obj_save(c);
    obj_load(&b, sav);
    // obj_load(&b, obj_save(c)); // @fixme: this expression in mingw
    test_obj_equality(&b, c);
}

// --- reflection

typedef struct MyVec3 { OBJ
    float x,y,z;
} MyVec3;

OBJTYPEDEF(MyVec3,77)

typedef struct MyTransform {
    MyVec3 location;          ///R @todo: ideally, we would want self-reflection to inscribe these members
    MyVec3 rotation;          ///R @todo: ideally, we would want self-reflection to inscribe these members
    float  scale;             ///R @todo: ideally, we would want self-reflection to inscribe these members
} MyTransform;

/*
// @todo: which is technically like doing
AUTORUN {
    STRUCT(MyTransform, MyVec3, location);
    STRUCT(MyTransform, MyVec3, rotation);
    STRUCT(MyTransform, float, scale);
}
*/

OBJTYPEDEF(MyTransform,78);

typedef struct MyObject { OBJ
    char *id;
    int spawnx,spawny;
    float time;
    struct MyObject *next;
    MyTransform tr;
} MyObject;

OBJTYPEDEF(MyObject,79);


AUTOTEST {
    STRUCT( MyVec3, float, x, "Right" );
    STRUCT( MyVec3, float, y, "Forward" );
    STRUCT( MyVec3, float, z, "Up" );

    STRUCT( MyTransform, MyVec3, location, "World location (absolute)" );
    STRUCT( MyTransform, MyVec3, rotation, "Local rotation (in degrees)" );
    STRUCT( MyTransform, float, scale, "Local scale (in centimeters)" );

    STRUCT( MyObject, int, spawnx, "Actor Spawn X" );
    STRUCT( MyObject, int, spawny, "Actor Spawn Y" );
    STRUCT( MyObject, string, id, "Actor name" );
    STRUCT( MyObject, MyTransform, tr, "Actor transform" );
    STRUCT( MyObject, float, time, "Actor time" );
    STRUCT( MyObject, MyObject *, next, "Next actor in seq" );

    // reflect_print("MyVec3");
    // reflect_print("MyTransform");
    // reflect_print("MyObject");

    // construct a type from a reflected struct
    MyVec3 *o = obj_new(MyVec3, 1,2,-3);
    test( 12 == obj_size(o) );
    MyVec3 *o2 = obj_make("[MyVec3]\nfloat.y=2\nfloat.x=1\nfloat.z=-3");
    test( !obj_comp(o,o2) ) || obj_hexdump(o), obj_hexdump(o2);

    for each_objmember(o,type,name,ptr) {
        /**/ if( !strcmp(type, "float") )  printf("%s %s = %f\n", type, name, *(float*)ptr );
        else if( !strcmp(type, "double") ) printf("%s %s = %f\n", type, name, *(double*)ptr );
    }

    test_obj_console(o);
    test_obj_console(o2);

    // Setup objects
    MyObject *root = obj_make("[MyObject]");
    obj_hexdump(root);

    MyObject *oo = obj_make("[MyObject]\nid=\"An identifier!\"\nx=123\ny=256\nrotation=90\nnext=root\n");
    obj_hexdump(oo);

    // Dump contents of our objects

    obj_print(oo);
    puts("---");

    obj_hexdump(oo);
    puts("---");

    // Save to mem

    char *sav = obj_savebin(oo);
    test( sav && strlen(sav) > 0 );

    // Clear

    obj_zero(oo);
    obj_hexdump(oo);
    puts("---");

    // Reload

    obj_loadbin(oo, sav);
    obj_hexdump(oo);
}

// --- Benchmarks for call overhead.

AUTOTEST {
    // Here, we're using a blank ctor call as a method to test/stress call overhead.
    //
    // results (old i5-4300/1.90Ghz laptop):
    // v1: 427 million calls/s. compiled with "cl /Ox     /Os /MT /DNDEBUG /GL /GF /arch:AVX2"
    // v2: 450 million calls/s. compiled with "cl /Ox /O2     /MT /DNDEBUG     /GF /arch:AVX2"

    double t;
    enum { N = 100000000 };

    t = -time_ss();
        MyVec3 o = obj(MyVec3, 1,2,3); obj_setname(&o, "MyVec3");
        for( unsigned i = 0; i < N; ++i ) {
            obj_ctor(&o);
        }
    t += time_ss();
    printf("Benchmark: %5.2f objcalls/s %5.2fM objcalls/s\n", N/(t), (N/1000)/(t*1000)); // ((N+N)*5) / (t) );

    t = -time_ss();
        MyVec3 *op = obj_new(MyVec3, 1,2,3);
        for( unsigned i = 0; i < N; ++i ) {
            obj_ctor(op);
        }
    t += time_ss();
    printf("Benchmark: %5.2f objcalls/s %5.2fM objcalls/s\n", N/(t), (N/1000)/(t*1000)); // ((N+N)*5) / (t) );
}

// --- metas

AUTOTEST {
    box b = box(1,2,3,4);

    test( !strcmp("box", obj_type(&b)) );
    test( !strcmp("box", obj_name(&b)) );

    b = box(1,2,3,4);
    obj_setname(&b, "MyBox1");

    test( !strcmp("box", obj_type(&b)) );
    test( !strcmp("MyBox1", obj_name(&b)) );

    test_obj_metadatas(&b);

    obj_free(&b);
}



TYPEDEF_STRUCT(test_vec3_serial, __COUNTER__,
    vec3 position;
    vec3 accel;
);
AUTOTEST {
    STRUCT(test_vec3_serial, vec3, position);
    STRUCT(test_vec3_serial, vec3, accel);
    test_vec3_serial v = obj(test_vec3_serial, {1,2,3},{4,5,6}), z = obj(test_vec3_serial);
    test(obj_comp(&v,&z) != 0) || obj_print(&v) & obj_print(&z);
    obj_loadini(&z, obj_saveini(&v));
    test(obj_comp(&v,&z) == 0) || obj_print(&z);
}

TYPEDEF_STRUCT(MyObject2, __COUNTER__,
    const char* id;
    int x,y;
    float rotation;
    struct MyObject2 *next;
);
AUTORUN {
    STRUCT(MyObject2, const char *, id);
    STRUCT(MyObject2, int, x);
    STRUCT(MyObject2, int, y);
    STRUCT(MyObject2, float, rotation);
    STRUCT(MyObject2, struct MyObject2*, next);

    // Construct two objects
    MyObject2 *root = obj_new(MyObject2);
    MyObject2 *o = obj_new(MyObject2, "An identifier!", 0x11, 0x22, 3.1415f, root );
    // Copy tests
    {
        printf("%d vs %d vs %d\n", (int)sizeof(MyObject2), obj_size(o), (int)sizeof(obj) + obj_size(o) + (int)sizeof(array(void*)));
        MyObject2 *clone = obj_clone(o);
        test(obj_comp(clone,o) == 0) || obj_print(o) & obj_print(clone) & obj_hexdump(o) & obj_hexdump(clone);
        test(obj_free(clone) == 0);
    }

    {
        MyObject2 *copy = obj_new(MyObject2);
        test(obj_copy(copy, o));
        test(obj_comp(copy,o)==0) || obj_print(copy);
        test(obj_free(copy) == 0);
    }

    {
        MyObject2 *copy = obj_new(MyObject2, "A different identifier!", 0x33, 0x44, 0.0f, root );
        test(obj_copy(copy, o));
        test(obj_comp(copy,o)==0) || obj_print(copy);
        test(obj_free(copy) == 0);
    }

    {
        void *copy = obj_malloc(100); // untyped class
        obj_mutate(copy, o);
        obj_print(copy);
        obj_copy(copy, o);
        obj_print(copy);
        obj_free(copy);
    }
}