/*

 * Copyright 2010 Jerome Glisse <glisse@freedesktop.org>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * on the rights to use, copy, modify, merge, publish, distribute, sub

 * license, and/or sell copies of the Software, and to permit persons to whom

 * the Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

 * USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 * Authors:

 *      Jerome Glisse

 */

#include <errno.h>

#include <stdlib.h>

#include <string.h>

#include "bof.h"

/*

 * helpers

 */

static int bof_entry_grow(bof_t *bof)

{

	bof_t **array;

	if (bof->array_size < bof->nentry)

		return 0;

	array = realloc(bof->array, (bof->nentry + 16) * sizeof(void*));

	if (array == NULL)

		return -ENOMEM;

	bof->array = array;

	bof->nentry += 16;

	return 0;

}

/*

 * object 

 */

bof_t *bof_object(void)

{

	bof_t *object;

	object = calloc(1, sizeof(bof_t));

	if (object == NULL)

		return NULL;

	object->refcount = 1;

	object->type = BOF_TYPE_OBJECT;

	object->size = 12;

	return object;

}

bof_t *bof_object_get(bof_t *object, const char *keyname)

{

	unsigned i;

	for (i = 0; i < object->array_size; i += 2) {

		if (!strcmp(object->array[i]->value, keyname)) {

			return object->array[i + 1];

		}

	}

	return NULL;

}

int bof_object_set(bof_t *object, const char *keyname, bof_t *value)

{

	bof_t *key;

	int r;

	if (object->type != BOF_TYPE_OBJECT)

		return -EINVAL;

	r = bof_entry_grow(object);

	if (r)

		return r;

	key = bof_string(keyname);

	if (key == NULL)

		return -ENOMEM;

	object->array[object->array_size++] = key;

	object->array[object->array_size++] = value;

	object->size += value->size;

	object->size += key->size;

	bof_incref(value);

	return 0;

}

/*

 * array

 */

bof_t *bof_array(void)

{

	bof_t *array = bof_object();

	if (array == NULL)

		return NULL;

	array->type = BOF_TYPE_ARRAY;

	array->size = 12;

	return array;

}

int bof_array_append(bof_t *array, bof_t *value)

{

	int r;

	if (array->type != BOF_TYPE_ARRAY)

		return -EINVAL;

	r = bof_entry_grow(array);

	if (r)

		return r;

	array->array[array->array_size++] = value;

	array->size += value->size;

	bof_incref(value);

	return 0;

}

bof_t *bof_array_get(bof_t *bof, unsigned i)

{

	if (!bof_is_array(bof) || i >= bof->array_size)

		return NULL;

	return bof->array[i];

}

unsigned bof_array_size(bof_t *bof)

{

	if (!bof_is_array(bof))

		return 0;

	return bof->array_size;

}

/*

 * blob

 */

bof_t *bof_blob(unsigned size, void *value)

{

	bof_t *blob = bof_object();

	if (blob == NULL)

		return NULL;

	blob->type = BOF_TYPE_BLOB;

	blob->value = calloc(1, size);

	if (blob->value == NULL) {

		bof_decref(blob);

		return NULL;

	}

	blob->size = size;

	memcpy(blob->value, value, size);

	blob->size += 12;

	return blob;

}

unsigned bof_blob_size(bof_t *bof)

{

	if (!bof_is_blob(bof))

		return 0;

	return bof->size - 12;

}

void *bof_blob_value(bof_t *bof)

{

	if (!bof_is_blob(bof))

		return NULL;

	return bof->value;

}

/*

 * string

 */

bof_t *bof_string(const char *value)

{

	bof_t *string = bof_object();

	if (string == NULL)

		return NULL;

	string->type = BOF_TYPE_STRING;

	string->size = strlen(value) + 1;

	string->value = calloc(1, string->size);

	if (string->value == NULL) {

		bof_decref(string);

		return NULL;

	}

	strcpy(string->value, value);

	string->size += 12;

	return string;

}

/*

 *  int32

 */

bof_t *bof_int32(int32_t value)

{

	bof_t *int32 = bof_object();

	if (int32 == NULL)

		return NULL;

	int32->type = BOF_TYPE_INT32;

	int32->size = 4;

	int32->value = calloc(1, int32->size);

	if (int32->value == NULL) {

		bof_decref(int32);

		return NULL;

	}

	memcpy(int32->value, &value, 4);

	int32->size += 12;

	return int32;

}

int32_t bof_int32_value(bof_t *bof)

{

	return *((uint32_t*)bof->value);

}

/*

 *  common

 */

static void bof_indent(int level)

{

	int i;

	for (i = 0; i < level; i++)

		fprintf(stderr, " ");

}

static void bof_print_bof(bof_t *bof, int level, int entry)

{

	bof_indent(level);

	if (bof == NULL) {

		fprintf(stderr, "--NULL-- for entry %d\n", entry);

		return;

	}

	switch (bof->type) {

	case BOF_TYPE_STRING:

		fprintf(stderr, "%p string [%s %d]\n", bof, (char*)bof->value, bof->size);

		break;

	case BOF_TYPE_INT32:

		fprintf(stderr, "%p int32 [%d %d]\n", bof, *(int*)bof->value, bof->size);

		break;

	case BOF_TYPE_BLOB:

		fprintf(stderr, "%p blob [%d]\n", bof, bof->size);

		break;

	case BOF_TYPE_NULL:

		fprintf(stderr, "%p null [%d]\n", bof, bof->size);

		break;

	case BOF_TYPE_OBJECT:

		fprintf(stderr, "%p object [%d %d]\n", bof, bof->array_size / 2, bof->size);

		break;

	case BOF_TYPE_ARRAY:

		fprintf(stderr, "%p array [%d %d]\n", bof, bof->array_size, bof->size);

		break;

	default:

		fprintf(stderr, "%p unknown [%d]\n", bof, bof->type);

		return;

	}

}

static void bof_print_rec(bof_t *bof, int level, int entry)

{

	unsigned i;

	bof_print_bof(bof, level, entry);

	for (i = 0; i < bof->array_size; i++) {

		bof_print_rec(bof->array[i], level + 2, i);

	}

}

void bof_print(bof_t *bof)

{

	bof_print_rec(bof, 0, 0);

}

static int bof_read(bof_t *root, FILE *file, long end, int level)

{

	bof_t *bof = NULL;

	int r;

	if (ftell(file) >= end) {

		return 0;

	}

	r = bof_entry_grow(root);

	if (r)

		return r;

	bof = bof_object();

	if (bof == NULL)

		return -ENOMEM;

	bof->offset = ftell(file);

	r = fread(&bof->type, 4, 1, file);

	if (r != 1)

		goto out_err;

	r = fread(&bof->size, 4, 1, file);

	if (r != 1)

		goto out_err;

	r = fread(&bof->array_size, 4, 1, file);

	if (r != 1)

		goto out_err;

	switch (bof->type) {

	case BOF_TYPE_STRING:

	case BOF_TYPE_INT32:

	case BOF_TYPE_BLOB:

		bof->value = calloc(1, bof->size - 12);

		if (bof->value == NULL) {

			goto out_err;

		}

		r = fread(bof->value, bof->size - 12, 1, file);

		if (r != 1) {

			fprintf(stderr, "error reading %d\n", bof->size - 12);

			goto out_err;

		}

		break;

	case BOF_TYPE_NULL:

		return 0;

	case BOF_TYPE_OBJECT:

	case BOF_TYPE_ARRAY:

		r = bof_read(bof, file, bof->offset + bof->size, level + 2);

		if (r)

			goto out_err;

		break;

	default:

		fprintf(stderr, "invalid type %d\n", bof->type);

		goto out_err;

	}

	root->array[root->centry++] = bof;

	return bof_read(root, file, end, level);

out_err:

	bof_decref(bof);

	return -EINVAL;

}

bof_t *bof_load_file(const char *filename)

{

	bof_t *root = bof_object();

	int r;

	if (root == NULL) {

		fprintf(stderr, "%s failed to create root object\n", __func__);

		return NULL;

	}

	root->file = fopen(filename, "r");

	if (root->file == NULL)

		goto out_err;

	r = fseek(root->file, 0L, SEEK_SET);

	if (r) {

		fprintf(stderr, "%s failed to seek into file %s\n", __func__, filename);

		goto out_err;

	}

	root->offset = ftell(root->file);

	r = fread(&root->type, 4, 1, root->file);

	if (r != 1)

		goto out_err;

	r = fread(&root->size, 4, 1, root->file);

	if (r != 1)

		goto out_err;

	r = fread(&root->array_size, 4, 1, root->file);

	if (r != 1)

		goto out_err;

	r = bof_read(root, root->file, root->offset + root->size, 2);

	if (r)

		goto out_err;

	return root;

out_err:

	bof_decref(root);

	return NULL;

}

void bof_incref(bof_t *bof)

{

	bof->refcount++;

}

void bof_decref(bof_t *bof)

{

	unsigned i;

	if (bof == NULL)

		return;

	if (--bof->refcount > 0)

		return;

	for (i = 0; i < bof->array_size; i++) {

		bof_decref(bof->array[i]);

		bof->array[i] = NULL;

	}

	bof->array_size = 0;

	if (bof->file) {

		fclose(bof->file);

		bof->file = NULL;

	}

	free(bof->array);

	free(bof->value);

	free(bof);

}

static int bof_file_write(bof_t *bof, FILE *file)

{

	unsigned i;

	int r;

	r = fwrite(&bof->type, 4, 1, file);

	if (r != 1)

		return -EINVAL;

	r = fwrite(&bof->size, 4, 1, file);

	if (r != 1)

		return -EINVAL;

	r = fwrite(&bof->array_size, 4, 1, file);

	if (r != 1)

		return -EINVAL;

	switch (bof->type) {

	case BOF_TYPE_NULL:

		if (bof->size)

			return -EINVAL;

		break;

	case BOF_TYPE_STRING:

	case BOF_TYPE_INT32:

	case BOF_TYPE_BLOB:

		r = fwrite(bof->value, bof->size - 12, 1, file);

		if (r != 1)

			return -EINVAL;

		break;

	case BOF_TYPE_OBJECT:

	case BOF_TYPE_ARRAY:

		for (i = 0; i < bof->array_size; i++) {

			r = bof_file_write(bof->array[i], file);

			if (r)

				return r;

		}

		break;

	default:

		return -EINVAL;

	}

	return 0;

}

int bof_dump_file(bof_t *bof, const char *filename)

{

	unsigned i;

	int r = 0;

	if (bof->file) {

		fclose(bof->file);

		bof->file = NULL;

	}

	bof->file = fopen(filename, "w");

	if (bof->file == NULL) {

		fprintf(stderr, "%s failed to open file %s\n", __func__, filename);

		r = -EINVAL;

		goto out_err;

	}

	r = fseek(bof->file, 0L, SEEK_SET);

	if (r) {

		fprintf(stderr, "%s failed to seek into file %s\n", __func__, filename);

		goto out_err;

	}

	r = fwrite(&bof->type, 4, 1, bof->file);

	if (r != 1)

		goto out_err;

	r = fwrite(&bof->size, 4, 1, bof->file);

	if (r != 1)

		goto out_err;

	r = fwrite(&bof->array_size, 4, 1, bof->file);

	if (r != 1)

		goto out_err;

	for (i = 0; i < bof->array_size; i++) {

		r = bof_file_write(bof->array[i], bof->file);

		if (r)

			return r;

	}

out_err:

	fclose(bof->file);

	bof->file = NULL;

	return r;

}