From 37fd77686da4d8123fc2d3d621d093ea555957b5 Mon Sep 17 00:00:00 2001
From: Rory Coffey <coffeyrt@gmail.com>
Date: Sun, 18 Jul 2021 16:10:12 -0400
Subject: [PATCH] quit added and working along with terminal readouts

---
 src/main.rs | 101 ++++++++++++++++++++++++++++++++--------------------
 1 file changed, 63 insertions(+), 38 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index f00b1dd..407edf8 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,6 +12,25 @@ use termion::{async_stdin, raw::IntoRawMode};
 fn main() {
     let (dir_code, station, clock_brightness, vehicle_code) = arguments().unwrap_or_else(|err| panic!("ERROR - train_times - {}", err));
     let minimum_display_min = 5i64;
+
+    // setup the screen as blank with 'q to quit'
+    let out = stdout();
+    let mut stdout_main = out.lock().into_raw_mode().unwrap();
+    let mut stdin = async_stdin().bytes();
+
+    write!(stdout_main, "{}{}{}",
+        termion::clear::All,
+        termion::cursor::Goto(1, 1),
+        termion::cursor::Hide
+           ).unwrap();
+    write!(stdout_main, "{}{}q{}{} to quit", 
+        termion::color::Fg(termion::color::Green),
+        termion::style::Bold,
+        termion::color::Fg(termion::color::Reset),
+        termion::style::NoBold).unwrap();
+    stdout_main.flush().unwrap();
+    drop(stdout_main);
+
     // get the initial time trains and put them in a thread safe value to be passed back and forth
     // between threads
     let train_times_option = Arc::new(Mutex::new(
@@ -30,39 +49,36 @@ fn main() {
     let quit = Arc::new(Mutex::new(false));
     let quit_clone = Arc::clone(&quit);
     // In a new thread find train times every minute and replace train_times with new value
-    let train_time_thread = thread::spawn(move || loop {
-        thread::sleep(time::Duration::from_secs(60));
-        let new_train_times = mbta_countdown::train_time::train_times(&dir_code, &station, &vehicle_code)
-            .unwrap_or_else(|err| panic!("ERROR - train_times - {}", err));
-        let mut old_train = train_times_clone.lock().unwrap();
-        *old_train = new_train_times;
-        let quit_unlocked = quit_clone.lock().unwrap();
-        if *quit_unlocked {break};
+    let train_time_thread = thread::spawn(move || {
+        let mut seconds_left;
+        let out = stdout();
+        loop {
+            for sec_pause in 0..59 {
+                if *quit_clone.lock().unwrap() {break};
+                seconds_left = 60 - sec_pause;
+                let mut stdout_thread = out.lock().into_raw_mode().unwrap();
+                write!(stdout_thread, "{}{}",
+                       termion::cursor::Goto(1, 2),
+                       termion::clear::CurrentLine, 
+                       ).unwrap();
+                write!(stdout_thread, "{}{}{}{}{} seconds until getting next train time update", 
+                       termion::color::Fg(termion::color::Green),
+                       termion::style::Bold, 
+                       seconds_left,
+                       termion::color::Fg(termion::color::Reset),
+                       termion::style::NoBold).unwrap();
+                stdout_thread.flush().unwrap();
+                drop(stdout_thread);
+                thread::sleep(time::Duration::from_secs(1));
+            };
+            let new_train_times = mbta_countdown::train_time::train_times(&dir_code, &station, &vehicle_code)
+                .unwrap_or_else(|err| panic!("ERROR - train_times - {}", err));
+            let mut old_train = train_times_clone.lock().unwrap();
+            *old_train = new_train_times;
+            if *quit_clone.lock().unwrap() {break};
+        };
     });
 
-    let stdout = stdout();
-    let mut stdout = stdout.lock().into_raw_mode().unwrap();
-    let mut stdin = async_stdin().bytes();
-
-    // setup the screen as blank with 'q to quit'
-    write!(stdout,
-           "{}{}",
-           termion::clear::All,
-           termion::cursor::Goto(1, 1))
-            .unwrap();
-
-    write!(stdout, "{}", termion::clear::CurrentLine).unwrap();
-    write!(stdout, "{}{}q{}{} to quit", 
-        termion::color::Fg(termion::color::Green),
-        termion::style::Bold,
-        termion::color::Fg(termion::color::Reset),
-        termion::style::NoBold).unwrap();
-
-    write!(stdout,
-           "{}{}",
-           termion::cursor::Goto(1, 2), termion::cursor::Hide)
-            .unwrap();
-
     // continually update screen and clock every 0.25 seconds
     loop {
         thread::sleep(time::Duration::from_millis(250));
@@ -88,20 +104,29 @@ fn main() {
 
         // get key input and quit if q is pressed with async_stdin
         let key_input = stdin.next();
+
         match key_input {
-            Some(Ok(b'q')) => break,
-            Some(a) => write!(stdout, "{}\r{}",termion::clear::CurrentLine, a.unwrap() as char).unwrap(),
+            Some(Ok(b'q')) => {
+                *quit.lock().unwrap() = true;
+                break},
+            Some(a) => {
+                let mut stdout_main = out.lock().into_raw_mode().unwrap();
+                write!(stdout_main, "{}{}",termion::cursor::Goto(1,3), a.unwrap() as char).unwrap();
+                stdout_main.flush().unwrap();
+                drop(stdout_main);
+            },
             _ => (),
         }
-        stdout.flush().unwrap();
     }
-    write!(stdout, "{}{}Cleaning up and quiting.  May take up to a minute",
-        termion::clear::All,
+
+    let mut stdout_main = out.lock().into_raw_mode().unwrap();
+    write!(stdout_main, "{}{}Cleaning up and quiting\r\n",
+        termion::cursor::Goto(1, 4),
         termion::cursor::Show).unwrap();
+    stdout_main.flush().unwrap();
+    drop(stdout_main);
     screen.clear_display(true).unwrap_or_else(|err| panic!("ERROR - clear_display - {}", err));
     clock.clear_display().unwrap_or_else(|err| panic!("ERROR - clear_display - {}", err));
-    let mut quit_unlocked = quit.lock().unwrap();
-    *quit_unlocked = true;
     train_time_thread.join().unwrap_or_else(|err| panic!("ERROR - clear_display - {:?}", err));
 }