use std::cmp::max;
use std::cmp::min;
use std::sync::Arc;
use std::sync::Mutex;
use std::time::Duration;
use crossterm::event::Event;
use crossterm::event::KeyEventKind;
use itertools::Itertools;
use neptune_cash::api::export::KeyType;
use neptune_cash::application::config::network::Network;
use neptune_cash::application::rpc::auth;
use neptune_cash::state::wallet::address::SpendingKey;
use ratatui::layout::Constraint;
use ratatui::layout::Margin;
use ratatui::style::Color;
use ratatui::style::Modifier;
use ratatui::style::Style;
use ratatui::widgets::Block;
use ratatui::widgets::Borders;
use ratatui::widgets::Cell;
use ratatui::widgets::Row;
use ratatui::widgets::StatefulWidget;
use ratatui::widgets::Table;
use ratatui::widgets::Widget;
use tarpc::context;
use tokio::select;
use tokio::task::JoinHandle;
use tokio::time::sleep;
use unicode_width::UnicodeWidthStr;
use super::dashboard_app::DashboardEvent;
use super::screen::Screen;
use crate::dashboard_rpc_client::DashboardRpcClient;
use crate::scrollable_table::ScrollableTable;
type AddressUpdate = SpendingKey;
type AddressUpdateArc = Arc<std::sync::Mutex<Vec<AddressUpdate>>>;
type DashboardEventArc = Arc<std::sync::Mutex<Option<DashboardEvent>>>;
type JoinHandleArc = Arc<Mutex<JoinHandle<()>>>;
#[derive(Debug, Clone)]
pub struct AddressScreen {
active: bool,
fg: Color,
bg: Color,
in_focus: bool,
data: AddressUpdateArc,
server: Arc<DashboardRpcClient>,
poll_task: Option<JoinHandleArc>,
escalatable_event: DashboardEventArc,
scrollable_table: ScrollableTable<AddressUpdate>,
network: Network,
token: auth::Token,
}
impl AddressScreen {
pub fn new(rpc_server: Arc<DashboardRpcClient>, network: Network, token: auth::Token) -> Self {
let data = Arc::new(Mutex::new(vec![]));
AddressScreen {
active: false,
fg: Color::Gray,
bg: Color::Black,
in_focus: false,
data: data.clone(),
server: rpc_server,
poll_task: None,
escalatable_event: Arc::new(std::sync::Mutex::new(None)),
scrollable_table: ScrollableTable::new(data),
network,
token,
}
}
async fn run_polling_loop(
rpc_client: Arc<DashboardRpcClient>,
token: auth::Token,
address_updates: AddressUpdateArc,
escalatable_event: DashboardEventArc,
) -> ! {
macro_rules! setup_poller {
($name: ident) => {
let $name = sleep(Duration::from_millis(1));
tokio::pin!($name);
};
}
macro_rules! reset_poller {
($name: ident, $period: expr) => {
$name.as_mut().reset(tokio::time::Instant::now() + $period);
};
}
setup_poller!(addresses);
loop {
select! {
_ = &mut addresses => {
let keys = rpc_client.known_keys(context::current(), token).await.unwrap().unwrap();
*address_updates.lock().unwrap() = keys;
*escalatable_event.lock().unwrap() = Some(DashboardEvent::RefreshScreen);
reset_poller!(addresses, Duration::from_secs(10));
},
}
}
}
pub fn handle(&mut self, event: DashboardEvent) -> Option<DashboardEvent> {
let mut escalate_event = None;
if self.in_focus {
if let DashboardEvent::ConsoleEvent(Event::Key(key)) = event {
if key.kind == KeyEventKind::Press {
if self.scrollable_table.handle_navigation(&event) {
return None;
}
escalate_event = Some(event);
}
}
}
escalate_event
}
}
impl Screen for AddressScreen {
fn activate(&mut self) {
self.active = true;
let server_arc = self.server.clone();
let token = self.token;
let data_arc = self.data.clone();
let escalatable_event_arc = self.escalatable_event.clone();
self.poll_task = Some(Arc::new(Mutex::new(tokio::spawn(async move {
AddressScreen::run_polling_loop(server_arc, token, data_arc, escalatable_event_arc)
.await;
}))));
}
fn deactivate(&mut self) {
self.active = false;
if let Some(task_handle) = &self.poll_task {
(*task_handle.lock().unwrap()).abort();
}
}
fn focus(&mut self) {
self.fg = Color::White;
self.in_focus = true;
}
fn unfocus(&mut self) {
self.fg = Color::Gray;
self.in_focus = false;
}
fn escalatable_event(&self) -> DashboardEventArc {
self.escalatable_event.clone()
}
}
impl Widget for AddressScreen {
fn render(mut self, area: ratatui::layout::Rect, buf: &mut ratatui::buffer::Buffer) {
let style: Style = if self.in_focus {
Style::default().fg(Color::LightCyan).bg(self.bg)
} else {
Style::default().fg(Color::Gray).bg(self.bg)
};
Block::default()
.borders(Borders::ALL)
.title("Known Addresses")
.style(style)
.render(area, buf);
let mut table_canvas = area.inner(Margin {
vertical: 2,
horizontal: 2,
});
let style = Style::default().fg(self.fg).bg(self.bg);
let selected_style = style.add_modifier(Modifier::REVERSED);
let header = vec!["type", "address (abbreviated)"];
let matrix = self
.data
.lock()
.unwrap()
.iter()
.rev()
.map(|key| {
vec![
KeyType::from(key).to_string(),
key.to_address()
.to_display_bech32m_abbreviated(self.network)
.unwrap(),
]
})
.collect_vec();
let ncols = header.len();
let mut widths: Vec<usize> = header.iter().map(|h| h.width()).collect();
for (i, w) in widths.iter_mut().enumerate() {
if let Some(body_max) = matrix.iter().map(|row| row[i].width()).max() {
*w = max(*w, body_max);
}
}
let mut widths_with_bars = vec![1];
widths_with_bars.append(
&mut widths
.iter()
.zip(vec![1; ncols].iter())
.map(|(w, o)| vec![*w, *o])
.collect_vec()
.concat(),
);
let mut header_with_bars = vec!["│".to_string()];
header_with_bars.append(
&mut header
.clone()
.into_iter()
.zip(vec!["│"; ncols].iter())
.map(|(h, &b)| vec![h.to_string(), b.to_string()])
.collect_vec()
.concat(),
);
let mut top_with_bars = widths_with_bars
.iter()
.enumerate()
.map(|(i, w)| {
if i % 2 == 0 {
"┬".to_string()
} else {
"─".to_string().repeat(*w)
}
})
.collect_vec();
top_with_bars[0] = "╭".to_string();
*top_with_bars.last_mut().unwrap() = "╮".to_string();
let mut separator_with_bars = widths_with_bars
.iter()
.enumerate()
.map(|(i, w)| {
if i % 2 == 0 {
"┼".to_string()
} else {
"─".to_string().repeat(*w)
}
})
.collect_vec();
separator_with_bars[0] = "├".to_string();
*separator_with_bars.last_mut().unwrap() = "┤".to_string();
let mut footer_with_bars = widths_with_bars
.iter()
.enumerate()
.map(|(i, w)| {
if i % 2 == 0 {
"┴".to_string()
} else {
"─".to_string().repeat(*w)
}
})
.collect_vec();
footer_with_bars[0] = "╰".to_string();
*footer_with_bars.last_mut().unwrap() = "╯".to_string();
let mut body = matrix
.iter()
.map(|row| {
let mut row_with_bars = vec!["│".to_string()];
row_with_bars.append(
&mut row
.iter()
.zip(vec!["│"; ncols].iter())
.map(|(r, &b)| vec![r.to_string(), b.to_string()])
.collect_vec()
.concat(),
);
row_with_bars
})
.map(|row| Row::new(row.iter().map(|c| Cell::from(c.to_string()))))
.collect_vec();
for (i, item) in body.iter_mut().enumerate() {
if i % 2 == 0 {
*item = item.clone().style(Style::default().bg(Color::DarkGray));
}
}
let mut rows: Vec<Row> = vec![
Row::new(top_with_bars),
Row::new(header_with_bars),
Row::new(separator_with_bars),
];
rows.append(&mut body);
rows.push(Row::new(footer_with_bars));
let width_constraints = widths_with_bars
.iter()
.map(|w| Constraint::Length(*w as u16))
.collect_vec();
let table = Table::new(rows, width_constraints)
.style(style)
.row_highlight_style(selected_style);
table_canvas.width = min(
table_canvas.width,
widths.iter().sum::<usize>() as u16 + 3 * widths.len() as u16 + 1,
);
StatefulWidget::render(table, table_canvas, buf, self.scrollable_table.state_mut());
}
}