// Copyright(c) 2018-2020, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * 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.
// * Neither the name  of Intel Corporation  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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER  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.

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif // HAVE_CONFIG_H
#include <errno.h>
#include <getopt.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#ifdef _WIN32
#define EX_OK 0
#define EX_USAGE (-1)
#define EX_SOFTWARE (-2)
#define EX_TEMPFAIL (-3)
#else
#include <sysexits.h>
#endif

#include "argsfilter.h"
#include "opae/fpga.h"

#include "fpgainfo.h"

#include "errors.h"
#include "fmeinfo.h"
#include "portinfo.h"
#include "tempinfo.h"
#include "powerinfo.h"
#include "bmcinfo.h"
#include "board.h"

void help(void);

typedef fpga_result (*filter_fn)(fpga_properties *, int, char **);
typedef fpga_result (*command_fn)(fpga_token *, int, int, char **);
typedef void (*help_fn)(void);

// define a list of command words and
// function ptrs to the command handler
static struct command_handler {
	const char *command;
	filter_fn filter;
	command_fn run;
	help_fn help;
} cmd_array[] = {
	{.command = "errors",
	 .filter = errors_filter,
	 .run = errors_command,
	 .help = errors_help},
	{.command = "power",
	 .filter = power_filter,
	 .run = power_command,
	 .help = power_help},
	{.command = "temp",
	 .filter = temp_filter,
	 .run = temp_command,
	 .help = temp_help},
	{.command = "fme",
	 .filter = fme_filter,
	 .run = fme_command,
	 .help = fme_help},
	{.command = "port",
	 .filter = port_filter,
	 .run = port_command,
	 .help = port_help},
	{.command = "perf",
	 .filter = bmc_filter,
	 .run = perf_command,
	 .help = perf_help},
	{.command = "bmc",
	 .filter = bmc_filter,
	 .run = bmc_command,
	 .help = bmc_help},
	{.command = "mac",
	 .filter = mac_filter,
	 .run = mac_command,
	 .help = mac_help},
	{.command = "phy",
	 .filter = phy_filter,
	 .run = phy_command,
	 .help = phy_help},
	{.command = "security",
	 .filter = sec_filter,
	 .run = sec_command,
	 .help = sec_help},
};

/*
 * Parse command line arguments
 */
#define MAIN_GETOPT_STRING "+hv"
int parse_args(int argc, char *argv[])
{
	struct option longopts[] = {
		{"help", no_argument, NULL, 'h'},
		{"version", no_argument, NULL, 'v'},
		{0, 0, 0, 0},
	};

	int getopt_ret = -1;
	int option_index = 0;
	if (argc < 2) {
		help();
		return EX_USAGE;
	}

	while (-1
	       != (getopt_ret = getopt_long(argc, argv, MAIN_GETOPT_STRING,
					    longopts, &option_index))) {
		const char *tmp_optarg = optarg;

		if ((optarg) && ('=' == *tmp_optarg))
			++tmp_optarg;

		switch (getopt_ret) {
		case 'h': /* help */
			help();
			return EX_TEMPFAIL;

		case 'v': /* version */
			printf("fpgainfo %s %s%s\n",
			       OPAE_VERSION,
			       OPAE_GIT_COMMIT_HASH,
			       OPAE_GIT_SRC_TREE_DIRTY ? "*":"");
			return EX_TEMPFAIL;

		case ':': /* missing option argument */
			OPAE_ERR("Missing option argument\n");
			return EX_USAGE;

		case '?':
		default: /* invalid option */
			OPAE_ERR("Invalid cmdline options\n");
			return EX_USAGE;
		}
	}

	optind = 0;
	return EX_OK;
}

struct command_handler *get_command(char *cmd)
{
	int cmd_size = sizeof(cmd_array) / sizeof(cmd_array[0]);
	// find the command handler for the command
	int i = 0;
	for (i = 0; i < cmd_size; ++i) {
		if (!strcmp(cmd, cmd_array[i].command)) {
			return &cmd_array[i];
		}
	}
	return NULL;
}

/*
 * Print help
 */
void help(void)
{
	unsigned int i;

	printf("\n"
	       "fpgainfo\n"
	       "FPGA information utility\n"
	       "\n"
	       "Usage:\n"
	       "        fpgainfo [-h] [-B <bus>] [-D <device>] "
	       "[-F <function>] [-S <socket-id>] {");
	printf("%s", cmd_array[0].command);
	for (i = 1; i < sizeof(cmd_array) / sizeof(cmd_array[0]); i++) {
		printf(",%s", cmd_array[i].command);
	}
	printf("}\n\n"
	       "                -h,--help           Print this help\n"
	       "                -v,--version        Print version and exit\n"
	       "                -B,--bus            Set target bus number\n"
	       "                -D,--device         Set target device number\n"
	       "                -F,--function       Set target function number\n"
	       "                -S,--socket-id      Set target socket number\n"
	       "                --segment           Set target segment\n"
	       "\n");

	printf("Subcommands:\n");
	for (i = 0; i < sizeof(cmd_array) / sizeof(cmd_array[0]); i++) {
		cmd_array[i].help();
	}
}

int main(int argc, char *argv[])
{
	int ret_value = EX_OK;
	fpga_result res = FPGA_OK;
	uint32_t matches = 0;
	uint32_t i = 0;
	fpga_properties filter = NULL;
	fpga_token *tokens = NULL;

	if (NULL == setlocale(LC_ALL, "")) {
		OPAE_ERR("Could not set locale\n");
		return EX_SOFTWARE;
	}

	// start a filter using the first level command line arguments
	res = fpgaGetProperties(NULL, &filter);
	ON_FPGAINFO_ERR_GOTO(res, out_err, "creating properties object");

	ret_value = set_properties_from_args(filter, &res, &argc, argv);
	if (ret_value != EX_OK) {
		goto out_destroy;
	}

	ret_value = parse_args(argc, argv);
	if (ret_value != EX_OK) {
		fpgaDestroyProperties(&filter);
		return ret_value == EX_TEMPFAIL ? EX_OK : ret_value;
	}

	uint32_t num_tokens = 0;
	struct command_handler *handler = get_command(argv[1]);
	if (handler == NULL) {
		OPAE_ERR("Invalid command specified\n");
		help();
		goto out_destroy;
	}
	if (handler->filter) {
		res = handler->filter(&filter, argc, argv);
		ON_FPGAINFO_ERR_GOTO(res, out_destroy, 0);
	}
	res = fpgaEnumerate(&filter, 1, NULL, 0, &matches);
	ON_FPGAINFO_ERR_GOTO(res, out_destroy, "enumerating resources");

	if (0 == matches) {
		ret_value = EX_SOFTWARE;
		OPAE_ERR("No FPGA resources found.\n");
		goto out_destroy;
	}

	num_tokens = matches;
	tokens = (fpga_token *)malloc(num_tokens * sizeof(fpga_token));
	res = fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches);
	ON_FPGAINFO_ERR_GOTO(res, out_destroy_tokens, "enumerating resources");
	if (num_tokens != matches) {
		ret_value = EX_SOFTWARE;
		OPAE_ERR("token list changed in between enumeration calls\n");
		goto out_destroy_tokens;
	}

	res = handler->run(tokens, matches, argc, argv);

out_destroy_tokens:
	for (i = 0; i < num_tokens; i++) {
	    fpgaDestroyToken(&tokens[i]);
	}
	free(tokens);

out_destroy:
	if (res != FPGA_OK)
		ret_value = EX_SOFTWARE;
	fpgaDestroyProperties(&filter); /* not needed anymore */
out_err:
	return ret_value;
}