1use std::io::{BufReader, Read as _};
10use std::path::Path;
11
12use serde::Deserialize;
13
14use crate::{Dataset, Error, Feat, download};
15use utz_encode::{Poly, Ring};
16
17const REPO: &str = "https://github.com/evansiroky/timezone-boundary-builder";
18
19pub fn resolve_release(cache_dir: &Path) -> crate::Result<String> {
33 if let Ok(tag) = std::env::var("UTZ_TZBB_RELEASE")
34 && !tag.is_empty()
35 {
36 return Ok(tag);
37 }
38 let tag_file = cache_dir.join("tzbb-release.tag");
39 let probed: crate::Result<String> = (|| {
40 let agent: ureq::Agent = ureq::Agent::config_builder()
41 .max_redirects(0)
42 .build()
43 .into();
44 let response = agent.get(format!("{REPO}/releases/latest")).call()?;
45 response
46 .headers()
47 .get("location")
48 .and_then(|value| value.to_str().ok())
49 .and_then(|location| location.split_once("/releases/tag/"))
50 .map(|(_, tag)| tag.trim_matches('/').to_string())
51 .filter(|tag| !tag.is_empty())
52 .ok_or_else(|| Error::NoReleaseRedirect {
53 status: response.status().as_u16(),
54 })
55 })();
56 match probed {
57 Ok(tag) => {
58 std::fs::create_dir_all(cache_dir)?;
59 std::fs::write(&tag_file, &tag)?;
60 Ok(tag)
61 }
62 Err(error) => {
63 if let Some(tag) = std::fs::read_to_string(&tag_file)
64 .ok()
65 .map(|contents| contents.trim().to_string())
66 .filter(|tag| !tag.is_empty())
67 {
68 eprintln!(
69 "warning: resolving latest TZBB release failed ({error}); using cached tag {tag}"
70 );
71 return Ok(tag);
72 }
73 eprintln!(
74 "warning: resolving latest TZBB release failed ({error}); tagging asset \"dev\""
75 );
76 Ok("dev".into())
77 }
78 }
79}
80
81#[must_use]
87pub fn dataset_url(dataset: Dataset, release: &str) -> String {
88 let oceans = if dataset.oceans() { "-with-oceans" } else { "" };
89 let zone_set = match dataset.zone_set() {
90 "all" => "",
91 set_name => &format!("-{set_name}"),
92 };
93 format!("{REPO}/releases/download/{release}/timezones{oceans}{zone_set}.geojson.zip")
94}
95
96pub fn load_tzbb(dataset: Dataset, cache_dir: &Path) -> crate::Result<(Vec<Feat>, String)> {
103 let release = resolve_release(cache_dir)?;
104 let release_dir = cache_dir.join("tzbb").join(&release);
108 let zip_path = download::fetch(&dataset_url(dataset, &release), &release_dir)?;
109 Ok((load_geojson_zip(&zip_path)?, release))
110}
111
112pub fn load_geojson_zip(path: &Path) -> crate::Result<Vec<Feat>> {
118 let file = std::fs::File::open(path)?;
119 let mut zip = zip::ZipArchive::new(BufReader::new(file))?;
120 let name = (0..zip.len())
121 .map(|i| zip.name_for_index(i).unwrap_or("").to_string())
122 .find(|entry_name| {
123 Path::new(entry_name).extension().is_some_and(|extension| {
124 extension.eq_ignore_ascii_case("json") || extension.eq_ignore_ascii_case("geojson")
125 })
126 })
127 .ok_or_else(|| Error::NoGeojsonEntry { path: path.into() })?;
128 let mut bytes = Vec::new();
129 zip.by_name(&name)?.read_to_end(&mut bytes)?;
130 parse_geojson(&bytes)
131}
132
133#[derive(Deserialize)]
136struct Fc {
137 features: Vec<GjFeature>,
138}
139#[derive(Deserialize)]
140struct GjFeature {
141 properties: Props,
142 geometry: Geom,
143}
144#[derive(Deserialize)]
145struct Props {
146 tzid: Option<String>,
147}
148#[derive(Deserialize)]
149#[serde(tag = "type")]
150enum Geom {
151 Polygon {
152 coordinates: Vec<Vec<[f64; 2]>>,
153 },
154 MultiPolygon {
155 coordinates: Vec<Vec<Vec<[f64; 2]>>>,
156 },
157}
158
159pub fn parse_geojson(bytes: &[u8]) -> crate::Result<Vec<Feat>> {
165 let collection: Fc = serde_json::from_slice(bytes)?;
166 Ok(collection
167 .features
168 .into_iter()
169 .map(|feature| {
170 let polys: Vec<Poly> = match feature.geometry {
171 Geom::Polygon { coordinates } => vec![rings_of(coordinates)],
172 Geom::MultiPolygon { coordinates } => {
173 coordinates.into_iter().map(rings_of).collect()
174 }
175 };
176 Feat {
177 offset: 0.0,
178 tzid: feature.properties.tzid,
179 polys,
180 }
181 })
182 .collect())
183}
184
185fn rings_of(rings: Vec<Vec<[f64; 2]>>) -> Poly {
186 rings
187 .into_iter()
188 .map(|ring| strip_close(ring.into_iter().map(|[x, y]| (x, y)).collect()))
189 .collect()
190}
191
192fn strip_close(mut ring: Ring) -> Ring {
193 if ring.len() > 1 && ring.first() == ring.last() {
194 ring.pop();
195 }
196 ring
197}