/*
	Copyright(C) 2016, Red Hat, Inc., Stanislav Kozina

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef UTILS_H_
#define	UTILS_H_

#include <stdarg.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>

/*
 * Changes to file format that keep backward compatibility call for
 * incementing the minor number, changes that don't calls for
 * incrementing the major number.
 */
#define _VERSION(s,j) _STR(s,j)
#define _STR(s,j) _STR2(Version: s##.j\n)
#define _STR2(s) #s

#define FILEFMT_VERSION_MAJOR	1
#define FILEFMT_VERSION_MINOR	0
#define FILEFMT_VERSION_STRING	\
	_VERSION(FILEFMT_VERSION_MAJOR,FILEFMT_VERSION_MINOR)

#define	fail(fmt, ...)	{					\
	fprintf(stderr, "%s():%d ", __func__, __LINE__);	\
	fprintf(stderr, fmt, ## __VA_ARGS__);			\
	exit(1);						\
}

static inline void safe_asprintf(char **strp, const char *fmt, ...)
{
	va_list arglist;

	va_start(arglist, fmt);
	if (vasprintf(strp, fmt, arglist) == -1)
		fail("asprintf failed: %s", strerror(errno));
	va_end(arglist);
}

static inline void *safe_zmalloc(size_t size)
{
	void *result = malloc(size);

	if (result == NULL)
		fail("Malloc of size %zu failed", size);
	memset(result, 0, size);
	return result;
}

static inline void *safe_realloc(void *ptr, size_t size)
{
	void *result = realloc(ptr, size);

	if (result == NULL)
		fail("Rellloc of size %zu failed: %s\n", size, strerror(errno));
	return result;
}

static inline void *safe_strdup(const char *s)
{
	void *result = strdup(s);

	if (result == NULL)
		fail("strdup() of \"%s\" failed", s);
	return result;
}

static inline void *safe_strdup_or_null(const char *s)
{
	if (s == NULL)
		return NULL;
	return safe_strdup(s);
}

static inline bool safe_streq(const char *s1, const char *s2)
{
	if ((s1 == NULL) != (s2 == NULL))
		return false;
	if (s1)
		return !strcmp(s1, s2);
	return true;
}

static inline bool safe_strendswith(const char *s1, const char *s2)
{
	int len1, len2;

	if ((s1 == NULL) != (s2 == NULL))
		return false;

	if (!s1)
		return true;

	len1 = strlen(s1);
	len2 = strlen(s2);

	if ((len1 == 0) || (len2 == 0))
		return false;

	if (len2 > len1)
		return false;

	return strcmp(s1 + len1 - len2, s2) == 0;
}

static inline ssize_t safe_getline(char **lineptr, size_t *n, FILE *stream)
{
	ssize_t ret = getline(lineptr, n, stream);

	if ((ret == -1) && (errno != ENOENT))
		fail("getline failed: %s\n", strerror(errno));

	return ret;
}

static inline FILE *safe_fopen(char *filename)
{
	FILE *file;

	file = fopen(filename, "r");
	if (!file)
		fail("Failed to open kABI file: %s\n", filename);

	return file;
}

typedef enum {
	WALK_CONT,
	WALK_STOP,
	WALK_SKIP,
} walk_rv_t;

extern void walk_dir(char *, bool, walk_rv_t (*)(char *, void *), void *);
extern int check_is_directory(char *);
extern void rec_mkdir(char *);
extern void safe_rename(const char *, const char *);
extern char *path_normalize(char *);
extern char *filenametotype(const char *);
extern char *filenametosymbol(const char *);

extern void global_string_keeper_init(void);
extern void global_string_keeper_free(void);
extern const char *global_string_get_copy(const char *string);
extern const char *global_string_get_move(char *string);

#endif /* UTILS_H */