feat(ui): Full Sonarr system tab support

Signed-off-by: Alex Clarke <alex.j.tusa@gmail.com>

src/ui/sonarr_ui/mod.rs

@@ -14,6 +14,7 @@ use ratatui::{
   Frame,
 };
 use root_folders::RootFoldersUi;
+use system::SystemUi;
 
 use crate::{
   app::App,
@@ -43,6 +44,7 @@ mod history;
 mod indexers;
 mod library;
 mod root_folders;
+mod system;
 
 #[cfg(test)]
 #[path = "sonarr_ui_tests.rs"]
@@ -66,6 +68,7 @@ impl DrawUi for SonarrUi {
       _ if HistoryUi::accepts(route) => HistoryUi::draw(f, app, content_area),
       _ if RootFoldersUi::accepts(route) => RootFoldersUi::draw(f, app, content_area),
       _ if IndexersUi::accepts(route) => IndexersUi::draw(f, app, content_area),
+      _ if SystemUi::accepts(route) => SystemUi::draw(f, app, content_area),
       _ => (),
     }
   }

src/ui/sonarr_ui/system/mod.rs

@@ -0,0 +1,232 @@
+use std::ops::Sub;
+
+use chrono::Utc;
+use ratatui::layout::Layout;
+use ratatui::style::Style;
+use ratatui::text::{Span, Text};
+use ratatui::widgets::{Cell, Paragraph, Row};
+use ratatui::{
+  layout::{Constraint, Rect},
+  widgets::ListItem,
+  Frame,
+};
+
+use crate::app::App;
+use crate::models::servarr_data::sonarr::sonarr_data::ActiveSonarrBlock;
+use crate::models::servarr_models::QueueEvent;
+use crate::models::sonarr_models::SonarrTask;
+use crate::ui::sonarr_ui::system::system_details_ui::SystemDetailsUi;
+use crate::ui::styles::ManagarrStyle;
+use crate::ui::utils::{
+  convert_to_minutes_hours_days, layout_block_top_border, style_log_list_item,
+};
+use crate::ui::widgets::loading_block::LoadingBlock;
+use crate::ui::widgets::managarr_table::ManagarrTable;
+use crate::ui::widgets::selectable_list::SelectableList;
+use crate::{
+  models::Route,
+  ui::{utils::title_block, DrawUi},
+};
+
+mod system_details_ui;
+
+#[cfg(test)]
+#[path = "system_ui_tests.rs"]
+mod system_ui_tests;
+
+pub(super) const TASK_TABLE_HEADERS: [&str; 4] =
+  ["Name", "Interval", "Last Execution", "Next Execution"];
+
+pub(super) const TASK_TABLE_CONSTRAINTS: [Constraint; 4] = [
+  Constraint::Percentage(30),
+  Constraint::Percentage(23),
+  Constraint::Percentage(23),
+  Constraint::Percentage(23),
+];
+
+pub(super) struct SystemUi;
+
+impl DrawUi for SystemUi {
+  fn accepts(route: Route) -> bool {
+    if let Route::Sonarr(active_sonarr_block, _) = route {
+      return SystemDetailsUi::accepts(route) || active_sonarr_block == ActiveSonarrBlock::System;
+    }
+
+    false
+  }
+
+  fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+    let route = app.get_current_route();
+
+    match route {
+      _ if SystemDetailsUi::accepts(route) => SystemDetailsUi::draw(f, app, area),
+      _ if matches!(route, Route::Sonarr(ActiveSonarrBlock::System, _)) => {
+        draw_system_ui_layout(f, app, area)
+      }
+      _ => (),
+    }
+  }
+}
+
+pub(super) fn draw_system_ui_layout(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+  let [activities_area, logs_area, help_area] = Layout::vertical([
+    Constraint::Ratio(1, 2),
+    Constraint::Ratio(1, 2),
+    Constraint::Min(2),
+  ])
+  .areas(area);
+
+  let [tasks_area, events_area] =
+    Layout::horizontal([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)]).areas(activities_area);
+
+  draw_tasks(f, app, tasks_area);
+  draw_queued_events(f, app, events_area);
+  draw_logs(f, app, logs_area);
+  draw_help(f, app, help_area);
+}
+
+fn draw_tasks(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+  let tasks_row_mapping = |task: &SonarrTask| {
+    let task_props = extract_task_props(task);
+
+    Row::new(vec![
+      Cell::from(task_props.name),
+      Cell::from(task_props.interval),
+      Cell::from(task_props.last_execution),
+      Cell::from(task_props.next_execution),
+    ])
+    .primary()
+  };
+  let tasks_table = ManagarrTable::new(Some(&mut app.data.sonarr_data.tasks), tasks_row_mapping)
+    .block(title_block("Tasks"))
+    .loading(app.is_loading)
+    .highlight_rows(false)
+    .headers(TASK_TABLE_HEADERS)
+    .constraints(TASK_TABLE_CONSTRAINTS);
+
+  f.render_widget(tasks_table, area);
+}
+
+pub(super) fn draw_queued_events(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+  let events_row_mapping = |event: &QueueEvent| {
+    let queued = convert_to_minutes_hours_days(Utc::now().sub(event.queued).num_minutes());
+    let queued_string = if queued != "now" {
+      format!("{queued} ago")
+    } else {
+      queued
+    };
+    let started_string = if event.started.is_some() {
+      let started =
+        convert_to_minutes_hours_days(Utc::now().sub(event.started.unwrap()).num_minutes());
+
+      if started != "now" {
+        format!("{started} ago")
+      } else {
+        started
+      }
+    } else {
+      String::new()
+    };
+
+    let duration = if event.duration.is_some() {
+      &event.duration.as_ref().unwrap()[..8]
+    } else {
+      ""
+    };
+
+    Row::new(vec![
+      Cell::from(event.trigger.clone()),
+      Cell::from(event.status.clone()),
+      Cell::from(event.command_name.clone()),
+      Cell::from(queued_string),
+      Cell::from(started_string),
+      Cell::from(duration.to_owned()),
+    ])
+    .primary()
+  };
+  let events_table = ManagarrTable::new(
+    Some(&mut app.data.sonarr_data.queued_events),
+    events_row_mapping,
+  )
+  .block(title_block("Queued Events"))
+  .loading(app.is_loading)
+  .highlight_rows(false)
+  .headers(["Trigger", "Status", "Name", "Queued", "Started", "Duration"])
+  .constraints([
+    Constraint::Percentage(13),
+    Constraint::Percentage(13),
+    Constraint::Percentage(30),
+    Constraint::Percentage(16),
+    Constraint::Percentage(14),
+    Constraint::Percentage(14),
+  ]);
+
+  f.render_widget(events_table, area);
+}
+
+fn draw_logs(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+  let block = title_block("Logs");
+
+  if app.data.sonarr_data.logs.items.is_empty() {
+    f.render_widget(LoadingBlock::new(app.is_loading, block), area);
+    return;
+  }
+
+  let logs_box = SelectableList::new(&mut app.data.sonarr_data.logs, |log| {
+    let log_line = log.to_string();
+    let level = log_line.split('|').collect::<Vec<&str>>()[1].to_string();
+
+    style_log_list_item(ListItem::new(Text::from(Span::raw(log_line))), level)
+  })
+  .block(block)
+  .highlight_style(Style::new().default());
+
+  f.render_widget(logs_box, area);
+}
+
+fn draw_help(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+  let help_text = Text::from(
+    format!(
+      " {}",
+      app
+        .data
+        .sonarr_data
+        .main_tabs
+        .get_active_tab_contextual_help()
+        .unwrap()
+    )
+    .help(),
+  );
+  let help_paragraph = Paragraph::new(help_text)
+    .block(layout_block_top_border())
+    .left_aligned();
+
+  f.render_widget(help_paragraph, area);
+}
+
+pub(super) struct TaskProps {
+  pub(super) name: String,
+  pub(super) interval: String,
+  pub(super) last_execution: String,
+  pub(super) next_execution: String,
+}
+
+pub(super) fn extract_task_props(task: &SonarrTask) -> TaskProps {
+  let interval = convert_to_minutes_hours_days(task.interval);
+  let next_execution =
+    convert_to_minutes_hours_days((task.next_execution - Utc::now()).num_minutes());
+  let last_execution =
+    convert_to_minutes_hours_days((Utc::now() - task.last_execution).num_minutes());
+  let last_execution_string = if last_execution != "now" {
+    format!("{last_execution} ago")
+  } else {
+    last_execution
+  };
+
+  TaskProps {
+    name: task.name.clone(),
+    interval,
+    last_execution: last_execution_string,
+    next_execution,
+  }
+}

src/ui/sonarr_ui/system/system_details_ui.rs

@@ -0,0 +1,180 @@
+use ratatui::layout::{Alignment, Rect};
+use ratatui::text::{Span, Text};
+use ratatui::widgets::{Cell, ListItem, Paragraph, Row};
+use ratatui::Frame;
+
+use crate::app::context_clues::{build_context_clue_string, BARE_POPUP_CONTEXT_CLUES};
+use crate::app::sonarr::sonarr_context_clues::SYSTEM_TASKS_CONTEXT_CLUES;
+use crate::app::App;
+use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, SYSTEM_DETAILS_BLOCKS};
+use crate::models::sonarr_models::SonarrTask;
+use crate::models::Route;
+use crate::ui::sonarr_ui::system::{
+  draw_queued_events, draw_system_ui_layout, extract_task_props, TASK_TABLE_CONSTRAINTS,
+  TASK_TABLE_HEADERS,
+};
+use crate::ui::styles::ManagarrStyle;
+use crate::ui::utils::{borderless_block, style_log_list_item, title_block};
+use crate::ui::widgets::confirmation_prompt::ConfirmationPrompt;
+use crate::ui::widgets::loading_block::LoadingBlock;
+use crate::ui::widgets::managarr_table::ManagarrTable;
+use crate::ui::widgets::popup::{Popup, Size};
+use crate::ui::widgets::selectable_list::SelectableList;
+use crate::ui::{draw_popup_over, DrawUi};
+
+#[cfg(test)]
+#[path = "system_details_ui_tests.rs"]
+mod system_details_ui_tests;
+
+pub(super) struct SystemDetailsUi;
+
+impl DrawUi for SystemDetailsUi {
+  fn accepts(route: Route) -> bool {
+    if let Route::Sonarr(active_sonarr_block, _) = route {
+      return SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block);
+    }
+
+    false
+  }
+
+  fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+    if let Route::Sonarr(active_sonarr_block, _) = app.get_current_route() {
+      match active_sonarr_block {
+        ActiveSonarrBlock::SystemLogs => {
+          draw_system_ui_layout(f, app, area);
+          draw_logs_popup(f, app);
+        }
+        ActiveSonarrBlock::SystemTasks | ActiveSonarrBlock::SystemTaskStartConfirmPrompt => {
+          draw_popup_over(
+            f,
+            app,
+            area,
+            draw_system_ui_layout,
+            draw_tasks_popup,
+            Size::Large,
+          )
+        }
+        ActiveSonarrBlock::SystemQueuedEvents => draw_popup_over(
+          f,
+          app,
+          area,
+          draw_system_ui_layout,
+          draw_queued_events,
+          Size::Medium,
+        ),
+        ActiveSonarrBlock::SystemUpdates => {
+          draw_system_ui_layout(f, app, area);
+          draw_updates_popup(f, app);
+        }
+        _ => (),
+      }
+    }
+  }
+}
+
+fn draw_logs_popup(f: &mut Frame<'_>, app: &mut App<'_>) {
+  let block = title_block("Log Details");
+  let help_footer = format!(
+    "<↑↓←→> scroll | {}",
+    build_context_clue_string(&BARE_POPUP_CONTEXT_CLUES)
+  );
+
+  if app.data.sonarr_data.log_details.items.is_empty() {
+    let loading = LoadingBlock::new(app.is_loading, borderless_block());
+    let popup = Popup::new(loading)
+      .size(Size::Large)
+      .block(block)
+      .footer(&help_footer);
+
+    f.render_widget(popup, f.area());
+    return;
+  }
+
+  let logs_list = SelectableList::new(&mut app.data.sonarr_data.log_details, |log| {
+    let log_line = log.to_string();
+    let level = log.text.split('|').collect::<Vec<&str>>()[1].to_string();
+
+    style_log_list_item(ListItem::new(Text::from(Span::raw(log_line))), level)
+  })
+  .block(borderless_block());
+  let popup = Popup::new(logs_list)
+    .size(Size::Large)
+    .block(block)
+    .footer(&help_footer);
+
+  f.render_widget(popup, f.area());
+}
+
+fn draw_tasks_popup(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
+  let help_footer = Some(build_context_clue_string(&SYSTEM_TASKS_CONTEXT_CLUES));
+  let tasks_row_mapping = |task: &SonarrTask| {
+    let task_props = extract_task_props(task);
+
+    Row::new(vec![
+      Cell::from(task_props.name),
+      Cell::from(task_props.interval),
+      Cell::from(task_props.last_execution),
+      Cell::from(task_props.next_execution),
+    ])
+    .primary()
+  };
+  let tasks_table = ManagarrTable::new(Some(&mut app.data.sonarr_data.tasks), tasks_row_mapping)
+    .block(borderless_block())
+    .loading(app.is_loading)
+    .margin(1)
+    .footer(help_footer)
+    .footer_alignment(Alignment::Center)
+    .headers(TASK_TABLE_HEADERS)
+    .constraints(TASK_TABLE_CONSTRAINTS);
+
+  f.render_widget(title_block("Tasks"), area);
+  f.render_widget(tasks_table, area);
+
+  if matches!(
+    app.get_current_route(),
+    Route::Sonarr(ActiveSonarrBlock::SystemTaskStartConfirmPrompt, _)
+  ) {
+    let prompt = format!(
+      "Do you want to manually start this task: {}?",
+      app.data.sonarr_data.tasks.current_selection().name
+    );
+    let confirmation_prompt = ConfirmationPrompt::new()
+      .title("Start Task")
+      .prompt(&prompt)
+      .yes_no_value(app.data.sonarr_data.prompt_confirm);
+
+    f.render_widget(
+      Popup::new(confirmation_prompt).size(Size::MediumPrompt),
+      f.area(),
+    );
+  }
+}
+
+fn draw_updates_popup(f: &mut Frame<'_>, app: &mut App<'_>) {
+  let help_footer = format!(
+    "<↑↓> scroll | {}",
+    build_context_clue_string(&BARE_POPUP_CONTEXT_CLUES)
+  );
+  let updates = app.data.sonarr_data.updates.get_text();
+  let block = title_block("Updates");
+
+  if !updates.is_empty() {
+    let updates_paragraph = Paragraph::new(Text::from(updates))
+      .block(borderless_block())
+      .scroll((app.data.sonarr_data.updates.offset, 0));
+    let popup = Popup::new(updates_paragraph)
+      .size(Size::Large)
+      .block(block)
+      .footer(&help_footer);
+
+    f.render_widget(popup, f.area());
+  } else {
+    let loading = LoadingBlock::new(app.is_loading, borderless_block());
+    let popup = Popup::new(loading)
+      .size(Size::Large)
+      .block(block)
+      .footer(&help_footer);
+
+    f.render_widget(popup, f.area());
+  }
+}

src/ui/sonarr_ui/system/system_details_ui_tests.rs

@@ -0,0 +1,21 @@
+#[cfg(test)]
+mod tests {
+  use strum::IntoEnumIterator;
+
+  use crate::models::servarr_data::sonarr::sonarr_data::{
+    ActiveSonarrBlock, SYSTEM_DETAILS_BLOCKS,
+  };
+  use crate::ui::sonarr_ui::system::system_details_ui::SystemDetailsUi;
+  use crate::ui::DrawUi;
+
+  #[test]
+  fn test_system_details_ui_accepts() {
+    ActiveSonarrBlock::iter().for_each(|active_sonarr_block| {
+      if SYSTEM_DETAILS_BLOCKS.contains(&active_sonarr_block) {
+        assert!(SystemDetailsUi::accepts(active_sonarr_block.into()));
+      } else {
+        assert!(!SystemDetailsUi::accepts(active_sonarr_block.into()));
+      }
+    });
+  }
+}

src/ui/sonarr_ui/system/system_ui_tests.rs

@@ -0,0 +1,25 @@
+#[cfg(test)]
+mod tests {
+  use strum::IntoEnumIterator;
+
+  use crate::models::servarr_data::sonarr::sonarr_data::{
+    ActiveSonarrBlock, SYSTEM_DETAILS_BLOCKS,
+  };
+  use crate::ui::sonarr_ui::system::SystemUi;
+  use crate::ui::DrawUi;
+
+  #[test]
+  fn test_system_ui_accepts() {
+    let mut system_ui_blocks = Vec::new();
+    system_ui_blocks.push(ActiveSonarrBlock::System);
+    system_ui_blocks.extend(SYSTEM_DETAILS_BLOCKS);
+
+    ActiveSonarrBlock::iter().for_each(|active_sonarr_block| {
+      if system_ui_blocks.contains(&active_sonarr_block) {
+        assert!(SystemUi::accepts(active_sonarr_block.into()));
+      } else {
+        assert!(!SystemUi::accepts(active_sonarr_block.into()));
+      }
+    });
+  }
+}