#include "system.h"

#include "rpmbuild.h"
#include "buildio.h"

#include "header.h"
#include "rpmlead.h"
#include "signature.h"

#include <err.h>	/* XXX !HAVE_ERR_H: get from misc */
#include "debug.h"

typedef enum injmode_e { INJ_UNKNOWN, INJ_ADD, INJ_DELETE, INJ_MODIFY } injmode_t;

injmode_t injmode = INJ_UNKNOWN;

typedef struct cmd_s {
    injmode_t	injmode;
    char *	tag;
    int_32	tagval;
    int		done;
    int		oldcnt;
    int		nvals;
    char **	vals;
} cmd_t;

#define	MAXCMDS	40
cmd_t *cmds[MAXCMDS];
int ncmds = 0;

static const char * pr_injmode(injmode_t injmode)
{
    switch(injmode) {
    case INJ_ADD:	return("add");
    case INJ_DELETE:	return("delete");
    case INJ_MODIFY:	return("modify");
    case INJ_UNKNOWN:	return("unknown");
    default:		return("???");
    }
    /*@notreached@*/
}

static const char *hdri18ntbl = "HEADER_I18NTABLE";

static const char * getTagString(int tval)
{
    const struct headerTagTableEntry *t;

    for (t = rpmTagTable; t->name != NULL; t++) {
	if (t->val == tval)
	    return t->name;
    }
    if (tval == HEADER_I18NTABLE)
	return hdri18ntbl;
    return NULL;
}

static int getTagVal(const char *tname)
{
    const struct headerTagTableEntry *t;
    int tval;

    if (xstrncasecmp("RPMTAG_", tname, sizeof("RPMTAG_"))) {
	char *tagname = alloca(sizeof("RPMTAG_") + strlen(tname));
	sprintf(tagname, "RPMTAG_%s", tname);
	tname = tagname;
    }

    for (t = rpmTagTable; t->name != NULL; t++) {
	if (!xstrncasecmp(tname, t->name, strlen(t->name)))
	    return t->val;
    }
    if (!xstrcasecmp(tname, hdri18ntbl))
	return HEADER_I18NTABLE;

    tval = atoi(tname);
    return tval;
}

static const struct headerTypeTableEntry {
    char *name;
    int_32 val;
} rpmTypeTable[] = {
    {"RPM_NULL_TYPE",	0},
    {"RPM_CHAR_TYPE",	1},
    {"RPM_INT8_TYPE",	2},
    {"RPM_INT16_TYPE",	3},
    {"RPM_INT32_TYPE",	4},
    {"RPM_INT64_TYPE",	5},
    {"RPM_STRING_TYPE",	6},
    {"RPM_BIN_TYPE",	7},
    {"RPM_STRING_ARRAY_TYPE",	8},
    {"RPM_I18NSTRING_TYPE",	9},
    {NULL,	0}
};

static char *
getTypeString(int tval)
{
    const struct headerTypeTableEntry *t;
    static char buf[128];

    for (t = rpmTypeTable; t->name != NULL; t++) {
	if (t->val == tval)
	    return t->name;
    }
    sprintf(buf, "<RPM_%d_TYPE>", tval);
    return buf;
}

/* ========================================================================= */

enum cvtaction {CA_OLD, CA_NEW, CA_OMIT, CA_ERR};

static enum cvtaction convertAMD(enum cvtaction ca, int_32 type,
	void ** nvalsp, int_32 *ncountp, cmd_t *newc)
{
    int i;

    if (newc == NULL)
	return ca;
    if (!(nvalsp && ncountp))
	return CA_ERR;

    *nvalsp = NULL;
    *ncountp = 0;

    switch (ca) {
    case CA_OLD:
    case CA_OMIT:
    case CA_ERR:
    default:
	break;
    case CA_NEW:
	switch (type) {
	case RPM_INT32_TYPE:
	{   int_32 *intp = xmalloc(newc->nvals * sizeof(*intp));
	    for (i = 0; i < newc->nvals; i++) {
		long ival;
		char *end;
		end = NULL;
		ival = strtol(newc->vals[i], &end, 0);
		if (end && *end)
		    break;
		if ((((unsigned long)ival) >> (8*sizeof(*intp))) != 0)
		    break;
		intp[i] = ival;
	    }
	    if (i < newc->nvals) {
		ca = CA_ERR;
		free(intp);
		break;
	    }
	    *nvalsp = intp;
	    *ncountp = newc->nvals;
	}   break;
	case RPM_BIN_TYPE:	/* icons & signatures */
	case RPM_STRING_TYPE:
	    if (newc->nvals != 1) {
		newc->done = 0;
		ca = CA_ERR;
		break;
	    }
	    *nvalsp = xstrdup(newc->vals[0]);
	    *ncountp = newc->nvals;
	    break;
	case RPM_STRING_ARRAY_TYPE:
	{   const char **av = xmalloc((newc->nvals+1) * sizeof(char *));
	    for (i = 0; i < newc->nvals; i++) {
		av[i] = newc->vals[i];
	    }
	    av[newc->nvals] = NULL;
	    *nvalsp = av;
	    *ncountp = newc->nvals;
	}   break;
	case RPM_NULL_TYPE:
	case RPM_CHAR_TYPE:
	case RPM_INT8_TYPE:	/* arch & os */
	case RPM_INT16_TYPE:	/* file modes & rdevs */
	case RPM_I18NSTRING_TYPE:
	default:	/* this conversion cannot be performed (yet) */
	    newc->done = 0;
	    ca = CA_ERR;
	    break;
	}
	break;
    }

    return ca;
}

static enum cvtaction convertExistingAMD(int_32 tag, int_32 type,
	void ** valsp, int_32 *countp, void ** nvalsp, int_32 *ncountp,
	cmd_t *cmds[], int ncmds)
{
    cmd_t *newc = NULL;
    enum cvtaction ca = CA_OLD;
    int i;

    if (!((tag >= RPMTAG_NAME && tag < RPMTAG_FIRSTFREE_TAG)
        || tag >= RPMTAG_EXTERNAL_TAG))
	return ca;

    for (i = 0; i < ncmds; i++) {
	cmd_t *c;
	c = cmds[i];

	if (tag != c->tagval)
	    continue;
	if (c->done)
	    continue;

	switch (c->injmode) {
	case INJ_ADD:
	    if (ca != CA_OMIT) {/* old tag was deleted, now adding again */
		c->done = -1;
		continue;
	    }
	    ca = CA_NEW;
	    newc = c;
	    c->done = 1;
	    break;
	case INJ_MODIFY:	/* XXX for now, this is delete, then add */
	    if (ca == CA_OMIT) {/* old tag was deleted, can't modify */
		c->done = -1;
		continue;
	    }
	    ca = CA_NEW;
	    newc = c;
	    c->done = 1;
	    break;
	case INJ_DELETE:
	    if (ca == CA_OMIT)	{/* old tag was deleted, now deleting again */
		c->done = -1;
		continue;
	    }
	    ca = CA_OMIT;
	    newc = c;
	    c->done = 1;
	    break;
	case INJ_UNKNOWN:
	default:
	    c->done = -1;
	    break;
	}
    }

    if (newc) {
	ca = convertAMD(ca, type, nvalsp, ncountp, newc);
	switch (ca) {
	case CA_OMIT:
	case CA_NEW:
	    newc->oldcnt = *countp;
	    break;
	case CA_OLD:
	case CA_ERR:
	    break;
	}
    }
    return ca;
}

static
Header headerCopyWithConvert(Header h, cmd_t *cmds[], int ncmds)
{
    int_32 tag, type, count;
    void *vals;
    HeaderIterator headerIter;
    Header res = headerNew();
   
    headerIter = headerInitIterator(h);

    while (headerNextIterator(headerIter, &tag, &type, &vals, &count)) {
	enum cvtaction ca;
	void *nvals;
	int_32 ncount;

	nvals = NULL;
	ncount = 0;
	ca = convertExistingAMD(tag, type, &vals, &count, &nvals, &ncount, cmds, ncmds);
	switch (ca) {
	case CA_ERR:
	case CA_OLD:		/* copy old tag and values to header */	
	default:
	    /* Don't copy the old changelog, we'll do that later. */
	    switch (tag) {
	    case RPMTAG_CHANGELOGTIME:
	    case RPMTAG_CHANGELOGNAME:
	    case RPMTAG_CHANGELOGTEXT:
		break;
	    default:
		headerAddEntry(res, tag, type, vals, count);
		break;
	    }
	    break;
	case CA_NEW:		/* copy new tag and values to header */	
	    headerAddEntry(res, tag, type, nvals, ncount);
	    break;
	case CA_OMIT:		/* delete old tag and values from header */
	    break;
	}

	if (type == RPM_STRING_ARRAY_TYPE || type == RPM_I18NSTRING_TYPE)
	    free(vals);
	if (nvals)
	    free(nvals);
    }

    headerFreeIterator(headerIter);

    return res;
}

static char * genChangelog(cmd_t *cmds[], int ncmds)
{
#define	MYBUFSIZ (2*BUFSIZ)
    char *b, *buf = xmalloc(MYBUFSIZ);
    int i;

    b = buf;
    for (i = 0; i < ncmds; i++) {
	cmd_t *c;

	if ((c = cmds[i]) == NULL)
	    continue;

	b += sprintf(b, "- %s tag %s(%d)",
		pr_injmode(c->injmode), c->tag, c->tagval);

	if (c->oldcnt || c->nvals) {
	    *b++ = '\t';
	    *b++ = '(';
	    if (c->oldcnt)
		b += sprintf(b, "oldcnt %d", c->oldcnt);
	    if (c->oldcnt && c->nvals) {
		*b++ = ',';
		*b++ = ' ';
	    }
	    if (c->nvals)
		b += sprintf(b, "nvals %d", c->nvals);
	    *b++ = ')';
	}
	*b++ = '\n';
    }
    *b = '\0';

    return buf;
}

static int
headerInject(Header *hdrp, cmd_t *cmds[], int ncmds)
{
    Header h;
    int ec = 0;
    int i;

    if (!(hdrp && cmds && ncmds > 0))
	return -1;

    h = headerCopyWithConvert(*hdrp, cmds, ncmds);
    for (i = 0; i < ncmds; i++) {
	cmd_t *c;
	int rc;

	if ((c = cmds[i]) == NULL)
	    continue;

	rc = headerIsEntry(h, c->tagval);
	if (!rc && !c->done && c->injmode != INJ_DELETE) {
	    int_32 type, ncount;
	    void *nvals;
	    enum cvtaction ca;

	    type = (c->nvals > 0) ? RPM_STRING_ARRAY_TYPE : RPM_STRING_TYPE;
	    ca = convertAMD(CA_NEW, type, &nvals, &ncount, c);
	    if (ca == CA_NEW)
		headerAddEntry(h, c->tagval, type, nvals, ncount);
	    rc = headerIsEntry(h, c->tagval);
	}

	switch(c->injmode) {
	case INJ_ADD:
	    if (!(rc && c->done > 0)) {
		warnx(_("failed to add tag %s"), getTagString(c->tagval));
		ec = 1;
	    }
	    break;
	case INJ_DELETE:
	    if (!(!rc && c->done > 0)) {
		warnx(_("failed to delete tag %s"), getTagString(c->tagval));
		ec = 1;
	    }
	    break;
	case INJ_MODIFY:
	    if (!(rc && c->done > 0)) {
		warnx(_("failed to modify tag %s"), getTagString(c->tagval));
		ec = 1;
	    }
	    break;
	case INJ_UNKNOWN:
	default:
	    ec = 1;
	    break;
	}

	/* XXX possibly need strict mode to exit immediately here */
    }

    if (ec == 0 && *hdrp) {
	static char name[512] = "";
	static const char *text = NULL;
	static int cltags[] = {
	    RPMTAG_CHANGELOGTIME,
	    RPMTAG_CHANGELOGNAME,
	    RPMTAG_CHANGELOGTEXT,
	    0
	};

	if (name[0] == '\0')
	    sprintf(name, "rpminject <%s@%s>", getUname(getuid()), buildHost());
	if (text == NULL)
	    text = genChangelog(cmds, ncmds);
	
	addChangelogEntry(h, *getBuildTime(), name, text);
	headerCopyTags(*hdrp, h, cltags);
	headerSort(h);
	*hdrp = headerFree(*hdrp);
	*hdrp = h;
    } else {
	h = headerFree(h);
    }

    return ec;
}

/* ========================================================================= */

static int
rewriteRPM(const char *fni, const char *fno, cmd_t *cmds[], int ncmds)
{
    struct rpmlead lead;	/* XXX FIXME: exorcize lead/arch/os */
    Header sigs;
    Spec spec;
    CSA_t csabuf, *csa = &csabuf;
    int rc;

    csa->cpioArchiveSize = 0;
    csa->cpioFdIn = fdNew("init (rewriteRPM)");
    csa->cpioList = NULL;
    csa->cpioCount = 0;
    csa->lead = &lead;		/* XXX FIXME: exorcize lead/arch/os */

    /* Read rpm and (partially) recreate spec/pkg control structures */
    if ((rc = readRPM(fni, &spec, &lead, &sigs, csa)) != 0)
	return rc;

    /* Inject new strings into header tags */
    if ((rc = headerInject(&spec->packages->header, cmds, ncmds)) != 0)
	goto exit;

    /* Rewrite the rpm */
    if (lead.type == RPMLEAD_SOURCE) {
	rc = writeRPM(&spec->packages->header, fno, (int)lead.type,
		csa, spec->passPhrase, &(spec->cookie));
    } else {
	rc = writeRPM(&spec->packages->header, fno, (int)lead.type,
		csa, spec->passPhrase, NULL);
    }

exit:
    Fclose(csa->cpioFdIn);
    return rc;

}

/* ========================================================================= */

static int
do_inject(cmd_t *cmds[], int ncmds, const char *argv[])
{
    const char *arg;
    int ec = 0;

    if (argv == NULL || *argv == NULL) {
	/* XXX generate lead/header to stdout */
	return 0;
    }

    while ((arg = *argv++) != NULL) {
	char *fni = xmalloc(strlen(arg) + sizeof("-SAVE"));
	const char *fno = arg;

	strcpy(fni, arg);
	strcat(fni, "-SAVE");
	unlink(fni);
	if (link(fno, fni)) {
	    warn(_("can't link temp input file %s"), fni);
	    ec++;
	    continue;
	}
	if (rewriteRPM(fni, fno, cmds, ncmds)) {
	    unlink(fno);
	    if (rename(fni, fno))
		warn(_("can't rename %s to %s"), fni, fno);
	    ec++;
	}
	if (fni) free(fni);
    }

    return ec;
}

static struct poptOption optionsTable[] = {
 { "add",	'a', 0, 0, 'a',			NULL, NULL },
 { "del",	'd', 0, 0, 'd',			NULL, NULL },
 { "injtags",	'i', 0, 0, 'i',			NULL, NULL },
 { "modify",	'm', 0, 0, 'm',			NULL, NULL },
 { "tag",	't', POPT_ARG_STRING, 0, 't',	NULL, NULL },
 { "value",	'v', POPT_ARG_STRING, 0, 'v',	NULL, NULL },
 { NULL,	0, 0, 0, 0,			NULL, NULL }
};

int
main(int argc, char *argv[])
{
    poptContext optCon;
    char * optArg;
    cmd_t *c = NULL;
    int arg;
    int ec = 0;
    injmode_t lastmode = INJ_UNKNOWN;

#if HAVE_MCHECK_H && HAVE_MTRACE
    mtrace();  /* Trace malloc only if MALLOC_TRACE=mtrace-output-file. */
#endif

    setprogname(argv[0]);	/* Retrofit glibc __progname */
    (void)setlocale(LC_ALL, "" );

#ifdef  __LCLINT__
#define LOCALEDIR	"/usr/share/locale"
#endif
    (void)bindtextdomain(PACKAGE, LOCALEDIR);
    (void)textdomain(PACKAGE);

    optCon = poptGetContext("rpminject", argc, argv, optionsTable, 0);
    poptReadDefaultConfig(optCon, 1);

    while ((arg = poptGetNextOpt(optCon)) > 0) {
	optArg = poptGetOptArg(optCon);
	switch (arg) {
	case 'a':
	    injmode = INJ_ADD;
	    break;
	case 'd':
	    injmode = INJ_DELETE;
	    break;
	case 'm':
	    injmode = INJ_MODIFY;
	    break;
	case 't':
	    if (ncmds == 0 || c == NULL)
		errx(EXIT_FAILURE, _("missing inject mode before \"--tag %s\""), optArg);
	    if (c->tag) {
		if (c->injmode != INJ_DELETE &&
		  (c->nvals <= 0 || c->vals == NULL))
		    errx(EXIT_FAILURE, _("add/modify inject mode with \"--tag %s\" needs a value"), c->tag);
		cmds[ncmds] = c = xcalloc(1, sizeof(cmd_t));
		cmds[ncmds]->injmode = cmds[ncmds-1]->injmode;
		ncmds++;
	    }
	    c->tagval = getTagVal(optArg);
	    if (!((c->tagval >= RPMTAG_NAME && c->tagval < RPMTAG_FIRSTFREE_TAG)
	        || c->tagval >= RPMTAG_EXTERNAL_TAG))
		errx(EXIT_FAILURE, _("unknown rpm tag \"--tag %s\""), optArg);
	    c->tag = xstrdup(optArg);
	    break;
	case 'v':
	    if (ncmds == 0 || c == NULL)
		errx(EXIT_FAILURE, _("missing inject mode before \"--value %s\""), optArg);
	    if (c->tag == NULL)
		errx(EXIT_FAILURE, _("missing tag name before \"--value %s\""), optArg);
	    if (c->nvals == 0 || c->vals == NULL) {
		c->vals = xcalloc(2, sizeof(char *));
	    } else {
		c->vals = xrealloc(c->vals,
				(c->nvals+2)*sizeof(char *));
	    }
	    c->vals[c->nvals++] = xstrdup(optArg);
	    c->vals[c->nvals] = NULL;
	    break;
	case 'i':
	    rpmDisplayQueryTags(stdout);
	    exit(EXIT_SUCCESS);
	    break;
	default:
	    errx(EXIT_FAILURE, _("unknown popt return (%d)"), arg);
	    /*@notreached@*/ break;
	}

	if (injmode != lastmode) {
	    cmds[ncmds] = c = xcalloc(1, sizeof(cmd_t));
	    cmds[ncmds]->injmode = lastmode = injmode;
	    ncmds++;
	}
    }

    /* XXX I don't want to read rpmrc */
    addMacro(NULL, "_tmppath", NULL, "/tmp", RMIL_DEFAULT);

    ec = do_inject(cmds, ncmds, poptGetArgs(optCon));

    optCon = poptFreeContext(optCon);
    return ec;
}