/**************************************************************/

/*  tpax: a topological pax implementation                    */

/*  Copyright (C) 2020--2024  SysDeer Technologies, LLC       */

/*  Released under GPLv2 and GPLv3; see COPYING.TPAX.         */

/**************************************************************/

#include <fcntl.h>

#include <stdio.h>

#include <unistd.h>

#include <tpax/tpax.h>

#include "tpax_driver_impl.h"

#include "tpax_dprintf_impl.h"

#ifndef TPAX_DRIVER_FLAGS

#define TPAX_DRIVER_FLAGS	TPAX_DRIVER_VERBOSITY_ERRORS \

				| TPAX_DRIVER_VERBOSITY_USAGE \

				| TPAX_DRIVER_DIR_MEMBER_RECURSE

#endif

static const char vermsg[] = "%s%s%s (https://git.foss21.org/tpax): "

			     "version %s%d.%d.%d%s.\n"

			     "[commit reference: %s%s%s]\n";

static const char * const tpax_ver_color[6] = {

		"\x1b[1m\x1b[35m","\x1b[0m",

		"\x1b[1m\x1b[32m","\x1b[0m",

		"\x1b[1m\x1b[34m","\x1b[0m"

};

static const char * const tpax_ver_plain[6] = {

		"","",

		"","",

		"",""

};

static ssize_t tpax_version(struct tpax_driver_ctx * dctx, int fdout)

{

	const struct tpax_source_version * verinfo;

	const char * const * verclr;

	verinfo = tpax_api_source_version();

	verclr  = isatty(fdout) ? tpax_ver_color : tpax_ver_plain;

	return tpax_dprintf(

			fdout,vermsg,

			verclr[0],dctx->program,verclr[1],

			verclr[2],verinfo->major,verinfo->minor,

			verinfo->revision,verclr[3],

			verclr[4],verinfo->commit,verclr[5]);

}

static void tpax_perform_unit_actions(

	const struct tpax_driver_ctx *	dctx,

	struct tpax_unit_ctx *		uctx)

{

	if (dctx->cctx->drvflags & TPAX_DRIVER_EXEC_MODE_WRITE)

		tpax_archive_enqueue(dctx,uctx);

}

static void tpax_archive_write_and_seal(

	const struct tpax_driver_ctx *	dctx)

{

	if (tpax_archive_write(dctx) == TPAX_OK)

		tpax_archive_seal(dctx);

}

static void tpax_perform_archive_actions(

	const struct tpax_driver_ctx *	dctx)

{

	if (dctx->cctx->drvflags & TPAX_DRIVER_EXEC_MODE_WRITE)

		tpax_archive_write_and_seal(dctx);

}

static int tpax_exit(struct tpax_driver_ctx * dctx, int ret)

{

	tpax_output_error_vector(dctx);

	tpax_lib_free_driver_ctx(dctx);

	return ret;

}

int tpax_main(char ** argv, char ** envp, const struct tpax_fd_ctx * fdctx)

{

	int			ret;

	int			fdout;

	int                     fdcwd;

	uint64_t		flags;

	struct tpax_driver_ctx *	dctx;

	struct tpax_unit_ctx *	uctx;

	const char **		unit;

	flags = TPAX_DRIVER_FLAGS;

	fdout = fdctx ? fdctx->fdout : STDOUT_FILENO;

	fdcwd = fdctx ? fdctx->fdcwd : AT_FDCWD;

	if ((ret = tpax_lib_get_driver_ctx(argv,envp,flags,fdctx,&dctx)))

		return (ret == TPAX_USAGE)

			? !argv || !argv[0] || !argv[1]

			: TPAX_ERROR;

	if (dctx->cctx->drvflags & TPAX_DRIVER_VERSION)

		if ((tpax_version(dctx,fdout)) < 0)

			return tpax_exit(dctx,TPAX_ERROR);

	for (unit=dctx->units; *unit; unit++) {

		if (!(tpax_lib_get_unit_ctx(dctx,fdcwd,*unit,&uctx))) {

			tpax_perform_unit_actions(dctx,uctx);

			tpax_lib_free_unit_ctx(uctx);

		}

	}

	tpax_perform_archive_actions(dctx);

	return tpax_exit(dctx,dctx->errv[0] ? TPAX_ERROR : TPAX_OK);

}