use crate::broker::error::BrokerError;
use crate::broker::trait_::Broker;
use crate::domain::{Candle, CandleRequest};
pub const VELAS_POR_PAGINA: usize = 1000;
pub const PAGINAS_MAXIMAS: usize = 5_000;
#[derive(Debug, Clone, PartialEq)]
pub struct Ventana {
pub velas: Vec<Candle>,
pub paginas: usize,
pub completa: bool,
pub truncada: bool,
pub faltantes: usize,
}
pub fn ultimo_cierre(ahora: i64, intervalo: u64) -> i64 {
let paso = intervalo.max(1) as i64;
(ahora / paso) * paso - paso
}
pub fn paginas_estimadas(intervalo: u64, desde: i64, hasta: i64) -> usize {
if hasta <= desde {
return 0;
}
let paso = intervalo.max(1) as i64;
let velas = ((hasta - desde) as f64 / paso as f64).ceil().max(0.0) as usize;
velas.div_ceil(VELAS_POR_PAGINA)
}
pub async fn descargar(
broker: &dyn Broker,
simbolo: &str,
intervalo: u64,
desde: i64,
hasta: i64,
) -> Result<Ventana, BrokerError> {
if intervalo == 0 {
return Err(BrokerError::Internal("intervalo de vela 0".into()));
}
if hasta <= desde {
return Ok(Ventana {
velas: Vec::new(),
paginas: 0,
completa: true,
truncada: false,
faltantes: 0,
});
}
let mut velas: Vec<Candle> = Vec::new();
let mut paginas = 0usize;
let mut to = hasta;
let mut truncada = false;
loop {
if paginas >= PAGINAS_MAXIMAS {
truncada = true;
break;
}
if to < desde {
break;
}
let request = CandleRequest {
symbol: simbolo.to_string(),
interval: intervalo,
count: VELAS_POR_PAGINA,
end_time: Some(to),
};
let pagina = broker.get_candles(request).await?;
paginas += 1;
if pagina.is_empty() {
break;
}
let antes = velas.len();
velas.extend(pagina.into_iter().filter(|v| v.from >= desde));
velas.sort_by_key(|v| v.from);
velas.dedup_by_key(|v| v.from);
let Some(mas_vieja) = velas.first().map(|v| v.from) else {
break;
};
if mas_vieja <= desde {
break;
}
if velas.len() == antes {
break;
}
to = mas_vieja - intervalo as i64;
}
let completa = velas.first().map(|v| v.from <= desde).unwrap_or(true);
let faltantes = faltantes(&velas, intervalo);
Ok(Ventana {
velas,
paginas,
completa,
truncada,
faltantes,
})
}
pub fn faltantes(velas: &[Candle], intervalo: u64) -> usize {
let (Some(primera), Some(ultima)) = (velas.first(), velas.last()) else {
return 0;
};
let paso = intervalo.max(1) as i64;
let esperadas = ((ultima.to - primera.from) / paso).max(0) as usize;
esperadas.saturating_sub(velas.len())
}
#[cfg(test)]
mod tests {
use super::*;
fn vela(from: i64, precio: f64) -> Candle {
Candle {
from,
to: from + 1,
open: precio,
close: precio,
high: precio,
low: precio,
volume: Some(1.0),
}
}
#[test]
fn ultimo_cierre_excluye_la_vela_en_curso() {
assert_eq!(ultimo_cierre(1_000, 60), 900);
assert_eq!(ultimo_cierre(1_000, 1), 999);
assert_eq!(ultimo_cierre(120, 60), 60);
}
#[test]
fn paginas_estimadas_cubre_la_semana() {
assert_eq!(paginas_estimadas(1, 0, 7 * 86_400), 605);
assert_eq!(paginas_estimadas(1, 0, 7_200), 8);
assert_eq!(paginas_estimadas(60, 0, 3_600), 1);
assert_eq!(paginas_estimadas(1, 100, 100), 0);
assert_eq!(paginas_estimadas(1, 200, 100), 0);
}
#[test]
fn faltantes_detecta_un_hueco() {
let velas = vec![vela(0, 1.0), vela(1, 1.1), vela(4, 1.2)];
assert_eq!(faltantes(&velas, 1), 2);
assert_eq!(faltantes(&velas[..2], 1), 0);
assert_eq!(faltantes(&[], 1), 0);
}
}