[Add] Propper logging design

src/gui/input_handler.rs

@@ -1,59 +1,51 @@
-use crate::ACTIVE_TASKS;
 use crate::gui::ui::{UI, UNIQUE};
 use crate::{RELOAD, SHUTDOWN};
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, poll, read};
+use crossterm::event::{Event, KeyEvent, KeyEventKind, KeyModifiers, poll, read};
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 use std::time::Duration;
 
 pub fn setup_input_handler(ui: Arc<UI>) {
     tokio::spawn(async move {
-        ACTIVE_TASKS.insert("Input Handler".to_string());
-
         loop {
-            {
-                let should_shutdown = *SHUTDOWN.read().await;
-                if should_shutdown {
-                    break;
-                }
+            if *SHUTDOWN.read().await {
+                break;
             }
 
-            let has_event = match poll(Duration::from_millis(100)) {
-                Ok(true) => true,
-                Ok(false) => false,
-                Err(_) => false,
-            };
+            let event_result = tokio::task::spawn_blocking(|| {
+                if let Ok(true) = poll(Duration::from_millis(100)) {
+                    read().ok().and_then(|ev| match ev {
+                        Event::Key(key) if key.kind == KeyEventKind::Press => Some(key),
+                        _ => None,
+                    })
+                } else {
+                    None
+                }
+            })
+            .await;
 
-            if has_event {
-                match read() {
-                    Ok(event) => {
-                        if let Event::Key(key_event) = event {
-                            if key_event.kind == KeyEventKind::Press {
-                                let uic = ui.clone();
-                                handle_input(key_event, uic).await;
-                                UNIQUE.store(true, Ordering::Relaxed);
-                            }
-                        }
-                    }
-                    Err(_) => (),
+            match event_result {
+                Ok(Some(key_event)) => {
+                    handle_input(key_event, ui.clone()).await;
+                    UNIQUE.store(true, Ordering::Relaxed);
+                }
+                Ok(_) => {}
+                Err(e) => {
+                    eprintln!("Input task error: {}", e);
+                    tokio::time::sleep(Duration::from_millis(10)).await;
                 }
             }
         }
-        {
-            ACTIVE_TASKS.remove("Input Handler");
-        }
     });
 }
 
 pub async fn handle_input(key: KeyEvent, ui: Arc<UI>) {
     match (key.code, key.modifiers) {
-        (KeyCode::Char('q'), KeyModifiers::CONTROL) => {
+        (crossterm::event::KeyCode::Char('q'), KeyModifiers::CONTROL)
+        | (crossterm::event::KeyCode::Char('c'), KeyModifiers::CONTROL) => {
             *SHUTDOWN.write().await = true;
         }
-        (KeyCode::Char('c'), KeyModifiers::CONTROL) => {
-            *SHUTDOWN.write().await = true;
-        }
-        (KeyCode::Char('r'), KeyModifiers::CONTROL) => {
+        (crossterm::event::KeyCode::Char('r'), KeyModifiers::CONTROL) => {
             *RELOAD.write().await = true;
             *SHUTDOWN.write().await = true;
         }