/*      $NetBSD: setterm.c,v 1.72 2024/05/17 23:32:50 uwe Exp $ */

/*
 * Copyright (c) 1981, 1993, 1994
 *      The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS OR CONTRIBUTORS 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>
#ifndef lint
#if 0
static char sccsid[] = "@(#)setterm.c   8.8 (Berkeley) 10/25/94";
#else
__RCSID("$NetBSD: setterm.c,v 1.72 2024/05/17 23:32:50 uwe Exp $");
#endif
#endif /* not lint */

#include <stdlib.h>
#include <string.h>
#include <termios.h>
#include <unistd.h>

#include "curses.h"
#include "curses_private.h"

static int does_esc_m(const char *cap);
static int does_ctrl_o(const char *exit_cap, const char *acs_cap);

attr_t   __mask_op, __mask_me, __mask_ue, __mask_se;

int
setterm(const char *type)
{

        return _cursesi_setterm(type, _cursesi_screen);
}

int
_cursesi_setterm(const char *type, SCREEN *screen)
{
        int unknown, r;
        char *p;

        if (type[0] == '\0')
                type = "xx";
        unknown = 0;
        if (screen->term)
                del_curterm(screen->term);
        (void)ti_setupterm(&screen->term, type, fileno(screen->outfd), &r);
        if (screen->term == NULL) {
                unknown++;
                (void)ti_setupterm(&screen->term, "dumb",
                    fileno(screen->outfd), &r);
                /* No dumb term? We can't continue */
                if (screen->term == NULL)
                        return ERR;
        }
        __CTRACE(__CTRACE_INIT, "setterm: tty = %s\n", type);

        /* lines and cols will have been setup correctly by ti_setupterm(3). */
        screen->LINES = t_lines(screen->term);
        screen->COLS = t_columns(screen->term);

        if (screen->filtered) {
                /* Disable use of clear, cud, cud1, cup, cuu1 and vpa. */
                screen->term->strs[TICODE_clear] = NULL;
                screen->term->strs[TICODE_cud] = NULL;
                screen->term->strs[TICODE_cud1] = NULL;
                screen->term->strs[TICODE_cup] = NULL;
                screen->term->strs[TICODE_cuu] = NULL;
                screen->term->strs[TICODE_cuu1] = NULL;
                screen->term->strs[TICODE_vpa] = NULL;
                /* Set the value of the home string to the value of
                 * the cr string. */
                screen->term->strs[TICODE_home] = screen->term->strs[TICODE_cr];
                /* Set lines equal to 1. */
                screen->LINES = 1;
                t_lines(screen->term) = 1;
        }
        __CTRACE(__CTRACE_INIT, "setterm: filtered %d\n", screen->filtered);

        if ((p = getenv("ESCDELAY")) != NULL)
                screen->ESCDELAY = (int)strtol(p, NULL, 0);
        else
                screen->ESCDELAY = ESCDELAY_DEFAULT;
        if ((p = getenv("TABSIZE")) != NULL)
                screen->TABSIZE = (int)strtol(p, NULL, 0);
        else if (t_init_tabs(screen->term) >= 0)
                screen->TABSIZE = (int)t_init_tabs(screen->term);
        else
                screen->TABSIZE = TABSIZE_DEFAULT;
        /*
         * Want cols > 4, otherwise things will fail.
         */
        if (screen->COLS <= 4)
                return ERR;

        LINES = screen->LINES;
        COLS = screen->COLS;
        ESCDELAY = screen->ESCDELAY;
        TABSIZE = screen->TABSIZE;

        __CTRACE(__CTRACE_INIT,
            "setterm: LINES = %d, COLS = %d, TABSIZE = %d\n",
            LINES, COLS, TABSIZE);

        /*
         * set the pad char, only take the first char of the pc capability
         * as this is all we can use.
         */
        screen->padchar = t_pad_char(screen->term) ?
            t_pad_char(screen->term)[0] : 0;

        /* If no scrolling commands, no quick change. */
        screen->noqch =
            (t_change_scroll_region(screen->term) == NULL ||
                t_cursor_home(screen->term) == NULL ||
                (t_parm_index(screen->term) == NULL &&
                    t_scroll_forward(screen->term) == NULL) ||
                (t_parm_rindex(screen->term) == NULL &&
                    t_scroll_reverse(screen->term) == NULL)) &&
            ((t_parm_insert_line(screen->term) == NULL &&
                t_insert_line(screen->term) == NULL) ||
                (t_parm_delete_line(screen->term) == NULL &&
                    t_delete_line(screen->term) == NULL));

        /*
         * Precalculate conflict info for color/attribute end commands.
         */
#ifndef HAVE_WCHAR
        screen->mask_op = __ATTRIBUTES & ~__COLOR;
#else
        screen->mask_op = WA_ATTRIBUTES & ~__COLOR;
#endif /* HAVE_WCHAR */

        const char *t_op = t_orig_pair(screen->term);
        const char *t_esm = t_exit_standout_mode(screen->term);
        const char *t_eum = t_exit_underline_mode(screen->term);
        const char *t_eam = t_exit_attribute_mode(screen->term);

        if (t_op != NULL) {
                if (does_esc_m(t_op))
                        screen->mask_op &=
                            ~(__STANDOUT | __UNDERSCORE | __TERMATTR);
                else {
                        if (t_esm != NULL && !strcmp(t_op, t_esm))
                                screen->mask_op &= ~__STANDOUT;

                        if (t_eum != NULL && !strcmp(t_op, t_eum))
                                screen->mask_op &= ~__UNDERSCORE;

                        if (t_eam != NULL && !strcmp(t_op, t_eam))
                                screen->mask_op &= ~__TERMATTR;
                }
        }
        /*
         * Assume that "me" turns off all attributes apart from ACS.
         * It might turn off ACS, so check for that.
         */
        if (t_exit_attribute_mode(screen->term) != NULL &&
            t_exit_alt_charset_mode(screen->term) != NULL &&
            does_ctrl_o(t_exit_attribute_mode(screen->term),
            t_exit_alt_charset_mode(screen->term)))
                screen->mask_me = 0;
        else
                screen->mask_me = __ALTCHARSET;

        /* Check what turning off the attributes also turns off */
#ifndef HAVE_WCHAR
        screen->mask_ue = __ATTRIBUTES & ~__UNDERSCORE;
#else
        screen->mask_ue = WA_ATTRIBUTES & ~__UNDERSCORE;
#endif /* HAVE_WCHAR */
        if (t_eum != NULL) {
                if (does_esc_m(t_eum))
                        screen->mask_ue &=
                            ~(__STANDOUT | __TERMATTR | __COLOR);
                else {
                        if (t_esm && !strcmp(t_eum, t_esm))
                                screen->mask_ue &= ~__STANDOUT;

                        if (t_eam != NULL && !strcmp(t_eum, t_eam))
                                screen->mask_ue &= ~__TERMATTR;

                        if (t_op != NULL && !strcmp(t_eum, t_op))
                                screen->mask_ue &= ~__COLOR;
                }
        }
#ifndef HAVE_WCHAR
        screen->mask_se = __ATTRIBUTES & ~__STANDOUT;
#else
        screen->mask_se = WA_ATTRIBUTES & ~__STANDOUT;
#endif /* HAVE_WCHAR */
        if (t_esm != NULL) {
                if (does_esc_m(t_esm))
                        screen->mask_se &=
                            ~(__UNDERSCORE | __TERMATTR | __COLOR);
                else {
                        if (t_eum != NULL && !strcmp(t_esm, t_eum))
                                screen->mask_se &= ~__UNDERSCORE;

                        if (t_eam != NULL && !strcmp(t_esm, t_eam))
                                screen->mask_se &= ~__TERMATTR;

                        if (t_op != NULL && !strcmp(t_esm, t_op))
                                screen->mask_se &= ~__COLOR;
                }
        }

        return unknown ? ERR : OK;
}

/*
 * _cursesi_resetterm --
 *  Copy the terminal instance data for the given screen to the global
 *  variables.
 */
void
_cursesi_resetterm(SCREEN *screen)
{

        LINES = screen->LINES;
        COLS = screen->COLS;
        ESCDELAY = screen->ESCDELAY;
        TABSIZE = screen->TABSIZE;
        __GT = screen->GT;

        __noqch = screen->noqch;
        __mask_op = screen->mask_op;
        __mask_me = screen->mask_me;
        __mask_ue = screen->mask_ue;
        __mask_se = screen->mask_se;

        set_curterm(screen->term);
}

/*
 * does_esc_m --
 * A hack for xterm-like terminals where "\E[m" or "\E[0m" will turn off
 * other attributes, so we check for this in the capability passed to us.
 * Note that we can't just do simple string comparison, as the capability
 * may contain multiple, ';' separated sequence parts.
 */
static int
does_esc_m(const char *cap)
{
#define WAITING 0
#define PARSING 1
#define NUMBER 2
#define FOUND 4
        const char *capptr;
        int seq;

        __CTRACE(__CTRACE_INIT, "does_esc_m: Checking %s\n", cap);
        /* Is it just "\E[m" or "\E[0m"? */
        if (!strcmp(cap, "\x1b[m") || !strcmp(cap, "\x1b[0m"))
                return 1;

        /* Does it contain a "\E[...m" sequence? */
        if (strlen(cap) < 4)
                return 0;
        capptr = cap;
        seq = WAITING;
        while (*capptr != 0) {
                switch (seq) {
                /* Start of sequence */
                case WAITING:
                        if (!strncmp(capptr, "\x1b[", 2)) {
                                capptr+=2;
                                if (*capptr == 'm')
                                        return 1;
                                else {
                                        seq=PARSING;
                                        continue;
                                }
                        }
                        break;
                /* Looking for '0' */
                case PARSING:
                        if (*capptr == '0')
                                seq=FOUND;
                        else if (*capptr > '0' && *capptr <= '9')
                                seq=NUMBER;
                        else if (*capptr != ';')
                                seq=WAITING;
                        break;
                /* Some other number */
                case NUMBER:
                        if (*capptr == ';')
                                seq=PARSING;
                        else if (!(*capptr >= '0' && *capptr <= '9'))
                                seq=WAITING;
                        break;
                /* Found a '0' */
                case FOUND:
                        if (*capptr == 'm')
                                return 1;
                        else if (!((*capptr >= '0' && *capptr <= '9') ||
                            *capptr == ';'))
                                seq=WAITING;
                        break;
                default:
                        break;
                }
                capptr++;
        }
        return 0;
}

/*
 * capdup_nodelay --
 * A helper for does_ctrl_o below that creates a copy of the given
 * capability with delay specifications dropped.
 */
static char *
capdup_nodelay(const char *src)
{
        char *clean, *dst;

        dst = clean = malloc(strlen(src) + 1);
        if (__predict_false(clean == NULL))
                return NULL;

        while (*src != '\0') {
                if (src[0] == '$' && src[1] == '<') {
                        const char *end = strchr(src + 2, '>');
                        if (__predict_true(end != NULL)) {
                                src = end + 1;
                                continue;
                        }
                }
                *dst++ = *src++;
        }

        *dst = '\0';
        return clean;
}

/*
 * does_ctrl_o --
 * A hack for vt100/xterm-like terminals where the "me" capability also
 * unsets acs.
 */
static int
does_ctrl_o(const char *exit_cap, const char *acs_cap)
{
        char *eptr, *aptr;
        int res;

        __CTRACE(__CTRACE_INIT, "does_ctrl_o: Testing %s for %s\n",
            exit_cap, acs_cap);

        eptr = capdup_nodelay(exit_cap);
        if (__predict_false(eptr == NULL))
                return 0;

        aptr = capdup_nodelay(acs_cap);
        if (__predict_false(aptr == NULL)) {
                free(eptr);
                return 0;
        }

        res = strstr(eptr, aptr) != NULL;

        free(eptr);
        free(aptr);
        return res;
}

/*
 * set_tabsize --
 *   Sets the tabsize for the current screen.
 */
int
set_tabsize(int tabsize)
{

        if (_cursesi_screen == NULL)
                return ERR;
        _cursesi_screen->TABSIZE = tabsize;
        TABSIZE = tabsize;
        return OK;
}