/*
Port from c++ is protected by a GNU Lesser GPLv3
Copyright © 2013 Sylvain BERTRAND <sylvain.bertrand@gmail.com>
*/
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>

#include "hb.h"
#include "hb-private.h"
#include "hb-atomic-private.h"
#include "hb-open-file-private.h"
#include "hb-blob-private.h"

struct hb_blob_t {
	atomic_int32_t ref_cnt;
	hb_bool_t immutable;

	const char *data;
	unsigned length;
	hb_memory_mode_t mode;

	void *user_data;
	hb_destroy_func_t destroy;
};

/*XXX:should go in lib "global init"*/
static hb_blob_t hb_blob_nil = {
	REF_CNT_INVALID_VAL,	/*ref_cnt */
	TRUE,			/*immutable */
	NULL,			/*data */
	0,			/*length */
	HB_MEMORY_MODE_READONLY,	/*mode */
	NULL,			/*user_data */
	NULL			/*destroy */
};

hb_blob_t *hb_blob_get_empty(void)
{
	return &hb_blob_nil;
}

hb_blob_t *hb_blob_reference(hb_blob_t * blob)
{
	if (hb_atomic_int32_get(&blob->ref_cnt) != REF_CNT_INVALID_VAL)
		hb_atomic_int32_add(&blob->ref_cnt, 1);
	return blob;
}

void hb_blob_make_immutable(hb_blob_t * blob)
{
	if (hb_atomic_int32_get(&blob->ref_cnt) == REF_CNT_INVALID_VAL)
		return;
	blob->immutable = TRUE;
}

unsigned hb_blob_get_length(hb_blob_t * blob)
{
	return blob->length;
}

const char *hb_blob_get_data(hb_blob_t * blob, unsigned *length)
{
	if (length)
		*length = blob->length;
	return blob->data;
}

static hb_bool_t try_make_writable_inplace_unix(hb_blob_t * blob)
{
	uintptr_t pagesize, mask, length;
	const char *addr;

	pagesize = (uintptr_t) sysconf(_SC_PAGESIZE);

	if ((uintptr_t) - 1L == pagesize)
		return FALSE;

	mask = ~(pagesize - 1);
	addr = (const char *)(((uintptr_t) blob->data) & mask);
	length =
	    (const char
	     *)(((uintptr_t) blob->data + blob->length + pagesize - 1)
		& mask) - addr;
	if (-1 == mprotect((void *)addr, length, PROT_READ | PROT_WRITE))
		return FALSE;

	blob->mode = HB_MEMORY_MODE_WRITABLE;
	return TRUE;
}

static hb_bool_t try_writable_inplace(hb_blob_t * blob)
{
	if (try_make_writable_inplace_unix(blob))
		return TRUE;

	/*Failed to make writable inplace, mark that */
	blob->mode = HB_MEMORY_MODE_READONLY;
	return FALSE;
}

static void hb_blob_destroy_user_data(hb_blob_t * blob)
{
	if (blob->destroy) {
		blob->destroy(blob->user_data);
		blob->user_data = NULL;
		blob->destroy = NULL;
	}
}

static hb_bool_t try_writable(hb_blob_t * blob)
{
	char *new_data;

	if (blob->immutable)
		return FALSE;

	if (blob->mode == HB_MEMORY_MODE_WRITABLE)
		return TRUE;

	if (blob->mode == HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE
	    && try_writable_inplace(blob))
		return TRUE;

	if (blob->mode == HB_MEMORY_MODE_WRITABLE)
		return TRUE;

	new_data = malloc(blob->length);
	if (!new_data)
		return FALSE;

	memcpy(new_data, blob->data, blob->length);
	hb_blob_destroy_user_data(blob);
	blob->mode = HB_MEMORY_MODE_WRITABLE;
	blob->data = new_data;
	blob->user_data = new_data;
	blob->destroy = free;
	return TRUE;
}

void hb_blob_destroy(hb_blob_t * blob)
{
	if (!blob)
		return;
	if (hb_atomic_int32_get(&blob->ref_cnt) == REF_CNT_INVALID_VAL)
		return;
	hb_atomic_int32_add(&blob->ref_cnt, -1);
	if (hb_atomic_int32_get(&blob->ref_cnt) > 0)
		return;
	hb_atomic_int32_set(&blob->ref_cnt, REF_CNT_INVALID_VAL);

	hb_blob_destroy_user_data(blob);
	free(blob);
}

hb_blob_t *hb_blob_create_sub_blob(hb_blob_t * parent,
				   unsigned offset, unsigned length)
{
	hb_blob_t *blob;

	if (!length || offset >= parent->length)
		return hb_blob_get_empty();

	hb_blob_make_immutable(parent);

	blob = hb_blob_create(parent->data + offset,
			      MIN(length, parent->length - offset),
			      HB_MEMORY_MODE_READONLY,
			      hb_blob_reference(parent),
			      (hb_destroy_func_t) hb_blob_destroy);
	return blob;
}

hb_blob_t *hb_blob_create(const char *data, unsigned length,
			  hb_memory_mode_t mode, void *user_data,
			  hb_destroy_func_t destroy)
{
	hb_blob_t *blob = calloc(1, sizeof(*blob));
	if (!length || !blob) {
		if (blob)
			free(blob);
		if (destroy)
			destroy(user_data);
		return hb_blob_get_empty();
	}
	hb_atomic_int32_set(&blob->ref_cnt, 1);
	blob->immutable = FALSE;

	blob->data = data;
	blob->length = length;
	blob->mode = mode;

	blob->user_data = user_data;
	blob->destroy = destroy;

	if (blob->mode == HB_MEMORY_MODE_DUPLICATE) {
		blob->mode = HB_MEMORY_MODE_READONLY;
		if (!try_writable(blob)) {
			hb_blob_destroy(blob);
			return hb_blob_get_empty();
		}
	}
	return blob;
}

struct ot_fnt_file *hb_blob_lock_instance(hb_blob_t * blob)
{
	const char *base;

	hb_blob_make_immutable(blob);
	base = hb_blob_get_data(blob, NULL);
	return (struct ot_fnt_file *)base;
}