/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * Copyright by the Board of Trustees of the University of Illinois.         *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of HDF5.  The full HDF5 copyright notice, including     *
 * terms governing use, modification, and redistribution, is contained in    *
 * the files COPYING and Copyright.html.  COPYING can be found at the root   *
 * of the source code distribution tree; Copyright.html can be found at the  *
 * root level of an installed copy of the electronic HDF5 document set and   *
 * is linked from the top-level documents page.  It can also be found at     *
 * http://hdfgroup.org/HDF5/doc/Copyright.html.  If you do not have          *
 * access to either file, you may request a copy from help@hdfgroup.org.     *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "h5repack.h"
#include "h5tools.h"
#include "h5tools_utils.h"

/*-------------------------------------------------------------------------
 * Function: init_packobject
 *
 * Purpose: initialize a pack_info_t structure
 *
 * Return: void
 *
 *-------------------------------------------------------------------------
 */

void init_packobject(pack_info_t *obj) {
	int j, k;

	HDstrcpy(obj->path, "\0");
	for (j = 0; j < H5_REPACK_MAX_NFILTERS; j++) {
		obj->filter[j].filtn = -1;
		for (k = 0; k < CD_VALUES; k++)
			obj->filter[j].cd_values[k] = 0;
	}
	obj->chunk.rank = -1;
	obj->refobj_id = -1;
	obj->layout = H5D_LAYOUT_ERROR;
	obj->nfilters = 0;
}

/*-------------------------------------------------------------------------
 * Function: aux_tblinsert_filter
 *
 * Purpose: auxiliary function, inserts the filter in object OBJS[ I ]
 *
 * Return: void
 *
 *-------------------------------------------------------------------------
 */

static void aux_tblinsert_filter(pack_opttbl_t *table, unsigned int I,
		filter_info_t filt) {
	if (table->objs[I].nfilters < H5_REPACK_MAX_NFILTERS) {
		table->objs[I].filter[table->objs[I].nfilters++] = filt;
	}
	else {
		error_msg(
				"cannot insert the filter in this object.\
        Maximum capacity exceeded\n");
	}
}

/*-------------------------------------------------------------------------
 * Function: aux_tblinsert_layout
 *
 * Purpose: auxiliary function, inserts the layout in object OBJS[ I ]
 *
 * Return: void
 *
 *-------------------------------------------------------------------------
 */

static void aux_tblinsert_layout(pack_opttbl_t *table, unsigned int I,
		pack_info_t *pack) {
	int k;

	table->objs[I].layout = pack->layout;
	if (H5D_CHUNKED == pack->layout) {
		/* -2 means the NONE option, remove chunking
		 and set the layout to contiguous */
		if (pack->chunk.rank == -2) {
			table->objs[I].layout = H5D_CONTIGUOUS;
			table->objs[I].chunk.rank = -2;
		}
		/* otherwise set the chunking type */
		else {
			table->objs[I].chunk.rank = pack->chunk.rank;
			for (k = 0; k < pack->chunk.rank; k++)
				table->objs[I].chunk.chunk_lengths[k] =
						pack->chunk.chunk_lengths[k];
		}
	}
}

/*-------------------------------------------------------------------------
 * Function: aux_inctable
 *
 * Purpose: auxiliary function, increases the size of the collection by N_OBJS
 *
 * Return: 0, ok, -1, fail
 *
 *-------------------------------------------------------------------------
 */

static int aux_inctable(pack_opttbl_t *table, int n_objs) {
	unsigned int i;

	table->size += n_objs;
	table->objs =
			(pack_info_t*) HDrealloc(table->objs, table->size * sizeof(pack_info_t));
	if (table->objs == NULL) {
		error_msg("not enough memory for options table\n");
		return -1;
	}
	for (i = table->nelems; i < table->size; i++) {
		init_packobject(&table->objs[i]);
	}
	return 0;
}


/*-------------------------------------------------------------------------
 * Function: options_table_init
 *
 * Purpose: init options table
 *
 * Return: 0, ok, -1, fail
 *
 *-------------------------------------------------------------------------
 */
int options_table_init(pack_opttbl_t **tbl) {
	unsigned int i;
	pack_opttbl_t *table;

	if (NULL == (table = (pack_opttbl_t *) HDmalloc(sizeof(pack_opttbl_t)))) {
		error_msg("not enough memory for options table\n");
		return -1;
	}

	table->size = 30;
	table->nelems = 0;
	if (NULL == (table->objs =
			(pack_info_t*) HDmalloc(table->size * sizeof(pack_info_t)))) {
		error_msg("not enough memory for options table\n");
		HDfree(table);
		return -1;
	}

	for (i = 0; i < table->size; i++)
		init_packobject(&table->objs[i]);

	*tbl = table;
	return 0;
}


/*-------------------------------------------------------------------------
 * Function: options_table_free
 *
 * Purpose: free table memory
 *
 * Return: 0
 *
 *-------------------------------------------------------------------------
 */

int options_table_free(pack_opttbl_t *table) {
	HDfree(table->objs);
	HDfree(table);
	return 0;
}

/*-------------------------------------------------------------------------
 * Function: options_add_layout
 *
 * Purpose: add a layout option to the option list
 *
 * Return: 0, ok, -1, fail
 *
 *-------------------------------------------------------------------------
 */

int options_add_layout(obj_list_t *obj_list, int n_objs, pack_info_t *pack,
		pack_opttbl_t *table) {
	unsigned int i, I;
	int j, added = 0, found = 0;

	/* increase the size of the collection by N_OBJS if necessary */
	if (table->nelems + n_objs >= table->size) {
		if (aux_inctable(table, n_objs) < 0)
			return -1;
	}

	/* search if this object is already in the table; "path" is the key */
	if (table->nelems > 0) {
		/* go tru the supplied list of names */
		for (j = 0; j < n_objs; j++) {
			/* linear table search */
			for (i = 0; i < table->nelems; i++) {
				/*already on the table */
				if (HDstrcmp(obj_list[j].obj,table->objs[i].path) == 0) {
					/* already chunk info inserted for this one; exit */
					if (table->objs[i].chunk.rank > 0) {
						error_msg(
								"chunk information already inserted for <%s>\n",
								obj_list[j].obj);
						HDexit(EXIT_FAILURE);
					}
					/* insert the layout info */
					else {
						aux_tblinsert_layout(table, i, pack);
						found = 1;
						break;
					}
				} /* if */
			} /* i */

			if (found == 0) {
				/* keep the grow in a temp var */
				I = table->nelems + added;
				added++;
				HDstrcpy(table->objs[I].path, obj_list[j].obj);
				aux_tblinsert_layout(table, I, pack);
			}
			/* cases where we have an already inserted name but there is a new name also
			 example:
			 -f dset1:GZIP=1 -l dset1,dset2:CHUNK=20x20
			 dset1 is already inserted, but dset2 must also be
			 */
			else if (found == 1
					&& HDstrcmp(obj_list[j].obj,table->objs[i].path) != 0) {
				/* keep the grow in a temp var */
				I = table->nelems + added;
				added++;
				HDstrcpy(table->objs[I].path, obj_list[j].obj);
				aux_tblinsert_layout(table, I, pack);
			}
		} /* j */
	}

	/* first time insertion */
	else {
		/* go tru the supplied list of names */
		for (j = 0; j < n_objs; j++) {
			I = table->nelems + added;
			added++;
			HDstrcpy(table->objs[I].path, obj_list[j].obj);
			aux_tblinsert_layout(table, I, pack);

		}
	}

	table->nelems += added;

	return 0;
}

/*-------------------------------------------------------------------------
 * Function: options_add_filter
 *
 * Purpose: add a compression -f option to the option list
 *
 * Return: 0, ok, -1, fail
 *
 *-------------------------------------------------------------------------
 */

int options_add_filter(obj_list_t *obj_list, int n_objs, filter_info_t filt,
		pack_opttbl_t *table) {

	unsigned int i, I;
	int j, added = 0, found = 0;

	/* increase the size of the collection by N_OBJS if necessary */
	if (table->nelems + n_objs >= table->size) {
		if (aux_inctable(table, n_objs) < 0)
			return -1;
	}

	/* search if this object is already in the table; "path" is the key */
	if (table->nelems > 0) {
		/* go tru the supplied list of names */
		for (j = 0; j < n_objs; j++) {
			/* linear table search */
			for (i = 0; i < table->nelems; i++) {
				/*already on the table */
				if (HDstrcmp(obj_list[j].obj,table->objs[i].path) == 0) {
					/* insert */
					aux_tblinsert_filter(table, i, filt);
					found = 1;
					break;
				} /* if */
			} /* i */

			if (found == 0) {
				/* keep the grow in a temp var */
				I = table->nelems + added;
				added++;
				HDstrcpy(table->objs[I].path, obj_list[j].obj);
				aux_tblinsert_filter(table, I, filt);
			}
			/* cases where we have an already inserted name but there is a new name also
			 example:
			 -l dset1:CHUNK=20x20 -f dset1,dset2:GZIP=1
			 dset1 is already inserted, but dset2 must also be
			 */
			else if (found == 1
					&& HDstrcmp(obj_list[j].obj,table->objs[i].path) != 0) {
				/* keep the grow in a temp var */
				I = table->nelems + added;
				added++;
				HDstrcpy(table->objs[I].path, obj_list[j].obj);
				aux_tblinsert_filter(table, I, filt);
			}
		} /* j */
	}

	/* first time insertion */
	else {
		/* go tru the supplied list of names */
		for (j = 0; j < n_objs; j++) {
			I = table->nelems + added;
			added++;
			HDstrcpy(table->objs[I].path, obj_list[j].obj);
			aux_tblinsert_filter(table, I, filt);
		}
	}

	table->nelems += added;

	return 0;
}

/*-------------------------------------------------------------------------
 * Function: options_get_object
 *
 * Purpose: get object from table; "path" is the key
 *
 * Return: pack_info_t* OBJECT or NULL if not found; PATH is the key
 *
 *-------------------------------------------------------------------------
 */

pack_info_t* options_get_object(const char *path, pack_opttbl_t *table) {
	unsigned int i;
	char tbl_path[MAX_NC_NAME + 1]; /* +1 for start with "/" case */

	for (i = 0; i < table->nelems; i++) {
		/* make full path (start with "/") to compare correctly  */
		if (HDstrncmp(table->objs[i].path, "/", 1)) {
			HDstrcpy(tbl_path, "/");
			HDstrcat(tbl_path, table->objs[i].path);
		}
		else
			HDstrcpy(tbl_path, table->objs[i].path);

		/* found it */
		if (HDstrcmp(tbl_path, path) == 0) {
			return (&table->objs[i]);
		}
	}

	return NULL;
}