package com.yelang.common.utils.tyme;
import java.time.LocalDate;
import com.tyme.jd.JulianDay;
import com.tyme.solar.SolarTerm;
import com.tyme.solar.SolarTime;
public class WinterSolsticeCalculator {
    // 冬至日期計算方法
    public static LocalDate calculateWinterSolstice(int year) {}
    // 數(shù)九天周期計算方法
    public static WinterSolsticeInfo calculateNineNinePeriod(int year) {}
    // 數(shù)九天信息封裝內部類
    public static class WinterSolsticeInfo {}
    // 測試主方法
    public static void main(String[] args) {}
}

/**
 * 計算指定年份的冬至日期（公歷近似計算）
 * 冬至通常為12月21日或22日
 */
public static LocalDate calculateWinterSolstice(int year) {
    // 實際應用中可以使用更精確的算法
    String name = "冬至";
    // 根據年份和節(jié)氣名稱獲取冬至節(jié)氣對象
    SolarTerm term = SolarTerm.fromName(year, name);
    // 獲取儒略日（天文學中用于日期計算的連續(xù)天數(shù)）
    JulianDay julianDay = term.getJulianDay();
    // 從儒略日轉換為公歷時刻
    SolarTime solarTime = julianDay.getSolarTime();
    // 封裝為LocalDate對象返回
    return LocalDate.of(solarTime.getYear(), solarTime.getMonth(), solarTime.getDay());
}

/**
 * 計算數(shù)九天起止日期
 * 從冬至日開始，每9天為一九，共九九八十一天
 */
public static WinterSolsticeInfo calculateNineNinePeriod(int year) {
    // 先獲取當年冬至日
    LocalDate winterSolstice = calculateWinterSolstice(year);

    // 構建數(shù)九天信息對象，依次傳入各九的結束日期
    return new WinterSolsticeInfo(year, winterSolstice, 
        winterSolstice.plusDays(9),  // 一九結束（第9天）
        winterSolstice.plusDays(18), // 二九結束（第18天）
        winterSolstice.plusDays(27), // 三九結束（第27天）
        winterSolstice.plusDays(36), // 四九結束（第36天）
        winterSolstice.plusDays(45), // 五九結束（第45天）
        winterSolstice.plusDays(54), // 六九結束（第54天）
        winterSolstice.plusDays(63), // 七九結束（第63天）
        winterSolstice.plusDays(72), // 八九結束（第72天）
        winterSolstice.plusDays(80)  // 九九結束（第81天，80天偏移）
    );
}

private int year; // 所屬年份
private LocalDate winterSolstice; // 冬至日
private LocalDate[] nineEndDates; // 各九結束日期
private LocalDate[] nineStartDates; // 各九開始日期
public WinterSolsticeInfo(int year, LocalDate winterSolstice, LocalDate... endDates) {
    this.year = year;
    this.winterSolstice = winterSolstice;
    this.nineEndDates = endDates;
    this.nineStartDates = new LocalDate[9];
    // 計算每個九的開始日期
    for (int i = 0; i < 9; i++) {
        if (i == 0) {
            // 一九開始于冬至日
            nineStartDates[i] = winterSolstice;
        } else {
            // 后續(xù)各九開始于前一九結束日的次日
            nineStartDates[i] = nineEndDates[i - 1].plusDays(1);
        }
    }
}

/**
 * 獲取當前處于哪個九
 * @param date 待判斷日期
 * @return 1-9（對應一九至九九），-1表示不在數(shù)九天內
 */
public int getCurrentNinePeriod(LocalDate date) {
    // 日期早于冬至日，返回-1
    if (date.isBefore(winterSolstice))
        return -1;

    // 遍歷各九結束日期，判斷歸屬
    for (int i = 0; i < 9; i++) {
        if (!date.isAfter(nineEndDates[i])) {
            return i + 1; // 返回1-9
        }
    }
    // 日期晚于九九結束日，返回-1
    return -1;
}

/**
 * 獲取數(shù)九天描述（如一九、二九）
 * @param period 1-9的數(shù)字
 * @return 對應的中文描述
 */
public String getNinePeriodDescription(int period) {
    String[] descriptions = { "一九", "二九", "三九", "四九", "五九", "六九", "七九", "八九", "九九" };
    if (period >= 1 && period <= 9) {
        return descriptions[period - 1];
    }
    return "";
}

public static void main(String[] args) {
    // 測試冬至日計算
    System.out.println("=== 冬至日計算測試 ===");
    for (int year = 2023; year <= 2026; year++) {
        LocalDate solstice = WinterSolsticeCalculator.calculateWinterSolstice(year);
        System.out.println(year + "年冬至日: " + solstice);
    }

    // 測試數(shù)九天計算
    System.out.println("\n=== 2026年數(shù)九天 ===");
    WinterSolsticeCalculator.WinterSolsticeInfo info = WinterSolsticeCalculator.calculateNineNinePeriod(2026);

    System.out.println("冬至日: " + info.getWinterSolstice());

    for (int i = 0; i < 9; i++) {
        System.out.printf("%s: %s - %s%n", info.getNinePeriodDescription(i + 1), info.getNineStart(i),
                info.getNineEnd(i));
    }

    // 測試當前處于哪個九
    LocalDate today = LocalDate.now();
    int currentPeriod = info.getCurrentNinePeriod(today);
    System.out.println("\n今日(" + today + ")處于: "
            + (currentPeriod > 0 ? info.getNinePeriodDescription(currentPeriod) : "不在數(shù)九天內"));
}

public static LocalDate calculateWinterSolstice(int year) {
    // 增加年份合法性校驗
    if (year < 1900 || year > 2100) {
        throw new IllegalArgumentException("年份超出支持范圍（1900-2100）");
    }
    
    String name = "冬至";
    SolarTerm term = SolarTerm.fromName(year, name);
    // 處理節(jié)氣獲取失敗場景
    if (term == null) {
        throw new RuntimeException("無法計算" + year + "年冬至日期，請檢查tyme庫配置");
    }
    
    JulianDay julianDay = term.getJulianDay();
    SolarTime solarTime = julianDay.getSolarTime();
    return LocalDate.of(solarTime.getYear(), solarTime.getMonth(), solarTime.getDay());
}

// 靜態(tài)緩存，存儲已計算的數(shù)九天信息
private static final Map<Integer, WinterSolsticeInfo> CACHE = new ConcurrentHashMap<>();

public static WinterSolsticeInfo calculateNineNinePeriod(int year) {
    // 先從緩存獲取，不存在則計算并放入緩存
    return new WinterSolsticeInfo(
	            year,
	            winterSolstice,
	            winterSolstice.plusDays(8),   // 一九結束（冬至日+8天）
	            winterSolstice.plusDays(17),  // 二九結束
	            winterSolstice.plusDays(26),  // 三九結束
	            winterSolstice.plusDays(35),  // 四九結束
	            winterSolstice.plusDays(44),  // 五九結束
	            winterSolstice.plusDays(53),  // 六九結束
	            winterSolstice.plusDays(62),  // 七九結束
	            winterSolstice.plusDays(71),  // 八九結束
	            winterSolstice.plusDays(80)   // 九九結束（80天=冬至日+80天，共81天）
	        );
}

=== 冬至日計算測試 ===
2023年冬至日: 2022-12-22
2024年冬至日: 2023-12-22
2025年冬至日: 2024-12-21
2026年冬至日: 2025-12-21

=== 2026年數(shù)九天 ===
冬至日: 2025-12-21
一九: 2025-12-21 - 2025-12-29
二九: 2025-12-30 - 2026-01-07
三九: 2026-01-08 - 2026-01-16
四九: 2026-01-17 - 2026-01-25
五九: 2026-01-26 - 2026-02-03
六九: 2026-02-04 - 2026-02-12
七九: 2026-02-13 - 2026-02-21
八九: 2026-02-22 - 2026-03-02
九九: 2026-03-03 - 2026-03-11

今日(2026-02-02)處于: 五九