use chrono::{Datelike, Duration, NaiveDate, Utc};
use serde::{Deserialize, Serialize};
use thiserror::Error;
use crate::number::to_bangla_digits;
#[derive(Debug, Error)]
pub enum BanglaDateError {
#[error("Invalid Gregorian date: {0}")]
InvalidDate(String),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Season {
pub name_en: &'static str,
pub name_bn: &'static str,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[repr(u8)]
pub enum BanglaMonth {
Boishakh = 1,
Joishtho = 2,
Ashar = 3,
Srabon = 4,
Bhadro = 5,
Ashwin = 6,
Kartik = 7,
Ogrohayon = 8,
Poush = 9,
Magh = 10,
Falgun = 11,
Chaitra = 12,
}
impl BanglaMonth {
pub fn name_en(&self) -> &'static str {
match self {
Self::Boishakh => "Boishakh",
Self::Joishtho => "Joishtho",
Self::Ashar => "Ashar",
Self::Srabon => "Srabon",
Self::Bhadro => "Bhadro",
Self::Ashwin => "Ashwin",
Self::Kartik => "Kartik",
Self::Ogrohayon => "Ogrohayon",
Self::Poush => "Poush",
Self::Magh => "Magh",
Self::Falgun => "Falgun",
Self::Chaitra => "Chaitra",
}
}
pub fn name_bn(&self) -> &'static str {
match self {
Self::Boishakh => "বৈশাখ",
Self::Joishtho => "জ্যৈষ্ঠ",
Self::Ashar => "আষাঢ়",
Self::Srabon => "শ্রাবণ",
Self::Bhadro => "ভাদ্র",
Self::Ashwin => "আশ্বিন",
Self::Kartik => "কার্তিক",
Self::Ogrohayon => "অগ্রহায়ণ",
Self::Poush => "পৌষ",
Self::Magh => "মাঘ",
Self::Falgun => "ফাল্গুন",
Self::Chaitra => "চৈত্র",
}
}
pub fn season(&self) -> Season {
match self {
Self::Boishakh | Self::Joishtho => Season {
name_en: "Summer",
name_bn: "গ্রীষ্ম",
},
Self::Ashar | Self::Srabon => Season {
name_en: "Monsoon",
name_bn: "বর্ষা",
},
Self::Bhadro | Self::Ashwin => Season {
name_en: "Autumn",
name_bn: "শরৎ",
},
Self::Kartik | Self::Ogrohayon => Season {
name_en: "Late Autumn",
name_bn: "হেমন্ত",
},
Self::Poush | Self::Magh => Season {
name_en: "Winter",
name_bn: "শীত",
},
Self::Falgun | Self::Chaitra => Season {
name_en: "Spring",
name_bn: "বসন্ত",
},
}
}
pub fn days_in_month(&self, bangla_year: i32) -> u32 {
match self {
Self::Boishakh
| Self::Joishtho
| Self::Ashar
| Self::Srabon
| Self::Bhadro
| Self::Ashwin => 31,
Self::Falgun => {
let g_year = bangla_year + 594;
if is_gregorian_leap(g_year) { 30 } else { 29 }
}
_ => 30,
}
}
pub fn from_index(i: u8) -> Option<Self> {
match i {
1 => Some(Self::Boishakh),
2 => Some(Self::Joishtho),
3 => Some(Self::Ashar),
4 => Some(Self::Srabon),
5 => Some(Self::Bhadro),
6 => Some(Self::Ashwin),
7 => Some(Self::Kartik),
8 => Some(Self::Ogrohayon),
9 => Some(Self::Poush),
10 => Some(Self::Magh),
11 => Some(Self::Falgun),
12 => Some(Self::Chaitra),
_ => None,
}
}
}
pub fn weekday_bn(weekday: chrono::Weekday) -> &'static str {
use chrono::Weekday::*;
match weekday {
Sun => "রবিবার",
Mon => "সোমবার",
Tue => "মঙ্গলবার",
Wed => "বুধবার",
Thu => "বৃহস্পতিবার",
Fri => "শুক্রবার",
Sat => "শনিবার",
}
}
pub fn weekday_en(weekday: chrono::Weekday) -> &'static str {
use chrono::Weekday::*;
match weekday {
Sun => "Sunday",
Mon => "Monday",
Tue => "Tuesday",
Wed => "Wednesday",
Thu => "Thursday",
Fri => "Friday",
Sat => "Saturday",
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BanglaDate {
pub gregorian_date: NaiveDate,
pub day: u32,
pub day_bn: String,
pub month: BanglaMonth,
pub year: i32,
pub year_bn: String,
pub season: Season,
pub weekday: &'static str,
pub weekday_bn: &'static str,
pub is_leap_year: bool,
pub formatted_bn: String,
pub formatted_en: String,
}
fn month_start(bangla_month: BanglaMonth, boishakh_g_year: i32) -> NaiveDate {
let y0 = boishakh_g_year; let y1 = boishakh_g_year + 1;
match bangla_month {
BanglaMonth::Boishakh => NaiveDate::from_ymd_opt(y0, 4, 14).unwrap(),
BanglaMonth::Joishtho => NaiveDate::from_ymd_opt(y0, 5, 15).unwrap(),
BanglaMonth::Ashar => NaiveDate::from_ymd_opt(y0, 6, 15).unwrap(),
BanglaMonth::Srabon => NaiveDate::from_ymd_opt(y0, 7, 16).unwrap(),
BanglaMonth::Bhadro => NaiveDate::from_ymd_opt(y0, 8, 16).unwrap(),
BanglaMonth::Ashwin => NaiveDate::from_ymd_opt(y0, 9, 16).unwrap(),
BanglaMonth::Kartik => NaiveDate::from_ymd_opt(y0, 10, 17).unwrap(),
BanglaMonth::Ogrohayon => NaiveDate::from_ymd_opt(y0, 11, 16).unwrap(),
BanglaMonth::Poush => NaiveDate::from_ymd_opt(y0, 12, 16).unwrap(),
BanglaMonth::Magh => NaiveDate::from_ymd_opt(y1, 1, 15).unwrap(),
BanglaMonth::Falgun => NaiveDate::from_ymd_opt(y1, 2, 14).unwrap(),
BanglaMonth::Chaitra => NaiveDate::from_ymd_opt(y1, 3, 15).unwrap(),
}
}
fn is_gregorian_leap(year: i32) -> bool {
(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
}
pub fn to_bangla_date(date: NaiveDate) -> Result<BanglaDate, BanglaDateError> {
let g_year = date.year();
let candidate_years = [g_year - 1, g_year];
let all_months = [
BanglaMonth::Boishakh,
BanglaMonth::Joishtho,
BanglaMonth::Ashar,
BanglaMonth::Srabon,
BanglaMonth::Bhadro,
BanglaMonth::Ashwin,
BanglaMonth::Kartik,
BanglaMonth::Ogrohayon,
BanglaMonth::Poush,
BanglaMonth::Magh,
BanglaMonth::Falgun,
BanglaMonth::Chaitra,
];
let mut segments: Vec<(NaiveDate, BanglaMonth, i32)> = Vec::new();
for &gy in &candidate_years {
let bangla_year = gy - 593; for &bm in &all_months {
let start = month_start(bm, gy);
segments.push((start, bm, bangla_year));
}
}
segments.sort_by_key(|s| s.0);
let (seg_start, seg_month, seg_bangla_year) = segments
.iter()
.rev()
.find(|(start, _, _)| *start <= date)
.copied()
.ok_or_else(|| BanglaDateError::InvalidDate(date.to_string()))?;
let diff = (date - seg_start).num_days();
let bangla_day = (diff + 1) as u32;
let boishakh_this_year = month_start(BanglaMonth::Boishakh, seg_bangla_year + 593);
let bangla_year = if date < boishakh_this_year {
seg_bangla_year - 1
} else {
seg_bangla_year
};
let final_bangla_year = if date < month_start(BanglaMonth::Boishakh, g_year - 593 + 593) {
g_year - 594
} else {
g_year - 593
};
let _ = bangla_year;
let g_leap_ref = final_bangla_year + 594;
let is_leap_year = is_gregorian_leap(g_leap_ref);
let season = seg_month.season();
let wd = date.weekday();
let formatted_bn = format!(
"{} {} {}",
to_bangla_digits(bangla_day),
seg_month.name_bn(),
to_bangla_digits(final_bangla_year)
);
let formatted_en = format!(
"{} {} {}",
bangla_day,
seg_month.name_en(),
final_bangla_year
);
Ok(BanglaDate {
gregorian_date: date,
day: bangla_day,
day_bn: to_bangla_digits(bangla_day),
month: seg_month,
year: final_bangla_year,
year_bn: to_bangla_digits(final_bangla_year),
season,
weekday: weekday_en(wd),
weekday_bn: weekday_bn(wd),
is_leap_year,
formatted_bn,
formatted_en,
})
}
pub fn today() -> Result<BanglaDate, BanglaDateError> {
let utc_now = Utc::now();
let bd_now = utc_now + Duration::hours(6);
to_bangla_date(bd_now.date_naive())
}
pub fn bangla_month_start(bangla_year: i32, month: BanglaMonth) -> NaiveDate {
let g_year = bangla_year + 593;
month_start(month, g_year)
}
pub fn bangla_month_calendar(
bangla_year: i32,
month: BanglaMonth,
) -> Result<Vec<BanglaDate>, BanglaDateError> {
let start = bangla_month_start(bangla_year, month);
let total = month.days_in_month(bangla_year);
(0..total)
.map(|i| to_bangla_date(start + Duration::days(i as i64)))
.collect()
}
pub fn gregorian_month_calendar(
g_year: i32,
g_month: u32,
) -> Result<Vec<BanglaDate>, BanglaDateError> {
if g_month < 1 || g_month > 12 {
return Err(BanglaDateError::InvalidDate(format!(
"Month {} is out of range (1–12)",
g_month
)));
}
let first = NaiveDate::from_ymd_opt(g_year, g_month, 1)
.ok_or_else(|| BanglaDateError::InvalidDate(format!("{}-{:02}", g_year, g_month)))?;
let last_day = (1..=31)
.rev()
.find_map(|d| NaiveDate::from_ymd_opt(g_year, g_month, d))
.unwrap();
let total = last_day.day();
(0..total)
.map(|i| to_bangla_date(first + Duration::days(i as i64)))
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::NaiveDate;
fn date(y: i32, m: u32, d: u32) -> NaiveDate {
NaiveDate::from_ymd_opt(y, m, d).unwrap()
}
#[test]
fn test_pohela_boishakh() {
let bd = to_bangla_date(date(2025, 4, 14)).unwrap();
assert_eq!(bd.month, BanglaMonth::Boishakh);
assert_eq!(bd.day, 1);
assert_eq!(bd.year, 1432);
}
#[test]
fn test_ashar() {
let bd = to_bangla_date(date(2025, 6, 29)).unwrap();
assert_eq!(bd.month, BanglaMonth::Ashar);
assert_eq!(bd.year, 1432);
}
#[test]
fn test_year_boundary_jan() {
let bd = to_bangla_date(date(2025, 1, 14)).unwrap();
assert_eq!(bd.year, 1431);
}
#[test]
fn test_formatted_bn_contains_month() {
let bd = to_bangla_date(date(2025, 4, 14)).unwrap();
assert!(bd.formatted_bn.contains("বৈশাখ"));
assert!(bd.formatted_bn.contains("১৪৩২"));
}
#[test]
fn test_bangla_month_calendar_length() {
let days = bangla_month_calendar(1432, BanglaMonth::Ashar).unwrap();
assert_eq!(days.len(), 31);
let days = bangla_month_calendar(1432, BanglaMonth::Kartik).unwrap();
assert_eq!(days.len(), 30);
}
#[test]
fn test_gregorian_month_calendar() {
let days = gregorian_month_calendar(2025, 6).unwrap();
assert_eq!(days.len(), 30);
assert!(days.iter().all(|d| d.gregorian_date.month() == 6));
}
#[test]
fn test_leap_year_falgun() {
let days = bangla_month_calendar(1430, BanglaMonth::Falgun).unwrap();
assert_eq!(days.len(), 30);
let days = bangla_month_calendar(1431, BanglaMonth::Falgun).unwrap();
assert_eq!(days.len(), 29);
}
}