/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2025 Oxide Computer Company
 */

/*
 * i2cadm port related operations.
 */

#include <stdarg.h>
#include <string.h>
#include <err.h>
#include <sys/sysmacros.h>
#include <ofmt.h>
#include <sys/debug.h>

#include "i2cadm.h"

static void
i2cadm_port_map_usage(FILE *f)
{
	(void) fprintf(f, "\ti2cadm port map [-o field,[...] [-H] [-p]] "
	    "<port>\n");
}

static void
i2cadm_port_map_help(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
	}

	(void) fprintf(stderr, "Usage:  i2cadm port map [-o field,[...] [-H] "
	    "[-p]] <port>\n");
	(void) fprintf(stderr, "\nPrint port address usage\n\n"
	    "\t-H\t\tomit the column header (requires -o)\n"
	    "\t-o field\toutput fields to print\n"
	    "\t-p\t\tparseable output (requires -o)\n");
	(void) fprintf(stderr, "\nThe following fields are supported when "
	    "using -o:\n"
	    "\taddr\t\tthe I2C address\n"
	    "\tcount\t\tthe number of devices using address\n"
	    "\ttype\t\tdescribes how the address is being used\n"
	    "\tmajor\t\tthe major number using a shared address\n"
	    "\tdriver\t\tthe driver name using a shared address\n");
}

typedef enum {
	I2CADM_MAP_TYPE_NONE,
	I2CADM_MAP_TYPE_LOCAL,
	I2CADM_MAP_TYPE_DS,
	I2CADM_MAP_TYPE_SHARED,
	I2CADM_MAP_TYPE_ERROR
} i2cadm_map_type_t;

typedef struct i2cadm_map {
	i2cadm_map_type_t map_type;
	uint32_t map_count;
	major_t map_major;
	char *map_shared;
} i2cadm_map_t;

typedef struct {
	major_t mn_major;
	char *mn_name;
} major_to_name_t;

int
i2cadm_major_to_name_cb(di_node_t node, void *arg)
{
	major_to_name_t *m = arg;
	if (di_driver_major(node) == m->mn_major) {
		const char *name = di_driver_name(node);
		if (name != NULL) {
			m->mn_name = strdup(name);
			if (m->mn_name == NULL) {
				err(EXIT_FAILURE, "failed to allocate memory "
				    "to duplicate driver name for major 0x%x",
				    m->mn_major);
			}
		}
		return (DI_WALK_TERMINATE);
	}
	return (DI_WALK_CONTINUE);
}

/*
 * Major number to name, the kind of max power way. While we could maybe parse
 * /etc/name_to_major, which really should be some set of library routines to be
 * honest, we're instead going to just walk a devinfo snapshot until we we find
 * a node with a matching major. The thing is, the node is present and a driver
 * is attached, otherwise it wouldn't have a shared address.
 */
static char *
i2cadm_major_to_name(major_t m)
{
	major_to_name_t arg = { .mn_major = m };
	di_node_t root = di_init("/", DINFOSUBTREE);
	if (root == DI_NODE_NIL) {
		err(EXIT_FAILURE, "failed to take devinfo snapshot");
	}

	(void) di_walk_node(root, DI_WALK_CLDFIRST, &arg,
	    i2cadm_major_to_name_cb);

	di_fini(root);
	return (arg.mn_name);
}

typedef enum {
	I2CADM_PORT_MAP_ADDR,
	I2CADM_PORT_MAP_COUNT,
	I2CADM_PORT_MAP_TYPE,
	I2CADM_PORT_MAP_MAJOR,
	I2CADM_PORT_MAP_DRIVER
} i2adm_port_map_otype_t;

typedef struct {
	uint16_t ipm_addr;
	const i2cadm_map_t *ipm_map;
} i2cadm_port_map_ofmt_t;

static boolean_t
i2cadm_port_map_ofmt_cb(ofmt_arg_t *ofarg, char *buf, uint_t buflen)
{
	i2cadm_port_map_ofmt_t *arg = ofarg->ofmt_cbarg;
	size_t len;
	const char *str;

	switch (ofarg->ofmt_id) {
	case I2CADM_PORT_MAP_ADDR:
		len = snprintf(buf, buflen, "%u", arg->ipm_addr);
		break;
	case I2CADM_PORT_MAP_COUNT:
		len = snprintf(buf, buflen, "%u", arg->ipm_map->map_count);
		break;
	case I2CADM_PORT_MAP_TYPE:
		switch (arg->ipm_map->map_type) {
		case I2CADM_MAP_TYPE_NONE:
			str = "none";
			break;
		case I2CADM_MAP_TYPE_LOCAL:
			str = "local";
			break;
		case I2CADM_MAP_TYPE_DS:
			str = "downstream";
			break;
		case I2CADM_MAP_TYPE_SHARED:
			str = "shared";
			break;
		case I2CADM_MAP_TYPE_ERROR:
			str = "error";
			break;
		default:
			abort();
		}
		len = strlcpy(buf, str, buflen);
		break;
	case I2CADM_PORT_MAP_MAJOR:
		if (arg->ipm_map->map_type == I2CADM_MAP_TYPE_SHARED) {
			len = snprintf(buf, buflen, "%u",
			    arg->ipm_map->map_major);
		} else {
			len = strlcpy(buf, "-", buflen);
		}
		break;
	case I2CADM_PORT_MAP_DRIVER:
		if (arg->ipm_map->map_type == I2CADM_MAP_TYPE_SHARED) {
			str = arg->ipm_map->map_shared;
			if (str == NULL)
				str = "unknown";
		} else {
			str = "-";
		}
		len = strlcpy(buf, str, buflen);
		break;
	default:
		return (B_FALSE);
	}

	return (len < buflen);
}

static const ofmt_field_t i2cadm_port_map_ofmt[] = {
	{ "ADDR", 8, I2CADM_PORT_MAP_ADDR, i2cadm_port_map_ofmt_cb },
	{ "COUNT", 8, I2CADM_PORT_MAP_COUNT, i2cadm_port_map_ofmt_cb },
	{ "TYPE", 16, I2CADM_PORT_MAP_TYPE, i2cadm_port_map_ofmt_cb },
	{ "MAJOR", 8, I2CADM_PORT_MAP_MAJOR, i2cadm_port_map_ofmt_cb },
	{ "DRIVER", 16, I2CADM_PORT_MAP_DRIVER, i2cadm_port_map_ofmt_cb },
	{ NULL, 0, 0, NULL }
};

static const char *key = ""
"\t- = No Device      L = Local Device\n"
"\tS = Shared         v = Downstream\n"
"\t                   E = Error\n";

static bool
i2cadm_port_map_table_cb(void *arg, uint16_t addr)
{
	const i2cadm_map_t *results = arg;
	bool shared = false;

	switch (results[addr].map_type) {
	case I2CADM_MAP_TYPE_NONE:
		(void) printf("%3s", "-");
		break;
	case I2CADM_MAP_TYPE_LOCAL:
		(void) printf("%3s", "L");
		break;
	case I2CADM_MAP_TYPE_DS:
		(void) printf("%2uv", results[addr].map_count);
		break;
	case I2CADM_MAP_TYPE_SHARED:
		shared = true;
		(void) printf("%2uS", results[addr].map_count);
		break;
	case I2CADM_MAP_TYPE_ERROR:
		(void) printf("%3s", "E");
		break;
	}

	return (shared);
}

static void
i2cadm_port_map_table_post(void *arg, uint16_t max_addr)
{
	const i2cadm_map_t *results = arg;
	(void) printf("\nShared Address Owners:\n");

	for (uint16_t i = 0; i < max_addr; i++) {
		if (results[i].map_type != I2CADM_MAP_TYPE_SHARED)
			continue;

		const char *name = results[i].map_shared;
		if (name == NULL)
			name = "unknown";
		if (max_addr > UINT8_MAX) {
			(void) printf("0x%03x: %s (%u)\n", i, name,
			    results[i].map_major);
		} else {
			(void) printf("0x%02x: %s (%u)\n", i, name,
			    results[i].map_major);
		}
	}
}

static int
i2cadm_port_map(int argc, char *argv[])
{
	int c;
	i2c_port_t *port;
	i2c_port_map_t *map;
	uint16_t max_addr = 1 << 7;
	i2cadm_map_t *results;
	boolean_t parse = B_FALSE;
	uint_t flags = 0;
	const char *fields = NULL;
	ofmt_status_t oferr;
	ofmt_handle_t ofmt;

	while ((c = getopt(argc, argv, ":Ho:p")) != -1) {
		switch (c) {
		case 'H':
			flags |= OFMT_NOHEADER;
			break;
		case 'o':
			fields = optarg;
			break;
		case 'p':
			parse = B_TRUE;
			flags |= OFMT_PARSABLE;
			break;
		case ':':
			i2cadm_port_map_help("option -%c requires an argument",
			    optopt);
			exit(EXIT_USAGE);
		case '?':
			i2cadm_port_map_help("unknown option: -%c", optopt);
			exit(EXIT_USAGE);
		}
	}

	argv += optind;
	argc -= optind;
	if (argc == 0) {
		errx(EXIT_USAGE, "missing required port");
	} else if (argc > 1) {
		errx(EXIT_USAGE, "encountered extraneous arguments starting "
		    "with %s", argv[1]);
	}

	if (!i2c_port_init_by_path(i2cadm.i2c_hdl, argv[0], &port)) {
		i2cadm_fatal("failed to parse port path %s", argv[0]);
	}

	if (!i2c_port_map_snap(port, &map)) {
		i2cadm_fatal("failed to get port map");
	}

	if (parse && fields == NULL) {
		errx(EXIT_USAGE, "-p requires fields specified with -o");
	}

	if (flags != 0 && fields == NULL) {
		errx(EXIT_USAGE, "-H can only be used with -o");
	}

	if (fields != NULL) {
		if (!parse) {
			flags |= OFMT_WRAP;
		}

		oferr = ofmt_open(fields, i2cadm_port_map_ofmt, flags, 0,
		    &ofmt);
		ofmt_check(oferr, parse, ofmt, i2cadm_ofmt_errx, warnx);
	}

	results = calloc(max_addr, sizeof (i2cadm_map_t));
	if (results == NULL) {
		err(EXIT_FAILURE, "failed to allocate port map results "
		    "tracking structure");
	}

	for (uint16_t i = 0; i < max_addr; i++) {
		i2c_addr_t addr = { I2C_ADDR_7BIT, i };
		bool ds;
		uint32_t ndevs;
		major_t major;

		if (!i2c_port_map_addr_info(map, &addr, &ndevs, &ds, &major)) {
			results[i].map_type = I2CADM_MAP_TYPE_ERROR;
			continue;
		}

		if (ndevs == 0) {
			results[i].map_type = I2CADM_MAP_TYPE_NONE;
			continue;
		}

		results[i].map_count = ndevs;
		if (major != DDI_MAJOR_T_NONE) {
			results[i].map_type = I2CADM_MAP_TYPE_SHARED;
			results[i].map_shared = i2cadm_major_to_name(major);
			results[i].map_major = major;
		} else if (ds) {
			results[i].map_type = I2CADM_MAP_TYPE_DS;
		} else {
			VERIFY3U(ndevs, ==, 1);
			results[i].map_type = I2CADM_MAP_TYPE_LOCAL;
		}
	}

	if (fields == NULL) {
		i2cadm_table_t table = {
			.table_port = argv[0],
			.table_key = key,
			.table_msg = "Address map for",
			.table_max = max_addr,
			.table_cb = i2cadm_port_map_table_cb,
			.table_post = i2cadm_port_map_table_post
		};
		i2cadm_print_table(&table, results);
	} else {
		for (uint16_t i = 0; i < max_addr; i++) {
			i2cadm_port_map_ofmt_t arg = {
				.ipm_addr = i,
				.ipm_map = &results[i]
			};
			ofmt_print(ofmt, &arg);
		}
		ofmt_close(ofmt);
	}

	for (uint16_t i = 0; i < max_addr; i++) {
		free(results[i].map_shared);
	}
	free(results);
	i2c_port_map_free(map);
	i2c_port_fini(port);
	return (0);
}

static void
i2cadm_port_list_usage(FILE *f)
{
	(void) fprintf(f, "\ti2cadm port list [-H] [-o field,[...] [-p]] "
	    "[filter]\n");
}

typedef enum {
	I2CADM_PORT_LIST_PATH,
	I2CADM_PORT_LIST_TYPE,
	I2CADM_PORT_LIST_NAME,
	I2CADM_PORT_LIST_NUM,
	I2CADM_PORT_LIST_NDEVS,
	I2CADM_PORT_LIST_TDEVS
} i2cadm_port_list_otype_tt;

typedef struct i2cadm_port_list_ofmt {
	i2c_port_t *ipl_port;
	i2c_port_map_t *ipl_map;
} i2cadm_port_list_ofmt_t;

static void
i2cadm_port_list_help(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
	}

	(void) fprintf(stderr, "Usage:  i2cadm port list [-H] "
	    "[-o field[,...] [-p]] [filter...]\n\n");
	(void) fprintf(stderr, "List I2C ports in the system. Each <filter> "
	    "selects ports based upon its\ntype, name, or the I2C path. "
	    "Multiple filters are treated as an OR. It is an\nerror if a "
	    "filter isn't used.\n\n"
	    "\t-H\t\tomit the column header\n"
	    "\t-o field\toutput fields to print\n"
	    "\t-p\t\tparseable output (requires -o)\n");
	(void) fprintf(stderr, "\nThe following fields are supported:\n"
	    "\tpath\t\tthe I2C path of the port\n"
	    "\ttype\t\tthe type of I2C port: controller or multiplexor\n"
	    "\tname\t\tthe port's name\n"
	    "\tportno\t\tthe system's port number (zero based)\n"
	    "\tndevs\t\tthe number of device's directly attached to this port\n"
	    "\ttdevs\t\tthe total number of devices under this port\n");
}

static boolean_t
i2cadm_port_list_ofmt_cb(ofmt_arg_t *ofarg, char *buf, uint_t buflen)
{
	uint32_t local, ds;
	i2cadm_port_list_ofmt_t *arg = ofarg->ofmt_cbarg;
	size_t len;

	switch (ofarg->ofmt_id) {
	case I2CADM_PORT_LIST_PATH:
		len = strlcpy(buf, i2c_port_path(arg->ipl_port), buflen);
		break;
	case I2CADM_PORT_LIST_TYPE:
		switch (i2c_port_type(arg->ipl_port)) {
		case I2C_PORT_TYPE_CTRL:
			len = strlcat(buf, "controller", buflen);
			break;
		case I2C_PORT_TYPE_MUX:
			len = strlcat(buf, "multiplexor", buflen);
			break;
		default:
			len = snprintf(buf, buflen, "unknown: 0x%x",
			    i2c_port_type(arg->ipl_port));
			break;
		}
		break;
	case I2CADM_PORT_LIST_NAME:
		len = strlcpy(buf, i2c_port_name(arg->ipl_port), buflen);
		break;
	case I2CADM_PORT_LIST_NUM:
		len = snprintf(buf, buflen, "%u",
		    i2c_port_portno(arg->ipl_port));
		break;
	case I2CADM_PORT_LIST_NDEVS:
		i2c_port_map_ndevs(arg->ipl_map, &local, NULL);
		len = snprintf(buf, buflen, "%u", local);
		break;
	case I2CADM_PORT_LIST_TDEVS:
		i2c_port_map_ndevs(arg->ipl_map, &local, &ds);
		len = snprintf(buf, buflen, "%u", local + ds);
		break;
	default:
		return (B_FALSE);
	}

	return (len < buflen);
}

static const char *i2cadm_port_list_fields = "path,type,portno,ndevs,tdevs";
static const ofmt_field_t i2cadm_port_list_ofmt[] = {
	{ "NAME", 12, I2CADM_PORT_LIST_NAME, i2cadm_port_list_ofmt_cb },
	{ "TYPE", 14, I2CADM_PORT_LIST_TYPE, i2cadm_port_list_ofmt_cb },
	{ "PORTNO", 8, I2CADM_PORT_LIST_NUM, i2cadm_port_list_ofmt_cb },
	{ "NDEVS", 8, I2CADM_PORT_LIST_NDEVS, i2cadm_port_list_ofmt_cb },
	{ "TDEVS", 8, I2CADM_PORT_LIST_TDEVS, i2cadm_port_list_ofmt_cb },
	{ "PATH", 32, I2CADM_PORT_LIST_PATH, i2cadm_port_list_ofmt_cb },
	{ NULL, 0, 0, NULL }
};

/*
 * We accept the following filters for matching ports:
 *
 *  - Matching on the ports name
 *  - Matching on the port's type
 *  - Matching on a portion of the port's path
 */
static bool
i2cadm_port_list_filt(const i2cadm_port_list_ofmt_t *arg, int nfilts,
    char **filts, bool *used)
{
	bool match = false;
	const char *type, *name, *path;

	if (nfilts == 0) {
		return (true);
	}

	name = i2c_port_name(arg->ipl_port);
	path = i2c_port_path(arg->ipl_port);
	size_t pathlen = strlen(path);
	if (i2c_port_type(arg->ipl_port) == I2C_PORT_TYPE_CTRL) {
		type = "controller";
	} else {
		type = "multiplexor";
	}

	for (int i = 0; i < nfilts; i++) {
		if (strcmp(filts[i], name) == 0) {
			used[i] = true;
			match = true;
			continue;
		}

		if (strcmp(filts[i], type) == 0) {
			used[i] = true;
			match = true;
			continue;
		}

		if (strcmp(filts[i], path) == 0) {
			used[i] = true;
			match = true;
			continue;
		}

		size_t len = strlen(filts[i]);
		if (len < pathlen && strncmp(path, filts[i], len) == 0) {
			used[i] = true;
			match = true;
			continue;
		}
	}

	return (match);
}

static int
i2cadm_port_list(int argc, char *argv[])
{
	int c, ret = EXIT_SUCCESS;
	uint_t flags = 0;
	boolean_t parse = B_FALSE;
	const char *fields = NULL;
	bool *filts = NULL, print = false;
	ofmt_status_t oferr;
	ofmt_handle_t ofmt;
	i2c_port_iter_t *iter;
	i2c_iter_t iret;
	const i2c_port_disc_t *disc;

	while ((c = getopt(argc, argv, ":Ho:p")) != -1) {
		switch (c) {
		case 'H':
			flags |= OFMT_NOHEADER;
			break;
		case 'o':
			fields = optarg;
			break;
		case 'p':
			parse = B_TRUE;
			flags |= OFMT_PARSABLE;
			break;
		case ':':
			i2cadm_port_list_help("option -%c requires an "
			    "argument", optopt);
			exit(EXIT_USAGE);
		case '?':
			i2cadm_port_list_help("unknown option: -%c",
			    optopt);
			exit(EXIT_USAGE);
		}
	}

	if (parse && fields == NULL) {
		errx(EXIT_USAGE, "-p requires fields specified with -o");
	}

	if (!parse) {
		flags |= OFMT_WRAP;
	}

	if (fields == NULL) {
		fields = i2cadm_port_list_fields;
	}

	argc -= optind;
	argv += optind;

	if (argc > 0) {
		filts = calloc(argc, sizeof (bool));
		if (filts == NULL) {
			err(EXIT_FAILURE, "failed to allocate memory for "
			    "filter tracking");
		}
	}

	oferr = ofmt_open(fields, i2cadm_port_list_ofmt, flags, 0, &ofmt);
	ofmt_check(oferr, parse, ofmt, i2cadm_ofmt_errx, warnx);


	if (!i2c_port_discover_init(i2cadm.i2c_hdl, &iter)) {
		i2cadm_fatal("failed to in initialize port discovery");
	}

	while ((iret = i2c_port_discover_step(iter, &disc)) == I2C_ITER_VALID) {
		i2cadm_port_list_ofmt_t arg;

		if (!i2c_port_init(i2cadm.i2c_hdl, i2c_port_disc_devi(disc),
		    &arg.ipl_port)) {
			i2cadm_warn("failed to initialize port %s",
			    i2c_port_disc_path(disc));
			continue;
		}

		if (!i2c_port_map_snap(arg.ipl_port, &arg.ipl_map)) {
			i2cadm_warn("failed to get port map for %s",
			    i2c_port_disc_path(disc));
			i2c_port_fini(arg.ipl_port);
			continue;
		}

		if (i2cadm_port_list_filt(&arg, argc, argv, filts)) {
			ofmt_print(ofmt, &arg);
			print = true;
		}

		i2c_port_map_free(arg.ipl_map);
		i2c_port_fini(arg.ipl_port);
	}

	if (iret == I2C_ITER_ERROR) {
		i2cadm_warn("failed to discover ports");
		ret = EXIT_FAILURE;
	}

	for (int i = 0; i < argc; i++) {
		if (!filts[i]) {
			warnx("filter '%s' did not match any ports",
			    argv[i]);
			ret = EXIT_FAILURE;
		}
	}

	if (!print && argc == 0) {
		warnx("no I2C ports found");
		ret = EXIT_FAILURE;
	}

	i2c_port_discover_fini(iter);
	return (ret);
}

static i2cadm_cmdtab_t i2cadm_port_cmds[] = {
	{ "list", i2cadm_port_list, i2cadm_port_list_usage },
	{ "map", i2cadm_port_map, i2cadm_port_map_usage },
};

int
i2cadm_port(int argc, char *argv[])
{
	return (i2cadm_walk_tab(i2cadm_port_cmds, ARRAY_SIZE(i2cadm_port_cmds),
	    argc, argv));
}

void
i2cadm_port_usage(FILE *f)
{
	i2cadm_walk_usage(i2cadm_port_cmds, ARRAY_SIZE(i2cadm_port_cmds), f);
}