/*
 * 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 2022 Oxide Computer Company
 */

#include <string.h>
#include <err.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ofmt.h>
#include <libdevinfo.h>
#include <strings.h>
#include <sys/debug.h>

#include "gpioadm.h"

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

static void __PRINTFLIKE(1)
gpioadm_controller_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:  gpioadm controller list [-H] [-o "
	    "field[,...] [-p]] [filter...]\n");
	(void) fprintf(stderr, "\nList GPIO controllers in the system and "
	    "associated information.\n\n"
	    "\t-H\t\tomit the column header\n"
	    "\t-o field\toutput fields to print\n"
	    "\t-p\t\tparsable output (requires -o)\n\n"
	    "The following fields are supported:\n"
	    "\tcontroller\tthe name of the controller\n"
	    "\tngpios\t\tthe number of GPIOs the controller has\n"
	    "\tndpios\t\tthe number of DPIOs the controller has\n"
	    "\tpath\t\tthe path to the minor node of the controller\n"
	    "\tprovider\tthe /devices path of the provider\n\n"
	    "Filters restrict output to the named controllers. Each filter is "
	    "treated\nlike an OR allowing one to limit output to specific "
	    "controllers. It is\nan error if a controller isn't found.\n");
}

typedef enum gpioadm_controller_list_otype {
	GPIOADM_CTRL_LIST_CTRLR,
	GPIOADM_CTRL_LIST_NGPIO,
	GPIOADM_CTRL_LIST_NDPIO,
	GPIOADM_CTRL_LIST_PATH,
	GPIOADM_CTRL_LIST_PROVIDER
} gpioadm_controllier_list_otype_t;

typedef struct gpioadm_controller_list_ofmt {
	const char *gclo_minor;
	const char *gclo_devpath;
	char *gclo_path;
	uint32_t gclo_ngpio;
	uint32_t gclo_ndpio;
} gpioadm_controller_list_ofmt_t;

static boolean_t
gpioadm_controller_list_ofmt_cb(ofmt_arg_t *ofarg, char *buf, uint_t buflen)
{
	gpioadm_controller_list_ofmt_t *gclo = ofarg->ofmt_cbarg;

	switch (ofarg->ofmt_id) {
	case GPIOADM_CTRL_LIST_CTRLR:
		if (strlcpy(buf, gclo->gclo_minor, buflen) >= buflen) {
			return (B_FALSE);
		}
		break;
	case GPIOADM_CTRL_LIST_NGPIO:
		if (snprintf(buf, buflen, "%u", gclo->gclo_ngpio) >= buflen) {
			return (B_FALSE);
		}
		break;
	case GPIOADM_CTRL_LIST_NDPIO:
		if (snprintf(buf, buflen, "%u", gclo->gclo_ndpio) >= buflen) {
			return (B_FALSE);
		}
		break;
	case GPIOADM_CTRL_LIST_PROVIDER:
		if (strlcpy(buf, gclo->gclo_devpath, buflen) >= buflen) {
			return (B_FALSE);
		}
		break;
	case GPIOADM_CTRL_LIST_PATH:
		/*
		 * Asking for the minor path can fail. So if we have nothing,
		 * just ignore this.
		 */
		if (gclo->gclo_path == NULL)
			break;
		if (strlcpy(buf, gclo->gclo_path, buflen) >= buflen) {
			return (B_FALSE);
		}
		break;
	default:
		abort();
	}
	return (B_TRUE);
}

static const char *gpioadm_controller_list_fields = "controller,ngpios,ndpios,"
	"provider";
static const ofmt_field_t gpioadm_controller_list_ofmt[] = {
	{ "CONTROLLER", 16, GPIOADM_CTRL_LIST_CTRLR,
	    gpioadm_controller_list_ofmt_cb },
	{ "NGPIOS", 8, GPIOADM_CTRL_LIST_NGPIO,
	    gpioadm_controller_list_ofmt_cb },
	{ "NDPIOS", 8, GPIOADM_CTRL_LIST_NDPIO,
	    gpioadm_controller_list_ofmt_cb },
	{ "PROVIDER", 42, GPIOADM_CTRL_LIST_PROVIDER,
	    gpioadm_controller_list_ofmt_cb },
	{ "PATH", 42, GPIOADM_CTRL_LIST_PATH,
	    gpioadm_controller_list_ofmt_cb },
	{ NULL, 0, 0, NULL }
};

typedef struct {
	ofmt_handle_t gcl_ofmt;
	uint32_t gcl_nprint;
	bool gcl_err;
	int gcl_nfilts;
	char **gcl_filts;
	bool *gcl_used;
} gpioadm_controller_list_t;

static bool
gpioadm_controller_list_cb(xpio_t *xpio, xpio_ctrl_disc_t *disc, void *arg)
{
	xpio_ctrl_t *ctrl;
	xpio_ctrl_info_t *info;
	gpioadm_controller_list_ofmt_t list;
	gpioadm_controller_list_t *gcl = arg;
	const char *mname = di_minor_name(disc->xcd_minor);

	if (gcl->gcl_nfilts > 0) {
		bool match = false;

		for (int i = 0; i < gcl->gcl_nfilts; i++) {
			if (strcmp(mname, gcl->gcl_filts[i]) == 0) {
				gcl->gcl_used[i] = true;
				match = true;
				break;
			}
		}

		if (!match) {
			return (true);
		}
	}

	if (!xpio_ctrl_init(xpio, disc->xcd_minor, &ctrl)) {
		gpioadm_warn("failed to initialize controller %s", mname);
		gcl->gcl_err = B_TRUE;
		return (true);
	}

	if (!xpio_ctrl_info(ctrl, &info)) {
		gpioadm_warn("failed to get controller info for %s", mname);
		xpio_ctrl_fini(ctrl);
		gcl->gcl_err = B_TRUE;
		return (true);
	}

	bzero(&list, sizeof (list));
	list.gclo_minor = mname;
	list.gclo_ngpio = xpio_ctrl_info_ngpios(info);
	list.gclo_ndpio = xpio_ctrl_info_ndpios(info);
	list.gclo_devpath = xpio_ctrl_info_devpath(info);
	list.gclo_path = di_devfs_minor_path(disc->xcd_minor);

	ofmt_print(gcl->gcl_ofmt, &list);
	gcl->gcl_nprint++;

	di_devfs_path_free(list.gclo_path);
	xpio_ctrl_info_free(info);
	xpio_ctrl_fini(ctrl);
	return (true);
}

static int
gpioadm_controller_list(int argc, char *argv[])
{
	int c;
	uint_t flags = 0;
	boolean_t parse = B_FALSE;
	const char *fields = NULL;
	ofmt_status_t oferr;
	ofmt_handle_t ofmt;
	gpioadm_controller_list_t gcl;

	(void) memset(&gcl, 0, sizeof (gcl));

	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 ':':
			gpioadm_controller_list_help("option -%c requires an "
			    "argument", optopt);
			exit(EXIT_USAGE);
		case '?':
			gpioadm_controller_list_help("unknown option: -%c",
			    optopt);
			exit(EXIT_USAGE);
		}
	}

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

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

	argc -= optind;
	argv += optind;
	if (argc > 0) {
		gcl.gcl_nfilts = argc;
		gcl.gcl_filts = argv;
		gcl.gcl_used = calloc(argc, sizeof (bool));
		if (gcl.gcl_used == NULL) {
			err(EXIT_FAILURE, "failed to allocate filter tracking "
			    "memory");
		}
	}
	oferr = ofmt_open(fields, gpioadm_controller_list_ofmt, flags, 0,
	    &ofmt);
	ofmt_check(oferr, parse, ofmt, gpioadm_ofmt_errx, warnx);

	gcl.gcl_nprint = 0;
	gcl.gcl_err = B_FALSE;
	gcl.gcl_ofmt = ofmt;
	xpio_ctrl_discover(gpioadm.gpio_xpio, gpioadm_controller_list_cb,
	    &gcl);

	for (int i = 0; i < gcl.gcl_nfilts; i++) {
		if (!gcl.gcl_used[i]) {
			warnx("filter '%s' did not match any controllers",
			    gcl.gcl_filts[i]);
			gcl.gcl_err = true;
		}
	}

	if (gcl.gcl_nprint == 0) {
		/*
		 * We only bother to warn about no controllers being found when
		 * there are no filters as otherwise the user would have gotten
		 * a message about unmatched filters just above.
		 */
		if (gcl.gcl_nfilts == 0) {
			warnx("no gpio controllers found");
		}
		gcl.gcl_err = true;
	}

	return (gcl.gcl_err ? EXIT_FAILURE : EXIT_SUCCESS);
}

static const gpioadm_cmdtab_t gpioadm_cmds_ctrl[] = {
	{ "list", gpioadm_controller_list, gpioadm_controller_list_usage },
	{ NULL, NULL, NULL }
};

int
gpioadm_controller(int argc, char *argv[])
{
	return (gpioadm_walk_tab(gpioadm_cmds_ctrl, argc, argv));
}

void
gpioadm_controller_usage(FILE *f)
{
	gpioadm_walk_usage(gpioadm_cmds_ctrl, f);
}