/*-
 * 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.
 */

#include <assert.h>
#include <err.h>
#include <math.h>
#include <stddef.h>

#include "calendar.h"
#include "basics.h"
#include "chinese.h"
#include "dates.h"
#include "days.h"
#include "ecclesiastical.h"
#include "gregorian.h"
#include "moon.h"
#include "nnames.h"
#include "parsedata.h"
#include "sun.h"
#include "utils.h"

static int      find_days_yearly(int sday_id, int offset,
                                 struct cal_day **dayp, char **edp);
static int      find_days_moon(int sday_id, int offset,
                               struct cal_day **dayp, char **edp);

static int      find_days_easter(int, struct cal_day **, char **);
static int      find_days_paskha(int, struct cal_day **, char **);
static int      find_days_advent(int, struct cal_day **, char **);
static int      find_days_cny(int, struct cal_day **, char **);
static int      find_days_cqingming(int, struct cal_day **, char **);
static int      find_days_cjieqi(int, struct cal_day **, char **);
static int      find_days_marequinox(int, struct cal_day **, char **);
static int      find_days_sepequinox(int, struct cal_day **, char **);
static int      find_days_junsolstice(int, struct cal_day **, char **);
static int      find_days_decsolstice(int, struct cal_day **, char **);
static int      find_days_newmoon(int, struct cal_day **, char **);
static int      find_days_fullmoon(int, struct cal_day **, char **);

#define SPECIALDAY_INIT0 \
        { SD_NONE, NULL, 0, NULL, 0, NULL }
#define SPECIALDAY_INIT(id, name, func) \
        { (id), name, sizeof(name)-1, NULL, 0, func }
struct specialday specialdays[] = {
        SPECIALDAY_INIT(SD_EASTER, "Easter", &find_days_easter),
        SPECIALDAY_INIT(SD_PASKHA, "Paskha", &find_days_paskha),
        SPECIALDAY_INIT(SD_ADVENT, "Advent", &find_days_advent),
        SPECIALDAY_INIT(SD_CNY, "ChineseNewYear", &find_days_cny),
        SPECIALDAY_INIT(SD_CQINGMING, "ChineseQingming", &find_days_cqingming),
        SPECIALDAY_INIT(SD_CJIEQI, "ChineseJieqi", &find_days_cjieqi),
        SPECIALDAY_INIT(SD_MAREQUINOX, "MarEquinox", &find_days_marequinox),
        SPECIALDAY_INIT(SD_SEPEQUINOX, "SepEquinox", &find_days_sepequinox),
        SPECIALDAY_INIT(SD_JUNSOLSTICE, "JunSolstice", &find_days_junsolstice),
        SPECIALDAY_INIT(SD_DECSOLSTICE, "DecSolstice", &find_days_decsolstice),
        SPECIALDAY_INIT(SD_NEWMOON, "NewMoon", &find_days_newmoon),
        SPECIALDAY_INIT(SD_FULLMOON, "FullMoon", &find_days_fullmoon),
        SPECIALDAY_INIT0,
};


static int
find_days_easter(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_EASTER, offset, dayp, edp);
}

static int
find_days_paskha(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_PASKHA, offset, dayp, edp);
}

static int
find_days_advent(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_ADVENT, offset, dayp, edp);
}

static int
find_days_cny(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_CNY, offset, dayp, edp);
}

static int
find_days_cqingming(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_CQINGMING, offset, dayp, edp);
}

static int
find_days_marequinox(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_MAREQUINOX, offset, dayp, edp);
}

static int
find_days_sepequinox(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_SEPEQUINOX, offset, dayp, edp);
}

static int
find_days_junsolstice(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_JUNSOLSTICE, offset, dayp, edp);
}

static int
find_days_decsolstice(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_yearly(SD_DECSOLSTICE, offset, dayp, edp);
}

/*
 * Find days of the yearly special day specified by $sday_id.
 */
static int
find_days_yearly(int sday_id, int offset, struct cal_day **dayp, char **edp)
{
        struct cal_day *dp;
        struct date date;
        double t, longitude;
        char buf[32];
        int rd, approx, month;
        int year1, year2;
        int count = 0;

        year1 = gregorian_year_from_fixed(Options.day_begin);
        year2 = gregorian_year_from_fixed(Options.day_end);
        for (int y = year1; y <= year2; y++) {
                t = NAN;

                switch (sday_id) {
                case SD_EASTER:
                        rd = easter(y);
                        break;
                case SD_PASKHA:
                        rd = orthodox_easter(y);
                        break;
                case SD_ADVENT:
                        rd = advent(y);
                        break;
                case SD_CNY:
                        rd = chinese_new_year(y);
                        break;
                case SD_CQINGMING:
                        rd = chinese_qingming(y);
                        break;
                case SD_MAREQUINOX:
                case SD_JUNSOLSTICE:
                case SD_SEPEQUINOX:
                case SD_DECSOLSTICE:
                        if (sday_id == SD_MAREQUINOX) {
                                month = 3;
                                longitude = 0.0;
                        } else if (sday_id == SD_JUNSOLSTICE) {
                                month = 6;
                                longitude = 90.0;
                        } else if (sday_id == SD_SEPEQUINOX) {
                                month = 9;
                                longitude = 180.0;
                        } else {
                                month = 12;
                                longitude = 270.0;
                        }
                        date_set(&date, y, month, 1);
                        approx = fixed_from_gregorian(&date);
                        t = solar_longitude_atafter(longitude, approx);
                        t += Options.location->zone;  /* to standard time */
                        rd = floor(t);
                        break;
                default:
                        errx(1, "%s: unknown special day: %d",
                             __func__, sday_id);
                }

                if ((dp = find_rd(rd, offset)) != NULL) {
                        if (count >= CAL_MAX_REPEAT) {
                                warnx("%s: too many repeats", __func__);
                                return count;
                        }
                        if (!isnan(t)) {
                                format_time(buf, sizeof(buf), t);
                                edp[count] = xstrdup(buf);
                        }
                        dayp[count++] = dp;
                }
        }

        return count;
}

/*
 * Find days of the 24 Chinese Jiéqì (节气)
 */
static int
find_days_cjieqi(int offset, struct cal_day **dayp, char **edp)
{
        const struct chinese_jieqi *jq;
        struct cal_day *dp;
        struct date date;
        char buf[32];
        int year1, year2;
        int rd, rd_begin, rd_end;
        int count = 0;

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

                for (rd = rd_begin; rd <= rd_end; rd += 14) {
                        rd = chinese_jieqi_onafter(rd, C_JIEQI_ALL, &jq);
                        if (rd > rd_end)
                                break;

                        if ((dp = find_rd(rd, offset)) != NULL) {
                                if (count >= CAL_MAX_REPEAT) {
                                        warnx("%s: too many repeats",
                                              __func__);
                                        return count;
                                }
                                snprintf(buf, sizeof(buf), "%s, %s",
                                         jq->name, jq->zhname);
                                edp[count] = xstrdup(buf);
                                dayp[count++] = dp;
                        }
                }
        }

        return count;
}

static int
find_days_newmoon(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_moon(SD_NEWMOON, offset, dayp, edp);
}

static int
find_days_fullmoon(int offset, struct cal_day **dayp, char **edp)
{
        return find_days_moon(SD_FULLMOON, offset, dayp, edp);
}

/*
 * Find days of the moon events specified by $sday_id.
 */
static int
find_days_moon(int sday_id, int offset, struct cal_day **dayp, char **edp)
{
        struct cal_day *dp;
        struct date date;
        double t, t_begin, t_end;
        char buf[32];
        int year1, year2;
        int count = 0;

        year1 = gregorian_year_from_fixed(Options.day_begin);
        year2 = gregorian_year_from_fixed(Options.day_end);
        for (int y = year1; y <= year2; y++) {
                date_set(&date, y, 1, 1);
                t_begin = fixed_from_gregorian(&date) - Options.location->zone;
                date.year++;
                t_end = fixed_from_gregorian(&date) - Options.location->zone;
                if (t_end > Options.day_end + 1 - Options.location->zone)
                        t_end = Options.day_end + 1 - Options.location->zone;
                                /* NOTE: '+1' to include the ending day */

                for (t = t_begin; t <= t_end; ) {
                        switch (sday_id) {
                        case SD_NEWMOON:
                                t = new_moon_atafter(t);
                                break;
                        case SD_FULLMOON:
                                t = lunar_phase_atafter(180, t);
                                break;
                        default:
                                errx(1, "%s: unknown moon event: %d",
                                     __func__, sday_id);
                        }

                        if (t > t_end)
                                break;

                        t += Options.location->zone;  /* to standard time */
                        if ((dp = find_rd(floor(t), offset)) != NULL) {
                                if (count >= CAL_MAX_REPEAT) {
                                        warnx("%s: too many repeats",
                                              __func__);
                                        return count;
                                }
                                format_time(buf, sizeof(buf), t);
                                edp[count] = xstrdup(buf);
                                dayp[count++] = dp;
                        }
                }
        }

        return count;
}

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

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

        while ((dp = loop_dates(dp)) != NULL) {
                if (year >= 0 && year != dp->year)
                        continue;
                if ((dp->month == month && dp->day == day) ||
                    /* day of zero means the last day of previous month */
                    (day == 0 && dp->last_dom && month == dp->month % 12 + 1)) {
                        if (count >= CAL_MAX_REPEAT) {
                                warnx("%s: too many repeats", __func__);
                                return count;
                        }
                        dayp[count++] = dp;
                }
        }

        return count;
}

/*
 * Find days of the specified day of month ($dom) of all months.
 */
int
find_days_dom(int dom, struct cal_day **dayp, char **edp __unused)
{
        struct cal_day *dp = NULL;
        int count = 0;

        while ((dp = loop_dates(dp)) != NULL) {
                if (dp->day == dom ||
                    /* day of zero means the last day of previous month */
                    (dom == 0 && dp->last_dom)) {
                        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 month ($month).
 */
int
find_days_month(int month, struct cal_day **dayp, char **edp __unused)
{
        struct cal_day *dp = NULL;
        int count = 0;

        while ((dp = loop_dates(dp)) != NULL) {
                if (dp->month == month) {
                        if (count >= CAL_MAX_REPEAT) {
                                warnx("%s: too many repeats", __func__);
                                return count;
                        }
                        dayp[count++] = dp;
                }
        }

        return count;
}

/*
 * If $index == 0, find days of every day-of-week ($dow) of the specified month
 * ($month).  Otherwise, find days of the indexed day-of-week of the month.
 * If month $month < 0, then find days in every month.
 */
int
find_days_mdow(int month, int dow, int index,
               struct cal_day **dayp, char **edp __unused)
{
        struct cal_day *dp = NULL;
        int count = 0;

        while ((dp = loop_dates(dp)) != NULL) {
                if (month >= 0 && month != dp->month)
                        continue;
                if (dp->dow[0] == dow) {
                        if (index != 0 &&
                            (index != dp->dow[1] && index != dp->dow[2])) {
                                /* Not the indexed day-of-week of month */
                                continue;
                        }
                        if (count >= CAL_MAX_REPEAT) {
                                warnx("%s: too many repeats", __func__);
                                return count;
                        }
                        dayp[count++] = dp;
                }
        }

        return count;
}