This crate provides a binary called `rad-tui` which can be used as a drop-in replacement for `rad`. It maps known commands and operations to internal ones, running the corresponding app, e.g.

runs the patch list app and calls `rad` with the operation and id selected. Commands or operations not known to `rad-tui` will be forwarded to `rad`, e.g. the following just calls `rad node`:

The apps are designed to be modular and could also be integrated with existing CLI tooling. The binary is can be called and its output collected and processed, e.g.

runs the patch list app and return a JSON object specifying the operation and id selected:

#[path = "apps/help.rs"]

pub mod tui_help;

#[path = "apps/inbox.rs"]

pub mod tui_inbox;

#[path = "apps/issue.rs"]

pub mod tui_issue;

#[path = "apps/patch.rs"]

pub mod tui_patch;

use std::ffi::OsString;

use radicle_cli::terminal as cli_term;

use radicle_term as term;

use cli_term::args::{Args, Error, Help};

use cli_term::Context;

use super::*;

pub const HELP: Help = Help {

    name: "help",

    description: "Print help",

    version: env!("CARGO_PKG_VERSION"),

    usage: "Usage: rad-tui help [--help]",

};

const COMMANDS: &[Help] = &[tui_help::HELP];

#[derive(Default)]

pub struct Options {}

impl Args for Options {

    fn from_args(_args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        Err(Error::HelpManual { name: "rad-tui" }.into())

    }

}

pub fn run(_options: Options, ctx: impl Context) -> anyhow::Result<()> {

    println!(

        "{} {}",

        term::format::secondary("Usage:").bold(),

        term::format::tertiary("rad-tui [COMMAND] [OPTIONS]"),

    );

    if let Err(e) = ctx.profile() {

        term::blank();

        match e.downcast_ref() {

            Some(Error::WithHint { err, hint }) => {

                term::print(term::format::yellow(err));

                term::print(term::format::yellow(hint));

            }

            Some(e) => {

                term::error(e);

            }

            None => {

                term::error(e);

            }

        }

        term::blank();

    }

    term::blank();

    println!("{}", term::format::secondary("Options:").bold(),);

    term::info!(

        "\t{} {}",

        term::format::tertiary(format!("{:-16}", "--no-forward")),

        term::format::default("Don't forward command to `rad` (default: false)")

    );

    term::info!(

        "\t{} {}",

        term::format::tertiary(format!("{:-16}", "--json")),

        term::format::default("Print version as JSON")

    );

    term::info!(

        "\t{} {}",

        term::format::tertiary(format!("{:-16}", "--version")),

        term::format::default("Print version")

    );

    term::info!(

        "\t{} {}",

        term::format::tertiary(format!("{:-16}", "--help")),

        term::format::default("Print command specific help")

    );

    term::blank();

    println!("{}", term::format::secondary("Commands:").bold(),);

    term::info!(

        "\t{} {}",

        term::format::tertiary(format!("{:-16}", "version")),

        term::format::default("Print version")

    );

    for help in COMMANDS {

        term::info!(

            "\t{} {}",

            term::format::tertiary(format!("{:-16}", help.name)),

            term::format::default(help.description)

        );

    }

    term::blank();

    println!(

        "See {} to learn about a specific command.",

        term::format::tertiary("`rad-tui <command> --help`")

    );

    term::blank();

    Ok(())

}

#[path = "inbox/list.rs"]

mod list;

use std::ffi::OsString;

use anyhow::anyhow;

use radicle::node::notifications::NotificationId;

use radicle::storage::{HasRepoId, ReadRepository};

use radicle_cli::terminal::{Args, Error, Help};

use crate::terminal;

use crate::ui::items::notification::filter::SortBy;

use self::list::{InboxOperation, RepositoryMode};

pub const HELP: Help = Help {

    name: "inbox",

    description: "Terminal interfaces for notifications",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad-tui inbox list [<option>...]

List options

    --sort-by <field>       Sort by `id` or `timestamp` (default: timestamp)

    --reverse, -r           Reverse the list

    --json                  Return JSON on stderr instead of calling `rad`

Other options

    --no-forward            Don't forward command to `rad` (default: true)

    --help                  Print help (enables forwarding)

"#,

};

#[derive(Debug, PartialEq)]

pub struct Options {

    op: Operation,

}

#[derive(Debug, PartialEq)]

pub enum Operation {

    List { opts: ListOptions },

    Other { args: Vec<OsString> },

    Unknown { args: Vec<OsString> },

}

#[derive(PartialEq, Eq)]

pub enum OperationName {

    List,

    Unknown,

}

#[derive(Debug, Default, Clone, PartialEq)]

pub struct ListOptions {

    mode: RepositoryMode,

    sort_by: SortBy,

    json: bool,

}

impl Args for Options {

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_args(args.clone());

        let mut op = OperationName::List;

        let mut forward = None;

        let mut json = false;

        let mut help = false;

        let mut repository_mode = None;

        let mut reverse = None;

        let mut field = None;

        let mut list_opts = ListOptions::default();

        while let Some(arg) = parser.next()? {

            match arg {

                Long("no-forward") => {

                    forward = Some(false);

                }

                Long("json") => {

                    json = true;

                }

                Long("help") | Short('h') => {

                    help = true;

                    // Only enable forwarding if it was not already disabled explicitly

                    forward = match forward {

                        Some(false) => Some(false),

                        _ => Some(true),

                    };

                }

                Long("reverse") | Short('r') => {

                    reverse = Some(true);

                }

                Long("sort-by") => {

                    use radicle_cli::terminal;

                    let val = parser.value()?;

                    match terminal::args::string(&val).as_str() {

                        "timestamp" => field = Some("timestamp"),

                        "id" => field = Some("id"),

                        other => anyhow::bail!("unknown sorting field '{other}'"),

                    }

                }

                Long("repo") if repository_mode.is_none() => {

                    use radicle_cli::terminal;

                    let val = parser.value()?;

                    let repo = terminal::args::rid(&val)?;

                    repository_mode = Some(RepositoryMode::ByRepo((repo, None)));

                }

                Long("all") | Short('a') if repository_mode.is_none() => {

                    repository_mode = Some(RepositoryMode::All);

                }

                Value(val) if op == OperationName::List => match val.to_string_lossy().as_ref() {

                    "list" => op = OperationName::List,

                    _ => {

                        op = OperationName::Unknown;

                        // Only enable forwarding if it was not already disabled explicitly

                        forward = match forward {

                            Some(false) => Some(false),

                            _ => Some(true),

                        };

                    }

                },

                _ => {

                    if op == OperationName::List {

                        return Err(anyhow!(arg.unexpected()));

                    }

                }

            }

        }

        // Disable forwarding if it was not enabled via `--help` or was

        // not disabled explicitly.

        let forward = forward.unwrap_or_default();

        // Show local help

        if help && !forward {

            return Err(Error::Help.into());

        }

        list_opts.mode = repository_mode.unwrap_or_default();

        list_opts.sort_by = if let Some(field) = field {

            SortBy {

                field,

                reverse: reverse.unwrap_or(false),

            }

        } else {

            SortBy::default()

        };

        // Map local commands. Forward help and ignore `no-forward`.

        let op = match op {

            OperationName::List if !forward => Operation::List {

                opts: ListOptions { json, ..list_opts },

            },

            OperationName::Unknown if !forward => Operation::Unknown { args },

            _ => Operation::Other { args },

        };

        Ok((Options { op }, vec![]))

    }

}

#[tokio::main]

pub async fn run(options: Options, ctx: impl radicle_cli::terminal::Context) -> anyhow::Result<()> {

    use radicle::storage::ReadStorage;

    let (_, rid) = radicle::rad::cwd()

        .map_err(|_| anyhow!("this command must be run in the context of a project"))?;

    match options.op {

        Operation::List { opts } => {

            #[derive(Default)]

            struct PreviousState {

                notif_id: Option<NotificationId>,

                search: Option<String>,

            }

            if let Err(err) = crate::log::enable() {

                println!("{err}");

            }

            log::info!("Starting inbox listing app in project {rid}..");

            let mut state = PreviousState::default();

            loop {

                let profile = ctx.profile()?;

                let repository = profile.storage.repository(rid)?;

                let context = list::Context {

                    profile,

                    project: repository.identity_doc()?.project()?,

                    rid: repository.rid(),

                    mode: opts.mode.clone(),

                    search: state.search.clone(),

                    sort_by: opts.sort_by,

                    _notif_id: state.notif_id,

                };

                let app = list::Tui::new(context);

                let selection = app.run().await?;

                if opts.json {

                    let selection = selection

                        .map(|o| serde_json::to_string(&o).unwrap_or_default())

                        .unwrap_or_default();

                    log::info!("Exiting inbox listing app..");

                    eprint!("{selection}");

                } else if let Some(selection) = selection {

                    if let Some(operation) = selection.operation.clone() {

                        match operation {

                            InboxOperation::Show { id, search } => {

                                state = PreviousState {

                                    notif_id: Some(id),

                                    search: Some(search),

                                };

                                terminal::run_rad(

                                    Some("inbox"),

                                    &["show".into(), id.to_string().into()],

                                )?;

                            }

                            InboxOperation::Clear { id, search } => {

                                state = PreviousState {

                                    notif_id: Some(id),

                                    search: Some(search),

                                };

                                terminal::run_rad(

                                    Some("inbox"),

                                    &["clear".into(), id.to_string().into()],

                                )?;

                            }

                        }

                    }

                } else {

                    break;

                }

            }

        }

        Operation::Other { args } => {

            terminal::run_rad(Some("inbox"), &args)?;

        }

        Operation::Unknown { .. } => {

            anyhow::bail!("unknown operation provided");

        }

    }

    Ok(())

}

#[cfg(test)]

mod cli {

    use radicle_cli::terminal::args::Error;

    use radicle_cli::terminal::Args;

    use super::{ListOptions, Operation, Options};

    #[test]

    fn empty_operation_should_default_to_list_and_not_be_forwarded(

    ) -> Result<(), Box<dyn std::error::Error>> {

        let expected_op = Operation::List {

            opts: ListOptions::default(),

        };

        let args = vec![];

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn empty_operation_with_help_should_be_forwarded() -> Result<(), Box<dyn std::error::Error>> {

        let args = vec!["--help".into()];

        let expected_op = Operation::Other { args: args.clone() };

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn empty_operation_with_help_should_not_be_forwarded() -> Result<(), Box<dyn std::error::Error>>

    {

        let args = vec!["--help".into(), "--no-forward".into()];

        let actual = Options::from_args(args).unwrap_err().downcast::<Error>()?;

        assert!(matches!(actual, Error::Help));

        Ok(())

    }

    #[test]

    fn empty_operation_should_not_be_forwarded() -> Result<(), Box<dyn std::error::Error>> {

        let expected_op = Operation::List {

            opts: ListOptions::default(),

        };

        let args = vec!["--no-forward".into()];

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn list_operation_should_not_be_forwarded() -> Result<(), Box<dyn std::error::Error>> {

        let expected_op = Operation::List {

            opts: ListOptions::default(),

        };

        let args = vec!["list".into()];

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn list_operation_should_not_be_forwarded_explicitly() -> Result<(), Box<dyn std::error::Error>>

    {

        let expected_op = Operation::List {

            opts: ListOptions::default(),

        };

        let args = vec!["list".into(), "--no-forward".into()];

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn list_operation_with_help_should_be_forwarded() -> Result<(), Box<dyn std::error::Error>> {

        let args = vec!["list".into(), "--help".into()];

        let expected_op = Operation::Other { args: args.clone() };

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn list_operation_with_help_should_not_be_forwarded() -> Result<(), Box<dyn std::error::Error>>

    {

        let args = vec!["list".into(), "--help".into(), "--no-forward".into()];

        let actual = Options::from_args(args).unwrap_err().downcast::<Error>()?;

        assert!(matches!(actual, Error::Help));

        Ok(())

    }

    #[test]

    fn list_operation_with_help_should_not_be_forwarded_reversed(

    ) -> Result<(), Box<dyn std::error::Error>> {

        let args = vec!["list".into(), "--no-forward".into(), "--help".into()];

        let actual = Options::from_args(args).unwrap_err().downcast::<Error>()?;

        assert!(matches!(actual, Error::Help));

        Ok(())

    }

    #[test]

    fn unknown_operation_should_be_forwarded() -> Result<(), Box<dyn std::error::Error>> {

        let args = vec!["operation".into()];

        let expected_op = Operation::Other { args: args.clone() };

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

    #[test]

    fn unknown_operation_should_not_be_forwarded() -> Result<(), Box<dyn std::error::Error>> {

        let args = vec!["operation".into(), "--no-forward".into()];

        let expected_op = Operation::Unknown { args: args.clone() };

        let (actual, _) = Options::from_args(args)?;

        assert_eq!(actual.op, expected_op);

        Ok(())

    }

}

use std::collections::hash_map::Entry;

use std::collections::HashMap;

use std::str::FromStr;

use std::sync::{Arc, Mutex};

use std::vec;

use anyhow::Result;

use ratatui::widgets::Clear;

use serde::Serialize;

use radicle::node::notifications::NotificationId;

use ratatui::layout::{Constraint, Layout};

use ratatui::prelude::*;

use ratatui::text::Span;

use ratatui::{Frame, Viewport};

use radicle::identity::Project;

use radicle::prelude::RepoId;

use radicle::storage::ReadStorage;

use radicle::Profile;

use radicle_tui as tui;

use tui::event::Key;

use tui::store;

use tui::task::{Process, Task};

use tui::ui;

use tui::ui::layout::Spacing;

use tui::ui::theme::Theme;

use tui::ui::widget::{

    Borders, Column, ContainerState, TableState, TextEditState, TextViewState, Window,

};

use tui::ui::{BufferedValue, Show, Ui};

use tui::{Channel, Exit};

use crate::settings;

use crate::ui::items::filter::Filter;

use crate::ui::items::notification::filter::{NotificationFilter, SortBy};

use crate::ui::items::notification::{Notification, NotificationKind};

#[derive(Clone, Default, Debug, PartialEq, Eq)]

pub enum RepositoryMode {

    #[default]

    Contextual,

    All,

    ByRepo((RepoId, Option<String>)),

}

/// The selected issue operation returned by the operation

/// selection widget.

#[derive(Clone, Debug, Eq, PartialEq, Serialize)]

pub enum InboxOperation {

    Show { id: NotificationId, search: String },

    Clear { id: NotificationId, search: String },

}

type Selection = tui::Selection<InboxOperation>;

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`:      Cancel

`q`:        Quit

# Specific keybindings

`enter`:    Show notification

`r`:        Reload notifications

`c`:        Clear notification

`/`:        Search

`?`:        Show help

# Searching

Examples:   state=unseen kind=cob bugfix

            kind=(cob:xyz.radicle.issue or cob:xyz.radicle.issue)

            state=unseen author=(did:key:... or did:key:...)"#;

#[derive(Clone, Debug)]

pub struct Context {

    pub profile: Profile,

    pub project: Project,

    pub rid: RepoId,

    pub mode: RepositoryMode,

    pub sort_by: SortBy,

    pub _notif_id: Option<NotificationId>,

    pub search: Option<String>,

}

pub struct Tui {

    context: Context,

}

impl Tui {

    pub fn new(context: Context) -> Self {

        Self { context }

    }

    pub async fn run(&self) -> Result<Option<Selection>> {

        let viewport = Viewport::Inline(20);

        let channel = Channel::default();

        let state = App::try_from(&self.context)?;

        tui::im(

            state,

            viewport,

            channel,

            vec![Loader::new(self.context.clone())],

        )

        .await

    }

}

#[derive(Clone, Debug)]

pub enum Change {

    Page {

        page: Page,

    },

    MainGroup {

        state: ContainerState,

    },

    Patches {

        state: TableState,

    },

    Search {

        search: BufferedValue<TextEditState>,

    },

    Help {

        state: TextViewState,

    },

}

#[derive(Clone, Debug)]

pub enum Message {

    Initialize,

    Changed(Change),

    ShowSearch,

    HideSearch { apply: bool },

    Reload,

    Loaded(Vec<Notification>),

    Exit { operation: Option<InboxOperation> },

    Quit,

}

#[derive(Clone, Debug)]

pub enum Page {

    Main,

    Help,

}

#[derive(Clone, Debug)]

pub struct AppState {

    page: Page,

    main_group: ContainerState,

    patches: TableState,

    search: BufferedValue<TextEditState>,

    show_search: bool,

    help: TextViewState,

    filter: NotificationFilter,

    loading: bool,

    initialized: bool,

    theme: Theme,

}

#[derive(Clone, Debug)]

pub struct App {

    context: Arc<Mutex<Context>>,

    notifications: Arc<Mutex<Vec<Notification>>>,

    state: AppState,

}

impl TryFrom<&Context> for App {

    type Error = anyhow::Error;

    fn try_from(context: &Context) -> Result<Self, Self::Error> {

        let settings = settings::Settings::default();

        let theme = settings::configure_theme(&settings);

        let search = context.search.as_ref().map(|s| s.trim().to_string());

        let (search, filter) = match search {

            Some(search) => (

                search.clone(),

                NotificationFilter::from_str(search.trim()).unwrap_or(NotificationFilter::Invalid),

            ),

            None => {

                let filter = NotificationFilter::default();

                (filter.to_string().trim().to_string(), filter)

            }

        };

        Ok(App {

            context: Arc::new(Mutex::new(context.clone())),

            notifications: Arc::new(Mutex::new(vec![])),

            state: AppState {

                page: Page::Main,

                main_group: ContainerState::new(3, Some(0)),

                patches: TableState::new(Some(0)),

                search: BufferedValue::new(TextEditState {

                    text: search.to_string(),

                    cursor: search.chars().count(),

                }),

                show_search: false,

                help: TextViewState::new(Position::default()),

                filter,

                loading: false,

                initialized: false,

                theme,

            },

        })

    }

}

impl store::Update<Message> for App {

    type Return = Selection;

    fn update(&mut self, message: Message) -> Option<tui::Exit<Selection>> {

        match message {

            Message::Initialize => {

                self.state.loading = true;

                self.state.initialized = true;

                None

            }

            Message::Quit => Some(Exit { value: None }),

            Message::Exit { operation } => Some(Exit {

                value: Some(Selection {

                    operation,

                    args: vec![],

                }),

            }),

            Message::ShowSearch => {

                self.state.main_group = ContainerState::new(3, None);

                self.state.show_search = true;

                None

            }

            Message::HideSearch { apply } => {

                self.state.main_group = ContainerState::new(3, Some(0));

                self.state.show_search = false;

                if apply {

                    self.state.search.apply();

                } else {

                    self.state.search.reset();

                }

                self.state.filter = NotificationFilter::from_str(&self.state.search.read().text)

                    .unwrap_or(NotificationFilter::Invalid);

                None

            }

            Message::Reload => {

                self.state.loading = true;

                None

            }

            Message::Loaded(notifications) => {

                self.apply_notifications(notifications);

                self.apply_sorting();

                self.state.loading = false;

                None

            }

            Message::Changed(changed) => match changed {

                Change::Page { page } => {

                    self.state.page = page;

                    None

                }

                Change::MainGroup { state } => {

                    self.state.main_group = state;

                    None

                }

                Change::Patches { state } => {

                    self.state.patches = state;

                    None

                }

                Change::Search { search } => {

                    self.state.search = search;

                    self.state.filter =

                        NotificationFilter::from_str(&self.state.search.read().text)

                            .unwrap_or(NotificationFilter::Invalid);

                    self.state.patches.select_first();

                    None

                }

                Change::Help { state } => {

                    self.state.help = state;

                    None

                }

            },

        }

    }

}

impl Show<Message> for App {

    fn show(&self, ctx: &ui::Context<Message>, frame: &mut Frame) -> Result<()> {

        Window::default().show(ctx, self.state.theme.clone(), |ui| {

            // Initialize

            if !self.state.initialized {

                ui.send_message(Message::Initialize);

            }

            match self.state.page {

                Page::Main => {

                    let show_search = self.state.show_search;

                    let mut page_focus = if show_search { Some(1) } else { Some(0) };

                    ui.container(

                        Layout::vertical([Constraint::Fill(1), Constraint::Length(2)]),

                        &mut page_focus,

                        |ui| {

                            let mut group_focus = self.state.main_group.focus();

                            let group = ui.container(

                                ui::Layout::Expandable3 { left_only: true },

                                &mut group_focus,

                                |ui| {

                                    self.show_browser(frame, ui);

                                },

                            );

                            if group.response.changed {

                                ui.send_message(Message::Changed(Change::MainGroup {

                                    state: ContainerState::new(3, group_focus),

                                }));

                            }

                            if show_search {

                                self.show_browser_search(frame, ui);

                            } else if let Some(0) = group_focus {

                                self.show_browser_footer(frame, ui);

                            }

                        },

                    );

                    if !show_search && ui.has_input(|key| key == Key::Char('?')) {

                        ui.send_message(Message::Changed(Change::Page { page: Page::Help }));

                    }

                }

                Page::Help => {

                    let layout = Layout::vertical([

                        Constraint::Length(3),

                        Constraint::Fill(1),

                        Constraint::Length(1),

                        Constraint::Length(1),

                    ]);

                    ui.container(layout, &mut Some(1), |ui| {

                        self.show_help_text(frame, ui);

                        self.show_help_context(frame, ui);

                        ui.shortcuts(frame, &[("?", "close")], '∙', Alignment::Left);

                    });

                    if ui.has_input(|key| key == Key::Char('?')) {

                        ui.send_message(Message::Changed(Change::Page { page: Page::Main }));

                    }

                }

            }

            if ui.has_input(|key| key == Key::Char('q')) {

                ui.send_message(Message::Quit);

            }

            if ui.has_input(|key| key == Key::Ctrl('c')) {

                ui.send_message(Message::Quit);

            }

        });

        Ok(())

    }

}

impl App {

    pub fn show_browser(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        let context = self.context.lock().unwrap();

        let notifs = self.notifications.lock().unwrap();

        let notifs = notifs

            .iter()

            .filter(|notif| self.state.filter.matches(notif))

            .cloned()

            .collect::<Vec<_>>();

        let mut selected = self.state.patches.selected();

        let header = [

            Column::new(Span::raw(" ● ").bold(), Constraint::Length(3)),

            Column::new(Span::raw("ID").bold(), Constraint::Length(8)).hide_medium(),

            Column::new(Span::raw("Summary").bold(), Constraint::Fill(1)),

            Column::new(Span::raw("Repository").bold(), Constraint::Length(16))

                .skip(context.mode != RepositoryMode::All),

            Column::new(Span::raw("OID").bold(), Constraint::Length(8)).hide_medium(),

            Column::new(Span::raw("Kind").bold(), Constraint::Length(20)).hide_small(),

            Column::new(Span::raw("Change").bold(), Constraint::Length(8)).hide_small(),

            Column::new(Span::raw("Author").bold(), Constraint::Length(16)).hide_medium(),

            Column::new(Span::raw("Updated").bold(), Constraint::Length(16)),

        ];

        ui.layout(

            Layout::vertical([Constraint::Length(3), Constraint::Min(1)]),

            Some(1),

            |ui| {

                ui.column_bar(frame, header.to_vec(), Spacing::from(1), Some(Borders::Top));

                let table = ui.table(

                    frame,

                    &mut selected,

                    &notifs,

                    header.to_vec(),

                    Some("".into()),

                    Spacing::from(1),

                    Some(Borders::BottomSides),

                );

                if table.changed {

                    ui.send_message(Message::Changed(Change::Patches {

                        state: TableState::new(selected),

                    }));

                }

                if self.state.loading {

                    self.show_loading_popup(frame, ui);

                }

                // TODO(erikli): Should only work if table has focus

                if ui.has_input(|key| key == Key::Char('/')) {

                    ui.send_message(Message::ShowSearch);

                }

            },

        );

        if ui.has_input(|key| key == Key::Char('r')) {

            ui.send_message(Message::Reload);

        }

        if let Some(notification) = selected.and_then(|s| notifs.get(s)) {

            if ui.has_input(|key| key == Key::Enter) {

                ui.send_message(Message::Exit {

                    operation: Some(InboxOperation::Show {

                        id: notification.id,

                        search: self.state.search.read().text,

                    }),

                });

            }

            if ui.has_input(|key| key == Key::Char('c')) {

                ui.send_message(Message::Exit {

                    operation: Some(InboxOperation::Clear {

                        id: notification.id,

                        search: self.state.search.read().text,

                    }),

                });

            }

        }

    }

    fn show_browser_footer(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        ui.layout(Layout::vertical([3, 1]), None, |ui| {

            self.show_browser_context(frame, ui);

            self.show_browser_shortcuts(frame, ui);

        });

    }

    pub fn show_browser_search(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        let (mut search_text, mut search_cursor) = (

            self.state.search.clone().read().text,

            self.state.search.clone().read().cursor,

        );

        let mut search = self.state.search.clone();

        let text_edit = ui.text_edit_singleline(

            frame,

            &mut search_text,

            &mut search_cursor,

            Some("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::Changed(Change::Search { search }));

        }

        if ui.has_input(|key| key == Key::Esc) {

            ui.send_message(Message::HideSearch { apply: false });

        }

        if ui.has_input(|key| key == Key::Enter) {

            ui.send_message(Message::HideSearch { apply: true });

        }

    }

    fn show_browser_context(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        let context = {

            let notifs = self.notifications.lock().unwrap();

            let search = self.state.search.read().text;

            let total_count = notifs.len();

            let filtered_count = notifs

                .iter()

                .filter(|patch| self.state.filter.matches(patch))

                .collect::<Vec<_>>()

                .len();

            let filtered_counts = format!(" {filtered_count}/{total_count} ");

            let seen_counts = notifs

                .iter()

                .fold((0, 0), |counts, notif| match notif.seen {

                    true => (counts.0 + 1, counts.1),

                    false => (counts.0, counts.1 + 1),

                });

            if self.state.filter.is_default() {

                let seen = format!(" {} ", seen_counts.0);

                let unseen = format!(" {} ", seen_counts.1);

                [

                    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)

                            .cyan()

                            .dim(),

                        Constraint::Fill(1),

                    ),

                    Column::new(

                        Span::raw("●")

                            .style(ui.theme().bar_on_black_style)

                            .gray()

                            .dim()

                            .bold(),

                        Constraint::Length(1),

                    ),

                    Column::new(

                        Span::raw(seen.clone())

                            .style(ui.theme().bar_on_black_style)

                            .dim(),

                        Constraint::Length(seen.chars().count() as u16),

                    ),

                    Column::new(

                        Span::raw("●")

                            .style(ui.theme().bar_on_black_style)

                            .cyan()

                            .dim()

                            .bold(),

                        Constraint::Length(1),

                    ),

                    Column::new(

                        Span::raw(unseen.clone())

                            .style(ui.theme().bar_on_black_style)

                            .dim(),

                        Constraint::Length(unseen.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)

                            .cyan(),

                        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()

            }

        };

        ui.column_bar(frame, context, Spacing::from(0), Some(Borders::None));

    }

    pub fn show_browser_shortcuts(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        ui.shortcuts(

            frame,

            &[

                ("enter", "show"),

                ("r", "reload"),

                ("c", "clear"),

                ("/", "search"),

                ("?", "help"),

            ],

            '∙',

            Alignment::Left,

        );

    }

    fn show_loading_popup(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        ui.popup(Layout::vertical([Constraint::Min(1)]), |ui| {

            ui.layout(

                Layout::vertical([Constraint::Min(1), Constraint::Length(3)]).margin(1),

                None,

                |ui| {

                    ui.label(frame, "");

                    ui.layout(

                        Layout::horizontal([Constraint::Min(1), Constraint::Length(11)]),

                        None,

                        |ui| {

                            ui.label(frame, "");

                            ui.layout(Layout::vertical([Constraint::Min(1)]), None, |ui| {

                                frame.render_widget(Clear, ui.area());

                                ui.column_bar(

                                    frame,

                                    [Column::new(

                                        Span::raw(" Loading ").magenta().rapid_blink(),

                                        Constraint::Fill(1),

                                    )]

                                    .to_vec(),

                                    Spacing::from(0),

                                    Some(Borders::All),

                                );

                            });

                        },

                    );

                },

            );

            ui.centered_text_view(frame, "Loading".slow_blink().yellow(), None);

        });

    }

    fn show_help_text(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        ui.column_bar(

            frame,

            [Column::new(Span::raw(" Help ").bold(), Constraint::Fill(1))].to_vec(),

            Spacing::from(0),

            Some(Borders::Top),

        );

        let mut cursor = self.state.help.cursor();

        let text_view = ui.text_view(

            frame,

            HELP.to_string(),

            &mut cursor,

            Some(Borders::BottomSides),

        );

        if text_view.changed {

            ui.send_message(Message::Changed(Change::Help {

                state: TextViewState::new(cursor),

            }))

        }

    }

    fn show_help_context(&self, frame: &mut Frame, ui: &mut Ui<Message>) {

        ui.column_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(),

            Spacing::from(0),

            Some(Borders::None),

        );

    }

}

impl App {

    fn apply_notifications(&mut self, notifications: Vec<Notification>) {

        let mut items = self.notifications.lock().unwrap();

        *items = notifications;

    }

    fn apply_sorting(&mut self) {

        let mut items = self.notifications.lock().unwrap();

        let context = self.context.lock().unwrap();

        // Apply sorting

        match context.sort_by.field {

            "timestamp" => items.sort_by(|a, b| a.timestamp.cmp(&b.timestamp)),

            "id" => items.sort_by(|a, b| a.id.cmp(&b.id)),

            _ => {}

        }

        if context.sort_by.reverse {

            items.reverse();

        }

        // Set project name

        let mode = match context.mode {

            RepositoryMode::ByRepo((rid, _)) => {

                let name = context.project.name().to_string();

                RepositoryMode::ByRepo((rid, Some(name)))

            }

            _ => context.mode.clone(),

        };

        // Sort by project if all notifications are shown

        if let RepositoryMode::All = mode {

            items.sort_by(|a, b| a.project.cmp(&b.project));

        }

    }

}

#[derive(Clone, Debug)]

pub struct Loader {

    context: Context,

}

impl Loader {

    fn new(context: Context) -> Self {

        Self { context }

    }

}

#[derive(Debug)]

pub struct NotificationLoader {

    context: Context,

}

impl NotificationLoader {

    fn new(context: Context) -> Self {

        NotificationLoader { context }

    }

}

impl Task for NotificationLoader {

    type Return = Message;

    fn run(&self) -> anyhow::Result<Vec<Self::Return>> {

        let profile = self.context.profile.clone();

        let notifs = profile.notifications_mut()?;

        let notifications = match self.context.mode {

            RepositoryMode::All => {

                // Store all repos the notifs arised from, such that

                // they can be referenced when loading issues and patches

                let repos = notifs

                    .all()?

                    .filter_map(|notif| notif.ok())

                    .filter_map(|notif| {

                        profile

                            .storage

                            .repository(notif.repo)

                            .ok()

                            .map(|repo| (notif.repo, repo))

                    })

                    .collect::<HashMap<_, _>>();

                // Only retrieve issues and patches once per repository

                let (mut issues, mut patches) = (HashMap::new(), HashMap::new());

                notifs

                    .all()?

                    .filter_map(|notif| notif.ok())

                    .map(|notif| match repos.get(&notif.repo) {

                        Some(repo) => {

                            let project = repo.project()?;

                            let (issues, patches) = {

                                (

                                    match issues.entry(repo.id) {

                                        Entry::Occupied(e) => e.into_mut(),

                                        Entry::Vacant(e) => e.insert(profile.issues(repo)?),

                                    },

                                    match patches.entry(repo.id) {

                                        Entry::Occupied(e) => e.into_mut(),

                                        Entry::Vacant(e) => e.insert(profile.patches(repo)?),

                                    },

                                )

                            };

                            match NotificationKind::new(repo, issues, patches, &notif)? {

                                Some(kind) => Notification::new(&profile, &project, &notif, kind),

                                _ => Ok(None),

                            }

                        }

                        _ => Ok(None),

                    })

                    .filter_map(|notif| notif.ok())

                    .flatten()

                    .collect::<Vec<_>>()

            }

            RepositoryMode::Contextual => {

                let repo = profile.storage.repository(self.context.rid)?;

                let project = repo.project()?;

                let issues = profile.issues(&repo)?;

                let patches = profile.patches(&repo)?;

                let by_repo = notifs.by_repo(&repo.id, "timestamp")?;

                by_repo

                    .filter_map(|notif| notif.ok())

                    .map(

                        |notif| match NotificationKind::new(&repo, &issues, &patches, &notif)? {

                            Some(kind) => Notification::new(&profile, &project, &notif, kind),

                            _ => Ok(None),

                        },

                    )

                    .filter_map(|notif| notif.ok())

                    .flatten()

                    .collect::<Vec<_>>()

            }

            RepositoryMode::ByRepo((rid, _)) => {

                let repo = profile.storage.repository(rid)?;

                let project = repo.project()?;

                let issues = profile.issues(&repo)?;

                let patches = profile.patches(&repo)?;

                let by_repo = notifs.by_repo(&repo.id, "timestamp")?;

                by_repo

                    .filter_map(|notif| notif.ok())

                    .map(

                        |notif| match NotificationKind::new(&repo, &issues, &patches, &notif)? {

                            Some(kind) => Notification::new(&profile, &project, &notif, kind),

                            _ => Ok(None),

                        },

                    )

                    .filter_map(|notif| notif.ok())

                    .flatten()

                    .collect::<Vec<_>>()

            }

        };

        Ok(vec![Message::Loaded(notifications)])

    }

}

impl Process<Message> for Loader {

    async fn process(&mut self, message: Message) -> anyhow::Result<Vec<Message>> {

        match message {

            Message::Initialize | Message::Reload => {

                let loader = NotificationLoader::new(self.context.clone());

                let messages = tokio::spawn(async move { loader.run() }).await.unwrap()?;

                Ok(messages)

            }

            _ => Ok(vec![]),

        }

    }

}

#[path = "issue/list.rs"]

mod list;

use std::ffi::OsString;

use anyhow::anyhow;

use radicle::cob::thread::CommentId;

use radicle::identity::RepoId;

use radicle::issue::{IssueId, State};

use radicle::prelude::Did;

use radicle::{issue, storage, Profile};

use radicle_cli as cli;

use cli::terminal::patch::Message;

use cli::terminal::Context;

use cli::terminal::{Args, Error, Help};

use crate::apps::tui_issue::list::IssueOperation;

use crate::terminal;

use crate::ui::items::filter::DidFilter;

use crate::ui::items::issue::filter::IssueFilter;

pub const HELP: Help = Help {

    name: "issue",

    description: "Terminal interfaces for issues",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad-tui issue list [<option>...]

List options

    --json              Return JSON on stderr instead of calling `rad`

Other options

    --no-forward        Don't forward command to `rad` (default: true)

    --help              Print help (enables forwarding)

"#,

};

#[derive(Debug, PartialEq)]

pub struct Options {

    op: Operation,

    repo: Option<RepoId>,

}

#[derive(Debug, PartialEq)]

pub enum Operation {

    List { opts: ListOptions },

    Other { args: Vec<OsString> },

    Unknown { args: Vec<OsString> },

}

#[derive(PartialEq, Eq)]

pub enum OperationName {

    List,

    Unknown,

}

#[derive(Clone, Debug, Eq, PartialEq)]

pub struct ListFilter {

    state: Option<State>,

    assigned: bool,

    assignees: Vec<Did>,

}

impl Default for ListFilter {

    fn default() -> Self {

        Self {

            state: Some(State::default()),

            assigned: false,

            assignees: vec![],

        }

    }

}

impl ListFilter {

    pub fn with_state(mut self, state: Option<State>) -> Self {

        self.state = state;

        self

    }

    pub fn with_assgined(mut self, assigned: bool) -> Self {

        self.assigned = assigned;

        self

    }

    pub fn with_assginee(mut self, assignee: Did) -> Self {

        self.assignees.push(assignee);

        self

    }

}

#[allow(clippy::from_over_into)]

impl Into<IssueFilter> for (Did, ListFilter) {

    fn into(self) -> IssueFilter {

        let (me, mut filter) = self;

        let mut and = filter

            .state

            .map(|s| vec![IssueFilter::State(s)])

            .unwrap_or(vec![]);

        let mut assignees = filter.assigned.then_some(vec![me]).unwrap_or_default();

        assignees.append(&mut filter.assignees);

        if assignees.len() == 1 {

            and.push(IssueFilter::Assignee(DidFilter::Single(

                *assignees.first().unwrap(),

            )));

        } else if assignees.len() > 1 {

            and.push(IssueFilter::Assignee(DidFilter::Or(assignees)));

        }

        IssueFilter::And(and)

    }

}

#[derive(Debug, Default, Clone, PartialEq, Eq)]

pub struct ListOptions {

    filter: ListFilter,

    json: bool,

}

impl Args for Options {

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_args(args.clone());

        let mut op = OperationName::List;

        let mut repo = None;

        let mut forward = None;

        let mut json = false;

        let mut help = false;

        let mut list_opts = ListOptions::default();

        while let Some(arg) = parser.next()? {

            match arg {

                Long("no-forward") => {

                    forward = Some(false);

                }

                Long("json") => {

                    json = true;

                }

                Long("help") | Short('h') => {

                    help = true;

                    // Only enable forwarding if it was not already disabled explicitly

                    forward = match forward {

                        Some(false) => Some(false),

                        _ => Some(true),

                    };

                }

                Long("all") if op == OperationName::List => {

                    list_opts.filter = list_opts.filter.with_state(None);

                }

                Long("open") if op == OperationName::List => {

                    list_opts.filter = list_opts.filter.with_state(Some(issue::State::Open));

                }

                Long("solved") if op == OperationName::List => {

                    list_opts.filter = list_opts.filter.with_state(Some(issue::State::Closed {

                        reason: issue::CloseReason::Solved,

                    }));

                }

                Long("closed") if op == OperationName::List => {

                    list_opts.filter = list_opts.filter.with_state(Some(issue::State::Closed {

                        reason: issue::CloseReason::Other,

                    }));

                }

                Long("assigned") if op == OperationName::List => {

                    if let Ok(val) = parser.value() {

                        list_opts.filter = list_opts

                            .filter

                            .with_assginee(cli::terminal::args::did(&val)?);

                    } else {

                        list_opts.filter = list_opts.filter.with_assgined(true);

                    }

                }

                Long("repo") => {

                    let val = parser.value()?;

                    let rid = cli::terminal::args::rid(&val)?;

                    repo = Some(rid);

                }