/*      $OpenBSD: util.c,v 1.71 2025/12/18 09:47:20 helg Exp $ */
/*      $NetBSD: util.c,v 1.8 2000/03/14 08:11:53 sato Exp $ */

/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Juergen Hannken-Illjes.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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/ioctl.h>
#include <sys/time.h>
#include <dev/wscons/wsconsio.h>
#include <dev/wscons/wsksymdef.h>
#include <err.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include "wsconsctl.h"
#include "mousecfg.h"

#define TABLEN(t)               (sizeof(t)/sizeof(t[0]))

extern struct wskbd_map_data kbmap;     /* from keyboard.c */
extern struct wskbd_map_data newkbmap;  /* from map_parse.y */
extern struct wsmouse_calibcoords wmcoords;     /* from mouse.c */

struct nameint {
        int value;
        char *name;
};

static const struct nameint kbtype_tab[] = {
        { WSKBD_TYPE_LK201,     "lk201" },
        { WSKBD_TYPE_LK401,     "lk401" },
        { WSKBD_TYPE_PC_XT,     "pc-xt" },
        { WSKBD_TYPE_PC_AT,     "pc-at" },
        { WSKBD_TYPE_USB,       "usb" },
        { WSKBD_TYPE_NEXT,      "NeXT" },
        { WSKBD_TYPE_HPC_KBD,   "hpc-kbd" },
        { WSKBD_TYPE_HPC_BTN,   "hpc-btn" },
        { WSKBD_TYPE_ADB,       "adb" },
        { WSKBD_TYPE_SUN,       "sun" },
        { WSKBD_TYPE_SUN5,      "sun5" },
        { WSKBD_TYPE_HIL,       "hil" },
        { WSKBD_TYPE_GSC,       "hp-ps2" },
        { WSKBD_TYPE_LUNA,      "luna" },
        { WSKBD_TYPE_ZAURUS,    "zaurus" },
        { WSKBD_TYPE_DOMAIN,    "domain" },
        { WSKBD_TYPE_BLUETOOTH, "bluetooth" },
        { WSKBD_TYPE_KPC,       "kpc" },
        { WSKBD_TYPE_SGI,       "sgi" },
};

static const struct nameint mstype_tab[] = {
        { WSMOUSE_TYPE_VSXXX,   "dec-tc" },
        { WSMOUSE_TYPE_PS2,     "ps2" },
        { WSMOUSE_TYPE_USB,     "usb" },
        { WSMOUSE_TYPE_LMS,     "lms" },
        { WSMOUSE_TYPE_MMS,     "mms" },
        { WSMOUSE_TYPE_TPANEL,  "touch-panel" },
        { WSMOUSE_TYPE_NEXT,    "NeXT" },
        { WSMOUSE_TYPE_ARCHIMEDES, "archimedes" },
        { WSMOUSE_TYPE_ADB,     "adb" },
        { WSMOUSE_TYPE_HIL,     "hil" },
        { WSMOUSE_TYPE_LUNA,    "luna" },
        { WSMOUSE_TYPE_DOMAIN,  "domain" },
        { WSMOUSE_TYPE_BLUETOOTH, "bluetooth" },
        { WSMOUSE_TYPE_SUN,     "sun" },
        { WSMOUSE_TYPE_SYNAPTICS, "synaptics" },
        { WSMOUSE_TYPE_ALPS,    "alps" },
        { WSMOUSE_TYPE_SGI,     "sgi" },
        { WSMOUSE_TYPE_ELANTECH, "elantech" },
        { WSMOUSE_TYPE_SYNAP_SBTN, "synaptics" },
        { WSMOUSE_TYPE_TOUCHPAD, "touchpad" },
};

static const struct nameint dpytype_tab[] = {
        { WSDISPLAY_TYPE_UNKNOWN,       "unknown" },
        { WSDISPLAY_TYPE_PM_MONO,       "dec-pm-mono" },
        { WSDISPLAY_TYPE_PM_COLOR,      "dec-pm-color" },
        { WSDISPLAY_TYPE_CFB,           "dec-cfb" },
        { WSDISPLAY_TYPE_XCFB,          "dec-xcfb" },
        { WSDISPLAY_TYPE_MFB,           "dec-mfb" },
        { WSDISPLAY_TYPE_SFB,           "dec-sfb" },
        { WSDISPLAY_TYPE_ISAVGA,        "vga-isa" },
        { WSDISPLAY_TYPE_PCIVGA,        "vga-pci" },
        { WSDISPLAY_TYPE_TGA,           "dec-tga-pci" },
        { WSDISPLAY_TYPE_SFBP,          "dec-sfb+" },
        { WSDISPLAY_TYPE_PCIMISC,       "generic-pci" },
        { WSDISPLAY_TYPE_NEXTMONO,      "next-mono" },
        { WSDISPLAY_TYPE_PX,            "dec-px" },
        { WSDISPLAY_TYPE_PXG,           "dec-pxg" },
        { WSDISPLAY_TYPE_TX,            "dec-tx" },
        { WSDISPLAY_TYPE_HPCFB,         "generic-hpc" },
        { WSDISPLAY_TYPE_VIDC,          "arm-vidc" },
        { WSDISPLAY_TYPE_SPX,           "dec-spx" },
        { WSDISPLAY_TYPE_GPX,           "dec-gpx" },
        { WSDISPLAY_TYPE_LCG,           "dec-lcg" },
        { WSDISPLAY_TYPE_VAX_MONO,      "dec-mono" },
        { WSDISPLAY_TYPE_SB_P9100,      "p9100" },
        { WSDISPLAY_TYPE_EGA,           "ega" },
        { WSDISPLAY_TYPE_DCPVR,         "powervr" },
        { WSDISPLAY_TYPE_SUN24,         "sun24" },
        { WSDISPLAY_TYPE_SUNBW,         "sunbw" },
        { WSDISPLAY_TYPE_STI,           "hp-sti" },
        { WSDISPLAY_TYPE_SUNCG3,        "suncg3" },
        { WSDISPLAY_TYPE_SUNCG6,        "suncg6" },
        { WSDISPLAY_TYPE_SUNFFB,        "sunffb" },
        { WSDISPLAY_TYPE_SUNCG14,       "suncg14" },
        { WSDISPLAY_TYPE_SUNCG2,        "suncg2" },
        { WSDISPLAY_TYPE_SUNCG4,        "suncg4" },
        { WSDISPLAY_TYPE_SUNCG8,        "suncg8" },
        { WSDISPLAY_TYPE_SUNTCX,        "suntcx" },
        { WSDISPLAY_TYPE_AGTEN,         "agten" },
        { WSDISPLAY_TYPE_XVIDEO,        "xvideo" },
        { WSDISPLAY_TYPE_SUNCG12,       "suncg12" },
        { WSDISPLAY_TYPE_MGX,           "mgx" },
        { WSDISPLAY_TYPE_SB_P9000,      "p9000" },
        { WSDISPLAY_TYPE_RFLEX,         "rasterflex" },
        { WSDISPLAY_TYPE_LUNA,          "luna" },
        { WSDISPLAY_TYPE_DVBOX,         "davinci" },
        { WSDISPLAY_TYPE_GBOX,          "gatorbox" },
        { WSDISPLAY_TYPE_RBOX,          "renaissance" },
        { WSDISPLAY_TYPE_HYPERION,      "hyperion" },
        { WSDISPLAY_TYPE_TOPCAT,        "topcat" },
        { WSDISPLAY_TYPE_PXALCD,        "pxalcd" },
        { WSDISPLAY_TYPE_MAC68K,        "mac68k" },
        { WSDISPLAY_TYPE_SUNLEO,        "sunleo" },
        { WSDISPLAY_TYPE_TVRX,          "tvrx" },
        { WSDISPLAY_TYPE_CFXGA,         "cfxga" },
        { WSDISPLAY_TYPE_LCSPX,         "dec-lcspx" },
        { WSDISPLAY_TYPE_GBE,           "gbe" },
        { WSDISPLAY_TYPE_LEGSS,         "dec-legss" },
        { WSDISPLAY_TYPE_IFB,           "ifb" },
        { WSDISPLAY_TYPE_RAPTOR,        "raptor" },
        { WSDISPLAY_TYPE_DL,            "displaylink" },
        { WSDISPLAY_TYPE_MACHFB,        "mach64" },
        { WSDISPLAY_TYPE_GFXP,          "gfxp" },
        { WSDISPLAY_TYPE_RADEONFB,      "radeon" },
        { WSDISPLAY_TYPE_SMFB,          "smfb" },
        { WSDISPLAY_TYPE_SISFB,         "sisfb" },
        { WSDISPLAY_TYPE_ODYSSEY,       "odyssey" },
        { WSDISPLAY_TYPE_IMPACT,        "impact" },
        { WSDISPLAY_TYPE_GRTWO,         "grtwo" },
        { WSDISPLAY_TYPE_NEWPORT,       "newport" },
        { WSDISPLAY_TYPE_LIGHT,         "light" },
        { WSDISPLAY_TYPE_INTELDRM,      "inteldrm" },
        { WSDISPLAY_TYPE_RADEONDRM,     "radeondrm" },
        { WSDISPLAY_TYPE_EFIFB,         "efifb" },
        { WSDISPLAY_TYPE_KMS,           "kms" },
        { WSDISPLAY_TYPE_ASTFB,         "astfb" },
        { WSDISPLAY_TYPE_VIOGPU,        "viogpu" }
};

static const struct nameint kbdenc_tab[] = {
        KB_ENCTAB
};

static const struct nameint kbdvar_tab[] = {
        KB_VARTAB
};

char *int2name(int, int, const struct nameint *, int);
int name2int(char *, const struct nameint *, int);
void print_kmap(struct wskbd_map_data *);
void print_emul(struct wsdisplay_emultype *);
void print_screen(struct wsdisplay_screentype *);

struct field *
field_by_name(struct field *field_tab, char *name)
{
        const char *p = strchr(name, '.');

        if (!p++)
                errx(1, "%s: illegal variable name", name);

        for (; field_tab->name; field_tab++)
                if (strcmp(field_tab->name, p) == 0)
                        return (field_tab);

        errx(1, "%s: not found", name);
}

struct field *
field_by_value(struct field *field_tab, void *addr)
{
        for (; field_tab->name; field_tab++)
                if (field_tab->valp == addr)
                        return (field_tab);

        errx(1, "internal error: field_by_value: not found");
}

char *
int2name(int val, int uflag, const struct nameint *tab, int len)
{
        static char tmp[20];
        int i;

        for (i = 0; i < len; i++)
                if (tab[i].value == val)
                        return(tab[i].name);

        if (uflag) {
                snprintf(tmp, sizeof(tmp), "unknown_%d", val);
                return(tmp);
        } else
                return(NULL);
}

int
name2int(char *val, const struct nameint *tab, int len)
{
        int i;

        for (i = 0; i < len; i++)
                if (strcmp(tab[i].name, val) == 0)
                        return(tab[i].value);
        return(-1);
}

void
pr_field(const char *pre, struct field *f, const char *sep)
{
        struct field_pc *pc;
        u_int flags;
        int i, n;
        char *p;

        if (sep)
                printf("%s.%s%s", pre, f->name, sep);

        switch (f->format) {
        case FMT_UINT:
                printf("%u", *((u_int *) f->valp));
                break;
        case FMT_INT:
                printf("%d", *((int *) f->valp));
                break;
        case FMT_BOOL:
                printf("%s", *((u_int *) f->valp)? "on" : "off");
                break;
        case FMT_PC:
                pc = f->valp;
                i = pc->max - pc->min;
                n = pc->cur - pc->min;
                printf("%u.%02u%%", n * 100 / i, ((n * 100) % i) * 100 / i);
                break;
        case FMT_KBDTYPE:
                p = int2name(*((u_int *) f->valp), 1,
                             kbtype_tab, TABLEN(kbtype_tab));
                printf("%s", p);
                break;
        case FMT_MSTYPE:
                p = int2name(*((u_int *) f->valp), 1,
                             mstype_tab, TABLEN(mstype_tab));
                printf("%s", p);
                break;
        case FMT_DPYTYPE:
                p = int2name(*((u_int *) f->valp), 1,
                             dpytype_tab, TABLEN(dpytype_tab));
                printf("%s", p);
                break;
        case FMT_KBDENC:
                p = int2name(KB_ENCODING(*((u_int *) f->valp)), 1,
                             kbdenc_tab, TABLEN(kbdenc_tab));
                printf("%s", p);

                flags = KB_VARIANT(*((u_int *) f->valp));
                for (i = 0; i < 32; i++) {
                        if (!(flags & (1 << i)))
                                continue;
                        p = int2name(flags & (1 << i), 1,
                                     kbdvar_tab, TABLEN(kbdvar_tab));
                        printf(".%s", p);
                }
                break;
        case FMT_KBMAP:
                print_kmap((struct wskbd_map_data *) f->valp);
                break;
        case FMT_SCALE:
                printf("%d,%d,%d,%d,%d,%d,%d", wmcoords.minx, wmcoords.maxx,
                    wmcoords.miny, wmcoords.maxy, wmcoords.swapxy,
                    wmcoords.resx, wmcoords.resy);
                break;
        case FMT_EMUL:
                print_emul((struct wsdisplay_emultype *) f->valp);
                break;
        case FMT_SCREEN:
                print_screen((struct wsdisplay_screentype *) f->valp);
                break;
        case FMT_STRING:
                printf("%s", (const char *)f->valp);
                break;
        case FMT_CFG:
                mousecfg_pr_field((struct wsmouse_parameters *) f->valp);
                break;
        default:
                errx(1, "internal error: pr_field: no format %d", f->format);
                break;
        }

        printf("\n");
}

void
rd_field(struct field *f, char *val, int merge)
{
        struct wscons_keymap *mp;
        struct field_pc *pc;
        u_int u, r, fr;
        char *p;
        int i;

        switch (f->format) {
        case FMT_UINT:
                if (sscanf(val, "%u", &u) != 1)
                        errx(1, "%s: not a number", val);
                if (merge)
                        *((u_int *) f->valp) += u;
                else
                        *((u_int *) f->valp) = u;
                break;
        case FMT_INT:
                if (sscanf(val, "%d", &i) != 1)
                        errx(1, "%s: not a number", val);
                if (merge)
                        *((int *) f->valp) += i;
                else
                        *((int *) f->valp) = i;
                break;
        case FMT_BOOL:
                if (*val != 'o' || (val[1] != 'n' &&
                    (val[1] != 'f' || val[2] != 'f')))
                        errx(1, "%s: invalid value (on/off)", val);
                *((u_int *) f->valp) = val[1] == 'n'? 1 : 0;
                break;
        case FMT_PC:
                fr = 0;
                if ((i = sscanf(val, "%u.%u%%", &u, &fr)) != 2 && i != 1)
                        errx(1, "%s: not a valid number", val);
                pc = f->valp;
                r = pc->max - pc->min;
                i = pc->min + (r * u) / 100 + (r * fr) / 100 / 100;
                if (merge == '+')
                        pc->cur += i;
                else if (merge == '-')
                        pc->cur -= i;
                else
                        pc->cur = i;
                if (pc->cur > pc->max)
                        pc->cur = pc->max;
                if (pc->cur < pc->min)
                        pc->cur = pc->min;
                break;
        case FMT_KBDENC:
                p = strchr(val, '.');
                if (p != NULL)
                        *p++ = '\0';

                i = name2int(val, kbdenc_tab, TABLEN(kbdenc_tab));
                if (i == -1)
                        errx(1, "%s: not a valid encoding", val);
                *((u_int *) f->valp) = i;

                while (p) {
                        val = p;
                        p = strchr(p, '.');
                        if (p != NULL)
                                *p++ = '\0';
                        i = name2int(val, kbdvar_tab, TABLEN(kbdvar_tab));
                        if (i == -1)
                                errx(1, "%s: not a valid variant", val);
                        *((u_int *) f->valp) |= i;
                }
                break;
        case FMT_KBMAP:
                if (! merge)
                        kbmap.maplen = 0;
                map_scan_setinput(val);
                yyparse();
                if (merge) {
                        if (newkbmap.maplen < kbmap.maplen)
                                newkbmap.maplen = kbmap.maplen;
                        for (i = 0; i < kbmap.maplen; i++) {
                                mp = newkbmap.map + i;
                                if (mp->command == KS_voidSymbol &&
                                    mp->group1[0] == KS_voidSymbol &&
                                    mp->group1[1] == KS_voidSymbol &&
                                    mp->group2[0] == KS_voidSymbol &&
                                    mp->group2[1] == KS_voidSymbol)
                                        *mp = kbmap.map[i];
                        }
                }
                kbmap.maplen = newkbmap.maplen;
                bcopy(newkbmap.map, kbmap.map,
                      kbmap.maplen*sizeof(struct wscons_keymap));
                break;
        case FMT_SCALE:
        {
                const char *errstr = 0;

                /* Unspecified values default to 0. */
                bzero(&wmcoords, sizeof(wmcoords));
                val = (void *)strtok(val, ",");
                if (val != NULL) {
                        wmcoords.minx = (int)strtonum(val,
                            -32768, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (!errstr && val != NULL) {
                        wmcoords.maxx = (int)strtonum(val,
                            -32768, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (!errstr && val != NULL) {
                        wmcoords.miny = (int)strtonum(val,
                            -32768, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (!errstr && val != NULL) {
                        wmcoords.maxy = (int)strtonum(val,
                            -32768, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (!errstr && val != NULL) {
                        wmcoords.swapxy = (int)strtonum(val,
                            -32768, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (!errstr && val != NULL) {
                        wmcoords.resx = (int)strtonum(val,
                            0, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (!errstr && val != NULL) {
                        wmcoords.resy = (int)strtonum(val,
                            0, 32767, &errstr);
                        val = (void *)strtok(NULL, ",");
                }
                if (errstr)
                        errx(1, "calibration value is %s", errstr);
                if (val != NULL)
                        errx(1, "too many calibration values");

                break;
        }
        case FMT_STRING:
                strlcpy(f->valp, val, WSFONT_NAME_SIZE);
                break;
        case FMT_CFG:
                mousecfg_rd_field((struct wsmouse_parameters *) f->valp, val);
                break;
        default:
                errx(1, "internal error: rd_field: no format %d", f->format);
                break;
        }
}

void
print_kmap(struct wskbd_map_data *map)
{
        struct wscons_keymap *mp;
        int i;

        for (i = 0; i < map->maplen; i++) {
                mp = map->map + i;

                if (mp->command == KS_voidSymbol &&
                    mp->group1[0] == KS_voidSymbol &&
                    mp->group1[1] == KS_voidSymbol &&
                    mp->group2[0] == KS_voidSymbol &&
                    mp->group2[1] == KS_voidSymbol)
                        continue;
                printf("\n");
                printf("keycode %u =", i);
                if (mp->command != KS_voidSymbol)
                        printf(" %s", ksym2name(mp->command));
                printf(" %s", ksym2name(mp->group1[0]));
                if (mp->group1[0] != mp->group1[1] ||
                    mp->group1[0] != mp->group2[0] ||
                    mp->group1[0] != mp->group2[1]) {
                        printf(" %s", ksym2name(mp->group1[1]));
                        if (mp->group1[0] != mp->group2[0] ||
                            mp->group1[1] != mp->group2[1]) {
                                printf(" %s", ksym2name(mp->group2[0]));
                                printf(" %s", ksym2name(mp->group2[1]));
                        }
                }
        }
        ksymenc(0);
}

void
print_emul(struct wsdisplay_emultype *emuls)
{
        struct wsdisplay_emultype e;
        int fd,i;
        char c='\0';

        fd=emuls->idx;
        e.idx=0;
        i = ioctl(fd, WSDISPLAYIO_GETEMULTYPE, &e);
        while(i == 0) {
                if (c != '\0')
                        printf("%c", c);
                printf("%s", e.name);
                c=',';
                e.idx++;
                i = ioctl(fd, WSDISPLAYIO_GETEMULTYPE, &e);
        }
}

void
print_screen(struct wsdisplay_screentype *screens)
{
        struct wsdisplay_screentype s;
        int fd,i;
        char c='\0';

        fd=screens->idx;
        s.idx=0;
        i = ioctl(fd, WSDISPLAYIO_GETSCREENTYPE, &s);
        while(i == 0) {
                if (c != '\0')
                        printf("%c", c);
                printf("%s", s.name);
                c=',';
                s.idx++;
                i = ioctl(fd, WSDISPLAYIO_GETSCREENTYPE, &s);
        }
}