name = "assert_cmd"

version = "2.0.16"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "dc1835b7f27878de8525dc71410b5a31cdcc5f230aed5ba5df968e09c201b23d"

dependencies = [

 "anstyle",

 "bstr",

 "doc-comment",

 "libc",

 "predicates",

 "predicates-core",

 "predicates-tree",

 "wait-timeout",

]

[[package]]

name = "bstr"

version = "1.11.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "531a9155a481e2ee699d4f98f43c0ca4ff8ee1bfd55c31e9e98fb29d2b176fe0"

dependencies = [

 "memchr",

 "regex-automata",

 "serde",

]

[[package]]

name = "difflib"

version = "0.4.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"

[[package]]

name = "doc-comment"

version = "0.3.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"

[[package]]

name = "float-cmp"

version = "0.10.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b09cf3155332e944990140d967ff5eceb70df778b34f77d8075db46e4704e6d8"

dependencies = [

 "num-traits",

]

[[package]]

name = "predicates"

version = "3.1.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "a5d19ee57562043d37e82899fade9a22ebab7be9cef5026b07fda9cdd4293573"

dependencies = [

 "anstyle",

 "difflib",

 "float-cmp",

 "normalize-line-endings",

 "predicates-core",

 "regex",

]

[[package]]

name = "predicates-core"

version = "1.0.9"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "727e462b119fe9c93fd0eb1429a5f7647394014cf3c04ab2c0350eeb09095ffa"

[[package]]

name = "predicates-tree"

version = "1.0.12"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "72dd2d6d381dfb73a193c7fca536518d7caee39fc8503f74e7dc0be0531b425c"

dependencies = [

 "predicates-core",

 "termtree",

]

[[package]]

 "assert_cmd",

 "predicates",

name = "termtree"

version = "0.5.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"

[[package]]

name = "wait-timeout"

version = "0.2.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"

dependencies = [

 "libc",

]

[[package]]

assert_cmd = "2.0.14"

predicates = "3.1.0"

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 interface, e.g.

```

rad-tui patch

```

runs the patch list interface 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`:

```

rad-tui node

```

The default forwarding behaviour can be overridden with a flag, e.g.

rad-tui help --no-forward

runs the internal help command instead of forwarding to `rad help`.

### Using a shell alias

In order to make the CLI integration opaque, a shell alias can be used:

```

alias rad="rad-tui"

```

#### List

rad-tui <patch | issue | inbox>

rad-tui <patch | issue | inbox> list

#### CLI integration via JSON

The interfaces 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.

rad-tui patch list --json

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

use radicle_cli::terminal as cli_term;

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

use cli_term::Context;

    description: "Print help",

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

    println!(

        "{} {}",

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

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

    );

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

    );

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

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

    println!(

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

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

    );

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

mod list;

    rad-tui inbox 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)

    List { opts: ListOptions },

    Other { args: Vec<OsString> },

    List,

    Other,

pub struct ListOptions {

    json: bool,

        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 list_opts = ListOptions::default();

                Long("no-forward") => {

                    forward = Some(false);

                }

                Long("json") => {

                    json = true;

                }

                    help = true;

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

                    forward = match forward {

                        Some(false) => Some(false),

                        _ => Some(true),

                    };

                // list options.

                Long("mode") | Short('m') if op == OperationName::List => {

                    list_opts.mode = list_opts.mode.with_selection(selection_mode)

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

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

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

                    _ => op = OperationName::Other,

                _ => {

                    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 = list_opts

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

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

        let op = match op {

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

                opts: ListOptions { json, ..list_opts },

            },

            _ => Operation::Other { args },

        Operation::List { opts } => {

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

            let context = list::Context {

            let selection = list::App::new(context).run().await?;

            if opts.json {

                let selection = selection

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

                    .unwrap_or_default();

                log::info!("About to print to `stderr`: {}", selection);

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

                eprint!("{selection}");

            } else if let Some(selection) = selection {

                let mut args = vec![];

                if let Some(operation) = selection.operation {

                    args.push(operation.to_string());

                }

                if let Some(id) = selection.ids.first() {

                    args.push(format!("{id}"));

                }

                let args = args.into_iter().map(OsString::from).collect::<Vec<_>>();

                let _ = crate::terminal::run_rad("inbox", &args);

            }

        }

        Operation::Other { args } => {

            let _ = crate::terminal::run_rad("inbox", &args);

#[cfg(test)]

mod cli {

    use std::process::Command;

    use assert_cmd::prelude::*;

    use predicates::prelude::*;

    mod assert {

        use predicates::prelude::*;

        use predicates::str::ContainsPredicate;

        pub fn is_tui() -> ContainsPredicate {

            predicate::str::contains("Inappropriate ioctl for device")

        }

        pub fn is_rad_manual() -> ContainsPredicate {

            predicate::str::contains("rad-inbox")

        }

        pub fn is_inbox_help() -> ContainsPredicate {

            predicate::str::contains("Terminal interfaces for notifications")

        }

    }

    #[test]

    // #[ignore = "breaks stdout"]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.arg("inbox");

        cmd.assert().failure().stdout(assert::is_tui());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.arg("inbox");

        cmd.assert().failure().stdout(assert::is_tui());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "--help"]);

        cmd.assert().success().stdout(assert::is_rad_manual());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "--help", "--no-forward"]);

        cmd.assert().success().stdout(assert::is_inbox_help());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "--no-forward"]);

        cmd.assert().failure().stdout(assert::is_tui());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "list"]);

        cmd.assert().failure().stdout(assert::is_tui());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "list", "--no-forward"]);

        cmd.assert().failure().stdout(assert::is_tui());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "list", "--help"]);

        cmd.assert().success().stdout(assert::is_rad_manual());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "list", "--help", "--no-forward"]);

        cmd.assert().success().stdout(assert::is_inbox_help());

        Ok(())

    }

    #[test]

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

    {

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "list", "--no-forward", "--help"]);

        cmd.assert().success().stdout(assert::is_inbox_help());

        Ok(())

    }

    #[test]

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

        let mut cmd = Command::cargo_bin("rad-tui")?;

        cmd.args(["inbox", "show"]);

        cmd.assert()

            .success()

            .stdout(predicate::str::contains("a Notification ID must be given"));

        Ok(())

    }

}

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

mod ui;

use std::str::FromStr;

use anyhow::Result;

use ratatui::Viewport;

use termion::event::Key;

use ratatui::layout::Constraint;

use ratatui::style::Stylize;

use ratatui::text::Text;

use radicle::identity::Project;

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

use radicle::storage::git::Repository;

use radicle::storage::ReadRepository;

use radicle::storage::ReadStorage;

use radicle::Profile;

use radicle_tui as tui;

use tui::store;

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::BufferedValue;

use tui::ui::Column;

use tui::{BoxedAny, Channel, Exit, PageStack};

use crate::cob::inbox;

use crate::ui::items::{Filter, NotificationItem, NotificationItemFilter};

use self::ui::Browser;

use self::ui::BrowserProps;

use super::common::SelectionMode;

use super::common::{Mode, RepositoryMode};

type Selection = tui::Selection<NotificationId>;

#[allow(dead_code)]

pub struct Context {

    pub profile: Profile,

    pub repository: Repository,

    pub mode: Mode,

    pub filter: inbox::Filter,

    pub sort_by: inbox::SortBy,

}

pub struct App {

    context: Context,

}

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

pub enum AppPage {

    Browse,

    Help,

}

#[derive(Clone, Debug)]

pub struct BrowserState {

    items: Vec<NotificationItem>,

    selected: Option<usize>,

    filter: NotificationItemFilter,

    search: BufferedValue<String>,

    show_search: bool,

}

impl BrowserState {

    pub fn notifications(&self) -> Vec<NotificationItem> {

        self.items

            .iter()

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

            .cloned()

            .collect()

    }

}

#[derive(Clone, Debug)]

pub struct HelpState {

    text: TextViewState,

}

#[derive(Clone, Debug)]

pub struct State {

    mode: Mode,

    project: Project,

    pages: PageStack<AppPage>,

    browser: BrowserState,

    help: HelpState,

}

impl TryFrom<&Context> for State {

    type Error = anyhow::Error;

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

        let doc = context.repository.identity_doc()?;

        let project = doc.project()?;

        let search = BufferedValue::new(String::new());

        let filter = NotificationItemFilter::from_str(&search.read()).unwrap_or_default();

        let mut notifications = match &context.mode.repository() {

            RepositoryMode::All => {

                let mut repos = context.profile.storage.repositories()?;

                repos.sort_by_key(|r| r.rid);

                let mut notifs = vec![];

                for repo in repos {

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

                    let items = inbox::all(&repo, &context.profile)?

                        .iter()

                        .map(|notif| NotificationItem::new(&context.profile, &repo, notif))

                        .filter_map(|item| item.ok())

                        .flatten()

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

                    notifs.extend(items);

                }

                notifs

            }

            RepositoryMode::Contextual => {

                let notifs = inbox::all(&context.repository, &context.profile)?;

                notifs

                    .iter()

                    .map(|notif| {

                        NotificationItem::new(&context.profile, &context.repository, notif)

                    })

                    .filter_map(|item| item.ok())

                    .flatten()

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

            }

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

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

                let notifs = inbox::all(&repo, &context.profile)?;

                notifs

                    .iter()

                    .map(|notif| NotificationItem::new(&context.profile, &repo, notif))

                    .filter_map(|item| item.ok())

                    .flatten()

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

            }

        };

        // Set project name

        let mode = match &context.mode.repository() {

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

                let project = context

                    .profile

                    .storage

                    .repository(*rid)?

                    .identity_doc()?

                    .project()?;

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

                context

                    .mode

                    .clone()

                    .with_repository(RepositoryMode::ByRepo((*rid, Some(name))))

            }

            _ => context.mode.clone(),

        };

        // Apply sorting

        match context.sort_by.field {

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

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

            _ => {}

        }

        if context.sort_by.reverse {

            notifications.reverse();

        }

        // Sort by project if all notifications are shown

        if let RepositoryMode::All = mode.repository() {

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

        }

        Ok(Self {

            mode: context.mode.clone(),

            project,

            pages: PageStack::new(vec![AppPage::Browse]),

            browser: BrowserState {

                items: notifications,

                selected: Some(0),

                filter,

                search,

                show_search: false,

            },

            help: HelpState {

                text: TextViewState::default().content(help_text()),

            },

        })

    }

}

#[derive(Clone, Debug)]

pub enum Message {

    Exit { selection: Option<Selection> },

    Select { selected: Option<usize> },

    OpenSearch,

    UpdateSearch { value: String },

    ApplySearch,

    CloseSearch,

    OpenHelp,

    LeavePage,

    ScrollHelp { state: TextViewState },

}

impl store::Update<Message> for State {

    type Return = Selection;

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

        match message {

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

            Message::Select { selected } => {

                self.browser.selected = selected;

                None

            }

            Message::OpenSearch => {

                self.browser.show_search = true;

                None

            }

            Message::UpdateSearch { value } => {

                self.browser.search.write(value);

                self.browser.filter = NotificationItemFilter::from_str(&self.browser.search.read())

                    .unwrap_or_default();

                if let Some(selected) = self.browser.selected {

                    if selected > self.browser.notifications().len() {

                        self.browser.selected = Some(0);

                    }

                }

                None

            }

            Message::ApplySearch => {

                self.browser.search.apply();

                self.browser.show_search = false;

                None

            }

            Message::CloseSearch => {

                self.browser.search.reset();

                self.browser.show_search = false;

                self.browser.filter = NotificationItemFilter::from_str(&self.browser.search.read())

                    .unwrap_or_default();

                None

            }

            Message::OpenHelp => {

                self.pages.push(AppPage::Help);

                None

            }

            Message::LeavePage => {

                self.pages.pop();

                None

            }

            Message::ScrollHelp { state } => {

                self.help.text = state;

                None

            }

        }

    }

}

impl App {

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

        Self { context }

    }

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

        let channel = Channel::default();

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

        let tx = channel.tx.clone();

        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: &State| {

                WindowProps::default()

                    .current_page(state.pages.peek().unwrap_or(&AppPage::Browse).clone())

                    .to_boxed_any()

                    .into()

            });

        tui::rm(state, window, Viewport::Inline(20), channel).await

    }

}

fn browser_page(_state: &State, channel: &Channel<Message>) -> Widget<State, Message> {

    let tx = channel.tx.clone();

    let content = Browser::new(tx.clone())

        .to_widget(tx.clone())

        .on_update(|state| BrowserProps::from(state).to_boxed_any().into());

    let shortcuts = Shortcuts::default()

        .to_widget(tx.clone())

        .on_update(|state: &State| {

            let shortcuts = if state.browser.show_search {

                vec![("esc", "cancel"), ("enter", "apply")]

            } else {

                match state.mode.selection() {

                    SelectionMode::Id => vec![("enter", "select"), ("/", "search")],

                    SelectionMode::Operation => vec![

                        ("enter", "show"),

                        ("c", "clear"),

                        ("/", "search"),

                        ("?", "help"),

                    ],

                }

            };

            ShortcutsProps::default()

                .shortcuts(&shortcuts)

                .to_boxed_any()

                .into()

        });

    Page::default()

        .content(content)

        .shortcuts(shortcuts)

        .to_widget(tx.clone())

        .on_event(|key, _, props| {

            let default = PageProps::default();

            let props = props

                .and_then(|props| props.inner_ref::<PageProps>())

                .unwrap_or(&default);

            if props.handle_keys {

                match key {

                    Key::Esc | Key::Ctrl('c') => Some(Message::Exit { selection: None }),

                    Key::Char('?') => Some(Message::OpenHelp),

                    _ => None,

                }

            } else {

                None

            }

        })

        .on_update(|state: &State| {

            PageProps::default()

                .handle_keys(!state.browser.show_search)

                .to_boxed_any()

                .into()

        })

}

fn help_page(_state: &State, channel: &Channel<Message>) -> Widget<State, Message> {

    let tx = channel.tx.clone();

    let content = Container::default()

        .header(Header::default().to_widget(tx.clone()).on_update(|_| {

            HeaderProps::default()

                .columns([Column::new(" Help ", Constraint::Fill(1))].to_vec())

                .to_boxed_any()

                .into()

        }))

        .content(

            TextView::default()

                .to_widget(tx.clone())

                .on_event(|_, vs, _| {

                    vs.and_then(|vs| vs.unwrap_textview())

                        .map(|tvs| Message::ScrollHelp { state: tvs })

                })

                .on_update(|state: &State| {

                    TextViewProps::default()

                        .state(Some(state.help.text.clone()))

                        .to_boxed_any()

                        .into()

                }),

        )

        .footer(

            Footer::default()

                .to_widget(tx.clone())

                .on_update(|state: &State| {

                    FooterProps::default()

                        .columns(

                            [

                                Column::new(Text::raw(""), Constraint::Fill(1)),

                                Column::new(

                                    span::default(&format!("{}%", state.help.text.scroll)).dim(),

                                    Constraint::Min(4),

                                ),

                            ]

                            .to_vec(),

                        )

                        .to_boxed_any()

                        .into()

                }),

        )

        .to_widget(tx.clone());

    let shortcuts = Shortcuts::default().to_widget(tx.clone()).on_update(|_| {

        ShortcutsProps::default()

            .shortcuts(&[("?", "close")])

            .to_boxed_any()

            .into()

    });

    Page::default()

        .content(content)

        .shortcuts(shortcuts)

        .to_widget(tx.clone())

        .on_event(|key, _, _| match key {

            Key::Esc | Key::Ctrl('c') => Some(Message::Exit { selection: None }),

            Key::Char('?') => Some(Message::LeavePage),

            _ => None,

        })

        .on_update(|_| PageProps::default().handle_keys(true).to_boxed_any().into())

}

fn help_text() -> String {

    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 notification (if --mode id)

`enter`:    Show notification

`c`:        Clear notifications

`/`:        Search

`?`:        Show help

# Searching

Pattern:    is:<state> | is:patch | is:issue | <search>

Example:    is:unseen is:patch Print"#

        .into()

}

use std::collections::HashMap;

use std::str::FromStr;

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_tui as tui;

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::{self, ViewProps};

use tui::ui::rm::widget::{RenderProps, ToWidget, View};

use tui::ui::span;

use tui::ui::Column;

use tui::{BoxedAny, Selection};

use crate::tui_inbox::common::{InboxOperation, Mode, RepositoryMode, SelectionMode};

use crate::ui::items::{NotificationItem, NotificationItemFilter, NotificationState};

use super::{Message, State};

type Widget = widget::Widget<State, Message>;

#[derive(Clone, Default)]

pub struct BrowserProps<'a> {

    /// Application mode: openation and id or id only.

    mode: Mode,

    /// Table title

    header: String,

    /// Filtered notifications.

    notifications: Vec<NotificationItem>,

    /// Current (selected) table index

    selected: Option<usize>,

    /// Notification statistics.

    stats: HashMap<String, usize>,

    /// 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 header = match state.mode.repository() {

            RepositoryMode::Contextual => state.project.name().to_string(),

            RepositoryMode::All => "All repositories".to_string(),

            RepositoryMode::ByRepo((_, name)) => name.clone().unwrap_or_default(),

        };

        let notifications = state.browser.notifications();

        // Compute statistics

        let mut seen = 0;

        let mut unseen = 0;

        for notification in &notifications {

            if notification.seen {

                seen += 1;

            } else {

                unseen += 1;

            }

        }

        let stats = HashMap::from([("Seen".to_string(), seen), ("Unseen".to_string(), unseen)]);

        Self {

            mode: state.mode.clone(),

            header,

            notifications,

            selected: state.browser.selected,

            stats,

            columns: [

                Column::new("", Constraint::Length(5)),

                Column::new("", Constraint::Length(3)),

                Column::new("", Constraint::Fill(5)),

                Column::new("", Constraint::Fill(1))

                    .skip(*state.mode.repository() != RepositoryMode::All),

                Column::new("", Constraint::Fill(1))

                    .hide_small()

                    .hide_medium(),

                Column::new("", Constraint::Length(8)),

                Column::new("", Constraint::Length(10)),

                Column::new("", Constraint::Min(12)).hide_small(),

                Column::new("", Constraint::Min(14)).hide_small(),

            ]

            .to_vec(),

            search: state.browser.search.read(),

            show_search: state.browser.show_search,

        }

    }

}

pub struct Browser {

    /// Notification widget

    notifications: Widget,

    /// Search widget

    search: Widget,

}

impl Browser {

    pub fn new(tx: UnboundedSender<Message>) -> Self {

        Self {

            notifications: 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(

                            [

                                Column::new("", Constraint::Length(0)),

                                Column::new(Text::from(props.header), Constraint::Fill(1)),

                            ]

                            .to_vec(),

                        )

                        .to_boxed_any()

                        .into()

                }))

                .content(

                    Table::<State, Message, NotificationItem, 9>::default()

                        .to_widget(tx.clone())

                        .on_event(|_, s, _| {

                            let (selected, _) =

                                s.and_then(|s| s.unwrap_table()).unwrap_or_default();

                            Some(Message::Select {

                                selected: Some(selected),

                            })

                        })

                        .on_update(|state| {

                            let props = BrowserProps::from(state);

                            TableProps::default()

                                .columns(props.columns)

                                .items(state.browser.notifications())

                                .selected(state.browser.selected)

                                .to_boxed_any()

                                .into()

                        }),

                )

                .footer(Footer::default().to_widget(tx.clone()).on_update(|state| {

                    let props = BrowserProps::from(state);

                    FooterProps::default()

                        .columns(browse_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.search.read().to_string())

                        .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),

                Key::Char('\n') => props

                    .selected

                    .and_then(|selected| props.notifications.get(selected))

                    .map(|notif| {

                        let selection = match props.mode.selection() {

                            SelectionMode::Operation => Selection::default()

                                .with_operation(InboxOperation::Show.to_string())

                                .with_id(notif.id),

                            SelectionMode::Id => Selection::default().with_id(notif.id),

                        };

                        Message::Exit {

                            selection: Some(selection),

                        }

                    }),

                Key::Char('c') => props

                    .selected

                    .and_then(|selected| props.notifications.get(selected))

                    .map(|notif| Message::Exit {

                        selection: Some(

                            Selection::default()

                                .with_operation(InboxOperation::Clear.to_string())

                                .with_id(notif.id),

                        ),

                    }),

                _ => {

                    self.notifications.handle_event(key);

                    None

                }

            }

        }

    }

    fn update(&mut self, _props: Option<&ViewProps>, state: &Self::State) {

        self.notifications.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.notifications

                .render(RenderProps::from(table_area), frame);

            self.search

                .render(RenderProps::from(search_area).focus(render.focus), frame);

        } else {

            self.notifications.render(render, frame);

        }

    }

}

fn browse_footer<'a>(props: &BrowserProps<'a>) -> Vec<Column<'a>> {

    let search = Line::from(vec![

        span::default(" Search ").cyan().dim().reversed(),

        span::default(" "),

        span::default(&props.search.to_string()).gray().dim(),

    ]);

    let seen = Line::from(vec![

        span::positive(&props.stats.get("Seen").unwrap_or(&0).to_string()).dim(),

        span::default(" Seen").dim(),

    ]);

    let unseen = Line::from(vec![

        span::positive(&props.stats.get("Unseen").unwrap_or(&0).to_string())

            .magenta()

            .dim(),

        span::default(" Unseen").dim(),

    ]);

    let sum = Line::from(vec![

        span::default("Σ ").dim(),

        span::default(&props.notifications.len().to_string()).dim(),

    ]);

    match NotificationItemFilter::from_str(&props.search)

        .unwrap_or_default()

        .state()

    {

        Some(state) => {

            let block = match state {

                NotificationState::Seen => seen,

                NotificationState::Unseen => unseen,

            };

            [

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

            ]

            .to_vec()

        }

        None => [

            Column::new(Text::from(search), Constraint::Fill(1)),

            Column::new(

                Text::from(seen.clone()),

                Constraint::Min(seen.width() as u16),

            ),

            Column::new(

                Text::from(unseen.clone()),

                Constraint::Min(unseen.width() as u16),

            ),

            Column::new(Text::from(sum.clone()), Constraint::Min(sum.width() as u16)),

        ]

        .to_vec(),

    }

}