/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2025 Oxide Computer Company
 */

/*
 * Dump all of the information discovered by libzoneinfo in a way that's usable
 * for diffing. We use the following directory layout from the root:
 *
 * dir: <continent-name>
 *	file: info
 *	dir: <country-name>
 *		file: info
 *		file: <tz-name>
 */

#include <err.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <libzoneinfo.h>
#include <sys/debug.h>
#include <errno.h>
#include <string.h>

static void
usage(const char *fmt, ...)
{
	if (fmt != NULL) {
		va_list ap;

		va_start(ap, fmt);
		vwarnx(fmt, ap);
		va_end(ap);
	}

	(void) fprintf(stderr, "Usage:  zoneinfo_dump -d dir\n");
}

static void
dump_timezone(int dirfd, const struct tz_continent *cont,
    const struct tz_country *country, const struct tz_timezone *tz)
{
	int fd;
	char *name;
	FILE *f;

	name = strdup(tz->tz_name);
	if (name == NULL) {
		err(EXIT_FAILURE, "failed to duplicate tz name %s",
		    tz->tz_name);
	}

	for (size_t i = 0; i < strlen(name); i++) {
		if (name[i] == '/')
			name[i] = '-';
	}

	if ((fd = openat(dirfd, name, O_RDWR| O_CREAT | O_TRUNC, 0644)) < 0) {
		err(EXIT_FAILURE, "failed to create tz file for %s/%s/%s",
		    cont->ctnt_name, country->ctry_code, name);
	}

	if ((f = fdopen(fd, "w")) == NULL) {
		err(EXIT_FAILURE, "failed to create stdio stream for "
		    "tz %s/%s/%s file", cont->ctnt_name, country->ctry_code,
		    name);
	}

	(void) fprintf(f, "name: %s\n", tz->tz_name);
	(void) fprintf(f, "oname: %s\n", tz->tz_oname);
	(void) fprintf(f, "id: %s\n", tz->tz_id_desc);
	(void) fprintf(f, "desc: %s\n", tz->tz_display_desc);
	(void) fprintf(f, "lat: %d.%u.%u.%u\n", tz->tz_coord.lat_sign,
	    tz->tz_coord.lat_degree, tz->tz_coord.lat_minute,
	    tz->tz_coord.lat_second);
	(void) fprintf(f, "long: %d.%u.%u.%u\n", tz->tz_coord.long_sign,
	    tz->tz_coord.long_degree, tz->tz_coord.long_minute,
	    tz->tz_coord.long_second);

	VERIFY0(fflush(f));
	VERIFY0(fclose(f));

	free(name);
}

static void
dump_country(int cfd, const struct tz_continent *cont,
    struct tz_country *country)
{
	int dirfd, infofd, ret, found = 0;
	struct tz_timezone *zones;
	FILE *f;

	if (mkdirat(cfd, country->ctry_code, 0755) != 0 && errno != EEXIST) {
		err(EXIT_FAILURE, "failed to make country directory %s/%s",
		    cont->ctnt_name, country->ctry_code);
	}

	if ((dirfd = openat(cfd, country->ctry_code, O_DIRECTORY)) < 0) {
		err(EXIT_FAILURE, "failed to open country %s/%s",
		    cont->ctnt_name, country->ctry_code);
	}

	if ((infofd = openat(dirfd, "info", O_RDWR| O_CREAT | O_TRUNC, 0644)) <
	    0) {
		err(EXIT_FAILURE, "failed to create info file for country "
		    "%s/%s", cont->ctnt_name, country->ctry_code);
	}

	if ((f = fdopen(infofd, "w")) == NULL) {
		err(EXIT_FAILURE, "failed to create stdio stream for "
		    "country %s/%s info file", cont->ctnt_name,
		    country->ctry_code);
	}

	(void) fprintf(f, "name: %s\n", country->ctry_code);
	(void) fprintf(f, "id: %s\n", country->ctry_id_desc);
	(void) fprintf(f, "desc: %s\n", country->ctry_display_desc);
	VERIFY0(country->ctry_status);
	VERIFY0(fflush(f));
	VERIFY0(fclose(f));

	ret = get_timezones_by_country(&zones, country);
	if (ret < 0) {
		err(EXIT_FAILURE, "failed to get timezones for country %s/%s",
		    cont->ctnt_name, country->ctry_code);
	}

	for (struct tz_timezone *t = zones; t != NULL; t = t->tz_next,
	    found++) {
		dump_timezone(dirfd, cont, country, t);
	}

	if (ret != found) {
		errx(EXIT_FAILURE, "zoneinfo said %u timezones should exist "
		    "for country %s/%s, but found %u\n", ret, cont->ctnt_name,
		    country->ctry_code, found);
	}

	VERIFY0(free_timezones(zones));
	VERIFY0(close(dirfd));
}

static void
dump_continent(int root, struct tz_continent *cont)
{
	int dirfd, infofd, ret, found = 0;
	struct tz_country *country;
	FILE *f;

	if (mkdirat(root, cont->ctnt_name, 0755) != 0 &&
	    errno != EEXIST) {
		err(EXIT_FAILURE, "failed to make continent %s",
		    cont->ctnt_name);
	}

	if ((dirfd = openat(root, cont->ctnt_name, O_DIRECTORY)) < 0) {
		err(EXIT_FAILURE, "failed to open continent %s",
		    cont->ctnt_name);
	}

	if ((infofd = openat(dirfd, "info", O_RDWR| O_CREAT | O_TRUNC, 0644)) <
	    0) {
		err(EXIT_FAILURE, "failed to create info file for continent "
		    "%s", cont->ctnt_name);
	}

	if ((f = fdopen(infofd, "w")) == NULL) {
		err(EXIT_FAILURE, "failed to create stdio stream for "
		    "continent %s info file", cont->ctnt_name);
	}

	(void) fprintf(f, "name: %s\n", cont->ctnt_name);
	(void) fprintf(f, "id: %s\n", cont->ctnt_id_desc);
	(void) fprintf(f, "desc: %s\n", cont->ctnt_display_desc);
	VERIFY0(fflush(f));
	VERIFY0(fclose(f));

	ret = get_tz_countries(&country, cont);
	if (ret < 0) {
		err(EXIT_FAILURE, "failed to get countries for continent %s",
		    cont->ctnt_name);
	}

	for (struct tz_country *c = country; c != NULL; c = c->ctry_next,
	    found++) {
		dump_country(dirfd, cont, c);
	}

	if (ret != found) {
		errx(EXIT_FAILURE, "zoneinfo said %u countries should exist "
		    "for continent %s, but found %u\n", ret, cont->ctnt_name,
		    found);
	}

	/* For each Country */
	VERIFY0(free_tz_countries(country));
	VERIFY0(close(dirfd));
}

int
main(int argc, char *argv[])
{
	int c, dirfd, ret, found = 0;
	const char *base = NULL;
	struct tz_continent *conts;

	while ((c = getopt(argc, argv, ":d:")) != -1) {
		switch (c) {
		case 'd':
			base = optarg;
			break;
		case '?':
			usage("option -%c requires an argument", optopt);
			exit(EXIT_FAILURE);
		case ':':
			usage("unknown option: -%c", optopt);
			exit(EXIT_FAILURE);
		}
	}

	if (base == NULL) {
		errx(EXIT_FAILURE, "missing required directory, please use "
		    "the -d flag");
	}

	if ((dirfd = open(base, O_RDONLY | O_DIRECTORY)) < 0) {
		err(EXIT_FAILURE, "failed to open directory %s", base);
	}

	ret = get_tz_continents(&conts);
	if (ret < 0) {
		err(EXIT_FAILURE, "failed to get continents");
	}

	for (struct tz_continent *c = conts; c != NULL; c = c->ctnt_next,
	    found++) {
		dump_continent(dirfd, c);
	}

	if (found != ret) {
		errx(EXIT_FAILURE, "zoneinfo said %u continents should exist, "
		    "but found %u\n", ret, found);
	}

	VERIFY0(free_tz_continents(conts));

	return (0);
}