///|
/// tz_format.mbt — strftime/strptime/RFC3339(chrono_tz-mbt MoonBit 移植)
/// strftime 格式化 + strptime 解析 + RFC3339 format/parse。

///|
/// 星期全名(0=Sunday..6=Saturday)。
let weekday_full : Array[String] = [
  "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday",
]

///|
/// 星期缩写(0=Sunday..6=Saturday)。
let weekday_abbr : Array[String] = [
  "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
]

///|
/// 月份全名(1-12)。
let month_full : Array[String] = [
  "", "January", "February", "March", "April", "May", "June", "July", "August", "September",
  "October", "November", "December",
]

///|
/// 月份缩写(1-12)。
let month_abbr : Array[String] = [
  "", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov",
  "Dec",
]

///|
/// 左补零到指定宽度。
fn pad_zero(n : Int64, width : Int32) -> String {
  let s = n.to_string()
  if s.length() >= width {
    s
  } else {
    let mut r = s
    while r.length() < width {
      r = "0" + r
    }
    r
  }
}

///|
/// 格式化偏移为 ±HHMM(strftime %z 用)。
fn format_offset_hhmm(offset_sec : Int32) -> String {
  let total_min = offset_sec / 60
  let sign = if total_min < 0 { "-" } else { "+" }
  let abs_min = if total_min < 0 { -total_min } else { total_min }
  let h = abs_min / 60
  let m = abs_min % 60
  "\{sign}\{pad_zero(h.to_int64(), 2)}\{pad_zero(m.to_int64(), 2)}"
}

///|
/// strftime:按格式串格式化 DateTime。
/// 支持:%Y %m %d %H %M %S %Z %z %A %a %B %b %j %% 及字面字符。
pub fn strftime(format : String, dt : DateTime) -> String {
  let local_dt = dt.naive_local()
  let mut result = ""
  let chars = format.to_array()
  let n = chars.length()
  let mut i = 0
  while i < n {
    let c = chars[i]
    if c == '%' && i + 1 < n {
      let spec = chars[i + 1]
      let part = match spec {
        'Y' => local_dt.year().to_string()
        'm' => pad_zero(local_dt.month(), 2)
        'd' => pad_zero(local_dt.day(), 2)
        'H' => pad_zero(local_dt.hour(), 2)
        'M' => pad_zero(local_dt.minute(), 2)
        'S' => pad_zero(local_dt.second(), 2)
        'Z' => dt.abbreviation()
        'z' => format_offset_hhmm(dt.offset_sec())
        'A' => weekday_full[local_dt.weekday().to_int()]
        'a' => weekday_abbr[local_dt.weekday().to_int()]
        'B' => month_full[local_dt.month().to_int()]
        'b' => month_abbr[local_dt.month().to_int()]
        'j' => pad_zero(local_dt.ordinal(), 3)
        '%' => "%"
        _ => "\{spec}"
      }
      result = result + part
      i = i + 2
    } else {
      result = result + c.to_string()
      i = i + 1
    }
  }
  result
}

///|

///|
/// 解析十进制数字,返回 (值, 新位置),失败返回 None。
fn parse_digits(
  s : Array[Char],
  start : Int32,
  count : Int32,
) -> (Int64, Int32)? {
  let mut val = 0L
  let mut i = 0
  while i < count {
    if start + i >= s.length() {
      return None
    }
    let c = s[start + i]
    if c < '0' || c > '9' {
      return None
    }
    val = val * 10L + (c.to_int() - '0'.to_int()).to_int64()
    i = i + 1
  }
  Some((val, start + count))
}

///|
/// 解析十进制数字(Int 索引版),返回 (值, 新位置),失败返回 None。
fn parse_digits_at(
  s : Array[Char],
  start : Int32,
  count : Int32,
) -> (Int64, Int32)? {
  let mut val = 0L
  let mut i = 0
  while i < count {
    if start + i >= s.length() {
      return None
    }
    let c = s[start + i]
    if c < '0' || c > '9' {
      return None
    }
    val = val * 10L + (c.to_int() - '0'.to_int()).to_int64()
    i = i + 1
  }
  Some((val, start + count))
}

///|
/// RFC3339 解析:`YYYY-MM-DDTHH:MM:SS±HH:MM` 或 `YYYY-MM-DDTHH:MM:SSZ`。
/// 返回 DateTime?(解析失败返回 None,不抛错,ADR-008 查无→T?)。
pub fn DateTime::parse_rfc3339(s : String) -> DateTime? {
  let chars = s.to_array()
  let n = chars.length()
  // 最短格式:YYYY-MM-DDTHH:MM:SSZ = 20 字符
  if n < 20 {
    return None
  }
  // 解析日期时间部分 YYYY-MM-DDTHH:MM:SS
  guard parse_digits(chars, 0, 4) is Some((year, p1)) else { return None }
  if p1 >= n || chars[p1] != '-' {
    return None
  }
  guard parse_digits(chars, p1 + 1, 2) is Some((month, p2)) else { return None }
  if p2 >= n || chars[p2] != '-' {
    return None
  }
  guard parse_digits(chars, p2 + 1, 2) is Some((day, p3)) else { return None }
  if p3 >= n || (chars[p3] != 'T' && chars[p3] != 't' && chars[p3] != ' ') {
    return None
  }
  guard parse_digits(chars, p3 + 1, 2) is Some((hour, p4)) else { return None }
  if p4 >= n || chars[p4] != ':' {
    return None
  }
  guard parse_digits(chars, p4 + 1, 2) is Some((min, p5)) else { return None }
  if p5 >= n || chars[p5] != ':' {
    return None
  }
  guard parse_digits(chars, p5 + 1, 2) is Some((sec, p6)) else { return None }
  // 解析时区后缀:Z 或 ±HH:MM
  let offset_sec : Int32 = if p6 < n && (chars[p6] == 'Z' || chars[p6] == 'z') {
    0
  } else {
    if p6 + 6 > n {
      return None
    }
    let sign : Int32 = if chars[p6] == '+' {
      1
    } else if chars[p6] == '-' {
      -1
    } else {
      return None
    }
    guard parse_digits(chars, p6 + 1, 2) is Some((oh, p7)) else { return None }
    if p7 >= n || chars[p7] != ':' {
      return None
    }
    guard parse_digits(chars, p7 + 1, 2) is Some((om, _)) else { return None }
    sign * (oh.to_int() * 3600 + om.to_int() * 60)
  }
  // 构造 NaiveDateTime(本地墙钟)
  let naive = NaiveDateTime::make(year, month, day, hour, min, sec)
  // UTC 时间戳 = 本地时间戳 - offset
  let utc_ts = naive.timestamp() - offset_sec.to_int64()
  // 查找匹配的时区
  let tz = Tz::from_str("UTC")
  match tz {
    Some(t) => {
      let off_span = @core.FixedTimespan::{ offset: offset_sec, name: "UTC", }
      let off = TzOffset::make(t, off_span)
      Some(DateTime::make(utc_ts, off))
    }
    None => None
  }
}

///|
/// strptime:按格式串解析输入为 DateTime。
/// 支持:%Y(4位年) %m(2位月) %d(2位日) %H(2位时) %M(2位分) %S(2位秒)
///       %y(2位年,00-68→2000s,69-99→1900s) %j(3位年中天数) %% 及字面字符。
/// 解析失败返回 None(ADR-008 查无→T?)。
pub fn strptime(format : String, input : String, tz : Tz) -> DateTime? {
  let fmt_chars = format.to_array()
  let in_chars = input.to_array()
  let fmt_n = fmt_chars.length()
  let in_n = in_chars.length()
  let mut fi = 0
  let mut ii = 0
  let mut year = 1970L
  let mut month = 1L
  let mut day = 1L
  let mut hour = 0L
  let mut minute = 0L
  let mut second = 0L
  let mut has_yday = false
  while fi < fmt_n {
    let fc = fmt_chars[fi]
    if fc == '%' && fi + 1 < fmt_n {
      let spec = fmt_chars[fi + 1]
      match spec {
        'Y' => {
          guard parse_digits_at(in_chars, ii, 4) is Some((v, np)) else {
            return None
          }
          year = v
          ii = np
        }
        'm' => {
          guard parse_digits_at(in_chars, ii, 2) is Some((v, np)) else {
            return None
          }
          month = v
          ii = np
        }
        'd' => {
          guard parse_digits_at(in_chars, ii, 2) is Some((v, np)) else {
            return None
          }
          day = v
          ii = np
        }
        'H' => {
          guard parse_digits_at(in_chars, ii, 2) is Some((v, np)) else {
            return None
          }
          hour = v
          ii = np
        }
        'M' => {
          guard parse_digits_at(in_chars, ii, 2) is Some((v, np)) else {
            return None
          }
          minute = v
          ii = np
        }
        'S' => {
          guard parse_digits_at(in_chars, ii, 2) is Some((v, np)) else {
            return None
          }
          second = v
          ii = np
        }
        'y' => {
          guard parse_digits_at(in_chars, ii, 2) is Some((v, np)) else {
            return None
          }
          year = if v <= 68L { 2000L + v } else { 1900L + v }
          ii = np
        }
        'j' => {
          guard parse_digits_at(in_chars, ii, 3) is Some((v, np)) else {
            return None
          }
          day = v
          has_yday = true
          ii = np
        }
        '%' => {
          if ii >= in_n || in_chars[ii] != '%' {
            return None
          }
          ii = ii + 1
        }
        _ => return None
      }
      fi = fi + 2
    } else {
      if ii >= in_n || in_chars[ii] != fc {
        return None
      }
      ii = ii + 1
      fi = fi + 1
    }
  }
  let naive = if has_yday {
    let d = Date::from_ordinal(year, day)
    NaiveDateTime::make(d.year(), d.month(), d.day(), hour, minute, second)
  } else {
    NaiveDateTime::make(year, month, day, hour, minute, second)
  }
  match tz.from_local_date_time(naive) {
    LocalResult::Single(dt) => Some(dt)
    _ => None
  }
}