mlbt 0.3.0

A terminal user interface for the MLB stats API. Watch a baseball game in your terminal! ⚾
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

use crate::app::{App, MenuItem};
use crate::state::messages::{NetworkRequest, RefreshableRequest};
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::time::interval;

pub struct PeriodicRefresher {
    network_requests: mpsc::Sender<RefreshableRequest>,
}

impl PeriodicRefresher {
    pub fn new(network_requests: mpsc::Sender<RefreshableRequest>) -> Self {
        Self { network_requests }
    }

    pub async fn run(self, app: std::sync::Arc<tokio::sync::Mutex<App>>) {
        let mut live_interval = interval(Duration::from_secs(10)); // Live data every 10s
        let mut schedule_interval = interval(Duration::from_secs(30)); // Schedule every 30s
        let mut standings_interval = interval(Duration::from_secs(1800)); // Standings every 30 minutes
        let mut stats_interval = interval(Duration::from_secs(1800)); // Stats every 30 minutes

        loop {
            tokio::select! {
                // Live game data updates (frequent for active games)
                _ = live_interval.tick() => {
                    let (active_tab, game_id, is_final) = {
                        let app = app.lock().await;
                        (
                            app.state.active_tab,
                            app.state.gameday.current_game_id(),
                            app.state.gameday.is_final(),
                        )
                    };

                    if active_tab == MenuItem::Gameday && game_id > 0 && !is_final {
                        let _ = self.network_requests.send(RefreshableRequest::force(NetworkRequest::GameData { game_id })).await;
                    }
                }

                // Schedule updates (moderate frequency)
                _ = schedule_interval.tick() => {
                    let (active_tab, date, game_id) = {
                        let app = app.lock().await;
                        (app.state.active_tab, app.state.schedule.date_selector.date, app.state.schedule.get_selected_game_opt().unwrap_or(0))
                    };

                    if active_tab == MenuItem::Scoreboard {
                        let _ = self.network_requests.send(RefreshableRequest::force(NetworkRequest::Schedule { date })).await;
                        if game_id > 0 {
                            let _ = self.network_requests.send(RefreshableRequest::force(NetworkRequest::GameData { game_id })).await;
                        }
                    }
                }

                // Standings updates (low frequency)
                _ = standings_interval.tick() => {
                    let (active_tab, date) = {
                        let app = app.lock().await;
                        (app.state.active_tab, app.state.standings.date_selector.date)
                    };

                    if active_tab == MenuItem::Standings {
                        let _ = self.network_requests.send(RefreshableRequest::force(NetworkRequest::Standings { date })).await;
                    }
                }

                // Stats updates (low frequency)
                _ = stats_interval.tick() => {
                    let (active_tab, date, stat_type) = {
                        let app = app.lock().await;
                        (app.state.active_tab, app.state.stats.date_selector.date, app.state.stats.stat_type)
                    };

                    if active_tab == MenuItem::Stats {
                        let _ = self.network_requests.send(RefreshableRequest::force(NetworkRequest::Stats { date, stat_type })).await;
                    }
                }
            }
        }
    }
}