use crate::calendar::era_table::find_era;
use crate::calendar::ganzhi::bazi;
use crate::calendar::lunar::{LunarDate, lunar_to_solar};
use crate::core::constants::{J2000, PI};
use crate::core::eph0::{moon_sun_delta_deg, sun_longitude_deg};
use crate::time::jd::JulianDay;
use std::sync::OnceLock;
const MODERN_EPOCH_JD: f64 = 2436935.0;
const fn kb(epoch: f64, slope: f64) -> (f64, f64) {
(epoch + J2000, slope)
}
const SHUO_KB_TABLE: &[(f64, f64)] = &[
kb(1457698.231017, 29.53067166),
kb(1546082.512234, 29.53085106),
kb(1640640.735300, 29.53060000),
kb(1642472.151543, 29.53085439),
kb(1683430.509300, 29.53086148),
kb(1752148.041079, 29.53085097),
kb(1807724.481520, 29.53059851),
kb(1883618.114100, 29.53060000),
kb(1907360.704700, 29.53060000),
kb(1936596.224900, 29.53060000),
kb(1939135.675300, 29.53060000),
];
const SHUO_KB_END: f64 = J2000 + 1947168.0;
const SHUO_KB_OFFSET: f64 = 14.0;
const QI_KB_TABLE: &[(f64, f64)] = &[
kb(1640650.479938, 15.21842500),
kb(1642476.703182, 15.21874996),
kb(1683430.515601, 15.218750011),
kb(1752157.640664, 15.218749978),
kb(1807675.003759, 15.218620279),
kb(1883627.765182, 15.218612292),
kb(1907369.128100, 15.218449176),
kb(1936603.140413, 15.218425000),
kb(1939145.524180, 15.218466998),
kb(1947180.798300, 15.218524844),
kb(1964362.041824, 15.218533526),
kb(1987372.340971, 15.218513908),
kb(1999653.819126, 15.218530782),
kb(2007445.469786, 15.218535181),
kb(2021324.917146, 15.218526248),
kb(2047257.232342, 15.218519654),
kb(2070282.898213, 15.218425000),
kb(2073204.872850, 15.218515221),
kb(2080144.500926, 15.218530782),
kb(2086703.688963, 15.218523776),
kb(2110033.182763, 15.218425000),
kb(2111190.300888, 15.218425000),
kb(2113731.271005, 15.218515671),
kb(2120670.840263, 15.218425000),
kb(2123973.309063, 15.218425000),
kb(2125068.997336, 15.218477932),
kb(2136026.312633, 15.218472436),
kb(2156099.495538, 15.218425000),
kb(2159021.324663, 15.218425000),
kb(2162308.575254, 15.218461742),
kb(2178485.706538, 15.218425000),
kb(2178759.662849, 15.218445786),
kb(2185334.020800, 15.218425000),
kb(2187525.481425, 15.218425000),
kb(2188621.191481, 15.218437494),
];
const QI_KB_END: f64 = J2000 + 2322147.76;
const QI_KB_OFFSET: f64 = 7.0;
const SB_ENC: &str = concat!(
"EqoFscDcrFpmEsF2DfFideFelFpFfFfFiaipqti1ksttikptikqckstekqttgkqttgkqteksttikptikq2fjstgjqttjkqttgkqt",
"ekstfkptikq2tijstgjiFkirFsAeACoFsiDaDiADc1AFbBfgdfikijFifegF1FhaikgFag1E2btaieeibggiffdeigFfqDfaiBkF",
"1kEaikhkigeidhhdiegcFfakF1ggkidbiaedksaFffckekidhhdhdikcikiakicjF1deedFhFccgicdekgiFbiaikcfi1kbFibef",
"gEgFdcFkFeFkdcfkF1kfkcickEiFkDacFiEfbiaejcFfffkhkdgkaiei1ehigikhdFikfckF1dhhdikcfgjikhfjicjicgiehdik",
"cikggcifgiejF1jkieFhegikggcikFegiegkfjebhigikggcikdgkaFkijcfkcikfkcifikiggkaeeigefkcdfcfkhkdgkegieid",
"hijcFfakhfgeidieidiegikhfkfckfcjbdehdikggikgkfkicjicjF1dbidikFiggcifgiejkiegkigcdiegfggcikdbgfgefjF1",
"kfegikggcikdgFkeeijcfkcikfkekcikdgkabhkFikaffcfkhkdgkegbiaekfkiakicjhfgqdq2fkiakgkfkhfkfcjiekgFebicg",
"gbedF1jikejbbbiakgbgkacgiejkijjgigfiakggfggcibFifjefjF1kfekdgjcibFeFkijcfkfhkfkeaieigekgbhkfikidfcje",
"aibgekgdkiffiffkiakF1jhbakgdki1dj1ikfkicjicjieeFkgdkicggkighdF1jfgkgfgbdkicggfggkidFkiekgijkeigfiski",
"ggfaidheigF1jekijcikickiggkidhhdbgcfkFikikhkigeidieFikggikhkffaffijhidhhakgdkhkijF1kiakF1kfheakgdkif",
"iggkigicjiejkieedikgdfcggkigieeiejfgkgkigbgikicggkiaideeijkefjeijikhkiggkiaidheigcikaikffikijgkiahi1",
"hhdikgjfifaakekighie1hiaikggikhkffakicjhiahaikggikhkijF1kfejfeFhidikggiffiggkigicjiekgieeigikggiffig",
"gkidheigkgfjkeigiegikifiggkidhedeijcfkFikikhkiggkidhh1ehigcikaffkhkiggkidhh1hhigikekfiFkFikcidhh1hit",
"cikggikhkfkicjicghiediaikggikhkijbjfejfeFhaikggifikiggkigiejkikgkgieeigikggiffiggkigieeigekijcijikgg",
"ifikiggkideedeijkefkfckikhkiggkidhh1ehijcikaffkhkiggkidhh1hhigikhkikFikfckcidhh1hiaikgjikhfjicjicgie",
"hdikcikggifikigiejfejkieFhegikggifikiggfghigkfjeijkhigikggifikiggkigieeijcijcikfksikifikiggkidehdeij",
"cfdckikhkiggkhghh1ehijikifffffkhsFngErD1pAfBoDd1BlEtFqA2AqoEpDqElAEsEeB2BmADlDkqBtC1FnEpDqnEmFsFsAFn",
"llBbFmDsDiCtDmAB2BmtCgpEplCpAEiBiEoFqFtEqsDcCnFtADnFlEgdkEgmEtEsCtDmADqFtAFrAtEcCqAE1BoFqC1F1DrFtBmF",
"tAC2ACnFaoCgADcADcCcFfoFtDlAFgmFqBq2bpEoAEmkqnEeCtAE1bAEqgDfFfCrgEcBrACfAAABqAAB1AAClEnFeCtCgAADqDoB",
"mtAAACbFiAAADsEtBqAB2FsDqpFqEmFsCeDtFlCeDtoEpClEqAAFrAFoCgFmFsFqEnAEcCqFeCtFtEnAEeFtAAEkFnErAABbFkAD",
"nAAeCtFeAfBoAEpFtAABtFqAApDcCGJ",
);
const QB_ENC: &str = concat!(
"FrcFs22AFsckF2tsDtFqEtF1posFdFgiFseFtmelpsEfhkF2anmelpFlF1ikrotcnEqEq2FfqmcDsrFor22FgFrcgDscFs22FgEe",
"FtE2sfFs22sCoEsaF2tsD1FpeE2eFsssEciFsFnmelpFcFhkF2tcnEqEpFgkrotcnEqrEtFermcDsrE222FgBmcmr22DaEfnaF22",
"2sD1FpeForeF2tssEfiFpEoeFssD1iFstEqFppDgFstcnEqEpFg11FscnEqrAoAF2ClAEsDmDtCtBaDlAFbAEpAAAAAD2FgBiBqo",
"BbnBaBoAAAAAAAEgDqAdBqAFrBaBoACdAAf1AACgAAAeBbCamDgEifAE2AABa1C1BgFdiAAACoCeE1ADiEifDaAEqAAFe1AcFbcA",
"AAAAF1iFaAAACpACmFmAAAAAAAACrDaAAADG0",
);
fn decompress(s: &str) -> Vec<u8> {
let mut out = Vec::with_capacity(s.len() * 3);
let zeros = |n: usize| std::iter::repeat_n(b'0', n);
for c in s.chars() {
if ('A'..='F').contains(&c) {
out.extend(zeros(((b'F' - c as u8 + 1) * 10) as usize));
} else if ('G'..='J').contains(&c) {
out.extend(zeros((b'J' - c as u8 + 2) as usize));
} else if ('a'..='g').contains(&c) {
out.extend(zeros((b'g' - c as u8 + 3) as usize));
out.push(b'1');
} else if ('l'..='t').contains(&c) {
out.extend(zeros((b't' - c as u8 + 1) as usize));
out.push(b'2');
} else {
match c {
'k' => out.extend_from_slice(b"01"),
'i' => out.extend_from_slice(b"001"),
'j' => out.extend_from_slice(b"0101"),
'h' => out.extend_from_slice(b"001001"),
'0'..='2' => out.push(c as u8),
_ => {}
}
}
}
out
}
fn sb_table() -> &'static [u8] {
static SB: OnceLock<Vec<u8>> = OnceLock::new();
SB.get_or_init(|| decompress(SB_ENC))
}
fn qb_table() -> &'static [u8] {
static QB: OnceLock<Vec<u8>> = OnceLock::new();
QB.get_or_init(|| decompress(QB_ENC))
}
fn rough_shuo(w: f64) -> f64 {
let v = 7771.37714500204;
let mut t = (w + 1.08472) / v;
t -= (-0.0000331 * t * t
+ 0.10976 * (0.785 + 8328.6914 * t).cos()
+ 0.02224 * (0.187 + 7214.0629 * t).cos()
- 0.03342 * (4.669 + 628.3076 * t).cos())
/ v;
t += (32.0 * (t + 1.8) * (t + 1.8) - 20.0) / 86400.0 / 36525.0;
t * 36525.0 + 8.0 / 24.0
}
fn rough_qi(w: f64) -> f64 {
let v = 628.3319653318;
let mut t = (w - 4.895062166) / v;
t -= (53.0 * t * t
+ 334116.0 * (4.67 + 628.307585 * t).cos()
+ 2061.0 * (2.678 + 628.3076 * t).cos() * t)
/ v
/ 1e7;
let l = 48950621.66
+ 6283319653.318 * t
+ 53.0 * t * t
+ 334166.0 * (4.669257 + 628.307585 * t).cos()
+ 3489.0 * (4.6261 + 1256.61517 * t).cos()
+ 2060.6 * (2.67823 + 628.307585 * t).cos() * t
- 994.0
- 834.0 * (2.1824 - 33.75705 * t).sin();
t -= (l / 1e7 - w) / 628.332 + (32.0 * (t + 1.8) * (t + 1.8) - 20.0) / 86400.0 / 36525.0;
t * 36525.0 + 8.0 / 24.0
}
fn calc_kb(table: &[(f64, f64)], end: f64, jd_abs: f64, offset: f64, special: Option<f64>) -> f64 {
for i in 0..table.len() {
let (epoch, slope) = table[i];
let next_epoch = if i + 1 < table.len() {
table[i + 1].0
} else {
end
};
if jd_abs + offset < next_epoch {
let n = ((jd_abs + offset - epoch) / slope).floor();
let mut d = epoch + slope * n;
d = (d + 0.5).floor();
if special.is_some_and(|sp| (d - sp).abs() < 1.0) {
d += 1.0;
}
return d;
}
}
let (epoch, slope) = table[table.len() - 1];
let n = ((jd_abs + offset - epoch) / slope).floor();
let mut d = epoch + slope * n;
d = (d + 0.5).floor();
d
}
fn calc_correct(
angle: f64, jd: f64, start: f64, step: f64, table: &[u8], rough_fn: fn(f64) -> f64, ) -> f64 {
let guess = rough_fn(angle);
let mut result = (guess + 0.5).floor() + J2000;
let idx = ((jd - start) / step).floor() as usize;
if let Some(&b) = table.get(idx) {
match b {
b'1' => result += 1.0,
b'2' => result -= 1.0,
_ => {}
}
}
result
}
fn newton_shuo(jd_approx: f64) -> f64 {
let n = ((jd_approx - 2451550.257) / 29.530588853).round() as i32;
let mut t = 2451550.257 + n as f64 * 29.530588853;
for _ in 0..10 {
let d = moon_sun_delta_deg(t);
if d.abs() < 1e-6 {
break;
}
let ep = 0.01;
let der = (moon_sun_delta_deg(t + ep) - moon_sun_delta_deg(t - ep)) / (2.0 * ep);
if der.abs() < 1e-10 {
break;
}
t -= d / der;
}
t
}
fn newton_qi(jd_approx: f64, target_lon: f64) -> f64 {
let mut jd = jd_approx;
for _ in 0..12 {
let lon = sun_longitude_deg(jd);
let mut diff = (lon - target_lon).rem_euclid(360.0);
if diff > 180.0 {
diff -= 360.0;
}
if diff.abs() < 1e-6 {
break;
}
jd -= diff * 365.25 / 360.0;
}
jd
}
pub fn calc_shuo(jd_abs: f64) -> f64 {
let kb_bound = SHUO_KB_TABLE[0].0 - SHUO_KB_OFFSET;
let correct_bound = SHUO_KB_END - SHUO_KB_OFFSET;
if jd_abs < kb_bound || jd_abs >= MODERN_EPOCH_JD {
return newton_shuo(jd_abs);
}
if jd_abs < correct_bound {
return calc_kb(
SHUO_KB_TABLE,
SHUO_KB_END,
jd_abs,
SHUO_KB_OFFSET,
Some(J2000 + 1683460.0),
);
}
let sb = sb_table();
let shuo_angle = ((jd_abs + SHUO_KB_OFFSET - J2000 - 2451551.0) / 29.5306).floor() * 2.0 * PI;
calc_correct(shuo_angle, jd_abs, correct_bound, 29.5306, sb, rough_shuo)
}
pub fn calc_qi(jd_abs: f64, target_lon: f64) -> f64 {
let kb_bound = QI_KB_TABLE[0].0 - QI_KB_OFFSET;
let correct_bound = QI_KB_END - QI_KB_OFFSET;
if jd_abs < kb_bound || jd_abs >= MODERN_EPOCH_JD {
return newton_qi(jd_abs, target_lon);
}
if jd_abs < correct_bound {
return calc_kb(QI_KB_TABLE, QI_KB_END, jd_abs, QI_KB_OFFSET, None);
}
let qb = qb_table();
let qi_angle =
((jd_abs + QI_KB_OFFSET - J2000 - 2451259.0) / 365.2422 * 24.0).floor() * PI / 12.0;
calc_correct(
qi_angle,
jd_abs,
correct_bound,
365.2422 / 24.0,
qb,
rough_qi,
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HistoricalEra {
Standard,
SpringAutumn,
WarringStates,
QinHan,
}
impl HistoricalEra {
pub fn from_year(year: i32) -> Self {
if year >= -104 {
Self::Standard
} else if year >= -221 {
Self::QinHan
} else if year >= -479 {
Self::WarringStates
} else if year >= -721 {
Self::SpringAutumn
} else {
Self::Standard
}
}
}
pub fn lunar_month_from_history(
month_index: usize,
leap: Option<usize>,
is_leap: bool,
era: HistoricalEra,
) -> (u32, &'static str) {
let shift = match era {
HistoricalEra::Standard => 10,
_ => 11,
};
let month_raw = if is_leap {
if leap.is_some() {
((month_index + shift - 1 + 12) % 12 + 1) as u32
} else {
((month_index + shift + 12) % 12 + 1) as u32
}
} else if let Some(lo) = leap {
if month_index > lo {
((month_index + shift - 1 + 12) % 12 + 1) as u32
} else {
((month_index + shift + 12) % 12 + 1) as u32
}
} else {
((month_index + shift + 12) % 12 + 1) as u32
};
let leap_name = if is_leap {
match era {
HistoricalEra::SpringAutumn => "\u{5341}\u{4e09}",
HistoricalEra::WarringStates | HistoricalEra::QinHan => "\u{540e}\u{4e5d}",
HistoricalEra::Standard => "\u{95f0}",
}
} else {
""
};
(month_raw, leap_name)
}
type LunarContext = (Vec<(i32, u32, u32)>, Option<usize>, HistoricalEra);
pub fn shuo_list(year: i32) -> Option<LunarContext> {
if !(-722..1900).contains(&year) {
return None;
}
let era = HistoricalEra::from_year(year);
let guess = JulianDay::from_ymd(year, 12, 1).0;
let dongzhi_jd = calc_qi(guess, 270.0);
let mut items = Vec::with_capacity(15);
let start = dongzhi_jd - 30.0;
let start_index = ((start - (J2000 + 2451550.257)) / 29.530588853).ceil() as i32;
for i in 0..15 {
let approx = J2000 + 2451550.257 + (start_index + i) as f64 * 29.530588853;
let shuo_jd = calc_shuo(approx);
let (y, m, d) = JulianDay(shuo_jd + 1.0 / 3.0).to_ymd();
items.push((y, m, d));
}
let leap = if items.len() > 13 {
(1..items.len().saturating_sub(1)).find(|&i| {
let start = JulianDay::from_ymd(items[i].0, items[i].1, items[i].2).0;
let end = JulianDay::from_ymd(items[i + 1].0, items[i + 1].1, items[i + 1].2).0;
(0..12).all(|q| {
let tj = calc_qi(start, q as f64 * 30.0);
tj < start || tj >= end
})
})
} else {
None
};
Some((items, leap, era))
}
use super::era_table::{ERA_TABLE, EraRecord};
pub fn era_names(year: i32) -> Vec<(&'static EraRecord, u32)> {
let mut results = Vec::new();
for rec in ERA_TABLE {
if year >= rec.start && year < rec.start + rec.duration {
let ordinal = (year - rec.start + 1) as u32;
results.push((rec, ordinal));
}
}
results
}
pub fn era_bazi(
era_name: &str,
ordinal: u32,
lunar_month: u32,
lunar_day: u32,
is_leap: bool,
hour_index: usize, longitude: f64,
) -> Option<crate::calendar::ganzhi::Bazi> {
let records = find_era(era_name);
if records.is_empty() {
return None;
}
let rec = records[0];
let solar_year = rec.start + ordinal as i32 - 1;
let lunar = LunarDate::new(solar_year, lunar_month, lunar_day, is_leap);
let (y, m, d) = lunar_to_solar(&lunar);
let hour = (hour_index * 2) as u32;
Some(bazi(y, m, d, hour, 0, longitude))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_decompress_sb() {
assert_eq!(sb_table().len(), 16598, "SB 16598");
assert_eq!(qb_table().len(), 7567, "QB 7567");
for &b in sb_table().iter() {
assert!(b == b'0' || b == b'1' || b == b'2');
}
for &b in qb_table().iter() {
assert!(b == b'0' || b == b'1' || b == b'2');
}
}
#[test]
fn test_low_shuo_epoch() {
let jd = rough_shuo(0.0);
let diff = (jd - 2451550.257 + J2000).abs();
assert!(
diff < 1.0,
"low_shuo at w=0 should be near epoch, diff={} d",
diff
);
}
#[test]
fn test_low_qi_vernal() {
let (_y, m, _d) = JulianDay(rough_qi(0.0) + J2000).to_ymd();
assert_eq!(m, 3);
}
#[test]
fn test_calc_shuo_fallback() {
assert!(calc_shuo(MODERN_EPOCH_JD + 100.0) > MODERN_EPOCH_JD + 50.0);
}
#[test]
fn test_items_1800() {
let (moons, _, era) = shuo_list(1800).unwrap();
assert_eq!(moons.len(), 15);
assert_eq!(era, HistoricalEra::Standard);
assert_eq!(
moons[0].1, 12,
"first moon month should be Dec, got {}",
moons[0].1
);
}
#[test]
fn test_items_era() {
assert_eq!(shuo_list(-500).unwrap().2, HistoricalEra::SpringAutumn);
}
#[test]
fn test_items_out() {
assert!(shuo_list(1900).is_none());
assert!(shuo_list(-800).is_none());
}
#[test]
fn test_era_names_tang() {
let n = era_names(627);
assert!(n.iter().any(|(rec, ord)| rec.era == "贞观" && *ord == 1));
}
#[test]
fn test_era_names_multi() {
assert!(era_names(556).len() >= 2);
}
#[test]
fn test_find_era_zhenguan() {
let recs = crate::calendar::era_table::find_era("贞观");
assert!(!recs.is_empty());
assert_eq!(recs[0].start_year(), 627);
}
#[test]
fn test_era_bazi_zhenguan() {
let bazi = era_bazi("贞观", 3, 5, 3, false, 4, 120.0).unwrap();
assert_eq!(bazi.year.gan, crate::calendar::ganzhi::Tiangan::Ji);
assert_eq!(bazi.year.zhi, crate::calendar::ganzhi::Dizhi::Chou);
}
#[test]
fn test_lunar_month_from_history() {
assert_eq!(
lunar_month_from_history(2, None, false, HistoricalEra::Standard).0,
1
);
assert_eq!(
lunar_month_from_history(2, None, false, HistoricalEra::SpringAutumn).0,
2
);
}
}