#include <agar/core.h>

typedef struct ag_object_class {
	char hier[AG_OBJECT_HIER_MAX];	/* Full inheritance hierarchy */
	AG_Size size;             	/* Size of instance structure */
	AG_Version ver;          	/* Version numbers */
	void (*init)(void *obj);
	void (*reset)(void *obj);
	void (*destroy)(void *obj);
	int  (*load)(void *obj, AG_DataSource *ds, const AG_Version *ver);
	int  (*save)(void *obj, AG_DataSource *ds);
	void *(*edit)(void *obj);
} AG_ObjectClass;

typedef struct ag_widget_class {
	struct ag_object_class _inherit;

	void (*draw)(void *);
	void (*size_request)(void *, AG_SizeReq *);
	/* ... */
} AG_WidgetClass;

"AG_Widget:MY_Widget@myLib,myOtherLib"

AG_RegisterNamespace("Agar", "AG_", "https://libagar.org/");

Agar(Widget:Button):MyLib(MyButton)

AG_Widget:AG_Button:MY_Button

typedef struct ag_object_header {
	char hier[AG_OBJECT_HIER_MAX];	    /* Inheritance hierarchy */
	char libs[AG_OBJECT_LIBS_MAX];	    /* Library list */
	char classSpec[AG_OBJECT_HIER_MAX]; /* Full class string */
	Uint32 dataOffs;                    /* Dataset offset */
	AG_Version ver;                     /* AG_Object version */
	Uint flags;                         /* Object flags */
} AG_ObjectHeader;

AG_Object myObject;

AG_ObjectInit(&obj, "myObject", &agObjectClass);
Debug(&obj, "Hello, world!\n");
AG_ObjectDestroy(&obj);

AG_Object *doc, *head, *title, *body, *p;
AG_Object *result;

doc   = AG_ObjectNew(NULL, "doc",   &agObjectClass);
head  = AG_ObjectNew(doc,  "head",  &agObjectClass);
title = AG_ObjectNew(head, "title", &agObjectClass);
body  = AG_ObjectNew(doc,  "body",  &agObjectClass);
p     = AG_ObjectNew(body, "p",     &agObjectClass);

result = AG_ObjectFindS(doc, "/doc/head/title");
if (result != NULL) {
	AG_Verbose("Title = %s\n", result->name);
}
AG_ObjectDestroy(doc);

void
ObjectNameToUpper(AG_Object *obj)
{
	char name[AG_OBJECT_NAME_MAX], *c;

	if (AG_ObjectCopyName(obj, name,
	    sizeof(name)) == -1) {
		return;
	}
	for (c = name; *c != '\0'; c++) {
		*c = toupper(*c);
	}
	AG_ObjectSetNameS(obj, name);
}

AG_Object parent1, parent2, child;

AG_ObjectInit(&parent1, NULL, &agObjectClass);
AG_ObjectInit(&parent2, NULL, &agObjectClass);
AG_ObjectInit(&child, NULL, &agObjectClass);

AG_ObjectAttach(&parent1, &child);
AG_ObjectDetach(&child);
AG_ObjectAttach(&parent2, &child);

struct my_class *chld;

AGOBJECT_FOREACH_CLASS(chld, parent, my_class, "MyClass") {
	printf("Child %s is an instance of MyClass.\n",
	    AGOBJECT(chld)->name);
}

AG_Button *btn = AG_ButtonNew(NULL, 0, NULL);

if (AG_OfClass(btn, "AG_Widget:AG_Button")) {
	/*
	 * btn is an instance of AG_Button,
	 * and NOT a subclass thereof.
	 */
}
if (AG_OfClass(btn, "AG_Widget:AG_Button:*")) {
	/*
	 * btn is an instance of AG_Button,
	 * OR a subclass thereof.
	 */
}

AG_Button *btn = AG_ButtonNew(NULL, 0, NULL);

if (OBJECT(btn)->cid == AGC_BUTTON) {
	/*
	 * btn is an instance of AG_Button,
	 * and NOT a subclass thereof.
	 */
}
if (AG_BUTTON_ISA(btn)) {
	/*
	 * btn is an instance of AG_Button
	 * OR a subclass thereof.
	 */
}

AG_ObjectClass myClass = {
	"MY_Class",
	sizeof(AG_Object),
	{ 1,0, 1234, 0xE03A },
	NULL,    /* init */
	NULL,    /* reset */
	NULL,    /* destroy */
	NULL,    /* load */
	NULL,    /* save */
	NULL     /* edit */
};

AG_Object *obj;

AG_RegisterClass(&myClass);

obj = AG_ObjectNew(NULL, NULL, &myClass);
Debug(obj, "Hello, world!\n");

AG_ObjectDestroy(obj);

/*
 * Public header file for MY_Dummy (my_dummy.h).
 */
typedef struct my_dummy {
	struct ag_object _inherit; /* AG_Object -> 
	                              MY_Dummy */
	Uint flags;
#define MY_DUMMY_OPT1 0x01  /* Some option */
#define MY_DUMMY_OPT2 0x02  /* Another option */
	int x,y;            /* Some integers */
	void *myData;       /* Allocated data */
} MY_Dummy;

extern AG_ObjectClass myDummyClass;
MY_Dummy *_Nullable MY_DummyNew(int, int, Uint);

/*
 * Implementation of MY_Dummy (my_dummy.c).
 */
#define MYDATASIZE 1024

MY_Dummy *
MY_DummyNew(int x, int y, Uint flags)
{
	MY_Dummy *d;

	d = AG_TryMalloc(sizeof(MY_Dummy));
	if (d == NULL) {
		return (NULL);
	}
	AG_ObjectInit(d, &mdDummyClass);
	d->x = x;
	d->y = y;
	d->flags = flags;
	return (d);
}

static void
Init(void *_Nonnull obj)
{
	MY_Dummy *d = obj;

	d->flags = 0;
	d->x = 0;
	d->y = 0;
	d->myData = Malloc(MYDATASIZE);
	memset(d->myData, 0, MYDATASIZE);
}

static void
Destroy(void *_Nonnull obj)
{
	MY_Dummy *d = obj;

	free(d->myData);
}

static int
Load(void *_Nonnull obj, AG_DataSource *_Nonnull ds,
    const AG_Version *_Nonnull ver)
{
	MY_Dummy *d = obj;

	d->flags = AG_ReadUint8(ds);
	d->x = (int)AG_ReadUint16(ds);
	d->y = (int)AG_ReadUint16(ds);
	return AG_Read(ds, d->myData, MYDATASIZE);
}

static int
Save(void *_Nonnull obj, AG_DataSource *_Nonnull ds)
{
	MY_Dummy *d = obj;

	AG_WriteUint8(ds, (Uint8)(d->flags));
	AG_WriteUint16(ds, (Uint16)d->x);
	AG_WriteUint16(ds, (Uint16)d->y);
	return AG_Write(ds, d->myData, MYDATASIZE);
}

AG_ObjectClass myDummyClass = {
	"MY_Dummy",
	sizeof(MY_Dummy),
	{ 1,0, 0,0 },
	Init,
	NULL,      /* reset */
	Destroy,
	Load,
	Save,
	NULL       /* edit */
};

AG_ObjectClass *C;

AG_RegisterNamespace("MyPackage", "MY_",
    "https://example.com/");

AG_RegisterClass(&myImageViewerClass);

C = AG_LookupClass("Agar(Widget):"
                   "MyPackage(ImageViewer)");
if (C != NULL) {
	AG_Verbose("Found class %s\n", C->name);
	AG_Verbose("Structure size = %d\n", C->size);
}

void
PrintInheritHier(AG_Object *obj)
{
	AG_ObjectClass *hier;
	int nHier, i;

	if (AG_ObjectGetInheritHier(obj,
	    &hier, &nHier) != 0) {
		AG_FatalError(NULL);
	}
	AG_Verbose("AG_Object");
	for (i = 0; i < nHier; i++) {
		AG_Verbose(" -> %s",
		    hier[i]->name);
	}
	AG_Verbose("\n");
	AG_Free(hier);
}

AG_Object obj;
int counter;

AG_ObjectInit(&obj, NULL, &agObjectClass);
AG_SetInt(&obj, "counter", 0);

if (AG_ObjectLoadFromFile(&obj,
    "test.obj") == -1)
	AG_FatalError(NULL);

counter = AG_GetInt(&obj, "counter");
AG_Debug(&obj, "Counter: %d -> %d\n",
    counter, counter+1);
AG_SetInt(&obj, "counter", counter+1);

AG_ObjectSaveToFile(obj, "test.obj");