#include <stdio.h>
#include <ownetapi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#include "parser.h"
#include "debug.h"
#include "string.h"
#include "utils.h"
#include "plugin.h"
#include "version.h"

static int parse_opts(const char *str, char *ow_path, size_t pathlen, double *offset)
{
	char *endptr;
	const char *start_str = str;
	const char offset_str[] = "offset=";

	if (!offset)
		return 0;

	/*
	 * Skip the onewire path entry. Options begin after the first
	 * white space
	 */
	for (; *str; str++)
		if (isspace(*str))
			break;

	/* Copy the onewire path without options */
	strncpy(ow_path, start_str, pathlen);
	ow_path[str - start_str] = '\0';

	/* Get the next non-space, which is where the argument begins */
	for (; *str; str++)
		if (!isspace(*str))
			break;

	if (strncmp(str, offset_str, sizeof(offset_str) - 1))
		return 0;
	str += sizeof(offset_str) - 1;

	*offset = strtod(str, &endptr);

	if (str != endptr)
		return 1;

	return 0;
}

static int make_uncached(char *path, size_t len)
{
	char p1[32], p2[32], *p = path;

	if (strstr(path, "/uncached/"))
		return 0;

	/*
	 * Naively assume the "uncached" string can be put after the
	 * first slash
	 */
	while (*p && *p != '/')
		p++;

	if (!*p)
		return -1;

	*p = 0;
	p++;

	strncpy(p1, path, sizeof(p1));
	strncpy(p2, p, sizeof(p2));
	snprintf(path, len, "%s/uncached/%s", p1, p2);

	return 0;
}

static int owfs_read(const char *mount_point, const char *path, char **res)
{
	char result[64];
	char file[2048];
	int fd, ret;

	snprintf(file, sizeof(file), "%s/%s", mount_point, path);

	fd = open(file, O_RDONLY | O_CLOEXEC);
	if (fd < 0) {
		pr_err("Failed to open file %s: %m\n", file);
		return -1;
	}

	ret = read(fd, result, sizeof(result));
	if (ret < 0) {
		pr_err("Failed to read from file %s: %m\n", file);
		goto out_close;
	}

	*res = strndup(result, sizeof(result));

out_close:
	close(fd);

	return ret;
}

static int is_mount_point(const char *str)
{
	/*
	 * Filesystem paths begin with a slash, everything else must
	 * be a network addresses
	 */
	if (str[0] == '/')
		return 1;

	return 0;
}

static int onewire_parser(char *rrd_data, const char **parser_data, void **s)
{
	OWNET_HANDLE h;
	const char *server_addr, *mount_point;
	char buf[24], *tmp;
	int i = 1, ret;
	int max_str = RRD_DATA_MAX_LEN;
	int is_mountpoint = is_mount_point(parser_data[0]);

	if (!parser_data) {
		pr_err("No parser data available\n");
		return -1;
	}

	if (is_mountpoint) {
		mount_point = parser_data[0];

		if (!mount_point) {
			pr_err("Server address not specified\n");
			return -1;
		}
	} else {
		server_addr = parser_data[0];

		if (!server_addr) {
			pr_err("Server address not specified\n");
			return -1;
		}

		h = OWNET_init(server_addr);
		if (h < 0) {
			pr_err("Failed to connect to server %s\n", server_addr);
			return -1;
		}
	}

	while (parser_data[i]) {
		double offset = 0, data;
		char *endptr;
		char ow_path[1024];
		int retries = 0;

		if (!strcmp("U", parser_data[i])) {
undefined:
			ret = snprintf(rrd_data, max_str, "U");
			max_str -= ret;
			rrd_data += ret;
			goto next;
		}

		parse_opts(parser_data[i], ow_path, sizeof(ow_path), &offset);

		while (1) {
			int fail, j;
			char *tmp2;

			tmp = NULL;
			pr_info("Reading data for entry %s with offset of %.2f\n",
				ow_path, offset);

			if (is_mountpoint)
				ret = owfs_read(mount_point, ow_path, &tmp);
			else
				ret = OWNET_read(h, ow_path, &tmp);

			/* Skip leading white space */
			tmp2 = tmp;
			for (j = 0; j < ret && *tmp2 == ' '; j++)
				tmp2++;

			if (ret > 0)
				fail = !strncmp(tmp2, "85", 2);
			else
				fail = 1;

			/*
			 * In case of failure, retry with uncached
			 * data. This is likely to help as it forces a
			 * retry even if the sensor is missing from
			 * the cache. We thread "85" also as a failure
			 * above, as temp sensors some times report 85
			 * under faulty conditions.
			 */
			if (ret > 0 && !fail)
				break;

			ret = make_uncached(ow_path, sizeof(ow_path));
			if (retries >= 10 || ret < 0) {
				pr_err("Failed to read entry %s: %m\n",
					parser_data[i]);
				goto undefined;
			}
			retries++;
			if (tmp)
				free(tmp);
		}

		/* The data from OWNET_read appears to not be NULL terminated */
		memcpy(buf, tmp, min(ret, sizeof(buf) -1));
		free(tmp);
		buf[ret] = 0;

		data = strtod(buf, &endptr);

		if (endptr == buf) {
			pr_err("Failed to parse data %s\n", buf);
			goto undefined;
		}

		data += offset;

		ret = snprintf(rrd_data, max_str, "%f", data);
		max_str -= ret;
		rrd_data += ret;

next:
		i++;
		if (!parser_data[i])
			break;

		ret = snprintf(rrd_data, max_str, ":");
		max_str -= ret;
		rrd_data += ret;
	}
	rrd_data = 0;

	if (!is_mountpoint)
		OWNET_finish();

	return 0;
}

static struct parser_info onewire_parser_info = {
	.name = "onewire",
	.parse = onewire_parser,
};

static int init_onewire_parser(void)
{
	return register_parser(&onewire_parser_info);
}

struct plugin_info plugin_info = {
	.name = "onewire_parser",
	.init = init_onewire_parser,
	.version = RRDD_VERSION,
};