/* $NetBSD: infocmp.c,v 1.17 2020/03/31 12:44:15 roy Exp $ */

/*
 * Copyright (c) 2009, 2010, 2020 The NetBSD Foundation, Inc.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Roy Marples.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: infocmp.c,v 1.17 2020/03/31 12:44:15 roy Exp $");

#include <sys/ioctl.h>

#include <ctype.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <term_private.h>
#include <term.h>
#include <unistd.h>
#include <util.h>

#define SW 8

typedef struct tient {
        char type;
        const char *id;
        signed char flag;
        int num;
        const char *str;
} TIENT;

static size_t cols;
static int aflag, cflag, nflag, qflag, xflag;

static size_t
outstr(FILE *f, const char *str)
{
        unsigned char ch;
        size_t r, l;

        r = 0;
        l = strlen(str);
        while ((ch = (unsigned char)(*str++)) != '\0') {
                switch (ch) {
                case 128:
                        ch = '0';
                        break;
                case '\033':
                        ch = 'E';
                        break;
                case '\014':
                        ch = 'f';
                        break;
                case '^': /* FALLTHROUGH */
                case ',': /* escape these */
                        break;
                case ' ':
                        ch = 's';
                        break;
                default:
                        if (ch == '\177') {
                                if (f != NULL)
                                        fputc('^', f);
                                ch = '?';
                                r++;
                        } else if (iscntrl(ch) &&
                            ch < 128 &&
                            ch != '\\' &&
                            (l < 4 || isdigit((unsigned char)*str)))
                        {
                                if (f != NULL)
                                        fputc('^', f);
                                ch += '@';
                                r++;
                        } else if (!isprint(ch)) {
                                if (f != NULL)
                                        fprintf(f, "\\%03o", ch);
                                r += 4;
                                continue;
                        }
                        goto prnt;
                }

                if (f != NULL)
                        fputc('\\', f);
                r++;
prnt:
                if (f != NULL)
                        fputc(ch, f);
                r++;
        }
        return r;
}

static int
ent_compare(const void *a, const void *b)
{
        const TIENT *ta, *tb;

        ta = (const TIENT *)a;
        tb = (const TIENT *)b;
        return strcmp(ta->id, tb->id);
}

static void
setdb(char *db)
{
        static const char *ext[] = { ".cdb", ".db" };

        for (size_t i = 0; i < __arraycount(ext); i++) {
                char *ptr = strstr(db, ext[i]);
                if (ptr == NULL || ptr[strlen(ext[i])] != '\0')
                        continue;
                *ptr = '\0';
                break;
        }
        setenv("TERMINFO", db, 1);
}

static void
print_ent(const TIENT *ents, size_t nents)
{
        size_t col, i, l;
        char nbuf[64];

        if (nents == 0)
                return;

        col = SW;
        printf("\t");
        for (i = 0; i < nents; i++) {
                if (*ents[i].id == '.' && aflag == 0)
                        continue;
                switch (ents[i].type) {
                case 'f':
                        if (ents[i].flag == ABSENT_BOOLEAN)
                                continue;
                        l = strlen(ents[i].id) + 2;
                        if (ents[i].flag == CANCELLED_BOOLEAN)
                                l++;
                        break;
                case 'n':
                        if (ents[i].num == ABSENT_NUMERIC)
                                continue;
                        if (VALID_NUMERIC(ents[i].num))
                                l = snprintf(nbuf, sizeof(nbuf), "%s#%d,",
                                    ents[i].id, ents[i].num);
                        else
                                l = snprintf(nbuf, sizeof(nbuf), "%s@,",
                                    ents[i].id);
                        break;
                case 's':
                        if (ents[i].str == ABSENT_STRING)
                                continue;
                        if (VALID_STRING(ents[i].str))
                                l = strlen(ents[i].id) +
                                    outstr(NULL, ents[i].str) + 7;
                        else
                                l = strlen(ents[i].id) + 3;
                        break;
                default:
                        errx(EXIT_FAILURE, "invalid type");
                }
                if (col != SW) {
                        if (col + l > cols) {
                                printf("\n\t");
                                col = SW;
                        } else
                                col += printf(" ");
                }
                switch (ents[i].type) {
                case 'f':
                        col += printf("%s", ents[i].id);
                        if (ents[i].flag == ABSENT_BOOLEAN ||
                            ents[i].flag == CANCELLED_BOOLEAN)
                                col += printf("@");
                        col += printf(",");
                        break;
                case 'n':
                        col += printf("%s", nbuf);
                        break;
                case 's':
                        col += printf("%s", ents[i].id);
                        if (VALID_STRING(ents[i].str)) {
                                col += printf("=");
                                col += outstr(stdout, ents[i].str);
                        } else
                                col += printf("@");
                        col += printf(",");
                        break;
                }
        }
        printf("\n");
}

static size_t
load_ents(TIENT *ents, TERMINAL *t, char type)
{
        size_t i, n, max;
        TERMUSERDEF *ud;

        switch (type) {
        case 'f':
                max = TIFLAGMAX;
                break;
        case 'n':
                max = TINUMMAX;
                break;
        default:
                max = TISTRMAX;
        }

        n = 0;
        for (i = 0; i <= max; i++) {
                switch (type) {
                case 'f':
                        if (t->flags[i] == 1 ||
                            (aflag && t->flags[i] == CANCELLED_BOOLEAN))
                        {
                                ents[n].id = _ti_flagid(i);
                                ents[n].type = 'f';
                                ents[n++].flag = t->flags[i];
                        }
                        break;
                case 'n':
                        if (VALID_NUMERIC(t->nums[i]) ||
                            (aflag && t->nums[i] == CANCELLED_NUMERIC))
                        {
                                ents[n].id = _ti_numid(i);
                                ents[n].type = 'n';
                                ents[n++].num = t->nums[i];
                        }
                        break;
                default:
                        if (VALID_STRING(t->strs[i]) ||
                            (aflag && t->strs[i] == CANCELLED_STRING))
                        {
                                ents[n].id = _ti_strid(i);
                                ents[n].type = 's';
                                ents[n++].str = t->strs[i];
                        }
                        break;
                }
        }

        if (xflag != 0 && t->_nuserdefs != 0) {
                for (i = 0; i < t->_nuserdefs; i++) {
                        ud = &t->_userdefs[i];
                        if (ud->type == type) {
                                switch (type) {
                                case 'f':
                                        if (!aflag &&
                                            !VALID_BOOLEAN(ud->flag))
                                                continue;
                                        break;
                                case 'n':
                                        if (!aflag &&
                                            !VALID_NUMERIC(ud->num))
                                                continue;
                                        break;
                                case 's':
                                        if (!aflag &&
                                            !VALID_STRING(ud->str))
                                                continue;
                                        break;
                                }
                                ents[n].id = ud->id;
                                ents[n].type = ud->type;
                                ents[n].flag = ud->flag;
                                ents[n].num = ud->num;
                                ents[n++].str = ud->str;
                        }
                }
        }

        qsort(ents, n, sizeof(TIENT), ent_compare);
        return n;
}

static void
cprint_ent(TIENT *ent)
{

        if (ent == NULL) {
                if (qflag == 0)
                        printf("NULL");
                else
                        printf("-");
        }

        switch (ent->type) {
        case 'f':
                if (VALID_BOOLEAN(ent->flag))
                        printf(ent->flag == 1 ? "T" : "F");
                else if (qflag == 0)
                        printf("F");
                else if (ent->flag == CANCELLED_BOOLEAN)
                        printf("@");
                else
                        printf("-");
                break;
        case 'n':
                if (VALID_NUMERIC(ent->num))
                        printf("%d", ent->num);
                else if (qflag == 0)
                        printf("NULL");
                else if (ent->num == CANCELLED_NUMERIC)
                        printf("@");
                else
                        printf("-");
                break;
        case 's':
                if (VALID_STRING(ent->str)) {
                        printf("'");
                        outstr(stdout, ent->str);
                        printf("'");
                } else if (qflag == 0)
                        printf("NULL");
                else if (ent->str == CANCELLED_STRING)
                        printf("@");
                else
                        printf("-");
                break;
        }
}

static void
compare_ents(TIENT *ents1, size_t n1, TIENT *ents2, size_t n2)
{
        size_t i1, i2;
        TIENT *e1, *e2, ee;
        int c;

        i1 = i2 = 0;
        ee.type = 'f';
        ee.flag = ABSENT_BOOLEAN;
        ee.num = ABSENT_NUMERIC;
        ee.str = ABSENT_STRING;
        while (i1 != n1 || i2 != n2) {
                if (i1 == n1)
                        c = 1;
                else if (i2 == n2)
                        c = -1;
                else
                        c = strcmp(ents1[i1].id, ents2[i2].id);
                if (c == 0) {
                        e1 = &ents1[i1++];
                        e2 = &ents2[i2++];
                } else if (c < 0) {
                        e1 = &ents1[i1++];
                        e2 = &ee;
                        ee.id = e1->id;
                        ee.type = e1->type;
                } else {
                        e1 = &ee;
                        e2 = &ents2[i2++];
                        ee.id = e2->id;
                        ee.type = e2->type;
                }
                switch (e1->type) {
                case 'f':
                        if (cflag != 0) {
                                if (e1->flag == e2->flag)
                                        printf("\t%s\n", ents1[i1].id);
                                continue;
                        }
                        if (e1->flag == e2->flag)
                                continue;
                        break;
                case 'n':
                        if (cflag != 0) {
                                if (e1->num == e2->num)
                                        printf("\t%s#%d\n",
                                            ents1[i1].id, ents1[i1].num);
                                continue;
                        }
                        if (e1->num == e2->num)
                                continue;
                        break;
                case 's':
                        if (cflag != 0) {
                                if (VALID_STRING(e1->str) &&
                                    VALID_STRING(e2->str) &&
                                    strcmp(e1->str, e2->str) == 0) {
                                        printf("\t%s=", ents1[i1].id);
                                        outstr(stdout, ents1[i1].str);
                                        printf("\n");
                                }
                                continue;
                        }
                        if (VALID_STRING(e1->str) &&
                            VALID_STRING(e2->str) &&
                            strcmp(e1->str, e2->str) == 0)
                                continue;
                        break;
                }
                printf("\t%s: ", e1->id);
                cprint_ent(e1);
                if (e1->type == 'f')
                        printf(":");
                else
                        printf(", ");
                cprint_ent(e2);
                printf(".\n");
        }
}

static TERMINAL *
load_term(const char *name)
{
        TERMINAL *t;

        t = ecalloc(1, sizeof(*t));
        if (name == NULL)
                name = getenv("TERM");
        if (name == NULL)
                name = "dumb";
        if (_ti_getterm(t, name, 1) == 1)
                return t;

        if (_ti_database == NULL)
                errx(EXIT_FAILURE,
                    "no terminal definition found in internal database");
        else
                errx(EXIT_FAILURE,
                    "no terminal definition found in %s.db", _ti_database);
}

static void
show_missing(TERMINAL *t1, TERMINAL *t2, char type)
{
        ssize_t i, max;
        const char *id;

        switch (type) {
        case 'f':
                max = TIFLAGMAX;
                break;
        case 'n':
                max = TINUMMAX;
                break;
        default:
                max = TISTRMAX;
        }

        for (i = 0; i <= max; i++) {
                switch (type) {
                case 'f':
                        if (t1->flags[i] != ABSENT_BOOLEAN ||
                            t2->flags[i] != ABSENT_BOOLEAN)
                                continue;
                        id = _ti_flagid(i);
                        break;
                case 'n':
                        if (t1->nums[i] != ABSENT_NUMERIC ||
                            t2->nums[i] != ABSENT_NUMERIC)
                                continue;
                        id = _ti_numid(i);
                        break;
                default:
                        if (t1->strs[i] != ABSENT_STRING ||
                            t2->strs[i] != ABSENT_STRING)
                                continue;
                        id = _ti_strid(i);
                        break;
                }
                printf("\t!%s.\n", id);
        }
}

static TERMUSERDEF *
find_userdef(TERMINAL *term, const char *id)
{
        size_t i;

        for (i = 0; i < term->_nuserdefs; i++)
                if (strcmp(term->_userdefs[i].id, id) == 0)
                        return &term->_userdefs[i];
        return NULL;
}

static void
use_terms(TERMINAL *term, size_t nuse, char **uterms)
{
        TERMINAL **terms;
        TERMUSERDEF *ud, *tud;
        size_t i, j, agree, absent, data;

        terms = ecalloc(nuse, sizeof(*terms));
        for (i = 0; i < nuse; i++) {
                if (strcmp(term->name, *uterms) == 0)
                        errx(EXIT_FAILURE, "cannot use same terminal");
                for (j = 0; j < i; j++)
                        if (strcmp(terms[j]->name, *uterms) == 0)
                                errx(EXIT_FAILURE, "cannot use same terminal");
                terms[i] = load_term(*uterms++);
        }

        for (i = 0; i < TIFLAGMAX + 1; i++) {
                agree = absent = data = 0;
                for (j = 0; j < nuse; j++) {
                        if (terms[j]->flags[i] == ABSENT_BOOLEAN ||
                            terms[j]->flags[i] == CANCELLED_BOOLEAN)
                                absent++;
                        else {
                                data++;
                                if (term->flags[i] == terms[j]->flags[i])
                                        agree++;
                        }
                }
                if (data == 0)
                        continue;
                if (agree > 0 && agree + absent == nuse)
                        term->flags[i] = ABSENT_BOOLEAN;
                else if (term->flags[i] == ABSENT_BOOLEAN)
                        term->flags[i] = CANCELLED_BOOLEAN;
        }

        for (i = 0; i < TINUMMAX + 1; i++) {
                agree = absent = data = 0;
                for (j = 0; j < nuse; j++) {
                        if (terms[j]->nums[i] == ABSENT_NUMERIC ||
                            terms[j]->nums[i] == CANCELLED_NUMERIC)
                                absent++;
                        else {
                                data++;
                                if (term->nums[i] == terms[j]->nums[i])
                                        agree++;
                        }
                }
                if (data == 0)
                        continue;
                if (agree > 0 && agree + absent == nuse)
                        term->nums[i] = ABSENT_NUMERIC;
                else if (term->nums[i] == ABSENT_NUMERIC)
                        term->nums[i] = CANCELLED_NUMERIC;
        }

        for (i = 0; i < TISTRMAX + 1; i++) {
                agree = absent = data = 0;
                for (j = 0; j < nuse; j++) {
                        if (terms[j]->strs[i] == ABSENT_STRING ||
                            terms[j]->strs[i] == CANCELLED_STRING)
                                absent++;
                        else {
                                data++;
                                if (VALID_STRING(term->strs[i]) &&
                                    strcmp(term->strs[i],
                                        terms[j]->strs[i]) == 0)
                                        agree++;
                        }
                }
                if (data == 0)
                        continue;
                if (agree > 0 && agree + absent == nuse)
                        term->strs[i] = ABSENT_STRING;
                else if (term->strs[i] == ABSENT_STRING)
                        term->strs[i] = CANCELLED_STRING;
        }

        /* User defined caps are more tricky.
           First we set any to absent that agree. */
        for (i = 0; i < term->_nuserdefs; i++) {
                agree = absent = data = 0;
                ud = &term->_userdefs[i];
                for (j = 0; j < nuse; j++) {
                        tud = find_userdef(terms[j], ud->id);
                        if (tud == NULL)
                                absent++;
                        else {
                                data++;
                                switch (ud->type) {
                                case 'f':
                                        if (tud->type == 'f' &&
                                            tud->flag == ud->flag)
                                                agree++;
                                        break;
                                case 'n':
                                        if (tud->type == 'n' &&
                                            tud->num == ud->num)
                                                agree++;
                                        break;
                                case 's':
                                        if (tud->type == 's' &&
                                            VALID_STRING(tud->str) &&
                                            VALID_STRING(ud->str) &&
                                            strcmp(ud->str, tud->str) == 0)
                                                agree++;
                                        break;
                                }
                        }
                }
                if (data == 0)
                        continue;
                if (agree > 0 && agree + absent == nuse) {
                        ud->flag = ABSENT_BOOLEAN;
                        ud->num = ABSENT_NUMERIC;
                        ud->str = ABSENT_STRING;
                }
        }

        /* Now add any that we don't have as cancelled */
        for (i = 0; i < nuse; i++) {
                for (j = 0; j < terms[i]->_nuserdefs; j++) {
                        ud = find_userdef(term, terms[i]->_userdefs[j].id);
                        if (ud != NULL)
                                continue; /* We have handled this */
                        term->_userdefs = erealloc(term->_userdefs,
                            sizeof(*term->_userdefs) * (term->_nuserdefs + 1));
                        tud = &term->_userdefs[term->_nuserdefs++];
                        tud->id = terms[i]->_userdefs[j].id;
                        tud->type = terms[i]->_userdefs[j].flag;
                        tud->flag = CANCELLED_BOOLEAN;
                        tud->num = CANCELLED_NUMERIC;
                        tud->str = CANCELLED_STRING;
                }
        }
}

int
main(int argc, char **argv)
{
        char *term, *Barg;
        int ch, uflag;
        TERMINAL *t, *t2;
        size_t n, n2;
        struct winsize ws;
        TIENT ents[TISTRMAX + 1], ents2[TISTRMAX + 1];

        cols = 80; /* default */
        term = getenv("COLUMNS");
        if (term != NULL)
                cols = strtoul(term, NULL, 10);
        else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0)
                cols = ws.ws_col;

        uflag = xflag = 0;
        Barg = NULL;
        while ((ch = getopt(argc, argv, "1A:B:acnquw:x")) != -1)
                switch (ch) {
                case '1':
                        cols = 1;
                        break;
                case 'A':
                        setdb(optarg);
                        break;
                case 'B':
                        Barg = optarg;
                        break;
                case 'a':
                        aflag = 1;
                        break;
                case 'c':
                        cflag = 1;
                        break;
                case 'n':
                        nflag = 1;
                        break;
                case 'q':
                        qflag = 1;
                        break;
                case 'u':
                        uflag = 1;
                        aflag = 1;
                        break;
                case 'w':
                        cols = strtoul(optarg, NULL, 10);
                        break;
                case 'x':
                        xflag = 1;
                        break;
                case '?':
                default:
                        fprintf(stderr,
                            "usage: %s [-1acnqux] [-A database] [-B database] "
                            "[-w cols] [term]\n",
                            getprogname());
                        return EXIT_FAILURE;
                }
        cols--;

        if (optind + 1 < argc)
                aflag = 1;

        if (optind < argc)
                term = argv[optind++];
        else
                term = NULL;
        t = load_term(term);

        if (uflag != 0)
                use_terms(t, argc - optind, argv + optind);

        if ((optind + 1 != argc && nflag == 0) || uflag != 0) {
                if (uflag == 0)
                        printf("# Reconstructed from %s\n",
                             _ti_database == NULL ?
                             "internal database" : _ti_database);
                /* Strip internal versioning */
                term = strchr(t->name, TERMINFO_VDELIM);
                if (term != NULL)
                        *term = '\0';
                printf("%s", t->name);
                if (t->_alias != NULL) {
                        char *alias, *aliascpy, *delim;

                        alias = aliascpy = estrdup(t->_alias);
                        while (alias != NULL && *alias != '\0') {
                                putchar('|');
                                delim = strchr(alias, TERMINFO_VDELIM);
                                if (delim != NULL)
                                        *delim++ = '\0';
                                printf("%s", alias);
                                if (delim != NULL) {
                                        while (*delim != '\0' && *delim != '|')
                                                delim++;
                                        if (*delim == '\0')
                                                alias = NULL;
                                        else
                                                alias = delim + 1;
                                } else
                                        alias = NULL;
                        }
                        free(aliascpy);
                }
                if (t->desc != NULL && *t->desc != '\0')
                        printf("|%s", t->desc);
                printf(",\n");

                n = load_ents(ents, t, 'f');
                print_ent(ents, n);
                n = load_ents(ents, t, 'n');
                print_ent(ents, n);
                n = load_ents(ents, t, 's');
                print_ent(ents, n);

                if (uflag != 0) {
                        printf("\t");
                        n = SW;
                        for (; optind < argc; optind++) {
                                n2 = 5 + strlen(argv[optind]);
                                if (n != SW) {
                                        if (n + n2 > cols) {
                                                printf("\n\t");
                                                n = SW;
                                        } else
                                                n += printf(" ");
                                }
                                n += printf("use=%s,", argv[optind]);
                        }
                        printf("\n");
                }
                return EXIT_SUCCESS;
        }

        if (Barg == NULL)
                unsetenv("TERMINFO");
        else
                setdb(Barg);
        t2 = load_term(argv[optind++]);
        printf("comparing %s to %s.\n", t->name, t2->name);
        if (qflag == 0)
                printf("    comparing booleans.\n");
        if (nflag == 0) {
                n = load_ents(ents, t, 'f');
                n2 = load_ents(ents2, t2, 'f');
                compare_ents(ents, n, ents2, n2);
        } else
                show_missing(t, t2, 'f');
        if (qflag == 0)
                printf("    comparing numbers.\n");
        if (nflag == 0) {
                n = load_ents(ents, t, 'n');
                n2 = load_ents(ents2, t2, 'n');
                compare_ents(ents, n, ents2, n2);
        } else
                show_missing(t, t2, 'n');
        if (qflag == 0)
                printf("    comparing strings.\n");
        if (nflag == 0) {
                n = load_ents(ents, t, 's');
                n2 = load_ents(ents2, t2, 's');
                compare_ents(ents, n, ents2, n2);
        } else
                show_missing(t, t2, 's');
        return EXIT_SUCCESS;
}