start work on tui app and rework secrets system

src/app.rs

@@ -0,0 +1,128 @@
+use color_eyre::Report;
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use ratatui::{prelude::CrosstermBackend, widgets::ListState, DefaultTerminal, Terminal};
+use ratatui_form::{Email, Form};
+use std::{io, path::Path};
+
+use crate::{
+    event::{AppEvent, Event, EventHandler},
+    form::FormState,
+    manifest::{load_manifest, Manifest},
+};
+
+// #[derive(Debug)]
+pub struct App {
+    pub running: bool,
+    pub list_state: ListState,
+    pub events: EventHandler,
+    pub isloadingmanifest: bool,
+    pub manifest: Option<Manifest>,
+}
+
+impl App {
+    pub fn new() -> Self {
+        Self {
+            running: true,
+            list_state: ListState::default().with_selected(Some(0)),
+            events: EventHandler::new(),
+            isloadingmanifest: false,
+            manifest: None,
+        }
+    }
+
+    pub async fn run(
+        mut self,
+        terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
+    ) -> color_eyre::Result<()> {
+        let project_root = Path::new("/home/nikkuss/dotfiles-new");
+        self.events.send(AppEvent::LoadManifest);
+
+        while self.running {
+            terminal.draw(|frame| frame.render_widget(&mut self, frame.area()))?;
+            match self.events.next().await? {
+                Event::Tick => self.tick(),
+                Event::Crossterm(event) => match event {
+                    crossterm::event::Event::Key(key_event)
+                        if key_event.kind == crossterm::event::KeyEventKind::Press =>
+                    {
+                        self.handle_key_events(key_event)?
+                    }
+                    _ => {}
+                },
+                Event::App(app_event) => match app_event {
+                    AppEvent::LoadManifest => {
+                        if !self.isloadingmanifest {
+                            let tx = self.events.clone_sender();
+                            tokio::spawn(async move {
+                                let result = load_manifest(&project_root).await;
+                                let _ = tx.send(Event::App(AppEvent::ManifestLoaded(result)));
+                            });
+                        }
+                    }
+                    AppEvent::ManifestLoaded(manifest) => {
+                        self.isloadingmanifest = false;
+                        match manifest {
+                            Ok(m) => {
+                                self.manifest = Some(m);
+                            }
+                            Err(e) => {
+                                self.display_error(e);
+                            }
+                        }
+                    }
+                    AppEvent::SelectionUp => self.selection_up(),
+                    AppEvent::SelectionDown => self.selection_down(),
+                    AppEvent::Quit => self.quit(),
+                },
+            }
+        }
+        Ok(())
+    }
+
+    /// Handles the key events and updates the state of [`App`].
+    pub fn handle_key_events(&mut self, key_event: KeyEvent) -> color_eyre::Result<()> {
+        match key_event.code {
+            KeyCode::Esc | KeyCode::Char('q') => self.events.send(AppEvent::Quit),
+            KeyCode::Char('c' | 'C') if key_event.modifiers == KeyModifiers::CONTROL => {
+                self.events.send(AppEvent::Quit)
+            }
+            KeyCode::Up => self.events.send(AppEvent::SelectionUp),
+            KeyCode::Down => self.events.send(AppEvent::SelectionDown),
+            KeyCode::Char('a') => self.create_secret(),
+            // Other handlers you could add here.
+            _ => {}
+        }
+        Ok(())
+    }
+
+    pub fn selected_secret_name(&self) -> Option<String> {
+        let selected = self.list_state.selected()?;
+        if let Some(manifest) = &self.manifest {
+            return manifest.secrets.keys().nth(selected).cloned();
+        }
+        None
+    }
+
+    /// Handles the tick event of the terminal.
+    ///
+    /// The tick event is where you can update the state of your application with any logic that
+    /// needs to be updated at a fixed frame rate. E.g. polling a server, updating an animation.
+    pub fn tick(&self) {}
+
+    /// Set running to false to quit the application.
+    pub fn quit(&mut self) {
+        self.running = false;
+    }
+
+    pub fn selection_down(&mut self) {
+        self.list_state.select_next();
+    }
+
+    pub fn selection_up(&mut self) {
+        self.list_state.select_previous();
+    }
+    pub fn display_error(&mut self, display_error: Report) {
+        // somehow display the error?
+    }
+    pub fn create_secret(&mut self) {}
+}