name = "addr2line"

version = "0.21.0"

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

checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"

dependencies = [

 "gimli",

]

[[package]]

name = "ahash"

version = "0.8.8"

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

checksum = "42cd52102d3df161c77a887b608d7a4897d7cc112886a9537b738a887a03aaff"

dependencies = [

 "cfg-if",

 "once_cell",

 "version_check",

 "zerocopy",

]

[[package]]

name = "allocator-api2"

version = "0.2.16"

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

checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"

[[package]]

name = "backtrace"

version = "0.3.69"

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

checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"

dependencies = [

 "addr2line",

 "cc",

 "cfg-if",

 "libc",

 "miniz_oxide",

 "object",

 "rustc-demangle",

]

[[package]]

name = "bytes"

version = "1.5.0"

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

checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"

[[package]]

name = "castaway"

version = "0.2.2"

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

checksum = "8a17ed5635fc8536268e5d4de1e22e81ac34419e5f052d4d51f4e01dcc263fcc"

dependencies = [

 "rustversion",

]

[[package]]

 "time 0.1.45",

name = "compact_str"

version = "0.7.1"

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

checksum = "f86b9c4c00838774a6d902ef931eff7470720c51d90c2e32cfe15dc304737b3f"

dependencies = [

 "castaway",

 "cfg-if",

 "itoa",

 "ryu",

 "static_assertions",

]

[[package]]

name = "deranged"

version = "0.3.11"

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

checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"

dependencies = [

 "powerfmt",

]

[[package]]

name = "futures-core"

version = "0.3.30"

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

checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"

[[package]]

name = "gimli"

version = "0.28.1"

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

checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"

[[package]]

dependencies = [

 "ahash",

 "allocator-api2",

]

name = "hermit-abi"

version = "0.3.5"

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

checksum = "d0c62115964e08cb8039170eb33c1d0e2388a256930279edca206fff675f82c3"

[[package]]

name = "itertools"

version = "0.12.1"

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

checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"

dependencies = [

 "either",

]

[[package]]

name = "lock_api"

version = "0.4.11"

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

checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"

dependencies = [

 "autocfg",

 "scopeguard",

]

[[package]]

name = "lru"

version = "0.12.2"

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

checksum = "db2c024b41519440580066ba82aab04092b333e09066a5eb86c7c4890df31f22"

dependencies = [

 "hashbrown",

]

[[package]]

name = "mio"

version = "0.8.10"

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

checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"

dependencies = [

 "libc",

 "wasi 0.11.0+wasi-snapshot-preview1",

 "windows-sys 0.48.0",

]

[[package]]

name = "num-conv"

version = "0.1.0"

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

checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"

[[package]]

name = "num_cpus"

version = "1.16.0"

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

checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"

dependencies = [

 "hermit-abi",

 "libc",

]

[[package]]

name = "num_threads"

version = "0.1.6"

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

checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44"

dependencies = [

 "libc",

]

[[package]]

name = "object"

version = "0.32.2"

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

checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"

dependencies = [

 "memchr",

]

[[package]]

name = "parking_lot"

version = "0.12.1"

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

checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"

dependencies = [

 "lock_api",

 "parking_lot_core",

]

[[package]]

name = "parking_lot_core"

version = "0.9.9"

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

checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"

dependencies = [

 "cfg-if",

 "libc",

 "redox_syscall 0.4.1",

 "smallvec",

 "windows-targets 0.48.1",

]

[[package]]

name = "pin-project-lite"

version = "0.2.13"

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

checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"

[[package]]

name = "powerfmt"

version = "0.2.0"

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

checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"

[[package]]

 "libc",

 "ratatui 0.26.1",

 "signal-hook",

 "tokio",

 "tokio-stream",

 "itertools 0.11.0",

 "strum 0.25.0",

name = "ratatui"

version = "0.26.1"

source = "git+https://github.com/erak/ratatui?branch=termion-cursor#e0fa5a0b27e2ef04ae84a5ba2b4e2050cc2037bb"

dependencies = [

 "bitflags 2.4.1",

 "cassowary",

 "compact_str",

 "indoc",

 "itertools 0.12.1",

 "lru",

 "paste",

 "stability",

 "strum 0.26.1",

 "termion 3.0.0",

 "time 0.3.34",

 "unicode-segmentation",

 "unicode-width",

]

[[package]]

name = "rustc-demangle"

version = "0.1.23"

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

checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"

[[package]]

name = "scopeguard"

version = "1.2.0"

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

checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

[[package]]

name = "signal-hook"

version = "0.3.17"

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

checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"

dependencies = [

 "libc",

 "signal-hook-registry",

]

[[package]]

name = "signal-hook-registry"

version = "1.4.1"

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

checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"

dependencies = [

 "libc",

]

[[package]]

name = "socket2"

version = "0.5.5"

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

checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"

dependencies = [

 "libc",

 "windows-sys 0.48.0",

]

[[package]]

name = "stability"

version = "0.1.1"

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

checksum = "ebd1b177894da2a2d9120208c3386066af06a488255caabc5de8ddca22dbc3ce"

dependencies = [

 "quote",

 "syn 1.0.109",

]

[[package]]

name = "static_assertions"

version = "1.1.0"

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

checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

[[package]]

 "strum_macros 0.25.3",

]

[[package]]

name = "strum"

version = "0.26.1"

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

checksum = "723b93e8addf9aa965ebe2d11da6d7540fa2283fcea14b3371ff055f7ba13f5f"

dependencies = [

 "strum_macros 0.26.1",

name = "strum_macros"

version = "0.26.1"

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

checksum = "7a3417fc93d76740d974a01654a09777cb500428cc874ca9f45edfe0c4d4cd18"

dependencies = [

 "heck",

 "proc-macro2",

 "quote",

 "rustversion",

 "syn 2.0.48",

]

[[package]]

name = "time"

version = "0.3.34"

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

checksum = "c8248b6521bb14bc45b4067159b9b6ad792e2d6d754d6c41fb50e29fefe38749"

dependencies = [

 "deranged",

 "libc",

 "num-conv",

 "num_threads",

 "powerfmt",

 "serde",

 "time-core",

]

[[package]]

name = "time-core"

version = "0.1.2"

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

checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"

[[package]]

name = "tokio"

version = "1.36.0"

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

checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"

dependencies = [

 "backtrace",

 "bytes",

 "libc",

 "mio",

 "num_cpus",

 "parking_lot",

 "pin-project-lite",

 "signal-hook-registry",

 "socket2",

 "tokio-macros",

 "windows-sys 0.48.0",

]

[[package]]

name = "tokio-macros"

version = "2.2.0"

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

checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"

dependencies = [

 "proc-macro2",

 "quote",

 "syn 2.0.48",

]

[[package]]

name = "tokio-stream"

version = "0.1.14"

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

checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"

dependencies = [

 "futures-core",

 "pin-project-lite",

 "tokio",

]

[[package]]

 "ratatui 0.23.0",

name = "zerocopy"

version = "0.7.32"

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

checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"

dependencies = [

 "zerocopy-derive",

]

[[package]]

name = "zerocopy-derive"

version = "0.7.32"

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

checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"

dependencies = [

 "proc-macro2",

 "quote",

 "syn 2.0.48",

]

[[package]]

[features]

default = ["flux"]

realm = ["dep:tuirealm", "dep:tui-realm-stdlib"]

flux = ["dep:tokio", "dep:tokio-stream"]

libc = { version = "^0.2" }

ratatui = { git = "https://github.com/erak/ratatui", branch = "termion-cursor", default-features = false, features = ["all-widgets", "termion"] }

signal-hook = { version = "0.3.17" }

tokio = { version = "1.32.0", features = ["full"], optional = true }

tokio-stream = { version = "0.1.14", optional = true }

tuirealm = { version = "^1.9.0", default-features = false, features = ["termion", "ratatui", "derive"], optional = true }

tui-realm-stdlib = { version = "1.3.1", default-features = false, features = ["termion", "ratatui"], optional = true }

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

mod common;

#[cfg(feature = "flux")]

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

mod flux;

#[cfg(feature = "realm")]

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

mod realm;

use tui::common::cob::inbox::{self};

    mode: common::Mode,

                        "operation" => common::Mode::Operation,

                        "id" => common::Mode::Id,

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

#[cfg(feature = "realm")]

    use tui::common::context;

    use tui::common::log;

    use tui::realm::Window;

    pub const FPS: u64 = 60;

            let mut app = realm::select::App::new(

            eprint!("{:?}", output);

        }

    }

    Ok(())

}

#[cfg(feature = "flux")]

#[tokio::main]

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

    use radicle::storage::ReadStorage;

    use tui::common::log;

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

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

    match options.op {

        Operation::Select { opts } => {

            let profile = terminal::profile()?;

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

            log::enable(&profile, "inbox", "select")?;

            let context = flux::select::Context {

                profile,

                repository,

                mode: opts.mode,

                filter: opts.filter.clone(),

                sort_by: opts.sort_by,

            };

            let output = flux::select::App::new(context).run().await?;

/// The application's subject. It tells the application

/// which widgets to render and which output to produce.

///

/// Depends on CLI arguments given by the user.

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

pub enum Mode {

    Id,

    #[default]

    Operation,

}

#[path = "flux/select.rs"]

pub mod select;

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

mod ui;

use anyhow::Result;

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

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

use radicle::Profile;

use radicle_tui as tui;

use tui::common::cob::inbox::{self};

use tui::flux::store::{State, Store};

use tui::flux::termination::{self, Interrupted};

use tui::flux::ui::cob::NotificationItem;

use tui::flux::ui::Frontend;

use tui::Exit;

use ui::ListPage;

use super::super::common;

type Selection = tui::Selection<NotificationId>;

pub struct Context {

    pub profile: Profile,

    pub repository: Repository,

    pub mode: common::Mode,

    pub filter: inbox::Filter,

    pub sort_by: inbox::SortBy,

}

pub struct App {

    context: Context,

}

#[derive(Clone, Debug)]

pub struct InboxState {

    notifications: Vec<NotificationItem>,

    selected: Option<NotificationItem>,

    mode: common::Mode,

}

impl TryFrom<&Context> for InboxState {

    type Error = anyhow::Error;

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

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

        let mut items = vec![];

        // Convert into UI items

        for notif in &notifications {

            if let Ok(notif) =

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

            {

                items.push(notif);

            }

        }

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

        }

        let selected = items.first().cloned();

        Ok(Self {

            notifications: items,

            selected,

            mode: context.mode.clone(),

        })

    }

}

pub enum Action {

    Exit { selection: Option<Selection> },

    Select { item: NotificationItem },

}

impl State<Action, Selection> for InboxState {

    fn tick(&self) {}

    fn handle_action(&mut self, action: Action) -> Option<Exit<Selection>> {

        match action {

            Action::Select { item } => {

                self.selected = Some(item);

                None

            }

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

        }

    }

}

impl App {

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

        Self { context }

    }

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

        let (terminator, mut interrupt_rx) = termination::create_termination();

        let (store, state_rx) = Store::<Action, InboxState, Selection>::new();

        let (frontend, action_rx) = Frontend::<Action>::new();

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

        tokio::try_join!(

            store.main_loop(state, terminator, action_rx, interrupt_rx.resubscribe()),

            frontend

                .main_loop::<InboxState, ListPage, Selection>(state_rx, interrupt_rx.resubscribe()),

        )?;

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

        }

    }

}

use std::vec;

use tokio::sync::mpsc::UnboundedSender;

use termion::event::Key;

use ratatui::backend::Backend;

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

use radicle_tui as tui;

use tui::flux::ui::cob::NotificationItem;

use tui::flux::ui::span;

use tui::flux::ui::widget::container::{Footer, FooterProps, Header, HeaderProps};

use tui::flux::ui::widget::{

    Render, Shortcut, Shortcuts, ShortcutsProps, Table, TableProps, Widget,

};

use tui::Selection;

use super::common::Mode;

use super::{Action, InboxState};

pub struct ListPageProps {

    selected: Option<NotificationItem>,

    mode: Mode,

}

impl From<&InboxState> for ListPageProps {

    fn from(state: &InboxState) -> Self {

        Self {

            selected: state.selected.clone(),

            mode: state.mode.clone(),

        }

    }

}

pub struct ListPage {

    /// Action sender

    pub action_tx: UnboundedSender<Action>,

    /// State mapped props

    props: ListPageProps,

    /// Notification widget

    notifications: Notifications,

    /// Shortcut widget

    shortcuts: Shortcuts<Action>,

}

impl Widget<InboxState, Action> for ListPage {

    fn new(state: &InboxState, action_tx: UnboundedSender<Action>) -> Self

    where

        Self: Sized,

    {

        Self {

            action_tx: action_tx.clone(),

            props: ListPageProps::from(state),

            notifications: Notifications::new(state, action_tx.clone()),

            shortcuts: Shortcuts::new(state, action_tx.clone()),

        }

        .move_with_state(state)

    }

    fn move_with_state(self, state: &InboxState) -> Self

    where

        Self: Sized,

    {

        ListPage {

            notifications: self.notifications.move_with_state(state),

            shortcuts: self.shortcuts.move_with_state(state),

            props: ListPageProps::from(state),

            ..self

        }

    }

    fn name(&self) -> &str {

        "list-page"

    }

    fn handle_key_event(&mut self, key: termion::event::Key) {

        match key {

            Key::Char('q') => {

                let _ = self.action_tx.send(Action::Exit { selection: None });

            }

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

                if let Some(selected) = &self.props.selected {

                    let selection = match self.props.mode {

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

                            .with_operation("show".to_string())

                            .with_id(selected.id),

                        Mode::Id => Selection::default().with_id(selected.id),

                    };

                    let _ = self.action_tx.send(Action::Exit {

                        selection: Some(selection),

                    });

                }

            }

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

                if let Some(selected) = &self.props.selected {

                    let _ = self.action_tx.send(Action::Exit {

                        selection: Some(

                            Selection::default()

                                .with_operation("clear".to_string())

                                .with_id(selected.id),

                        ),

                    });

                }

            }

            _ => {

                <Notifications as Widget<InboxState, Action>>::handle_key_event(

                    &mut self.notifications,

                    key,

                );

            }

        }

    }

}

impl Render<()> for ListPage {

    fn render<B: Backend>(&self, frame: &mut ratatui::Frame, _area: Rect, _props: ()) {

        let area = frame.size();

        let layout = tui::flux::ui::layout::default_page(area, 0u16, 1u16);

        let shortcuts = match self.props.mode {

            Mode::Id => vec![Shortcut::new("enter", "select"), Shortcut::new("q", "quit")],

            Mode::Operation => vec![

                Shortcut::new("enter", "show"),

                Shortcut::new("c", "clear"),

                Shortcut::new("q", "quit"),

            ],

        };

        self.notifications.render::<B>(frame, layout.component, ());

        self.shortcuts.render::<B>(

            frame,

            layout.shortcuts,

            ShortcutsProps {

                shortcuts,

                divider: '∙',

            },

        );

    }

}

struct NotificationsProps {

    notifications: Vec<NotificationItem>,

}

impl From<&InboxState> for NotificationsProps {

    fn from(state: &InboxState) -> Self {

        Self {

            notifications: state.notifications.clone(),

        }

    }

}

struct Notifications {

    /// Action sender

    action_tx: UnboundedSender<Action>,

    /// State mapped props

    props: NotificationsProps,

    /// Table header

    header: Header<Action>,

    /// Notification table

    table: Table<Action>,

    /// Table footer

    footer: Footer<Action>,

}

impl Widget<InboxState, Action> for Notifications {

    fn new(state: &InboxState, action_tx: UnboundedSender<Action>) -> Self {

        Self {

            action_tx: action_tx.clone(),

            props: NotificationsProps::from(state),

            header: Header::new(state, action_tx.clone()),

            table: Table::new(state, action_tx.clone()),

            footer: Footer::new(state, action_tx),

        }

    }

    fn move_with_state(self, state: &InboxState) -> Self

    where

        Self: Sized,

    {

        Self {

            props: NotificationsProps::from(state),

            header: self.header.move_with_state(state),

            table: self.table.move_with_state(state),

            footer: self.footer.move_with_state(state),

            ..self

        }

    }

    fn name(&self) -> &str {

        "notifications"

    }

    fn handle_key_event(&mut self, key: Key) {

        match key {

            Key::Up => {

                self.table.prev();

                let selected = self

                    .table

                    .selected()

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

                // TODO: propagate error

                if let Some(notif) = selected {

                    let _ = self.action_tx.send(Action::Select {

                        item: notif.clone(),

                    });

                }

            }

            Key::Down => {

                self.table.next(self.props.notifications.len());

                let selected = self

                    .table

                    .selected()

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

                // TODO: propagate error

                if let Some(notif) = selected {

                    let _ = self.action_tx.send(Action::Select {

                        item: notif.clone(),

                    });

                }

            }

            _ => {}

        }

    }

}

impl Render<()> for Notifications {

    fn render<B: Backend>(&self, frame: &mut ratatui::Frame, area: Rect, _props: ()) {

        let cutoff = 200;

        let cutoff_after = 8;

        let focus = false;

        let layout = Layout::default()

            .direction(Direction::Vertical)

            .constraints(vec![

                Constraint::Length(3),

                Constraint::Min(1),

                Constraint::Length(3),

            ])

            .split(area);

        let widths = [

            Constraint::Length(5),

            Constraint::Length(3),

            Constraint::Length(20),

            Constraint::Fill(1),

            Constraint::Length(8),

            Constraint::Length(10),

            Constraint::Length(15),

            Constraint::Length(18),

        ];

        let progress = {

            let step = self

                .table

                .selected()

                .map(|selected| selected.saturating_add(1).to_string())

                .unwrap_or("-".to_string());

            let length = self.props.notifications.len().to_string();

            span::badge(format!("{}/{}", step, length))

        };

        self.header.render::<B>(

            frame,

            layout[0],

            HeaderProps {

                cells: [

                    String::from("").into(),

                    String::from(" ● ").into(),

                    String::from("ID / Name").into(),

                    String::from("Summary").into(),

                    String::from("Type").into(),

                    String::from("Status").into(),

                    String::from("Author").into(),

                    String::from("Updated").into(),

                ],

                widths,

                focus,

                cutoff,

                cutoff_after,

            },

        );

        self.table.render::<B>(

            frame,

            layout[1],

            TableProps {

                items: self.props.notifications.to_vec(),

                has_header: true,

                has_footer: true,

                focus,

                widths,

                cutoff,

                cutoff_after,

            },

        );

        self.footer.render::<B>(

            frame,

            layout[2],

            FooterProps {

                cells: [

                    span::badge("/".to_string()),

                    String::from("").into(),

                    String::from("").into(),

                    progress.clone(),

                ],

                widths: [

                    Constraint::Length(3),

                    Constraint::Fill(1),

                    Constraint::Fill(1),

                    Constraint::Length(progress.width() as u16),

                ],

                focus,

                cutoff,

                cutoff_after,

            },

        );

    }

}

#[path = "realm/select.rs"]

pub mod select;

#[path = "select/event.rs"]

mod event;

#[path = "select/page.rs"]

mod page;

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

mod ui;

use std::fmt::Display;

use std::hash::Hash;

use anyhow::Result;

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

use serde::Serialize;

use tuirealm::application::PollStrategy;

use tuirealm::{Application, Frame, NoUserEvent, Sub, SubClause};

use radicle_tui as tui;

use tui::common::cob::inbox::{Filter, SortBy};

use tui::common::context::Context;

use tui::realm::ui::subscription;

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

use tui::realm::{PageStack, Tui};

use tui::Exit;

use page::ListView;

use super::super::common::Mode;

type Selection = tui::Selection<NotificationId>;

/// The selected issue operation returned by the operation

/// selection widget.

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

pub enum InboxOperation {

    Show,

    Clear,

}

impl Display for InboxOperation {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        match self {

            InboxOperation::Show => {

                write!(f, "show")

            }

            InboxOperation::Clear => {

                write!(f, "clear")

            }

        }

    }

}

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

pub enum ListCid {

    NotificationBrowser,

    Context,

    Shortcuts,

}

/// All component ids known to this application.

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

pub enum Cid {

    List(ListCid),

    #[default]

    GlobalListener,

}

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

pub enum Message {

    #[default]

    Tick,

    Quit(Option<Selection>),

    Batch(Vec<Message>),

}

pub struct App {

    context: Context,

    pages: PageStack<Cid, Message>,

    theme: Theme,

    mode: Mode,

    filter: Filter,

    sort_by: SortBy,

    quit: bool,

    output: Option<Selection>,

}

/// Creates a new application using a tui-realm-application, mounts all

/// components and sets focus to a default one.

#[allow(dead_code)]

impl App {

    pub fn new(context: Context, mode: Mode, filter: Filter, sort_by: SortBy) -> Self {

        Self {

            context,

            pages: PageStack::default(),

            theme: Theme::default(),

            mode,

            filter,

            sort_by,

            quit: false,

            output: None,

        }

    }

    fn view_list(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        theme: &Theme,

    ) -> Result<()> {

        let home = Box::new(ListView::new(

            self.mode.clone(),

            self.filter.clone(),

            self.sort_by,

        ));

        self.pages.push(home, app, &self.context, theme)?;

        Ok(())

    }

    fn process(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        message: Message,

    ) -> Result<Option<Message>> {

        let theme = Theme::default();

        match message {

            Message::Batch(messages) => {

                let mut results = vec![];

                for message in messages {

                    if let Some(result) = self.process(app, message)? {

                        results.push(result);

                    }

                }

                match results.len() {

                    0 => Ok(None),

                    1 => Ok(Some(results[0].to_owned())),

                    _ => Ok(Some(Message::Batch(results))),

                }

            }

            Message::Quit(output) => {

                self.quit = true;

                self.output = output;

                Ok(None)

            }

            _ => self

                .pages

                .peek_mut()?

                .update(app, &self.context, &theme, message),

        }

    }

}

impl Tui<Cid, Message, Selection> for App {

    fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        self.view_list(app, &self.theme.clone())?;

        // Add global key listener and subscribe to key events

        let global = tui::realm::ui::global_listener().to_boxed();

        app.mount(

            Cid::GlobalListener,

            global,

            vec![Sub::new(

                subscription::quit_clause(tuirealm::event::Key::Char('q')),

                SubClause::Always,

            )],

        )?;

        Ok(())

    }

    fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {

        if let Ok(page) = self.pages.peek_mut() {

            page.view(app, frame);

        }

    }

    fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {

        match app.tick(PollStrategy::Once) {

            Ok(messages) if !messages.is_empty() => {

                for message in messages {

                    let mut msg = Some(message);

                    while msg.is_some() {

                        msg = self.process(app, msg.unwrap())?;

                    }

                }

                Ok(true)

            }

            _ => Ok(false),

        }

    }

    fn exit(&self) -> Option<Exit<Selection>> {

        if self.quit {

            return Some(Exit {

                value: self.output.clone(),

            });

        }

        None

    }

}

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

use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};

use tuirealm::event::{Event, Key, KeyEvent};

use tuirealm::{MockComponent, NoUserEvent};

use radicle_tui as tui;

use tui::realm::ui::state::ItemState;

use tui::realm::ui::widget::container::{AppHeader, GlobalListener, LabeledContainer};

use tui::realm::ui::widget::context::{ContextBar, Shortcuts};

use tui::realm::ui::widget::list::PropertyList;

use tui::realm::ui::widget::Widget;

use super::ui::{IdSelect, OperationSelect};

use super::{InboxOperation, Message};

type Selection = tui::Selection<NotificationId>;

/// Since the framework does not know the type of messages that are being

/// passed around in the app, the following handlers need to be implemented for

/// each component used.

///

/// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.

impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent {

                code: Key::Char('q'),

                ..

            }) => Some(Message::Quit(None)),

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<IdSelect> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        let mut submit = || -> Option<NotificationId> {

            match self.perform(Cmd::Submit) {

                CmdResult::Submit(state) => {

                    let selected = ItemState::try_from(state).ok()?.selected()?;

                    let item = self.items().get(selected)?;

                    Some(item.id().to_owned())

                }

                _ => None,

            }

        };

        match event {

            Event::Keyboard(KeyEvent { code: Key::Up, .. })

            | Event::Keyboard(KeyEvent {

                code: Key::Char('k'),

                ..

            }) => {

                self.perform(Cmd::Move(MoveDirection::Up));

                Some(Message::Tick)

            }

            Event::Keyboard(KeyEvent {

                code: Key::Down, ..

            })

            | Event::Keyboard(KeyEvent {

                code: Key::Char('j'),

                ..

            }) => {

                self.perform(Cmd::Move(MoveDirection::Down));

                Some(Message::Tick)

            }

            Event::Keyboard(KeyEvent {

                code: Key::Enter, ..

            }) => submit().map(|id| {

                let selection = Selection {

                    operation: None,

                    ids: vec![id],

                    args: vec![],

                };

                Message::Quit(Some(selection))

            }),

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<OperationSelect> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        let mut submit = || -> Option<NotificationId> {

            match self.perform(Cmd::Submit) {

                CmdResult::Submit(state) => {

                    let selected = ItemState::try_from(state).ok()?.selected()?;

                    let item = self.items().get(selected)?;

                    Some(item.id().to_owned())

                }

                _ => None,

            }

        };

        match event {

            Event::Keyboard(KeyEvent { code: Key::Up, .. })

            | Event::Keyboard(KeyEvent {