Introduce support for immediate mode UIs — radicle-tui

add a new module im that provides an API to write immediate mode UIs on top of the application framework
move the existing, retained mode module to rm
reimplement patch select with an immediate mode UI
add examples for immediate mode UIs

 `radicle-tui` provides various terminal user interfaces for interacting with the [Radicle](https://radicle.xyz) code forge. It also exposes the application framework they were built with.
 # Table of Contents
 . [Getting Started](#getting-started)
     - [Installation](#installation)
     - [Usage](#usage)
    - [Installation](#installation)
    - [Usage](#usage)
 . [Application framework](#application-framework)
     - [Design](#design)
     - [Example](#example)
    - [Design](#design)
    - [Example](#example)
 . [Roadmap](#roadmap)
 . [Contributing](#contributing)
 . [Contact](#contact)

 # show an interface that let's you select a patch
 ./rad.sh patch show
 ```
 ```sh
 # show an interface that let's you select a patch and an operation
 ./rad.sh patch --tui

 ```
 rad-tui <patch | issue | inbox> select
 ```
 Same as above:
 ```

 #### Output
 All interfaces return a common JSON object on `stderr` that reflects the choices made by the user, e.g.:
 All interfaces return a common JSON object on `stderr` that reflects the choices made by the user, e.g.:
 ```
 { "operation": "show", "ids": ["546443226b300484a97a2b2d7c7000af6e8169ba"], args:[] }

 ## Application framework
 The library portion of this crate is a framework that is the foundation for all `radicle-tui` binaries. The framework is built on top of [ratatui](https://ratatui.rs) and mostly follows the Flux application pattern. It took some ideas from [tui-realm](https://github.com/veeso/tui-realm) and [cursive](https://github.com/gyscos/cursive). The concurrency model was mostly inspired by [rust-chat-server](https://github.com/Yengas/rust-chat-server).
 The library portion of this crate is a framework that is the foundation for all `radicle-tui` binaries. It supports building concurrent applications with an immediate mode UI. It comes with a widget library that provides low-level widgets such as lists, text fields etc. as well as higher-level application widgets such as windows, pages and various other containers.
 > **Note**: Existing core functionalities are considered to be stable, but the API may still change at any point. New features like configurations, used-defined keybindings, themes etc. will be added soon though.
 The framework comes with a widget library that provides low-level widgets such as lists, text fields etc. as well as higher-level application widgets such as windows, pages and various other containers.
 > **Note:** The widget library is under heavy development and still missing most low-level widgets. These will be added where needed by the `radicle-tui` binaries.
 > **Note:** The framework is under heavy development and still missing some required concepts / components as well as some common low-level widgets. These will be added where needed by the `radicle-tui` binaries.
 ### Design
 The framework was built with a few design goals in mind:
 The framework was built first and foremost with developer experience in mind:
 - **easy-to-use**: building new or changing existing applications should be as easy as possible; ready-made widgets should come with defaults for user interactions and rendering
 - **extensibility**: extending existing and building new widgets should be straight-forward; custom application logic components should be easy to implement
 - **flexibility**: widgets and application logic should be easy to change and compose; it should be all about changing and composing functions and not about writing boilerplate code
 - **async**: state updates and IO should be asynchronous and not block the UI
 - **declarative**: developers should rather think about the *What* then the *How*
 - **widget library**: custom widgets should be easy to build; ready-made widgets should come with defaults for user interactions and rendering
 #### Components
 The central pieces of the framework are the `Store`, the `Frontend` and a message passing system that let both communicate with each other. The `Store` handles the centralized application state and sends updates to the `Frontend`, whereas the `Frontend` handles user-interactions and sends messages to the `Store`, which updates the state accordingly.
 On top of this, an extensible widget library was built. A widget is defined by an implementation of the `View` trait and a `Widget` it is wrapped in. A `View` handles user-interactions, updates itself whenever the application state changed and renders itself frequently. A `Widget` adds additional support for properties and event, update and render callbacks. Properties define the data, configuration etc. of a widget. They are updated by the framework taking the properties built by the `on_update` callback. The `on_event` callback is used to emit application messages whenever a widget receives an event.
 The `Frontend` drives an _immediate mode_ `Ui`. In _immediate mode_, widgets are rendered the moment they're created and events are handled right before the actual drawing happens (in _retained mode_, you'd create stateful widgets once and later modify their properties or handle their events).
 The main idea is to build widgets that handle their specific events already, and that are updated with the properties built by the `on_update` callback. Custom logic is added by setting the `on_event` callback. E.g. the `Table` widget handles item selection already; items are set via the `on_update` callback and application messages are emitted via the `on_event` callback.
 > **Note:** The first versions of the framework provided a retained mode UI (rmUI) which was then replaced in favor of an immediate mode UI (imUI). The Retained mode UI is still supported, but it's recommended to use the new immediate mode UI.
 ### Example

 use termion::event::Key;
 use ratatui::text::Text;
 use ratatui::{Frame, Viewport};
 use radicle_tui as tui;
 use tui::store;
 use tui::ui::widget::text::{TextArea, TextAreaProps};
 use tui::ui::widget::ToWidget;
 use tui::{BoxedAny, Channel, Exit};
 use tui::ui::im::widget::Window;
 use tui::ui::im::Show;
 use tui::ui::im::{Borders, Context};
 use tui::{Channel, Exit};
 /// Centralized application state.
 #[derive(Clone, Debug)]
 struct State {
 struct App {
     hello: String,
 }
 /// All messages known by the application.
 #[derive(Clone, Debug)]
 enum Message {
     Quit,
 }
 /// Implementation of the app-state trait. It's updated whenever a message was received.
 /// Applications quit whenever an `Exit` is returned by the `update` function. The `Exit`
 /// type also provides and optional return value.
 impl store::State<()> for State {
     type Message = Message;
 impl store::Update<Message> for App {
     type Return = ();
     fn update(&mut self, message: Self::Message) -> Option<tui::Exit<()>> {
     fn update(&mut self, message: Message) -> Option<tui::Exit<()>> {
         match message {
             Message::Quit => Some(Exit { value: None }),
         }
     }
 }
 /// 1. Initializes the communication channel between frontend and state store
 /// 2. Initializes the application state
 /// 3. Builds a textarea widget which renders a welcome message and quits the
 ///    application when (q) is pressed
 /// 4. Runs the TUI application
 impl Show<Message> for App {
     fn show(&self, ctx: &Context<Message>, frame: &mut Frame) -> Result<()> {
         Window::default().show(ctx, |ui| {
             ui.text_view(frame, self.hello.clone(), &mut (0, 0), Some(Borders::None));
             if ui.input_global(|key| key == Key::Char('q')) {
                 ui.send_message(Message::Quit);
             }
         });
         Ok(())
     }
 }
 #[tokio::main]
 pub async fn main() -> Result<()> {
     let channel = Channel::default();
     let sender = channel.tx.clone();
     let state = State {
         hello: "Hey there, press (q) to quit...".to_string(),
     let app = App {
         hello: "Hello World!".to_string(),
     };
     let textarea = TextArea::default()
         .to_widget(sender.clone())
         .on_event(|key, _, _| match key {
             Key::Char('q') => Some(Message::Quit),
             _ => None,
         })
         .on_update(|state: &State| {
             TextAreaProps::default()
                 .text(&Text::raw(state.hello.clone()))
                 .to_boxed_any()
                 .into()
         });
     tui::run(channel, state, textarea).await?;
     tui::im(app, Viewport::default(), Channel::default()).await?;
     Ok(())
 }

 - [ ] Support user-defined keybindings
 - [ ] Patch review
 ### Later
 ### Later
 - [ ] Streamline CLI integration w/ config and flags for `rad` commands (e.g. `rad patch edit --tui`)`
 - [ ] Read COBs from JSON input

 If you have any suggestions that would make this better, please clone the repo and open a patch. You can also simply open an issue with the label "enhancement".
 ## License
 `radicle-tui` is distributed under the terms of both the MIT license and the Apache License (Version 2.0).
 See [LICENSE-APACHE](https://app.radicle.xyz/nodes/seed.radicle.xyz/rad:z39mP9rQAaGmERfUMPULfPUi473tY/tree/LICENSE-APACHE) and [LICENSE-MIT](https://app.radicle.xyz/nodes/seed.radicle.xyz/rad:z39mP9rQAaGmERfUMPULfPUi473tY/tree/LICENSE-MIT) for details.
 ## Contact
 Please get in touch on [Zulip](https://radicle.zulipchat.com).
 ## License
 ## Acknowledgments
 `radicle-tui` is distributed under the terms of both the MIT license and the Apache License (Version 2.0).
 Parts of this project rely on or were heavily inspired by some great open source projects. So we'd like to thank:
 See [LICENSE-APACHE](https://app.radicle.xyz/nodes/seed.radicle.xyz/rad:z39mP9rQAaGmERfUMPULfPUi473tY/tree/LICENSE-APACHE) and [LICENSE-MIT](https://app.radicle.xyz/nodes/seed.radicle.xyz/rad:z39mP9rQAaGmERfUMPULfPUi473tY/tree/LICENSE-MIT) for details.
 - [ratatui](https://ratatui.rs)
 - [egui](https://github.com/egui)
 - [tui-realm](https://github.com/veeso/tui-realm)
 - [tui-textarea](https://github.com/rhysd/tui-textarea)
 - [tui-rs-tree-widget](https://github.com/EdJoPaTo/tui-rs-tree-widget)
 - [rust-chat-server](https://github.com/Yengas/rust-chat-server)

 use anyhow::Result;
 use ratatui::Viewport;
 use termion::event::Key;
 use ratatui::layout::Constraint;

 use radicle_tui as tui;
 use tui::store;
 use tui::store::StateValue;
 use tui::ui::rm::widget::container::{Container, Footer, FooterProps, Header, HeaderProps};
 use tui::ui::rm::widget::input::{TextView, TextViewProps, TextViewState};
 use tui::ui::rm::widget::window::{
     Page, PageProps, Shortcuts, ShortcutsProps, Window, WindowProps,
 };
 use tui::ui::rm::widget::{ToWidget, Widget};
 use tui::ui::span;
 use tui::ui::widget::container::{Column, Container, Footer, FooterProps, Header, HeaderProps};
 use tui::ui::widget::input::TextView;
 use tui::ui::widget::input::TextViewProps;
 use tui::ui::widget::input::TextViewState;
 use tui::ui::widget::window::{Page, PageProps, Shortcuts, ShortcutsProps, Window, WindowProps};
 use tui::ui::widget::{ToWidget, Widget};
 use tui::ui::BufferedValue;
 use tui::ui::Column;
 use tui::{BoxedAny, Channel, Exit, PageStack};
 use crate::cob::inbox;

     items: Vec<NotificationItem>,
     selected: Option<usize>,
     filter: NotificationItemFilter,
     search: store::StateValue<String>,
     search: BufferedValue<String>,
     show_search: bool,
 }

         let doc = context.repository.identity_doc()?;
         let project = doc.project()?;
         let search = StateValue::new(String::new());
         let search = BufferedValue::new(String::new());
         let filter = NotificationItemFilter::from_str(&search.read()).unwrap_or_default();
         let mut notifications = match &context.mode.repository() {

     }
 }
 #[derive(Clone, Debug)]
 pub enum Message {
     Exit { selection: Option<Selection> },
     Select { selected: Option<usize> },

     ScrollHelp { state: TextViewState },
 }
 impl store::State<Selection> for State {
     type Message = Message;
 impl store::Update<Message> for State {
     type Return = Selection;
     fn update(&mut self, message: Message) -> Option<Exit<Selection>> {
         match message {

                     .into()
             });
         tui::run(channel, state, window).await
         tui::rm(state, window, Viewport::Inline(20), channel).await
     }
 }

 use radicle_tui as tui;
 use tui::ui::span;
 use tui::ui::widget::container::{
     Column, Container, ContainerProps, Footer, FooterProps, Header, HeaderProps,
 use tui::ui::rm::widget::container::{
     Container, ContainerProps, Footer, FooterProps, Header, HeaderProps,
 };
 use tui::ui::widget::input::{TextField, TextFieldProps};
 use tui::ui::widget::list::{Table, TableProps};
 use tui::ui::widget::{self, ViewProps};
 use tui::ui::widget::{RenderProps, ToWidget, View};
 use tui::ui::rm::widget::input::{TextField, TextFieldProps};
 use tui::ui::rm::widget::list::{Table, TableProps};
 use tui::ui::rm::widget::{self, ViewProps};
 use tui::ui::rm::widget::{RenderProps, ToWidget, View};
 use tui::ui::span;
 use tui::ui::Column;
 use tui::{BoxedAny, Selection};

 use radicle_tui as tui;
 use tui::store;
 use tui::store::StateValue;
 use tui::ui::span;
 use tui::ui::theme::Theme;
 use tui::ui::widget::container::{
     Column, Container, ContainerProps, Footer, FooterProps, Header, HeaderProps, SectionGroup,
 use tui::ui::rm::widget::container::{
     Container, ContainerProps, Footer, FooterProps, Header, HeaderProps, SectionGroup,
     SectionGroupProps, SplitContainer, SplitContainerFocus, SplitContainerProps,
 };
 use tui::ui::widget::input::{TextView, TextViewProps, TextViewState};
 use tui::ui::widget::list::{Tree, TreeProps};
 use tui::ui::widget::window::{Page, PageProps, Shortcuts, ShortcutsProps, Window, WindowProps};
 use tui::ui::widget::{PredefinedLayout, ToWidget, Widget};
 use tui::ui::rm::widget::input::{TextView, TextViewProps, TextViewState};
 use tui::ui::rm::widget::list::{Tree, TreeProps};
 use tui::ui::rm::widget::window::{
     Page, PageProps, Shortcuts, ShortcutsProps, Window, WindowProps,
 };
 use tui::ui::rm::widget::{PredefinedLayout, ToWidget, Widget};
 use tui::ui::theme::Theme;
 use tui::ui::Column;
 use tui::ui::{span, BufferedValue};
 use tui::{BoxedAny, Channel, Exit, PageStack};
 use crate::cob::issue;
 use crate::settings::{self, ThemeBundle, ThemeMode};
 use crate::ui::items::{CommentItem, IssueItem, IssueItemFilter};
 use crate::ui::widget::{BrowserState, IssueDetails, IssueDetailsProps};
 use crate::ui::rm::{BrowserState, IssueDetails, IssueDetailsProps};
 use crate::ui::TerminalInfo;
 use self::ui::{Browser, BrowserProps};

         let settings = settings::Settings::default();
         let issues = issue::all(&context.profile, &context.repository)?;
         let search = StateValue::new(context.filter.to_string());
         let search = BufferedValue::new(context.filter.to_string());
         let filter = IssueItemFilter::from_str(&search.read()).unwrap_or_default();
         let default_bundle = ThemeBundle::default();

                 mode: opts.mode,
                 filter: opts.filter.clone(),
             };
             let output = select::App::new(context).run().await?;
             let output = select::App::new(context, true).run().await?;
             let output = output
                 .map(|o| serde_json::to_string(&o).unwrap_or_default())

 #[path = "select/ui.rs"]
 mod ui;
 #[path = "select/imui.rs"]
 mod imui;
 #[path = "select/rmui.rs"]
 mod rmui;
 use std::str::FromStr;
 use anyhow::Result;
 use radicle::patch::PatchId;
 use radicle::storage::git::Repository;
 use radicle::Profile;
 use ratatui::Viewport;
 use termion::event::Key;
 use radicle_tui as tui;

 pub struct App {
     context: Context,
     im: bool,
 }
 impl App {
     pub fn new(context: Context, im: bool) -> Self {
         Self { context, im }
     }
     pub async fn run(&self) -> Result<Option<Selection>> {
         let viewport = Viewport::Inline(20);
         if self.im {
             let channel = Channel::default();
             let state = imui::App::try_from(&self.context)?;
             tui::im(state, viewport, channel).await
         } else {
             let channel = Channel::default();
             let tx = channel.tx.clone();
             let state = State::try_from(&self.context)?;
             let window = Window::default()
                 .page(AppPage::Browse, browser_page(&state, &channel))
                 .page(AppPage::Help, help_page(&state, &channel))
                 .to_widget(tx.clone())
                 .on_update(|state| {
                     WindowProps::default()
                         .current_page(state.pages.peek().unwrap_or(&AppPage::Browse).clone())
                         .to_boxed_any()
                         .into()
                 });
             tui::rm(state, window, viewport, channel).await
         }
     }
 }
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]

     fn try_from(context: &Context) -> Result<Self, Self::Error> {
         let patches = patch::all(&context.profile, &context.repository)?;
         let search = store::StateValue::new(context.filter.to_string());
         let search = BufferedValue::new(context.filter.to_string());
         let filter = PatchItemFilter::from_str(&context.filter.to_string()).unwrap_or_default();
         // Convert into UI items

 use std::str::FromStr;
 use anyhow::Result;
 use termion::event::Key;
 use ratatui::layout::{Constraint, Layout};
 use ratatui::style::Stylize;
 use ratatui::text::Span;
 use ratatui::Frame;
 use radicle_tui as tui;
 use tui::ui::im;
 use tui::ui::im::widget::{GroupState, TableState, TextEditState, TextViewState, Window};
 use tui::ui::im::Borders;
 use tui::ui::im::Show;
 use tui::ui::{BufferedValue, Column};
 use tui::{store, Exit};
 use crate::cob::patch;
 use crate::tui_patch::common::{Mode, PatchOperation};
 use crate::ui::items::{Filter, PatchItem, PatchItemFilter};
 use super::{Context, Selection};
 const HELP: &str = r#"# Generic keybindings
 `↑,k`:      move cursor one line up
 `↓,j:       move cursor one line down
 `PageUp`:   move cursor one page up
 `PageDown`: move cursor one page down
 `Home`:     move cursor to the first line
 `End`:      move cursor to the last line
 `Esc`:      Quit / cancel
 # Specific keybindings
 `enter`:    Select patch (if --mode id)
 `enter`:    Show patch
 `c`:        Checkout patch
 `d`:        Show patch diff
 `/`:        Search
 `?`:        Show help
 # Searching
 Pattern:    is:<state> | is:authored | authors:[<did>, <did>] | <search>
 Example:    is:open is:authored improve"#;
 #[derive(Clone, Debug)]
 pub enum Message {
     Quit,
     Exit {
         operation: Option<PatchOperation>,
     },
     ExitFromMode,
     PatchesChanged {
         state: TableState,
     },
     MainGroupChanged {
         state: GroupState,
     },
     PageChanged {
         page: Page,
     },
     HelpChanged {
         state: TextViewState,
     },
     ShowSearch,
     UpdateSearch {
         search: BufferedValue<TextEditState>,
     },
     HideSearch {
         apply: bool,
     },
 }
 #[derive(Clone, Debug)]
 pub enum Page {
     Main,
     Help,
 }
 #[derive(Clone, Debug)]
 pub struct Storage {
     patches: Vec<PatchItem>,
 }
 #[derive(Clone, Debug)]
 pub struct App {
     storage: Storage,
     mode: Mode,
     page: Page,
     main_group: GroupState,
     patches: TableState,
     search: BufferedValue<TextEditState>,
     show_search: bool,
     help: TextViewState,
     filter: PatchItemFilter,
 }
 impl TryFrom<&Context> for App {
     type Error = anyhow::Error;
     fn try_from(context: &Context) -> Result<Self, Self::Error> {
         let patches = patch::all(&context.profile, &context.repository)?;
         let search = context.filter.to_string();
         let filter = PatchItemFilter::from_str(&context.filter.to_string()).unwrap_or_default();
         let mut items = vec![];
         for patch in patches {
             if let Ok(item) = PatchItem::new(&context.profile, &context.repository, patch.clone()) {
                 items.push(item);
             }
         }
         items.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
         Ok(App {
             storage: Storage {
                 patches: items.clone(),
             },
             mode: context.mode.clone(),
             page: Page::Main,
             main_group: GroupState::new(3, Some(0)),
             patches: TableState::new(Some(0)),
             search: BufferedValue::new(TextEditState {
                 text: search,
                 cursor: 0,
             }),
             show_search: false,
             help: TextViewState::new(HELP, (0, 0)),
             filter,
         })
     }
 }
 impl store::Update<Message> for App {
     type Return = Selection;
     fn update(&mut self, message: Message) -> Option<tui::Exit<Selection>> {
         log::debug!("[State] Received message: {:?}", message);
         match message {
             Message::Quit => Some(Exit { value: None }),
             Message::Exit { operation } => self.selected_patch().map(|issue| Exit {
                 value: Some(Selection {
                     operation: operation.map(|op| op.to_string()),
                     ids: vec![issue.id],
                     args: vec![],
                 }),
             }),
             Message::ExitFromMode => {
                 let operation = match self.mode {
                     Mode::Operation => Some(PatchOperation::Show.to_string()),
                     Mode::Id => None,
                 };
                 self.selected_patch().map(|issue| Exit {
                     value: Some(Selection {
                         operation,
                         ids: vec![issue.id],
                         args: vec![],
                     }),
                 })
             }
             Message::PatchesChanged { state } => {
                 self.patches = state;
                 None
             }
             Message::MainGroupChanged { state } => {
                 self.main_group = state;
                 None
             }
             Message::PageChanged { page } => {
                 self.page = page;
                 None
             }
             Message::ShowSearch => {
                 self.main_group = GroupState::new(3, None);
                 self.show_search = true;
                 None
             }
             Message::HideSearch { apply } => {
                 self.main_group = GroupState::new(3, Some(0));
                 self.show_search = false;
                 if apply {
                     self.search.apply();
                 } else {
                     self.search.reset();
                 }
                 self.filter =
                     PatchItemFilter::from_str(&self.search.read().text).unwrap_or_default();
                 None
             }
             Message::UpdateSearch { search } => {
                 self.search = search;
                 self.filter =
                     PatchItemFilter::from_str(&self.search.read().text).unwrap_or_default();
                 self.patches.select_first();
                 None
             }
             Message::HelpChanged { state } => {
                 self.help = state;
                 None
             }
         }
     }
 }
 impl Show<Message> for App {
     fn show(&self, ctx: &im::Context<Message>, frame: &mut Frame) -> Result<()> {
         Window::default().show(ctx, |ui| {
             match self.page {
                 Page::Main => {
                     let show_search = self.show_search;
                     let mut page_focus = if show_search { Some(1) } else { Some(0) };
                     let mut group_focus = self.main_group.focus();
                     ui.group(
                         Layout::vertical([Constraint::Fill(1), Constraint::Length(2)]),
                         &mut page_focus,
                         |ui| {
                             let group = ui.group(
                                 im::Layout::Expandable3 { left_only: true },
                                 &mut group_focus,
                                 |ui| {
                                     self.show_patches(frame, ui);
                                     ui.text_view(
                                         frame,
                                         String::new(),
                                         &mut (0, 0),
                                         Some(Borders::All),
                                     );
                                     ui.text_view(
                                         frame,
                                         String::new(),
                                         &mut (0, 0),
                                         Some(Borders::All),
                                     );
                                 },
                             );
                             if group.response.changed {
                                 ui.send_message(Message::MainGroupChanged {
                                     state: GroupState::new(3, group_focus),
                                 });
                             }
                             if show_search {
                                 self.show_search_text_edit(frame, ui);
                             } else {
                                 ui.layout(Layout::vertical([1, 1]), |ui| {
                                     ui.bar(
                                         frame,
                                         match group_focus {
                                             Some(0) => browser_context(ui, self),
                                             _ => default_context(ui),
                                         },
                                         Some(Borders::None),
                                     );
                                     ui.shortcuts(
                                         frame,
                                         &match self.mode {
                                             Mode::Id => {
                                                 [("enter", "select"), ("/", "search")].to_vec()
                                             }
                                             Mode::Operation => [
                                                 ("enter", "show"),
                                                 ("c", "checkout"),
                                                 ("d", "diff"),
                                                 ("/", "search"),
                                                 ("?", "help"),
                                             ]
                                             .to_vec(),
                                         },
                                         '∙',
                                     );
                                 });
                                 if ui.input_global(|key| key == Key::Esc) {
                                     ui.send_message(Message::Quit);
                                 }
                                 if ui.input_global(|key| key == Key::Char('?')) {
                                     ui.send_message(Message::PageChanged { page: Page::Help });
                                 }
                                 if ui.input_global(|key| key == Key::Char('\n')) {
                                     ui.send_message(Message::ExitFromMode);
                                 }
                                 if ui.input_global(|key| key == Key::Char('d')) {
                                     ui.send_message(Message::Exit {
                                         operation: Some(PatchOperation::Diff),
                                     });
                                 }
                                 if ui.input_global(|key| key == Key::Char('c')) {
                                     ui.send_message(Message::Exit {
                                         operation: Some(PatchOperation::Checkout),
                                     });
                                 }
                             }
                         },
                     );
                 }
                 Page::Help => {
                     let mut cursor = self.help.cursor();
                     let layout = Layout::vertical([
                         Constraint::Length(3),
                         Constraint::Fill(1),
                         Constraint::Length(1),
                         Constraint::Length(1),
                     ]);
                     ui.layout(layout, |ui| {
                         ui.set_focus(Some(0));
                         ui.columns(
                             frame,
                             [Column::new(Span::raw(" Help ").bold(), Constraint::Fill(1))].to_vec(),
                             Some(Borders::Top),
                         );
                         ui.set_focus(Some(1));
                         let text_view = ui.text_view(
                             frame,
                             self.help.text().to_string(),
                             &mut cursor,
                             Some(Borders::BottomSides),
                         );
                         if text_view.changed {
                             ui.send_message(Message::HelpChanged {
                                 state: TextViewState::new(self.help.text().to_string(), cursor),
                             })
                         }
                         ui.bar(
                             frame,
                             [
                                 Column::new(
                                     Span::raw(" ".to_string())
                                         .into_left_aligned_line()
                                         .style(ui.theme().bar_on_black_style),
                                     Constraint::Fill(1),
                                 ),
                                 Column::new(
                                     Span::raw(" ")
                                         .into_right_aligned_line()
                                         .cyan()
                                         .dim()
                                         .reversed(),
                                     Constraint::Length(6),
                                 ),
                             ]
                             .to_vec(),
                             Some(Borders::None),
                         );
                         ui.shortcuts(frame, &[("?", "close")], '∙');
                     });
                     if ui.input_global(|key| key == Key::Char('?')) {
                         ui.send_message(Message::PageChanged { page: Page::Main });
                     }
                     if ui.input_global(|key| key == Key::Esc) {
                         ui.send_message(Message::Quit);
                     }
                 }
             }
             if ui.input_global(|key| key == Key::Ctrl('c')) {
                 ui.send_message(Message::Quit);
             }
         });
         Ok(())
     }
 }
 impl App {
     pub fn show_patches(&self, frame: &mut Frame, ui: &mut im::Ui<Message>) {
         let patches = self
             .storage
             .patches
             .iter()
             .filter(|patch| self.filter.matches(patch))
             .cloned()
             .collect::<Vec<_>>();
         let mut selected = self.patches.selected();
         let header = [
             Column::new(Span::raw(" ● ").bold(), Constraint::Length(3)),
             Column::new(Span::raw("ID").bold(), Constraint::Length(8)),
             Column::new(Span::raw("Title").bold(), Constraint::Fill(1)),
             Column::new(Span::raw("Author").bold(), Constraint::Length(16)).hide_small(),
             Column::new("", Constraint::Length(16)).hide_medium(),
             Column::new(Span::raw("Head").bold(), Constraint::Length(8)).hide_small(),
             Column::new(Span::raw("+").bold(), Constraint::Length(6)).hide_small(),
             Column::new(Span::raw("-").bold(), Constraint::Length(6)).hide_small(),
             Column::new(Span::raw("Updated").bold(), Constraint::Length(16)).hide_small(),
         ];
         let table = ui.headered_table(frame, &mut selected, &patches, header);
         if table.changed {
             ui.send_message(Message::PatchesChanged {
                 state: TableState::new(selected),
             });
         }
         // TODO(erikli): Should only work if table has focus
         if ui.input_global(|key| key == Key::Char('/')) {
             ui.send_message(Message::ShowSearch);
         }
     }
     pub fn show_search_text_edit(&self, frame: &mut Frame, ui: &mut im::Ui<Message>) {
         let (mut search_text, mut search_cursor) = (
             self.search.clone().read().text,
             self.search.clone().read().cursor,
         );
         let mut search = self.search.clone();
         let text_edit = ui.text_edit_labeled_singleline(
             frame,
             &mut search_text,
             &mut search_cursor,
             "Search".to_string(),
             Some(Borders::Spacer { top: 0, left: 0 }),
         );
         if text_edit.changed {
             search.write(TextEditState {
                 text: search_text,
                 cursor: search_cursor,
             });
             ui.send_message(Message::UpdateSearch { search });
         }
         if ui.input_global(|key| key == Key::Esc) {
             ui.send_message(Message::HideSearch { apply: false });
         }
         if ui.input_global(|key| key == Key::Char('\n')) {
             ui.send_message(Message::HideSearch { apply: true });
         }
     }
 }
 impl App {
     pub fn selected_patch(&self) -> Option<&PatchItem> {
         let patches = self
             .storage
             .patches
             .iter()
             .filter(|patch| self.filter.matches(patch))
             .collect::<Vec<_>>();
         self.patches
             .selected()
             .and_then(|selected| patches.get(selected))
             .copied()
     }
 }
 fn browser_context<'a>(ui: &im::Ui<Message>, app: &'a App) -> Vec<Column<'a>> {
     let search = app.search.read().text;
     let total_count = app.storage.patches.len();
     let filtered_count = app
         .storage
         .patches
         .iter()
         .filter(|patch| app.filter.matches(patch))
         .collect::<Vec<_>>()
         .len();
     let experimental = false;
     if experimental {
         [
             Column::new(
                 Span::raw(" Search ".to_string()).cyan().dim().reversed(),
                 Constraint::Length(8),
             ),
             Column::new(Span::raw("".to_string()), Constraint::Length(1)),
             Column::new(
                 Span::raw(format!(" {} ", search))
                     .into_left_aligned_line()
                     .cyan()
                     .dim()
                     .reversed(),
                 Constraint::Length((search.chars().count() + 2) as u16),
             ),
             Column::new(Span::raw("".to_string()), Constraint::Fill(1)),
             Column::new(
                 Span::raw(" 0% ")
                     .into_right_aligned_line()
                     .red()
                     .dim()
                     .reversed(),
                 Constraint::Length(6),
             ),
         ]
         .to_vec()
     } else {
         let filtered_counts = format!(" {filtered_count}/{total_count} ");
         let state_counts =
             app.storage
                 .patches
                 .iter()
                 .fold((0, 0, 0, 0), |counts, patch| match patch.state {
                     radicle::patch::State::Draft => (counts.0 + 1, counts.1, counts.2, counts.3),
                     radicle::patch::State::Open { conflicts: _ } => {
                         (counts.0, counts.1 + 1, counts.2, counts.3)
                     }
                     radicle::patch::State::Archived => (counts.0, counts.1, counts.2 + 1, counts.3),
                     radicle::patch::State::Merged {
                         revision: _,
                         commit: _,
                     } => (counts.0, counts.1, counts.2, counts.3 + 1),
                 });
         if app.filter.is_default() {
             let draft = format!(" {} ", state_counts.0);
             let open = format!(" {} ", state_counts.1);
             let archived = format!(" {} ", state_counts.2);
             let merged = format!(" {} ", state_counts.3);
             [
                 Column::new(
                     Span::raw(" Search ".to_string()).cyan().dim().reversed(),
                     Constraint::Length(8),
                 ),
                 Column::new(
                     Span::raw(format!(" {search} "))
                         .into_left_aligned_line()
                         .style(ui.theme().bar_on_black_style),
                     Constraint::Fill(1),
                 ),
                 Column::new(
                     Span::raw("●")
                         .style(ui.theme().bar_on_black_style)
                         .dim()
                         .bold(),
                     Constraint::Length(1),
                 ),
                 Column::new(
                     Span::raw(draft.clone())
                         .style(ui.theme().bar_on_black_style)
                         .dim(),
                     Constraint::Length(draft.chars().count() as u16),
                 ),
                 Column::new(
                     Span::raw("●")
                         .style(ui.theme().bar_on_black_style)
                         .green()
                         .dim()
                         .bold(),
                     Constraint::Length(1),
                 ),
                 Column::new(
                     Span::raw(open.clone())
                         .style(ui.theme().bar_on_black_style)
                         .dim(),
                     Constraint::Length(open.chars().count() as u16),
                 ),
                 Column::new(
                     Span::raw("●")
                         .style(ui.theme().bar_on_black_style)
                         .yellow()
                         .dim()
                         .bold(),
                     Constraint::Length(1),
                 ),
                 Column::new(
                     Span::raw(archived.clone())
                         .style(ui.theme().bar_on_black_style)
                         .dim(),
                     Constraint::Length(archived.chars().count() as u16),
                 ),
                 Column::new(
                     Span::raw("✔")
                         .style(ui.theme().bar_on_black_style)
                         .magenta()
                         .dim()
                         .bold(),
                     Constraint::Length(1),
                 ),
                 Column::new(
                     Span::raw(merged.clone())
                         .style(ui.theme().bar_on_black_style)
                         .dim(),
                     Constraint::Length(merged.chars().count() as u16),
                 ),
                 Column::new(
                     Span::raw(filtered_counts.clone())
                         .into_right_aligned_line()
                         .cyan()
                         .dim()
                         .reversed(),
                     Constraint::Length(filtered_counts.chars().count() as u16),
                 ),
             ]
             .to_vec()
         } else {
             [
                 Column::new(
                     Span::raw(" Search ".to_string()).cyan().dim().reversed(),
                     Constraint::Length(8),
                 ),
                 Column::new(
                     Span::raw(format!(" {search} "))
                         .into_left_aligned_line()
                         .style(ui.theme().bar_on_black_style),
                     Constraint::Fill(1),
                 ),
                 Column::new(
                     Span::raw(filtered_counts.clone())
                         .into_right_aligned_line()
                         .cyan()
                         .dim()
                         .reversed(),
                     Constraint::Length(filtered_counts.chars().count() as u16),
                 ),
             ]
             .to_vec()
         }
     }
 }
 fn default_context<'a>(ui: &im::Ui<Message>) -> Vec<Column<'a>> {
     [
         Column::new(
             Span::raw(" ".to_string())
                 .into_left_aligned_line()
                 .style(ui.theme().bar_on_black_style),
             Constraint::Fill(1),
         ),
         Column::new(
             Span::raw(" 0% ")
                 .into_right_aligned_line()
                 .cyan()
                 .dim()
                 .reversed(),
             Constraint::Length(6),
         ),
     ]
     .to_vec()
 }

 use std::collections::HashMap;
 use std::str::FromStr;
 use std::vec;
 use ratatui::Frame;
 use tokio::sync::mpsc::UnboundedSender;
 use termion::event::Key;
 use ratatui::layout::{Constraint, Layout};
 use ratatui::style::Stylize;
 use ratatui::text::{Line, Text};
 use radicle::patch;
 use radicle::patch::Status;
 use radicle_tui as tui;
 use tui::ui::rm::widget;
 use tui::ui::rm::widget::container::{
     Container, ContainerProps, Footer, FooterProps, Header, HeaderProps,
 };
 use tui::ui::rm::widget::input::{TextField, TextFieldProps};
 use tui::ui::rm::widget::list::{Table, TableProps};
 use tui::ui::rm::widget::ViewProps;
 use tui::ui::rm::widget::{RenderProps, ToWidget, View};
 use tui::ui::span;
 use tui::ui::Column;
 use tui::BoxedAny;
 use crate::ui::items::{PatchItem, PatchItemFilter};
 use super::{Message, State};
 type Widget = widget::Widget<State, Message>;
 #[derive(Clone, Default)]
 pub struct BrowserProps<'a> {
     /// Filtered patches.
     patches: Vec<PatchItem>,
     /// Patch statistics.
     stats: HashMap<String, usize>,
     /// Header columns
     header: Vec<Column<'a>>,
     /// Table columns
     columns: Vec<Column<'a>>,
     /// If search widget should be shown.
     show_search: bool,
     /// Current search string.
     search: String,
 }
 impl<'a> From<&State> for BrowserProps<'a> {
     fn from(state: &State) -> Self {
         let mut draft = 0;
         let mut open = 0;
         let mut archived = 0;
         let mut merged = 0;
         let patches = state.browser.items();
         for patch in &patches {
             match patch.state {
                 patch::State::Draft => draft += 1,
                 patch::State::Open { conflicts: _ } => open += 1,
                 patch::State::Archived => archived += 1,
                 patch::State::Merged {
                     commit: _,
                     revision: _,
                 } => merged += 1,
             }
         }
         let stats = HashMap::from([
             ("Draft".to_string(), draft),
             ("Open".to_string(), open),
             ("Archived".to_string(), archived),
             ("Merged".to_string(), merged),
         ]);
         Self {
             patches,
             stats,
             header: [
                 Column::new(" ● ", Constraint::Length(3)),
                 Column::new("ID", Constraint::Length(8)),
                 Column::new("Title", Constraint::Fill(1)),
                 Column::new("Author", Constraint::Length(16)).hide_small(),
                 Column::new("", Constraint::Length(16)).hide_medium(),
                 Column::new("Head", Constraint::Length(8)).hide_small(),
                 Column::new("+", Constraint::Length(6)).hide_small(),
                 Column::new("-", Constraint::Length(6)).hide_small(),
                 Column::new("Updated", Constraint::Length(16)).hide_small(),
             ]
             .to_vec(),
             columns: [
                 Column::new(" ● ", Constraint::Length(3)),
                 Column::new("ID", Constraint::Length(8)),
                 Column::new("Title", Constraint::Fill(1)),
                 Column::new("Author", Constraint::Length(16)).hide_small(),
                 Column::new("", Constraint::Length(16)).hide_medium(),
                 Column::new("Head", Constraint::Length(8)).hide_small(),
                 Column::new("+", Constraint::Length(6)).hide_small(),
                 Column::new("-", Constraint::Length(6)).hide_small(),
                 Column::new("Updated", Constraint::Length(16)).hide_small(),
             ]
             .to_vec(),
             show_search: state.browser.is_search_shown(),
             search: state.browser.read_search(),
         }
     }
 }
 pub struct Browser {
     /// Patches widget
     patches: Widget,
     /// Search widget
     search: Widget,
 }
 impl Browser {
     pub fn new(tx: UnboundedSender<Message>) -> Self {
         Self {
             patches: Container::default()
                 .header(Header::default().to_widget(tx.clone()).on_update(|state| {
                     // TODO: remove and use state directly
                     let props = BrowserProps::from(state);
                     HeaderProps::default()
                         .columns(props.header.clone())
                         .to_boxed_any()
                         .into()
                 }))
                 .content(
                     Table::<State, Message, PatchItem, 9>::default()
                         .to_widget(tx.clone())
                         .on_event(|_, s, _| {
                             let (selected, _) =
                                 s.and_then(|s| s.unwrap_table()).unwrap_or_default();
                             Some(Message::SelectPatch {
                                 selected: Some(selected),
                             })
                         })
                         .on_update(|state| {
                             // TODO: remove and use state directly
                             let props = BrowserProps::from(state);
                             TableProps::default()
                                 .columns(props.columns)
                                 .items(state.browser.items())
                                 .selected(state.browser.selected())
                                 .to_boxed_any()
                                 .into()
                         }),
                 )
                 .footer(Footer::default().to_widget(tx.clone()).on_update(|state| {
                     // TODO: remove and use state directly
                     let props = BrowserProps::from(state);
                     FooterProps::default()
                         .columns(browser_footer(&props))
                         .to_boxed_any()
                         .into()
                 }))
                 .to_widget(tx.clone())
                 .on_update(|state| {
                     ContainerProps::default()
                         .hide_footer(BrowserProps::from(state).show_search)
                         .to_boxed_any()
                         .into()
                 }),
             search: TextField::default()
                 .to_widget(tx.clone())
                 .on_event(|_, s, _| {
                     Some(Message::UpdateSearch {
                         value: s.and_then(|i| i.unwrap_string()).unwrap_or_default(),
                     })
                 })
                 .on_update(|state: &State| {
                     TextFieldProps::default()
                         .text(&state.browser.read_search())
                         .title("Search")
                         .inline(true)
                         .to_boxed_any()
                         .into()
                 }),
         }
     }
 }
 impl View for Browser {
     type Message = Message;
     type State = State;
     fn handle_event(&mut self, props: Option<&ViewProps>, key: Key) -> Option<Self::Message> {
         let default = BrowserProps::default();
         let props = props
             .and_then(|props| props.inner_ref::<BrowserProps>())
             .unwrap_or(&default);
         if props.show_search {
             match key {
                 Key::Esc => {
                     self.search.reset();
                     Some(Message::CloseSearch)
                 }
                 Key::Char('\n') => Some(Message::ApplySearch),
                 _ => {
                     self.search.handle_event(key);
                     None
                 }
             }
         } else {
             match key {
                 Key::Char('/') => Some(Message::OpenSearch),
                 _ => {
                     self.patches.handle_event(key);
                     None
                 }
             }
         }
     }
     fn update(&mut self, _props: Option<&ViewProps>, state: &Self::State) {
         self.patches.update(state);
         self.search.update(state);
     }
     fn render(&mut self, props: Option<&ViewProps>, render: RenderProps, frame: &mut Frame) {
         let default = BrowserProps::default();
         let props = props
             .and_then(|props| props.inner_ref::<BrowserProps>())
             .unwrap_or(&default);
         if props.show_search {
             let [table_area, search_area] =
                 Layout::vertical([Constraint::Min(1), Constraint::Length(2)]).areas(render.area);
             let [_, search_area, _] = Layout::horizontal([
                 Constraint::Length(1),
                 Constraint::Min(1),
                 Constraint::Length(1),
             ])
             .areas(search_area);
             self.patches.render(RenderProps::from(table_area), frame);
             self.search
                 .render(RenderProps::from(search_area).focus(render.focus), frame);
         } else {
             self.patches.render(render, frame);
         }
     }
 }
 fn browser_footer<'a>(props: &BrowserProps<'a>) -> Vec<Column<'a>> {
     let filter = PatchItemFilter::from_str(&props.search).unwrap_or_default();
     let search = Line::from(vec![
         span::default(" Search ").cyan().dim().reversed(),
         span::default(" "),
         span::default(&props.search.to_string()).gray().dim(),
     ]);
     let draft = Line::from(vec![
         span::default(&props.stats.get("Draft").unwrap_or(&0).to_string()).dim(),
         span::default(" Draft").dim(),
     ]);
     let open = Line::from(vec![
         span::positive(&props.stats.get("Open").unwrap_or(&0).to_string()).dim(),
         span::default(" Open").dim(),
     ]);
     let merged = Line::from(vec![
         span::default(&props.stats.get("Merged").unwrap_or(&0).to_string())
             .magenta()
             .dim(),
         span::default(" Merged").dim(),
     ]);
     let archived = Line::from(vec![
         span::default(&props.stats.get("Archived").unwrap_or(&0).to_string())
             .yellow()
             .dim(),
         span::default(" Archived").dim(),
     ]);
     let sum = Line::from(vec![
         span::default("Σ ").dim(),
         span::default(&props.patches.len().to_string()).dim(),
     ]);
     match filter.status() {
         Some(state) => {
             let block = match state {
                 Status::Draft => draft,
                 Status::Open => open,
                 Status::Merged => merged,
                 Status::Archived => archived,
             };
             vec![
                 Column::new(Text::from(search), Constraint::Fill(1)),
                 Column::new(
                     Text::from(block.clone()),
                     Constraint::Min(block.width() as u16),
                 ),
                 Column::new(Text::from(sum.clone()), Constraint::Min(sum.width() as u16)),
             ]
         }
         None => vec![
             Column::new(Text::from(search), Constraint::Fill(1)),
             Column::new(
                 Text::from(draft.clone()),
                 Constraint::Min(draft.width() as u16),
             ),
             Column::new(
                 Text::from(open.clone()),
                 Constraint::Min(open.width() as u16),
             ),
             Column::new(
                 Text::from(merged.clone()),
                 Constraint::Min(merged.width() as u16),
             ),
             Column::new(
                 Text::from(archived.clone()),
                 Constraint::Min(archived.width() as u16),
             ),
             Column::new(Text::from(sum.clone()), Constraint::Min(sum.width() as u16)),
         ],
     }
 }

 pub mod format;
 pub mod im;
 pub mod items;
 pub mod widget;
 pub mod rm;
 #[derive(Clone, Debug)]
 pub struct TerminalInfo {

 use termion::event::Key;
 use ratatui::layout::{Constraint, Layout};
 use ratatui::Frame;
 use radicle_tui as tui;
 use tui::ui::im::widget::{TableState, TextEditState, Widget};
 use tui::ui::im::{Borders, Response, Ui};
 use tui::ui::{BufferedValue, Column, ToRow};
 pub struct UiExt<'a, M>(&'a mut Ui<M>);
 impl<'a, M> UiExt<'a, M> {
     pub fn new(ui: &'a mut Ui<M>) -> Self {
         Self(ui)
     }
 }
 impl<'a, M> From<&'a mut Ui<M>> for UiExt<'a, M> {
     fn from(ui: &'a mut Ui<M>) -> Self {
         Self::new(ui)
     }
 }
 #[allow(dead_code)]
 impl<'a, M> UiExt<'a, M>
 where
     M: Clone,
 {
     #[allow(clippy::too_many_arguments)]
     pub fn browser<R, const W: usize>(
         &mut self,
         frame: &mut Frame,
         selected: &'a mut Option<usize>,
         items: &'a Vec<R>,
         header: impl IntoIterator<Item = Column<'a>>,
         footer: impl IntoIterator<Item = Column<'a>>,
         show_search: &'a mut bool,
         search: &'a mut BufferedValue<TextEditState>,
     ) -> Response
     where
         R: ToRow<W> + Clone,
     {
         Browser::<R, W>::new(selected, items, header, footer, show_search, search).ui(self.0, frame)
     }
 }
 #[allow(dead_code)]
 #[derive(Clone, Debug)]
 pub struct BrowserState {
     items: TableState,
     search: BufferedValue<TextEditState>,
     show_search: bool,
 }
 #[allow(dead_code)]
 impl BrowserState {
     pub fn new(items: TableState, search: BufferedValue<TextEditState>, show_search: bool) -> Self {
         Self {
             items,
             search,
             show_search,
         }
     }
     pub fn selected(&self) -> Option<usize> {
         self.items.selected()
     }
 }
 pub struct Browser<'a, R, const W: usize> {
     items: &'a Vec<R>,
     selected: &'a mut Option<usize>,
     header: Vec<Column<'a>>,
     footer: Vec<Column<'a>>,
     show_search: &'a mut bool,
     search: &'a mut BufferedValue<TextEditState>,
 }
 #[allow(dead_code)]
 impl<'a, R, const W: usize> Browser<'a, R, W> {
     pub fn new(
         selected: &'a mut Option<usize>,
         items: &'a Vec<R>,
         header: impl IntoIterator<Item = Column<'a>>,
         footer: impl IntoIterator<Item = Column<'a>>,
         show_search: &'a mut bool,
         search: &'a mut BufferedValue<TextEditState>,
     ) -> Self {
         Self {
             items,
             selected,
             header: header.into_iter().collect(),
             footer: footer.into_iter().collect(),
             show_search,
             search,
         }
     }
     pub fn items(&self) -> &Vec<R> {
         self.items
     }
 }
 /// TODO(erikli): Implement `show` that returns an `InnerResponse` such that it can
 /// used like a group.
 impl<'a, R, const W: usize> Widget for Browser<'a, R, W>
 where
     R: ToRow<W> + Clone,
 {
     fn ui<M>(self, ui: &mut Ui<M>, frame: &mut Frame) -> Response
     where
         M: Clone,
     {
         let mut response = Response::default();
         let (_, has_focus) = ui.current_area().unwrap_or_default();
         let (mut text, mut cursor) = (self.search.read().text, self.search.read().cursor);
         ui.layout(
             Layout::vertical([
                 Constraint::Length(3),
                 Constraint::Min(1),
                 Constraint::Length(if *self.show_search { 2 } else { 3 }),
             ]),
             |ui| {
                 // TODO(erikli): Find better solution for border focus workaround or improve
                 // interface for manually advancing / setting the focus index.
                 if has_focus && !*self.show_search {
                     ui.set_focus(Some(0));
                 }
                 ui.columns(frame, self.header.clone().to_vec(), Some(Borders::Top));
                 if has_focus && !*self.show_search {
                     ui.set_focus(Some(1));
                 }
                 let table = ui.table(
                     frame,
                     self.selected,
                     self.items,
                     self.header.to_vec(),
                     if *self.show_search {
                         Some(Borders::BottomSides)
                     } else {
                         Some(Borders::Sides)
                     },
                 );
                 response.changed |= table.changed;
                 if *self.show_search {
                     if has_focus {
                         ui.set_focus(Some(2));
                     }
                     let text_edit = ui.text_edit_labeled_singleline(
                         frame,
                         &mut text,
                         &mut cursor,
                         "Search".to_string(),
                         Some(Borders::Spacer { top: 0, left: 1 }),
                     );
                     self.search.write(TextEditState { text, cursor });
                     response.changed |= text_edit.changed;
                 } else {
                     if has_focus {
                         ui.set_focus(Some(2));
                     }
                     ui.columns(frame, self.footer.clone().to_vec(), Some(Borders::Bottom));
                 }
             },
         );
         if !*self.show_search {
             if ui.input_global(|key| key == Key::Char('/')) {
                 *self.show_search = true;
             }
         } else {
             if ui.input_global(|key| key == Key::Esc) {
                 *self.show_search = false;
                 self.search.reset();
             }
             if ui.input_global(|key| key == Key::Char('\n')) {
                 *self.show_search = false;
                 self.search.apply();
             }
         }
         response
     }
 }

 use tui::ui::span;
 use tui::ui::theme::style;
 use tui::ui::widget::list::{ToRow, ToTree};
 use tui::ui::{ToRow, ToTree};
 use super::super::git;
 use super::format;

     pub fn status(&self) -> Option<patch::Status> {
         self.status
     }
     pub fn is_default(&self) -> bool {
         *self == PatchItemFilter::default()
     }
 }
 impl Filter<PatchItem> for PatchItemFilter {

             }
         }
         let search = if search.is_empty() {
             None
         } else {
             Some(search)
         };
         Ok(Self {
             status,
             authored,
             authors,
             search: Some(search),
             search,
         })
     }
 }

 use std::marker::PhantomData;
 use std::str::FromStr;
 use radicle::issue::{self, CloseReason};
 use ratatui::layout::{Constraint, Layout};
 use ratatui::style::Stylize;
 use ratatui::text::{Line, Span, Text};
 use ratatui::widgets::Row;
 use ratatui::Frame;
 use radicle_tui as tui;
 use tui::ui::rm::widget::{RenderProps, View, ViewProps};
 use tui::ui::theme::style;
 use tui::ui::{layout, span, BufferedValue};
 use super::format;
 use super::items::IssueItem;
 use crate::ui::items::Filter;
 /// A `BrowserState` represents the internal state of a browser widget.
 /// A browser widget would consist of 2 child widgets: a list of items and a
 /// buffered search field. The search fields value is used to build an
 /// item filter that the item list reacts on dynamically.
 #[derive(Clone, Debug)]
 pub struct BrowserState<I, F> {
     items: Vec<I>,
     selected: Option<usize>,
     filter: F,
     search: BufferedValue<String>,
     show_search: bool,
 }
 impl<I, F> Default for BrowserState<I, F>
 where
     I: Clone,
     F: Filter<I> + Default + FromStr,
 {
     fn default() -> Self {
         Self {
             items: vec![],
             selected: None,
             filter: F::default(),
             search: BufferedValue::new(String::default()),
             show_search: false,
         }
     }
 }
 impl<I, F> BrowserState<I, F>
 where
     I: Clone,
     F: Filter<I> + Default + FromStr,
 {
     pub fn build(items: Vec<I>, filter: F, search: BufferedValue<String>) -> Self {
         let selected = items.first().map(|_| 0);
         Self {
             items,
             selected,
             filter,
             search,
             ..Default::default()
         }
     }
     pub fn items(&self) -> Vec<I> {
         self.items_ref().into_iter().cloned().collect()
     }
     pub fn items_ref(&self) -> Vec<&I> {
         self.items
             .iter()
             .filter(|patch| self.filter.matches(patch))
             .collect()
     }
     pub fn selected(&self) -> Option<usize> {
         self.selected
     }
     pub fn selected_item(&self) -> Option<&I> {
         self.selected
             .and_then(|selected| self.items_ref().get(selected).copied())
     }
     pub fn select_item(&mut self, selected: Option<usize>) -> Option<&I> {
         self.selected = selected;
         self.selected_item()
     }
     pub fn select_first_item(&mut self) -> Option<&I> {
         self.selected.and_then(|selected| {
             if selected > self.items_ref().len() {
                 self.selected = Some(0);
                 self.items_ref().first().cloned()
             } else {
                 self.items_ref().get(selected).cloned()
             }
         })
     }
     fn filter_items(&mut self) {
         self.filter = F::from_str(&self.search.read()).unwrap_or_default();
     }
     pub fn update_search(&mut self, value: String) {
         self.search.write(value);
         self.filter_items();
     }
     pub fn show_search(&mut self) {
         self.show_search = true;
     }
     pub fn hide_search(&mut self) {
         self.show_search = false;
     }
     pub fn apply_search(&mut self) {
         self.search.apply();
     }
     pub fn reset_search(&mut self) {
         self.search.reset();
         self.filter_items();
     }
     pub fn is_search_shown(&self) -> bool {
         self.show_search
     }
     pub fn read_search(&self) -> String {
         self.search.read()
     }
 }
 #[derive(Clone, Default)]
 pub struct IssueDetailsProps {
     issue: Option<IssueItem>,
     dim: bool,
 }
 impl IssueDetailsProps {
     pub fn issue(mut self, issue: Option<IssueItem>) -> Self {
         self.issue = issue;
         self
     }
     pub fn dim(mut self, dim: bool) -> Self {
         self.dim = dim;
         self
     }
 }
 pub struct IssueDetails<S, M> {
     /// Phantom
     phantom: PhantomData<(S, M)>,
 }
 impl<S, M> Default for IssueDetails<S, M> {
     fn default() -> Self {
         Self {
             phantom: PhantomData,
         }
     }
 }
 impl<S, M> View for IssueDetails<S, M> {
     type State = S;
     type Message = M;
     fn render(&mut self, props: Option<&ViewProps>, render: RenderProps, frame: &mut Frame) {
         let default = IssueDetailsProps::default();
         let props = props
             .and_then(|props| props.inner_ref::<IssueDetailsProps>())
             .unwrap_or(&default);
         let [area] = Layout::default()
             .constraints([Constraint::Min(1)])
             .horizontal_margin(1)
             .areas(render.area);
         if let Some(issue) = props.issue.as_ref() {
             let author = match &issue.author.alias {
                 Some(alias) => {
                     if issue.author.you {
                         span::alias(&format!("{}", alias))
                     } else {
                         span::alias(alias)
                     }
                 }
                 None => match &issue.author.human_nid {
                     Some(nid) => span::alias(nid).dim(),
                     None => span::blank(),
                 },
             };
             let did = match &issue.author.human_nid {
                 Some(nid) => {
                     if issue.author.you {
                         span::alias("(you)").dim().italic()
                     } else {
                         span::alias(nid).dim()
                     }
                 }
                 None => span::blank(),
             };
             let labels = format::labels(&issue.labels);
             let status = match issue.state {
                 issue::State::Open => Text::styled("open", style::green()),
                 issue::State::Closed { reason } => match reason {
                     CloseReason::Solved => Line::from(
                         [
                             Span::styled("closed", style::red()),
                             Span::raw(" "),
                             Span::styled("(solved)", style::red().italic().dim()),
                         ]
                         .to_vec(),
                     )
                     .into(),
                     CloseReason::Other => Text::styled("closed", style::red()),
                 },
             };
             let table = ratatui::widgets::Table::new(
                 [
                     Row::new([
                         Text::raw("Title").cyan(),
                         Text::raw(issue.title.clone()).bold(),
                     ]),
                     Row::new([
                         Text::raw("Issue").cyan(),
                         Text::raw(issue.id.to_string()).bold(),
                     ]),
                     Row::new([
                         Text::raw("Author").cyan(),
                         Line::from([author, " ".into(), did].to_vec()).into(),
                     ]),
                     Row::new([Text::raw("Labels").cyan(), Text::from(labels).blue()]),
                     Row::new([Text::raw("Status").cyan(), status]),
                 ],
                 [Constraint::Length(8), Constraint::Fill(1)],
             );
             let table = if !render.focus && props.dim {
                 table.dim()
             } else {
                 table
             };
             frame.render_widget(table, area);
         } else {
             let center = layout::centered_rect(render.area, 50, 10);
             let hint = Text::from(span::default("No issue selected"))
                 .centered()
                 .light_magenta()
                 .dim();
             frame.render_widget(hint, center);
         }
     }
 }

 // use anyhow::Result;
 // use termion::event::Key;
 // use ratatui::{Frame, Viewport};
 // use radicle_tui as tui;
 // use tui::store;
 // use tui::ui::im::widget::Window;
 // use tui::ui::im::Show;
 // use tui::ui::im::{Borders, Context};
 // use tui::{Channel, Exit};
 // const ALIEN: &str = r#"
 //      ///             ///    ,---------------------------------.
 //      ///             ///    | Hey there, press (q) to quit... |
 //         //         //       '---------------------------------'
 //         //,,,///,,,//      ..
 //      ///////////////////  .
 //   //////@@@@@//////@@@@@///
 //   //////@@###//////@@###///
 // ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
 //      ,,,  ///   ///  ,,,
 //      ,,,  ///   ///  ,,,
 //           ///   ///
 //         /////   /////
 // "#;
 // #[derive(Clone, Debug)]
 // struct App {
 //     alien: String,
 // }
 // #[derive(Clone, Debug)]
 // enum Message {
 //     Quit,
 // }
 // impl store::Update<Message> for App {
 //     type Return = ();
 //     fn update(&mut self, message: Message) -> Option<tui::Exit<()>> {
 //         match message {
 //             Message::Quit => Some(Exit { value: None }),
 //         }
 //     }
 // }
 // impl Show<Message> for App {
 //     fn show(&self, ctx: &Context<Message>, frame: &mut Frame) -> Result<()> {
 //         Window::default().show(ctx, |ui| {
 //             ui.text_view(frame, self.alien.clone(), &mut (0, 0), Some(Borders::None));
 //             if ui.input_global(|key| key == Key::Char('q')) {
 //                 ui.send_message(Message::Quit);
 //             }
 //         });
 //         Ok(())
 //     }
 // }
 // #[tokio::main]
 // pub async fn main() -> Result<()> {
 //     let app = App {
 //         alien: ALIEN.to_string(),
 //     };
 //     tui::im(app, Viewport::default(), Channel::default()).await?;
 //     Ok(())
 // }
 use anyhow::Result;
 use termion::event::Key;
 use ratatui::style::Color;
 use ratatui::text::Text;
 use ratatui::{Frame, Viewport};
 use radicle_tui as tui;
 use tui::store;
 use tui::ui::widget::input::{TextArea, TextAreaProps};
 use tui::ui::widget::ToWidget;
 use tui::{BoxedAny, Channel, Exit};
 const ALIEN: &str = r#"
      ///             ///    ,---------------------------------.
      ///             ///    | Hey there, press (q) to quit... |
         //         //       '---------------------------------'
         //,,,///,,,//      ..
      ///////////////////  .
   //////@@@@@//////@@@@@///
   //////@@###//////@@###///
 ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
      ,,,  ///   ///  ,,,
      ,,,  ///   ///  ,,,
           ///   ///
         /////   /////
 "#;
 use tui::ui::im::widget::Window;
 use tui::ui::im::Show;
 use tui::ui::im::{Borders, Context};
 use tui::{Channel, Exit};
 #[derive(Clone, Debug)]
 struct State {
     alien: String,
 struct App {
     hello: String,
 }
 #[derive(Clone, Debug)]
 enum Message {
     Quit,
 }
 impl store::State<()> for State {
     type Message = Message;
 impl store::Update<Message> for App {
     type Return = ();
     fn update(&mut self, message: Self::Message) -> Option<tui::Exit<()>> {
     fn update(&mut self, message: Message) -> Option<tui::Exit<()>> {
         match message {
             Message::Quit => Some(Exit { value: None }),
         }
     }
 }
 impl Show<Message> for App {
     fn show(&self, ctx: &Context<Message>, frame: &mut Frame) -> Result<()> {
         Window::default().show(ctx, |ui| {
             ui.text_view(frame, self.hello.clone(), &mut (0, 0), Some(Borders::None));
             if ui.input_global(|key| key == Key::Char('q')) {
                 ui.send_message(Message::Quit);
             }
         });
         Ok(())
     }
 }
 #[tokio::main]
 pub async fn main() -> Result<()> {
     let channel = Channel::default();
     let sender = channel.tx.clone();
     let state = State {
         alien: ALIEN.to_string(),
     let app = App {
         hello: "Hello World!".to_string(),
     };
     let scene = TextArea::default()
         .to_widget(sender.clone())
         .on_event(|key, _, _| match key {
             Key::Char('q') => Some(Message::Quit),
             _ => None,
         })
         .on_update(|state: &State| {
             TextAreaProps::default()
                 .content(Text::styled(state.alien.clone(), Color::Rgb(85, 85, 255)))
                 .handle_keys(false)
                 .to_boxed_any()
                 .into()
         });
     tui::run(channel, state, scene).await?;
     tui::im(app, Viewport::default(), Channel::default()).await?;
     Ok(())
 }

 use std::time::{SystemTime, UNIX_EPOCH};
 use anyhow::Result;
 use termion::event::Key;
 use ratatui::layout::{Constraint, Layout};
 use ratatui::style::Stylize;
 use ratatui::text::Span;
 use ratatui::widgets::Cell;
 use ratatui::{Frame, Viewport};
 use radicle_tui as tui;
 use tui::ui::im::widget::Window;
 use tui::ui::im::{Borders, Context};
 use tui::ui::{Column, ToRow};
 use tui::Channel;
 use tui::{
     store::Update,
     ui::im::{widget::TableState, Show},
     Exit,
 };
 #[derive(Clone, Debug)]
 struct Item {
     id: usize,
     title: String,
     timestamp: usize,
 }
 impl ToRow<3> for Item {
     fn to_row(&self) -> [Cell; 3] {
         [
             Span::raw(self.id.to_string()).magenta().dim().into(),
             Span::raw(self.title.clone()).into(),
             Span::raw(self.timestamp.to_string())
                 .dark_gray()
                 .italic()
                 .into(),
         ]
     }
 }
 #[derive(Clone, Debug)]
 struct App {
     items: Vec<Item>,
     selector: TableState,
 }
 #[derive(Clone, Debug)]
 enum Message {
     SelectionChanged { state: TableState },
     Return,
     Quit,
 }
 impl Update<Message> for App {
     type Return = usize;
     fn update(&mut self, message: Message) -> Option<tui::Exit<Self::Return>> {
         match message {
             Message::SelectionChanged { state } => {
                 self.selector = state;
                 None
             }
             Message::Return => self
                 .selector
                 .selected()
                 .and_then(|selected| self.items.get(selected))
                 .and_then(|item| {
                     Some(Exit {
                         value: Some(item.id),
                     })
                 }),
             Message::Quit => Some(Exit { value: None }),
         }
     }
 }
 impl Show<Message> for App {
     fn show(&self, ctx: &Context<Message>, frame: &mut Frame) -> Result<()> {
         Window::default().show(ctx, |ui| {
             ui.layout(
                 Layout::vertical([
                     Constraint::Length(1),
                     Constraint::Min(1),
                     Constraint::Length(1),
                 ]),
                 |ui| {
                     let columns = [
                         Column::new(Span::raw("Id").bold(), Constraint::Length(4)),
                         Column::new(Span::raw("Title").bold(), Constraint::Fill(1)),
                         Column::new(Span::raw("Timestamp").bold(), Constraint::Fill(1)),
                     ]
                     .to_vec();
                     let mut selected = self.selector.selected();
                     ui.columns(frame, columns.clone(), Some(Borders::None));
                     ui.set_focus(Some(1));
                     let table = ui.table(
                         frame,
                         &mut selected,
                         &self.items,
                         columns,
                         Some(Borders::None),
                     );
                     if table.changed {
                         ui.send_message(Message::SelectionChanged {
                             state: TableState::new(selected),
                         })
                     }
                     ui.shortcuts(frame, &[("q", "quit")], '|');
                     if ui.input_global(|key| key == Key::Char('\n')) {
                         ui.send_message(Message::Return);
                     }
                 },
             );
             if ui.input_global(|key| key == Key::Char('q')) {
                 ui.send_message(Message::Quit);
             }
         });
         Ok(())
     }
 }
 #[tokio::main]
 pub async fn main() -> Result<()> {
     let app = App {
         items: (0..200)
             .map(|id| Item {
                 id,
                 title: format!("Title of item #{}", id),
                 timestamp: SystemTime::now()
                     .duration_since(UNIX_EPOCH)
                     .expect("Could not read system time")
                     .as_secs() as usize,
             })
             .collect(),
         selector: TableState::new(Some(0)),
     };
     if let Some(exit) = tui::im(app, Viewport::Inline(12), Channel::default()).await? {
         println!("{exit}");
     } else {
         anyhow::bail!("No selection");
     }
     Ok(())
 }

 #[derive(Clone, Copy)]
 #[derive(Clone, Copy, Debug)]
 pub enum Event {
     Key(termion::event::Key),
     Resize,

 use std::any::Any;
 use std::fmt::Debug;
 use ratatui::Viewport;
 use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use serde::ser::{Serialize, SerializeStruct, Serializer};
 use anyhow::Result;
 use store::State;
 use store::Update;
 use task::Interrupted;
 use ui::widget::Widget;
 use ui::Frontend;
 use ui::im;
 use ui::im::Show;
 use ui::rm;
 /// An optional return value.
 #[derive(Clone, Debug)]

 /// Initialize a `Store` with the `State` given and a `Frontend` with the `Widget` given,
 /// and run their main loops concurrently. Connect them to the `Channel` and also to
 /// an interrupt broadcast channel also initialized in this function.
 pub async fn run<S, M, P>(channel: Channel<M>, state: S, root: Widget<S, M>) -> Result<Option<P>>
 pub async fn rm<S, M, P>(
     state: S,
     root: rm::widget::Widget<S, M>,
     viewport: Viewport,
     channel: Channel<M>,
 ) -> Result<Option<P>>
 where
     S: State<P, Message = M> + Clone + Debug + Send + Sync + 'static,
     M: 'static,
     S: Update<M, Return = P> + Clone + Debug + Send + Sync + 'static,
     M: Debug + Send + Sync + 'static,
     P: Clone + Debug + Send + Sync + 'static,
 {
     let (terminator, mut interrupt_rx) = task::create_termination();
     let (store, state_rx) = store::Store::<S, M, P>::new();
     let frontend = Frontend::default();
     let frontend = rm::Frontend::default();
     tokio::try_join!(
         store.main_loop(state, terminator, channel.rx, interrupt_rx.resubscribe()),
         frontend.main_loop(root, state_rx, interrupt_rx.resubscribe()),
         store.run(state, terminator, channel.rx, interrupt_rx.resubscribe()),
         frontend.run(root, state_rx, interrupt_rx.resubscribe(), viewport),
     )?;
     if let Ok(reason) = interrupt_rx.recv().await {
         match reason {
             Interrupted::User { payload } => Ok(payload),
             Interrupted::OsSignal => anyhow::bail!("exited because of an os sig int"),
         }
     } else {
         anyhow::bail!("exited because of an unexpected error");
     }
 }
 /// Initialize a `Store` with the `State` given and a `Frontend` with the `App` given,
 /// and run their main loops concurrently. Connect them to the `Channel` and also to
 /// an interrupt broadcast channel also initialized in this function.
 pub async fn im<S, M, P>(state: S, viewport: Viewport, channel: Channel<M>) -> Result<Option<P>>
 where
     S: Update<M, Return = P> + Show<M> + Clone + Debug + Send + Sync + 'static,
     M: Clone + Debug + Send + Sync + 'static,
     P: Clone + Debug + Send + Sync + 'static,
 {
     let (terminator, mut interrupt_rx) = task::create_termination();
     let state_tx = channel.tx.clone();
     let (store, state_rx) = store::Store::<S, M, P>::new();
     let frontend = im::Frontend::default();
     tokio::try_join!(
         store.run(state, terminator, channel.rx, interrupt_rx.resubscribe()),
         frontend.run(state_tx, state_rx, interrupt_rx.resubscribe(), viewport),
     )?;
     if let Ok(reason) = interrupt_rx.recv().await {