/*
 * SPDX-License-Identifier: AGPL-3.0-only
 * Copyright (c) Camden Dixie O'Brien
 */

#include "time_manager.h"

#include "console.h"
#include "settings.h"
#include "time_sntp.h"
#include "time_storage.h"

#include "esp_log.h"
#include "esp_timer.h"
#include "fatal.h"
#include <string.h>
#include <sys/time.h>

#define TAG "Time"

#define TM_YEAR_OFFSET 1900
#define TM_MONTH_OFFSET 1

#define UPDATE_PERIOD_US 1000000UL
#define MAX_CALLBACKS 8

static TimeCallback callbacks[MAX_CALLBACKS];
static unsigned callback_count;

static void handle_timezone_update(const char *timezone)
{
	setenv("TZ", timezone, 1);
	tzset();
	time_sntp_restart();
}

static void run_callbacks(void *arg)
{
	const Time time = get_time();
	for (unsigned i = 0; i < callback_count; ++i)
		callbacks[i](time);
}

static int time_command_func(int argc, char **argv)
{
	if (argc == 1) {
		const Time time = get_time();
		printf("%02u:%02u:%02u\n", time.hour, time.minute, time.second);
		return 0;
	} else if (argc == 2) {
		if (strcmp(argv[1], "store") == 0) {
			time_storage_save();
			return 0;
		} else {
			Time time;
			const int result = sscanf(
			    argv[1], "%02u:%02u:%02u", &time.hour, &time.minute,
			    &time.second);
			if (result < 2 || time.hour > 23 || time.minute > 59
			    || time.second > 59) {
				printf("Invalid time\n");
				return 1;
			}
			set_time(time);
			return 0;
		}
	} else {
		printf("Invalid number of arguments\n");
		return 1;
	}
}

static int date_command_func(int argc, char **argv)
{
	if (argc == 1) {
		const Date date = get_date();
		printf("%04u-%02u-%02u\n", date.year, date.month, date.day);
		return 0;
	} else if (argc == 2) {
		if (strcmp(argv[1], "week-day") == 0) {
			const WeekDay day = get_week_day();
			printf("%s\n", week_day_name(day));
			return 0;
		}
		Date date;
		const int result = sscanf(
		    argv[1], "%04u-%02u-%02u", &date.year, &date.month, &date.day);
		if (result != 3 || date.month == 0 || date.month > 12
		    || date.day == 0 || date.day > 31) {
			printf("Invalid date\n");
			return 1;
		}
		set_date(date);
		return 0;
	} else {
		printf("Invalid number of arguments\n");
		return 1;
	}
}

void time_manager_init(void)
{
	esp_err_t error;

	callback_count = 0;

	time_sntp_init();
	time_storage_init();

	char timezone[SETTINGS_MAX_VALUE_SIZE];
	(void)settings_get_timezone(timezone, SETTINGS_MAX_VALUE_SIZE);
	handle_timezone_update(timezone);
	settings_add_timezone_callback(&handle_timezone_update);

	esp_timer_handle_t update_timer;
	const esp_timer_create_args_t update_timer_config = {
		.callback = &run_callbacks,
		.arg = NULL,
		.name = "time updates",
	};
	error = esp_timer_create(&update_timer_config, &update_timer);
	if (error != ESP_OK) {
		ESP_LOGE(TAG, "Error creating update timer: %04x", error);
		FATAL();
	}
	error = esp_timer_start_periodic(update_timer, UPDATE_PERIOD_US);
	if (error != ESP_OK) {
		ESP_LOGE(TAG, "Error starting update timer: %04x", error);
		FATAL();
	}

	console_register(
	    "time", "Get, set or store the time",
	    "time [hh:mm:ss] OR time store", time_command_func);
	console_register(
	    "date", "Get or set the date, or get the day of the week",
	    "date [yyyy-mm-dd] OR date week-day", date_command_func);
}

void add_time_callback(TimeCallback callback)
{
	if (callback_count >= MAX_CALLBACKS) {
		ESP_LOGE(TAG, "Max number of time callbacks exceeded");
		return;
	}
	callbacks[callback_count] = callback;
	++callback_count;
}

Time get_time(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	return (Time) {
		.hour = timeinfo.tm_hour,
		.minute = timeinfo.tm_min,
		.second = timeinfo.tm_sec,
	};
}

void set_time(Time time)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	timeinfo.tm_hour = time.hour;
	timeinfo.tm_min = time.minute;
	timeinfo.tm_sec = time.second;

	tv.tv_sec = mktime(&timeinfo);
	settimeofday(&tv, NULL);
}

Date get_date(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	return (Date) {
		.year = timeinfo.tm_year + TM_YEAR_OFFSET,
		.month = timeinfo.tm_mon + TM_MONTH_OFFSET,
		.day = timeinfo.tm_mday,
	};
}

void set_date(Date date)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);

	timeinfo.tm_year = date.year - TM_YEAR_OFFSET;
	timeinfo.tm_mon = date.month - TM_MONTH_OFFSET;
	timeinfo.tm_mday = date.day;

	tv.tv_sec = mktime(&timeinfo);
	settimeofday(&tv, NULL);
}

WeekDay get_week_day(void)
{
	struct timeval tv;
	gettimeofday(&tv, NULL);
	struct tm timeinfo;
	(void)localtime_r(&tv.tv_sec, &timeinfo);
	if (timeinfo.tm_wday == 0)
		return WEEK_DAY_SUNDAY;
	else
		return (WeekDay)(timeinfo.tm_wday - 1);
}

const char *week_day_name(WeekDay day)
{
	switch (day) {
	case WEEK_DAY_MONDAY:
		return "Monday";
	case WEEK_DAY_TUESDAY:
		return "Tuesday";
	case WEEK_DAY_WEDNESDAY:
		return "Wednesday";
	case WEEK_DAY_THURSDAY:
		return "Thursday";
	case WEEK_DAY_FRIDAY:
		return "Friday";
	case WEEK_DAY_SATURDAY:
		return "Saturday";
	case WEEK_DAY_SUNDAY:
		return "Sunday";

	default:
		ESP_LOGE(
		    TAG, "Invalid day of the week passed to %s(): %u", __func__,
		    (unsigned)day);
		return "INVALID";
	}
}