JHHM

lol-cal

terminal lolesports schedule viewer
git clone https://jhhm.no/repos/lol-cal.git

lol-cal/src/app.rs

get raw file: app.rs

1use std::rc::Rc;
2
3use ratatui::{
4    DefaultTerminal, Frame,
5    crossterm::event::KeyEvent,
6    layout::{Constraint, Layout, Rect},
7};
8use strum::Display;
9use tracing::*;
10
11use crate::{
12    config::{self, Config},
13    event::{AppEvent, Event, EventHandler},
14    resources::ResourceManager,
15    widgets::{
16        events::{Events, ScheduleState},
17        fillchar::FillChar,
18        leagues::{Leagues, LeaguesState},
19    },
20};
21
22#[derive(Debug)]
23pub struct App {
24    pub running: bool,
25    pub events: EventHandler,
26    pub config: Rc<Config>,
27    pub resources: ResourceManager,
28
29    pub mode: Mode,
30    pub leagues: Leagues,
31    pub leagues_state: LeaguesState,
32    pub schedule: Events,
33    pub schedule_state: ScheduleState,
34}
35
36#[derive(Debug, Default, Display)]
37pub enum Mode {
38    None,
39    #[default]
40    Leagues,
41    Events,
42}
43
44impl App {
45    pub fn new() -> Result<Self, config::Error> {
46        let config = Rc::new(Config::new()?);
47        let resources = ResourceManager::new(config.data_dir.clone());
48        let schedule = Events::new(config.clone());
49        let leagues = Leagues::new(config.clone());
50        let events = EventHandler::new();
51
52        Ok(App {
53            running: true,
54            events: events,
55            config: config,
56            resources: resources,
57            mode: Mode::default(),
58            leagues: leagues,
59            leagues_state: LeaguesState::default(),
60            schedule: schedule,
61            schedule_state: ScheduleState::default(),
62        })
63    }
64
65    pub fn init(&mut self) {
66        self.events.send(AppEvent::ReloadLeagues);
67        self.schedule_state.spoil_results = self.config.spoil_results;
68        self.schedule_state.spoil_matches = self.config.spoil_matches;
69    }
70
71    fn handle_up(&mut self) {
72        match self.mode {
73            Mode::None => {}
74            Mode::Leagues => self.leagues_state.list_state.scroll_up_by(1),
75            Mode::Events => self.schedule_state.scroll_up_by(1),
76        }
77    }
78
79    fn handle_down(&mut self) {
80        match self.mode {
81            Mode::None => {}
82            Mode::Leagues => self.leagues_state.list_state.scroll_down_by(1),
83            Mode::Events => self.schedule_state.scroll_down_by(1),
84        }
85    }
86
87    fn handle_left(&mut self) {
88        match self.mode {
89            Mode::Leagues => {}
90            Mode::Events | Mode::None => {
91                self.mode = Mode::Leagues;
92                self.schedule_state.focused = false;
93                self.leagues_state.focused = true;
94            }
95        }
96    }
97
98    fn handle_right(&mut self) {
99        match self.mode {
100            Mode::Leagues | Mode::None => {
101                self.mode = Mode::Events;
102                self.schedule_state.focused = true;
103                self.leagues_state.focused = false;
104            }
105            Mode::Events => {}
106        }
107    }
108
109    fn handle_select(&mut self) {
110        match self.mode {
111            Mode::None => {}
112            Mode::Leagues => {
113                let id = self.leagues.select(&self.leagues_state.list_state);
114                if let Some((selected, id)) = id {
115                    match selected {
116                        true => self.set_active(id),
117                        false => self.schedule.unset_active(&id),
118                    }
119                    self.schedule_state.select_today(&self.schedule);
120                }
121            }
122            Mode::Events => {}
123        }
124    }
125
126    fn reload_leagues(&mut self) {
127        let sender = self.events.get_sender_clone();
128        let resources = self.resources.clone();
129        tokio::spawn(async move {
130            match resources.get_leagues().await {
131                Some(leagues) => sender
132                    .send(Event::App(AppEvent::RecieveLeagues(leagues)))
133                    .unwrap(),
134                None => {}
135            };
136        });
137    }
138
139    fn reload_schedule(&mut self) {
140        let slugs = self.leagues.get_selected_ids();
141        if slugs.is_empty() {
142            return;
143        }
144
145        let sender = self.events.get_sender_clone();
146        let resources = self.resources.clone();
147
148        tokio::spawn(async move {
149            for slug in slugs {
150                match resources.get_schedule(&slug).await {
151                    Some(events) => sender
152                        .send(Event::App(AppEvent::RecieveSchedule((slug, events))))
153                        .unwrap(),
154                    None => {}
155                };
156            }
157        });
158    }
159
160    fn set_active(&mut self, slug: String) {
161        self.schedule.set_active(slug);
162        if self.config.automatic_reload {
163            self.reload_schedule();
164        }
165    }
166
167    pub async fn run(mut self, mut terminal: DefaultTerminal) -> color_eyre::Result<()> {
168        while self.running {
169            terminal.draw(|frame| self.draw(frame, frame.area()))?;
170            match self.events.next().await? {
171                Event::Crossterm(event) => match event {
172                    crossterm::event::Event::Key(key_event) => self.handle_key_events(key_event)?,
173                    _ => {}
174                },
175                Event::App(app_event) => match app_event {
176                    AppEvent::Quit => self.quit(),
177                    AppEvent::Up => self.handle_up(),
178                    AppEvent::Down => self.handle_down(),
179                    AppEvent::Left => self.handle_left(),
180                    AppEvent::Right => self.handle_right(),
181                    AppEvent::Select => self.handle_select(),
182
183                    AppEvent::GotoToday => {
184                        self.schedule_state.select_today(&self.schedule);
185                        self.mode = Mode::Events;
186                        self.schedule_state.focused = true;
187                        self.leagues_state.focused = false;
188                    }
189                    AppEvent::ToggleSpoilResults => {
190                        self.schedule_state.spoil_results = !self.schedule_state.spoil_results
191                    }
192                    AppEvent::ToggleSpoilMatches => {
193                        self.schedule_state.spoil_matches = !self.schedule_state.spoil_matches
194                    }
195
196                    AppEvent::ReloadLeagues => self.reload_leagues(),
197                    AppEvent::RecieveLeagues(l) => {
198                        self.leagues.set_leagues(l);
199                        if !self.leagues.leagues.is_empty() {
200                            self.leagues_state.list_state.select_first();
201                            let default_leagues = self.config.default_leagues.clone();
202                            for name in &default_leagues {
203                                match self.leagues.select_name(name) {
204                                    Some(id) => self.set_active(id),
205                                    None => warn!("Could not find default league '{}'", name),
206                                }
207                            }
208                        }
209                    }
210                    AppEvent::ReloadSchedule => self.reload_schedule(),
211                    AppEvent::RecieveSchedule((slug, events)) => {
212                        self.schedule.add_events(slug, events);
213                        self.schedule_state.select_today(&self.schedule);
214                    }
215                },
216            }
217        }
218        Ok(())
219    }
220
221    pub fn handle_key_events(&mut self, key_event: KeyEvent) -> color_eyre::Result<()> {
222        match self.config.keybindings.get(&key_event) {
223            Some(app_event) => self.events.send(app_event.clone()),
224            None => {}
225        };
226        Ok(())
227    }
228
229    pub fn quit(&mut self) {
230        self.running = false;
231    }
232
233    fn draw(&mut self, frame: &mut Frame, area: Rect) {
234        // let vert_areas = Layout::vertical([Constraint::Max(1), Constraint::Min(0)]).split(area);
235        let schedule_min = 56;
236        let mut seperator = 0;
237        let mut league_padding = 3;
238        if self.config.style.border.is_some() {
239            league_padding += 2;
240        } else {
241            seperator = 1;
242        }
243        let hor_areas = Layout::horizontal([
244            Constraint::Length(self.leagues.longest + league_padding),
245            Constraint::Length(seperator),
246            Constraint::Min(schedule_min),
247        ])
248        .split(area);
249
250        let widget = FillChar::new('│');
251
252        frame.render_stateful_widget_ref(&self.leagues, hor_areas[0], &mut self.leagues_state);
253        frame.render_widget(widget, hor_areas[1]);
254        frame.render_stateful_widget_ref(&self.schedule, hor_areas[2], &mut self.schedule_state);
255
256        /*
257        let top_line = Text::from(format!(
258            "mode: {} | schedule_state: {} {:?}",
259            self.mode, self.schedule_state.offset, self.schedule_state.selected
260        ));
261
262        frame.render_widget(top_line, vert_areas[0]);
263        */
264    }
265}