// Copyright(c) 2017-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 <pthread.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>

#include "error_int.h"

#include "token_list_int.h"

/* global list of tokens we've seen */
static struct token_map *token_root;
/* mutex to protect global data structures */
extern pthread_mutex_t global_lock;

/**
 * @brief Add entry to linked list for tokens
 *	Will allocate memory (which is freed by token_cleanup())
 *
 * @param sysfspath
 * @param devpath
 *
 * @return
 */
struct _fpga_token *token_add(const char *sysfspath, const char *devpath)
{
	struct token_map *tmp;
	int err = 0;
	uint32_t device_instance;
	uint32_t subdev_instance;
	char *endptr = NULL;
	const char *ptr;
	size_t len;

	/* get the device instance id */
	ptr = strchr(sysfspath, '.');
	if (ptr == NULL) {
		OPAE_MSG("sysfspath does not meet expected format");
		return NULL;
	}

	device_instance = strtoul(++ptr, &endptr, 10);
	/* no digits in path */
	if (endptr == ptr) {
		OPAE_MSG("sysfspath does not meet expected format");
		return NULL;
	}

	/* get the sub-device (FME/Port) instance id */
	ptr = strrchr(sysfspath, '.');
	if (ptr == NULL) {
		OPAE_MSG("sysfspath does not meet expected format");
		return NULL;
	}

	subdev_instance = strtoul(++ptr, &endptr, 10);
	/* no digits in path */
	if (endptr == ptr) {
		OPAE_MSG("sysfspath does not meet expected format");
		return NULL;
	}

	if (pthread_mutex_lock(&global_lock)) {
		OPAE_MSG("Failed to lock global mutex");
		return NULL;
	}

	/* Prevent duplicate entries. */
	for (tmp = token_root ; NULL != tmp ; tmp = tmp->next) {
		if ((0 == strncmp(sysfspath, tmp->_token.sysfspath,
						SYSFS_PATH_MAX)) &&
				(0 == strncmp(devpath, tmp->_token.devpath,
					      DEV_PATH_MAX))) {
			err = pthread_mutex_unlock(&global_lock);
			if (err) {
				OPAE_ERR("pthread_mutex_unlock() failed: %S", strerror(err));
			}
			return &tmp->_token;
		}
	}

	tmp = malloc(sizeof(struct token_map));
	if (!tmp) {
		err = pthread_mutex_unlock(&global_lock);
		if (err) {
			OPAE_ERR("pthread_mutex_unlock() failed: %S", strerror(err));
		}
		return NULL;
	}


	/* populate error list */
	tmp->_token.errors = NULL;
	char errpath[SYSFS_PATH_MAX] = { 0, };

	if (snprintf(errpath, sizeof(errpath),
		     "%s/errors", sysfspath) < 0) {
		OPAE_ERR("snprintf buffer overflow");
		free(tmp);
		if (pthread_mutex_unlock(&global_lock)) {
			OPAE_ERR("pthread_mutex_unlock() failed: %S", strerror(err));
		}
		return NULL;
	}

	build_error_list(errpath, &tmp->_token.errors);

	/* mark data structure as valid */
	tmp->_token.magic = FPGA_TOKEN_MAGIC;

	/* assign the instances num from above */
	tmp->_token.device_instance = device_instance;
	tmp->_token.subdev_instance = subdev_instance;

	/* deep copy token data */
	len = strnlen(sysfspath, SYSFS_PATH_MAX - 1);
	memcpy(tmp->_token.sysfspath, sysfspath, len);
	tmp->_token.sysfspath[len] = '\0';

	len = strnlen(devpath, DEV_PATH_MAX - 1);
	memcpy(tmp->_token.devpath, devpath, len);
	tmp->_token.devpath[len] = '\0';

	tmp->next = token_root;
	token_root = tmp;

	err = pthread_mutex_unlock(&global_lock);
	if (err) {
		OPAE_ERR("pthread_mutex_unlock() failed: %S", strerror(err));
	}

	return &tmp->_token;
}

/**
 * @ brief Find the token that is the parent of _t
 *
 * @param _t
 *
 * @return parent of _t, or NULL if not found.
 */
struct _fpga_token *token_get_parent(struct _fpga_token *_t)
{
	char *p;
	char spath[SYSFS_PATH_MAX] = { 0, };
	char rpath[PATH_MAX] = { 0, };
	struct token_map *itr;
	int err = 0;
	char *rptr = NULL;
	fpga_result res = FPGA_OK;

	p = strstr(_t->sysfspath, FPGA_SYSFS_AFU);
	if (!p) // FME objects have no parent.
		return NULL;

	res = sysfs_get_fme_path(_t->sysfspath, spath);
	if (res) {
		OPAE_ERR("Could not find fme path for token: %s",
			 _t->sysfspath);
		return NULL;
	}

	if (pthread_mutex_lock(&global_lock)) {
		OPAE_MSG("Failed to lock global mutex");
		return NULL;
	}

	for (itr = token_root ; NULL != itr ; itr = itr->next) {
		rptr = realpath(itr->_token.sysfspath, rpath);
		if (rptr && !strncmp(spath, rptr, SYSFS_PATH_MAX)) {
			err = pthread_mutex_unlock(&global_lock);
			if (err) {
				OPAE_ERR("pthread_mutex_unlock() failed: %S", strerror(err));
			}
			return &itr->_token;
		}
	}

	err = pthread_mutex_unlock(&global_lock);
	if (err) {
		OPAE_ERR("pthread_mutex_unlock() failed: %S", strerror(err));
	}

	return NULL;
}

/*
 * Clean up remaining entries in linked list
 * Will delete all remaining entries
 */
void token_cleanup(void)
{
	int err = 0;
	struct error_list *p;

	err = pthread_mutex_lock(&global_lock);
	if (err) {
		OPAE_ERR("pthread_mutex_lock() failed: %s", strerror(err));
		return;
	}

	if (!token_root)
		goto out_unlock;

	while (token_root->next) {
		struct token_map *tmp = token_root;
		token_root = token_root->next;

		// free error list
		p = tmp->_token.errors;
		while (p) {
			struct error_list *q = p->next;
			free(p);
			p = q;
		}

		// invalidate magic (just in case)
		tmp->_token.magic = FPGA_INVALID_MAGIC;
		free(tmp);
	}

	// free error list
	p = token_root->_token.errors;
	while (p) {
		struct error_list *q = p->next;
		free(p);
		p = q;
	}

	// invalidate magic (just in case)
	token_root->_token.magic = FPGA_INVALID_MAGIC;
	free(token_root);

	token_root = NULL;

out_unlock:
	err = pthread_mutex_unlock(&global_lock);
	if (err) {
		OPAE_ERR("pthread_mutex_unlock() failed: %s", strerror(err));
	}
}