use time::Duration;
use crate::domain::{TimeRange, derive_acv_ademe};
use crate::ports::{Eco2mixArchive, IntensityRepository};
use super::ApplicationError;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct BackfillReport {
pub read: usize,
pub written: usize,
pub windows: usize,
}
pub struct BackfillHistory<A: Eco2mixArchive, R: IntensityRepository> {
archive: A,
repository: R,
window: Duration,
}
impl<A: Eco2mixArchive, R: IntensityRepository> BackfillHistory<A, R> {
pub fn new(archive: A, repository: R, window: Duration) -> Self {
Self {
archive,
repository,
window,
}
}
pub async fn execute(&self, range: TimeRange) -> Result<BackfillReport, ApplicationError> {
let mut report = BackfillReport::default();
for slice in slice_range(range, self.window) {
let batch = self.archive.export_national(slice).await?;
report.read += batch.len();
let mut enriched = Vec::with_capacity(batch.len() * 2);
for measurement in batch {
if let Some(acv) = derive_acv_ademe(&measurement) {
enriched.push(acv);
}
enriched.push(measurement);
}
report.written += self.repository.upsert_many(&enriched).await?;
report.windows += 1;
}
Ok(report)
}
pub async fn execute_regional(
&self,
range: TimeRange,
) -> Result<BackfillReport, ApplicationError> {
let mut report = BackfillReport::default();
for slice in slice_range(range, self.window) {
let batch = self.archive.export_regional(slice).await?;
report.read += batch.len();
report.written += self.repository.upsert_many(&batch).await?;
report.windows += 1;
}
Ok(report)
}
}
fn slice_range(range: TimeRange, window: Duration) -> Vec<TimeRange> {
let mut slices = Vec::new();
if window <= Duration::ZERO {
return slices;
}
let mut start = range.start();
while start < range.end() {
let end = start
.checked_add(window)
.map(|candidate| candidate.min(range.end()))
.unwrap_or_else(|| range.end());
let Some(slice) = TimeRange::new(start, end) else {
break;
};
slices.push(slice);
start = end;
}
slices
}