/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 2020 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Aaron LI <aly@aaronly.me>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 * 3. Neither the name of The DragonFly Project 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 HOLDERS 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.
 *
 * Reference:
 * Calendrical Calculations, The Ultimate Edition (4th Edition)
 * by Edward M. Reingold and Nachum Dershowitz
 * 2018, Cambridge University Press
 */

#include <stdbool.h>
#include <stdio.h>

#include "calendar.h"
#include "basics.h"
#include "dates.h"
#include "gregorian.h"
#include "julian.h"
#include "utils.h"

/*
 * Fixed date of the start of the Julian calendar.
 * Ref: Sec.(3.1), Eq.(3.2)
 */
static const int epoch = -1;  /* Gregorian: 0, December, 30 */

/*
 * Return true if $year is a leap year on the Julian calendar,
 * otherwise return false.
 * Ref: Sec.(3.1), Eq.(3.1)
 */
bool
julian_leap_year(int year)
{
	int i = (year > 0) ? 0 : 3;
	return (mod(year, 4) == i);
}

/*
 * Calculate the fixed date (RD) equivalent to the Julian date $date.
 * Ref: Sec.(3.1), Eq.(3.3)
 */
int
fixed_from_julian(const struct date *date)
{
	int y = (date->year >= 0) ? date->year : (date->year + 1);
	int rd = ((epoch - 1) + 365 * (y - 1) +
		  div_floor(y - 1, 4) +
		  div_floor(date->month * 367 - 362, 12));
	/* correct for the assumption that February always has 30 days */
	if (date->month <= 2)
		return rd + date->day;
	else if (julian_leap_year(date->year))
		return rd + date->day - 1;
	else
		return rd + date->day - 2;
}

/*
 * Calculate the Julian date (year, month, day) corresponding to the
 * fixed date $rd.
 * Ref: Sec.(3.1), Eq.(3.4)
 */
void
julian_from_fixed(int rd, struct date *date)
{
	int correction, pdays;

	date->year = div_floor(4 * (rd - epoch) + 1464, 1461);
	if (date->year <= 0)
		date->year--;

	struct date d = { date->year, 3, 1 };
	if (rd < fixed_from_julian(&d))
		correction = 0;
	else if (julian_leap_year(date->year))
		correction = 1;
	else
		correction = 2;

	d.month = 1;
	pdays = rd - fixed_from_julian(&d);
	date->month = div_floor(12 * (pdays + correction) + 373, 367);

	d.month = date->month;
	date->day = rd - fixed_from_julian(&d) + 1;
}

/**************************************************************************/

/*
 * Format the given fixed date $rd to '<month>/<day>' string in $buf.
 * Return the formatted string length.
 */
int
julian_format_date(char *buf, size_t size, int rd)
{
	static const char *month_names[] = {
		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
	};
	struct date jdate;

	julian_from_fixed(rd, &jdate);
	return snprintf(buf, size, "%s/%02d",
			month_names[jdate.month - 1], jdate.day);
}

/*
 * Calculate the Julian year corresponding to the fixed date $rd.
 */
static int
julian_year_from_fixed(int rd)
{
	struct date jdate;
	julian_from_fixed(rd, &jdate);
	return jdate.year;
}

/*
 * Find days of the specified Julian year ($year), month ($month) and
 * day ($day).
 * If year $year < 0, then year is ignored.
 */
int
julian_find_days_ymd(int year, int month, int day, struct cal_day **dayp,
		     char **edp __unused)
{
	struct cal_day *dp;
	struct date date;
	int rd, year1, year2;
	int count = 0;

	year1 = julian_year_from_fixed(Options.day_begin);
	year2 = julian_year_from_fixed(Options.day_end);
	for (int y = year1; y <= year2; y++) {
		if (year >= 0 && year != y)
			continue;
		date_set(&date, y, month, day);
		rd = fixed_from_julian(&date);
		if ((dp = find_rd(rd, 0)) != NULL) {
			if (count >= CAL_MAX_REPEAT) {
				warnx("%s: too many repeats", __func__);
				return count;
			}
			dayp[count++] = dp;
		}
	}

	return count;
}

/*
 * Find days of the specified Julian day of month ($dom) of all months.
 */
int
julian_find_days_dom(int dom, struct cal_day **dayp, char **edp __unused)
{
	struct cal_day *dp;
	struct date date;
	int year1, year2;
	int rd_begin, rd_end;
	int count = 0;

	year1 = julian_year_from_fixed(Options.day_begin);
	year2 = julian_year_from_fixed(Options.day_end);
	for (int y = year1; y <= year2; y++) {
		date_set(&date, y, 1, 1);
		rd_begin = fixed_from_julian(&date);
		date.year++;
		rd_end = fixed_from_julian(&date);
		if (rd_end > Options.day_end)
			rd_end = Options.day_end;

		for (int m = 1, rd = rd_begin; rd <= rd_end; m++) {
			date_set(&date, y, m, dom);
			rd = fixed_from_julian(&date);
			if ((dp = find_rd(rd, 0)) != NULL) {
				if (count >= CAL_MAX_REPEAT) {
					warnx("%s: too many repeats",
					      __func__);
					return count;
				}
				dayp[count++] = dp;
			}
		}
	}

	return count;
}

/*
 * Find days of all days of the specified Julian month ($month).
 */
int
julian_find_days_month(int month, struct cal_day **dayp, char **edp __unused)
{
	struct cal_day *dp;
	struct date date;
	int year1, year2;
	int rd_begin, rd_end;
	int count = 0;

	year1 = julian_year_from_fixed(Options.day_begin);
	year2 = julian_year_from_fixed(Options.day_end);
	for (int y = year1; y <= year2; y++) {
		date_set(&date, y, month, 1);
		rd_begin = fixed_from_julian(&date);
		date.month++;
		if (date.month > 12)
			date_set(&date, y+1, 1, 1);
		rd_end = fixed_from_julian(&date);
		if (rd_end > Options.day_end)
			rd_end = Options.day_end;

		for (int rd = rd_begin; rd <= rd_end; rd++) {
			if ((dp = find_rd(rd, 0)) != NULL) {
				if (count >= CAL_MAX_REPEAT) {
					warnx("%s: too many repeats",
					      __func__);
					return count;
				}
				dayp[count++] = dp;
			}
		}
	}

	return count;
}


/*
 * Print the Julian calendar of the given date $rd.
 */
void
show_julian_calendar(int rd)
{
	struct date gdate, jdate;
	bool leap;

	gregorian_from_fixed(rd, &gdate);
	julian_from_fixed(rd, &jdate);
	leap = julian_leap_year(jdate.year);

	printf("Gregorian date: %d-%02d-%02d\n",
	       gdate.year, gdate.month, gdate.day);
	printf("Julian date: %d-%02d-%02d\n",
	       jdate.year, jdate.month, jdate.day);
	printf("Leap year: %s\n", leap ? "yes" : "no");
}