1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

// Copyright 2020-2021 Ian Jackson and contributors to Otter
// SPDX-License-Identifier: AGPL-3.0-or-later
// There is NO WARRANTY.

use crate::prelude::*;

use parking_lot::{const_rwlock, RwLock};

#[derive(SerializeDisplay)]
#[derive(DeserializeFromStr)]
#[derive(Clone,Debug)]
pub struct Timezone(Arc<TzInfo>);

#[derive(Clone,Debug,Default)]
struct TzInfo {
  name: String,
  ctz: Option<chrono_tz::Tz>,
}

impl Timezone {
  pub fn name(&self) -> &str {
    &self.0.name
  }

  // Oh my god this API is awful!

  #[throws(as Option)]
  fn format_tz<'r, TZ: chrono::TimeZone>(
    tz: &TZ, ts: Timestamp, fmt: &'r str
  ) -> chrono::format::DelayedFormat<chrono::format::StrftimeItems<'r>>
    where <TZ as chrono::TimeZone>::Offset: Display
  {
    use chrono::DateTime;
    let dt = tz.timestamp_opt(ts.0.try_into().ok()?, 0).single()?;
    DateTime::format(&dt, fmt)
  }

  pub fn format(&self, ts: Timestamp) -> String {
    match (||{
      let fmt = "%Y-%m-%d %H:%M:%S %z";
      let df = match &self.0.ctz {
        Some(ctz) => Timezone::format_tz(ctz,                  ts, fmt),
        None      => Timezone::format_tz(&chrono::offset::Utc, ts, fmt),
      }
      .ok_or_else(
        || format!("timestamp {} out of range!", &ts.0)
      )?;
      Ok(format!("{}", df))
    })() {
      Ok(s) => s,
      Err(s) => s,
    }
  }

  pub fn default_todo() -> Self {
    Timezone::from_str("").unwrap()
  }
}

impl Display for Timezone {
  #[throws(fmt::Error)]
  fn fmt(&self, f: &mut Formatter) {
    write!(f, "{}", &self.0.name)?;
  }
}

type MemoTable = Option<HashMap<String, Timezone>>;
static MEMO: RwLock<MemoTable> = const_rwlock(None);

impl FromStr for Timezone {
  type Err = Void;
  #[throws(Void)]
  fn from_str(name: &str) -> Self {
    if name.is_empty() { return default() }

    let get = |memor: &MemoTable| memor.as_ref()?.get(name).map(Clone::clone);
    if let Some(got) = get(&MEMO.read()) { return got }

    // slow path
    let mut memow = MEMO.write();
    if let Some(got) = get(&memow) { return got }

    // really slow path
    let out = {
      let name = name.to_string();
      match chrono_tz::Tz::from_str(&name) {
        Ok(ctz) => {
          Arc::new(TzInfo { name, ctz: Some(ctz) })
        },
        Err(emsg) => {
          error!("Error loading timezone {:?}: {}, using UTC", name, emsg);
          Arc::new(TzInfo { name, ctz: None })
        }
      }
    };
    let out = Timezone(out);
    memow.get_or_insert_with(default)
      .insert(name.to_string(), out.clone());
    out
  }
}

impl Default for Timezone {
  fn default() -> Self {
    Timezone(Arc::new(TzInfo { ctz: None, name: default() }))
  }
}