#include "wdt.h"
#include "wdt-private.h"
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <fcntl.h>

#define WDT_MAX_TIMEOUT     40
#define WDT_CMD_BUFLEN      32
#define WDT_MAX_NAME_LEN    64

#define WDT_CMD_INIT_DONE   "init-done"
#define WDT_CMD_INIT_START  "init-start " /* init-start <time> */
#define WDT_CMD_REGISTER    "register " /* register <name> */
#define WDT_CMD_RELEASE     "release"
#define WDT_CMD_START       "start " /* start <name> */
#define WDT_CMD_TIMEOUT     "timeout " /* timeout <time> */
#define WDT_CMD_TRIGGER     "trigger"

/**
 */
int watchdog_announce(const char *name, int timeout)
{
	int ret = WDT_OK;
	int fd;

	if (timeout < 0) {
		return WDT_INVALID_TIMEOUT;
	}

	if (name == NULL) {
		return WDT_INVALID_NAME;
	}

	if (strlen(name) > WDT_MAX_NAME_LEN) {
		return WDT_INVALID_NAME;
	}

	fd = watchdog_open_device();
	if (fd < 0) {
		return fd;
	}

	if (dprintf(fd, WDT_CMD_START "%s", name) < 0) {
		switch (errno) {
		case EBADF:
			ret = WDT_UNKNOWN_HANDLE;
			goto wdt_error;
		default:
			ret = WDT_RESOURCE_ERROR;
			goto wdt_error;
		}
	}
	watchdog_settimeout(fd + 1, timeout);
wdt_error:
	close(fd);

	return ret;
}

/**
 */
int watchdog_init_start(int timeout)
{
	int ret = WDT_OK;
	int fd;

	if (timeout < 0) {
		return WDT_INVALID_TIMEOUT;
	}

	fd = watchdog_open_device();
	if (fd < 0) {
		return fd;
	}

	if (dprintf(fd, WDT_CMD_INIT_START "%d", timeout) < 0) {
		switch (errno) {
		case EBADF:
			ret =  WDT_UNKNOWN_HANDLE;
			break;
		default:
			ret = WDT_RESOURCE_ERROR;
		}
	}
	close(fd);

	return ret;
}

/**
 */
int watchdog_init_done(void)
{
	int ret = WDT_OK;
	int fd;

	fd = watchdog_open_device();
	if (fd < 0) {
		return fd;
	}

	if (write(fd, WDT_CMD_INIT_DONE, strlen(WDT_CMD_INIT_DONE)) < 0) {
		switch (errno) {
		case EBADF:
			ret = WDT_UNKNOWN_HANDLE;
			break;
		default:
			ret = WDT_RESOURCE_ERROR;
		}
	}
	close(fd);

	return ret;
}

#if 0
/**
 */
int watchdog_log(const char *__restrict format, ...)
{
	FILE *fd;
	va_list arg;

	fd = fopen("/var/wdtlog", "a+");

	va_start(arg, format);
	vfprintf(fd, format, arg);
	va_end(arg);

	fclose(fd);
}
#endif

/**
 */
int watchdog_register(const char *name)
{
	int ret;
	int fd;

	if (name == NULL) {
		return WDT_INVALID_NAME;
	}

	if (strlen(name) > WDT_MAX_NAME_LEN) {
		return WDT_INVALID_NAME;
	}

	fd = watchdog_open_device();
	if (fd < 0) {
		return fd;
	}

	if (dprintf(fd, WDT_CMD_REGISTER "%s", name) < 0) {
		switch (errno) {
		case EBADF:
			ret =  WDT_UNKNOWN_HANDLE;
			goto wdt_error;
		default:
			ret = WDT_RESOURCE_ERROR;
			goto wdt_error;
		}
	}

	return fd + 1;
wdt_error:
	close(fd);
	return ret;
}

/**
 */
int watchdog_get_fd(int handle)
{
	return handle - 1;
}

/**
 */
int watchdog_release(int handle)
{
	handle--;
	if (handle < 0) {
		return WDT_UNKNOWN_HANDLE;
	}

	if (write(handle, WDT_CMD_RELEASE, strlen(WDT_CMD_RELEASE)) < 0) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}
	close(handle);

	return WDT_OK;
}

/**
 */
int watchdog_settimeout(int handle, int timeout)
{
	handle--;
	if (handle < 0) {
		return WDT_UNKNOWN_HANDLE;
	}

	if (timeout <= 0) {
		return WDT_INVALID_TIMEOUT;
	}

	if (dprintf(handle, WDT_CMD_TIMEOUT "%d", timeout) < 0) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}

	return WDT_OK;
}

/**
 */
int watchdog_trigger(int handle)
{
	handle--;
	if (handle < 0) {
		return WDT_UNKNOWN_HANDLE;
	}
	if (write(handle, WDT_CMD_TRIGGER, strlen(WDT_CMD_TRIGGER)) < 0) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}

	return WDT_OK;
}

/**
 */
static int watchdog_set_non_blocking(int fd)
{
	int flags;

	flags = fcntl(fd, F_GETFL);
	if (flags == -1) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}

	if ((flags & O_NONBLOCK)) {
		return WDT_OK;
	}

	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags)) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}

	return WDT_OK;
}

/**
 */
static int watchdog_set_blocking(int fd)
{
	int flags;

	flags = fcntl(fd, F_GETFL);
	if (flags == -1) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}

	if ((flags & O_NONBLOCK) == 0) {
		return WDT_OK;
	}

	flags &= ~O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags)) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}

	return WDT_OK;
}

/**
 */
int watchdog_wait(int handle)
{
	char c;
	int ret;

	handle--;
	if (handle < 0) {
		return WDT_UNKNOWN_HANDLE;
	}
	watchdog_set_blocking(handle);
	ret = read(handle, (void *)&c, 1);
	if (ret < 0) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}
	return WDT_REQUEST;
}

/**
 */
int watchdog_poll(int handle)
{
	char c;
	int ret;

	handle--;
	if (handle < 0) {
		return WDT_UNKNOWN_HANDLE;
	}
	watchdog_set_non_blocking(handle);
	ret = read(handle, (void *)&c, 1);
	if (ret < 0) {
		switch (errno) {
		case EBADF:
			return WDT_UNKNOWN_HANDLE;
		case EAGAIN:
			return WDT_OK;
		default:
			return WDT_RESOURCE_ERROR;
		}
	}
	return WDT_REQUEST;
}