// 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 <signal.h>
#include "fpgad.h"
#include "monitor_thread.h"
#include "event_dispatcher_thread.h"
#include "events_api_thread.h"

#ifdef LOG
#undef LOG
#endif
#define LOG(format, ...) \
log_printf("main: " format, ##__VA_ARGS__)

struct fpgad_config global_config;

void sig_handler(int sig, siginfo_t *info, void *unused)
{
	UNUSED_PARAM(info);
	UNUSED_PARAM(unused);
	switch (sig) {
	case SIGINT:
		// Process interrupted.
		LOG("Got SIGINT. Exiting.\n");
		global_config.running = false;
		break;
	case SIGTERM:
		// Process terminated.
		LOG("Got SIGTERM. Exiting.\n");
		global_config.running = false;
		break;
	}
}

int main(int argc, char *argv[])
{
	int res;
	FILE *fp;

	memset(&global_config, 0, sizeof(global_config));

	global_config.poll_interval_usec = 100 * 1000;
	global_config.running = true;
	global_config.api_socket = "/tmp/fpga_event_socket";
	global_config.num_null_gbs = 0;

	log_set(stdout);

	res = cmd_parse_args(&global_config, argc, argv);
	if (res != 0) {
		if (res == -2)
			res = 0;
		else
			LOG("error parsing command line.\n");
		goto out_destroy;
	}

	if (cmd_canonicalize_paths(&global_config)) {
		LOG("error with paths.\n");
		goto out_destroy;
	}

	if (global_config.daemon) {

		res = daemonize(sig_handler,
				global_config.filemode,
				global_config.directory);
		if (res != 0) {
			LOG("daemonize failed: %s\n", strerror(res));
			goto out_destroy;
		}


	} else {
		struct sigaction sa;

		memset(&sa, 0, sizeof(sa));
		sa.sa_flags = SA_SIGINFO | SA_RESETHAND;
		sa.sa_sigaction = sig_handler;

		res = sigaction(SIGINT, &sa, NULL);
		if (res < 0) {
			LOG("failed to register SIGINT handler.\n");
			goto out_destroy;
		}

		res = sigaction(SIGTERM, &sa, NULL);
		if (res < 0) {
			LOG("failed to register SIGTERM handler.\n");
			goto out_destroy;
		}
	}

	if (log_open(global_config.logfile) < 0) {
		LOG("failed to open log file\n");
		res = 1;
		goto out_destroy;
	}

	fp = fopen(global_config.pidfile, "w");
	if (NULL == fp) {
		LOG("failed to open pid file\n");
		res = 1;
		goto out_destroy;
	}
	fprintf(fp, "%d\n", getpid());
	fclose(fp);

	res = mon_enumerate(&global_config);
	if (res) {
		LOG("OPAE device enumeration failed\n");
		goto out_destroy;
	}

	res = pthread_create(&global_config.event_dispatcher_thr,
			     NULL,
			     event_dispatcher_thread,
			     &event_dispatcher_config);
	if (res) {
		LOG("failed to create event_dispatcher_thread\n");
		global_config.running = false;
		goto out_destroy;
	}

	while (!evt_dispatcher_is_ready())
		usleep(1);

	res = pthread_create(&global_config.monitor_thr,
			     NULL,
			     monitor_thread,
			     &monitor_config);
	if (res) {
		LOG("failed to create monitor_thread\n");
		global_config.running = false;
		goto out_stop_event_dispatcher;
	}

	res = pthread_create(&global_config.events_api_thr,
			     NULL,
			     events_api_thread,
			     &events_api_config);
	if (res) {
		LOG("failed to create events_api_thread\n");
		global_config.running = false;
		goto out_stop_monitor;
	}

	if (pthread_join(global_config.events_api_thr, NULL)) {
		LOG("failed to join events_api_thread\n");
	}
out_stop_monitor:
	if (pthread_join(global_config.monitor_thr, NULL)) {
		LOG("failed to join monitor_thread\n");
	}
out_stop_event_dispatcher:
	if (pthread_join(global_config.event_dispatcher_thr, NULL)) {
		LOG("failed to join event_dispatcher_thread\n");
	}
out_destroy:
	mon_destroy(&global_config);
	cmd_destroy(&global_config);
	log_close();
	return res;
}