trtr

handlers.rs (7019B)

---

 use std::sync::Arc;
 
 use axum::{
     Json,
     extract::State,
     http::StatusCode,
     response::{Html, IntoResponse},
 };
 use dashmap::DashMap;
 use rand::{Rng, rng};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{data::AppData, session::{self, ActivePrediction, Direction}};
 
 #[derive(Clone)]
 pub struct AppState {
     pub data: Arc<AppData>,
     pub sessions: Arc<DashMap<String, session::SessionState>>,
 }
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
 fn is_leap(y: i32) -> bool {
     (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
 }
 
 fn month_days(y: i32, m: u32) -> i64 {
     match m {
         1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
         4 | 6 | 9 | 11 => 30,
         2 => if is_leap(y) { 29 } else { 28 },
         _ => 30,
     }
 }
 
 fn period_start_ts(year: i32, month: u32) -> i64 {
     let mut days: i64 = 0;
     for y in 1970..year {
         days += if is_leap(y) { 366 } else { 365 };
     }
     for m in 1..month {
         days += month_days(year, m);
     }
     days * 86400
 }
 
 fn candle_range(candles: &[crate::data::Candle], year: i32, month: Option<u32>) -> (usize, usize) {
     let lo_ts = period_start_ts(year, month.unwrap_or(1));
     let hi_ts = match month {
         Some(12) | None => period_start_ts(year + 1, 1),
         Some(m) => period_start_ts(year, m + 1),
     };
     let lo = candles.partition_point(|c| c.ts < lo_ts);
     let hi = candles.partition_point(|c| c.ts < hi_ts);
     (lo, hi)
 }
 
 // ── /api/session/new ──────────────────────────────────────────────────────────
 
 #[derive(Deserialize, Default)]
 pub struct NewSessionRequest {
     pub year: Option<i32>,
     pub month: Option<u32>,
 }
 
 #[derive(Serialize)]
 pub struct NewSessionResponse {
     session_id: String,
     candles: Vec<crate::data::Candle>,
 }
 
 pub async fn new_session(
     State(state): State<AppState>,
     Json(req): Json<NewSessionRequest>,
 ) -> impl IntoResponse {
     let total = state.data.candles.len();
     let mut rng = rng();
 
     let start = match req.year {
         None => session::random_start_index(total, &mut rng),
         Some(year) => {
             let (lo, hi) = candle_range(&state.data.candles, year, req.month);
             if hi.saturating_sub(lo) < 100 {
                 return (
                     StatusCode::BAD_REQUEST,
                     Json(serde_json::json!({"error": "not_enough_data"})),
                 ).into_response();
             }
             let max = hi.saturating_sub(100).min(total.saturating_sub(5100)).max(lo);
             rng.random_range(lo..=max)
         }
     };
 
     let s = session::SessionState::new(start);
     let candles = state.data.candles[start..=s.current_index].to_vec();
     let id = Uuid::new_v4().to_string();
     state.sessions.insert(id.clone(), s);
 
     Json(NewSessionResponse { session_id: id, candles }).into_response()
 }
 
 // ── /api/next ─────────────────────────────────────────────────────────────────
 
 #[derive(Deserialize)]
 pub struct SessionIdBody {
     pub session_id: String,
 }
 
 #[derive(Serialize)]
 pub struct ResolvedPrediction {
     entry_price: f64,
     close_price: f64,
     direction: Direction,
     fee_pct: f64,
     profit: f64,
 }
 
 #[derive(Serialize)]
 pub struct NextCandleResponse {
     candle: crate::data::Candle,
     resolved: Option<ResolvedPrediction>,
 }
 
 pub async fn next_candle(
     State(state): State<AppState>,
     Json(body): Json<SessionIdBody>,
 ) -> impl IntoResponse {
     let Some(mut s) = state.sessions.get_mut(&body.session_id) else {
         return (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "session_not_found"}))).into_response();
     };
 
     let next = s.current_index + 1;
     if next >= state.data.candles.len() {
         return (StatusCode::CONFLICT, Json(serde_json::json!({"error": "end_of_data"}))).into_response();
     }
 
     s.current_index = next;
     let candle = state.data.candles[next].clone();
 
     let resolved = if s.prediction.as_ref().map_or(false, |p| next >= p.target_index) {
         let pred = s.prediction.take().unwrap();
         let profit = session::resolve_prediction(&pred, candle.close);
         Some(ResolvedPrediction {
             entry_price: pred.entry_price,
             close_price: candle.close,
             direction: pred.direction,
             fee_pct: pred.fee_pct,
             profit,
         })
     } else {
         None
     };
     drop(s);
 
     Json(NextCandleResponse { candle, resolved }).into_response()
 }
 
 // ── /api/predict ──────────────────────────────────────────────────────────────
 
 #[derive(Deserialize)]
 pub struct PredictBody {
     session_id: String,
     bars_ahead: u32,
     direction: Direction,
     fee_pct: f64,
 }
 
 #[derive(Serialize)]
 pub struct PredictResponse {
     entry_price: f64,
 }
 
 pub async fn predict(
     State(state): State<AppState>,
     Json(body): Json<PredictBody>,
 ) -> impl IntoResponse {
     if body.bars_ahead == 0 {
         return (StatusCode::BAD_REQUEST, Json(serde_json::json!({"error": "bars_ahead_must_be_positive"}))).into_response();
     }
 
     let Some(mut s) = state.sessions.get_mut(&body.session_id) else {
         return (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "session_not_found"}))).into_response();
     };
 
     let entry_price = state.data.candles[s.current_index].close;
     s.prediction = Some(ActivePrediction {
         target_index: s.current_index + body.bars_ahead as usize,
         entry_price,
         direction: body.direction,
         fee_pct: body.fee_pct.clamp(0.0, 100.0),
     });
     drop(s);
 
     Json(PredictResponse { entry_price }).into_response()
 }
 
 // ── /api/predict/cancel ───────────────────────────────────────────────────────
 
 pub async fn cancel_predict(
     State(state): State<AppState>,
     Json(body): Json<SessionIdBody>,
 ) -> impl IntoResponse {
     let Some(mut s) = state.sessions.get_mut(&body.session_id) else {
         return (StatusCode::NOT_FOUND, Json(serde_json::json!({"error": "session_not_found"}))).into_response();
     };
     s.prediction = None;
     drop(s);
     Json(serde_json::json!({})).into_response()
 }
 
 // ── / ─────────────────────────────────────────────────────────────────────────
 
 pub async fn serve_html() -> impl IntoResponse {
     Html(include_str!("../frontend/index.html"))
 }