feat(handlers): Support for the episode details popup

src/handlers/sonarr_handlers/library/episode_details_handler.rs

@@ -0,0 +1,359 @@
+use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+use crate::app::App;
+use crate::event::Key;
+use crate::handle_table_events;
+use crate::handlers::sonarr_handlers::library::season_details_handler::releases_sorting_options;
+use crate::handlers::table_handler::TableHandlingConfig;
+use crate::handlers::{handle_prompt_toggle, KeyEventHandler};
+use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, EPISODE_DETAILS_BLOCKS};
+use crate::models::sonarr_models::{SonarrHistoryItem, SonarrRelease, SonarrReleaseDownloadBody};
+use crate::network::sonarr_network::SonarrEvent;
+
+#[cfg(test)]
+#[path = "episode_details_handler_tests.rs"]
+mod episode_details_handler_tests;
+
+pub(super) struct EpisodeDetailsHandler<'a, 'b> {
+  key: Key,
+  app: &'a mut App<'b>,
+  active_sonarr_block: ActiveSonarrBlock,
+  _context: Option<ActiveSonarrBlock>,
+}
+
+impl<'a, 'b> EpisodeDetailsHandler<'a, 'b> {
+  handle_table_events!(
+    self,
+    episode_history,
+    self
+      .app
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_mut()
+      .expect("Season details modal is undefined")
+      .episode_details_modal
+      .as_mut()
+      .expect("Episode details modal is undefined")
+      .episode_history,
+    SonarrHistoryItem
+  );
+  handle_table_events!(
+    self,
+    episode_releases,
+    self
+      .app
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_mut()
+      .expect("Season details modal is undefined")
+      .episode_details_modal
+      .as_mut()
+      .expect("Episode details modal is undefined")
+      .episode_releases,
+    SonarrRelease
+  );
+}
+
+impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for EpisodeDetailsHandler<'a, 'b> {
+  fn handle(&mut self) {
+    let episode_history_table_handling_config =
+      TableHandlingConfig::new(ActiveSonarrBlock::EpisodeHistory.into());
+    let episode_releases_table_handling_config =
+      TableHandlingConfig::new(ActiveSonarrBlock::ManualEpisodeSearch.into())
+        .sorting_block(ActiveSonarrBlock::ManualEpisodeSearchSortPrompt.into())
+        .sort_options(releases_sorting_options());
+
+    if !self.handle_episode_history_table_events(episode_history_table_handling_config)
+      && !self.handle_episode_releases_table_events(episode_releases_table_handling_config)
+    {
+      self.handle_key_event();
+    }
+  }
+
+  fn accepts(active_block: ActiveSonarrBlock) -> bool {
+    EPISODE_DETAILS_BLOCKS.contains(&active_block)
+  }
+
+  fn with(
+    key: Key,
+    app: &'a mut App<'b>,
+    active_sonarr_block: ActiveSonarrBlock,
+    _context: Option<ActiveSonarrBlock>,
+  ) -> Self {
+    Self {
+      key,
+      app,
+      active_sonarr_block,
+      _context,
+    }
+  }
+
+  fn get_key(&self) -> Key {
+    self.key
+  }
+
+  fn is_ready(&self) -> bool {
+    !self.app.is_loading
+      && if let Some(season_details_modal) = self.app.data.sonarr_data.season_details_modal.as_ref()
+      {
+        if let Some(episode_details_modal) = &season_details_modal.episode_details_modal {
+          match self.active_sonarr_block {
+            ActiveSonarrBlock::EpisodeHistory => !episode_details_modal.episode_history.is_empty(),
+            ActiveSonarrBlock::ManualEpisodeSearch => {
+              !episode_details_modal.episode_releases.is_empty()
+            }
+            _ => true,
+          }
+        } else {
+          false
+        }
+      } else {
+        false
+      }
+  }
+
+  fn handle_scroll_up(&mut self) {}
+
+  fn handle_scroll_down(&mut self) {}
+
+  fn handle_home(&mut self) {}
+
+  fn handle_end(&mut self) {}
+
+  fn handle_delete(&mut self) {}
+
+  fn handle_left_right_action(&mut self) {
+    match self.active_sonarr_block {
+      ActiveSonarrBlock::EpisodeDetails
+      | ActiveSonarrBlock::EpisodeHistory
+      | ActiveSonarrBlock::EpisodeFile
+      | ActiveSonarrBlock::ManualEpisodeSearch => match self.key {
+        _ if self.key == DEFAULT_KEYBINDINGS.left.key => {
+          self
+            .app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_mut()
+            .unwrap()
+            .episode_details_modal
+            .as_mut()
+            .unwrap()
+            .episode_details_tabs
+            .previous();
+          self.app.pop_and_push_navigation_stack(
+            self
+              .app
+              .data
+              .sonarr_data
+              .season_details_modal
+              .as_ref()
+              .unwrap()
+              .episode_details_modal
+              .as_ref()
+              .unwrap()
+              .episode_details_tabs
+              .get_active_route(),
+          );
+        }
+        _ if self.key == DEFAULT_KEYBINDINGS.right.key => {
+          self
+            .app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_mut()
+            .unwrap()
+            .episode_details_modal
+            .as_mut()
+            .unwrap()
+            .episode_details_tabs
+            .next();
+          self.app.pop_and_push_navigation_stack(
+            self
+              .app
+              .data
+              .sonarr_data
+              .season_details_modal
+              .as_ref()
+              .unwrap()
+              .episode_details_modal
+              .as_ref()
+              .unwrap()
+              .episode_details_tabs
+              .get_active_route(),
+          );
+        }
+        _ => (),
+      },
+      ActiveSonarrBlock::AutomaticallySearchEpisodePrompt
+      | ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt => {
+        handle_prompt_toggle(self.app, self.key);
+      }
+      _ => (),
+    }
+  }
+
+  fn handle_submit(&mut self) {
+    match self.active_sonarr_block {
+      ActiveSonarrBlock::EpisodeHistory => {
+        self
+          .app
+          .push_navigation_stack(ActiveSonarrBlock::EpisodeHistoryDetails.into());
+      }
+      ActiveSonarrBlock::AutomaticallySearchEpisodePrompt => {
+        if self.app.data.sonarr_data.prompt_confirm {
+          self.app.data.sonarr_data.prompt_confirm_action =
+            Some(SonarrEvent::TriggerAutomaticEpisodeSearch(None));
+        }
+
+        self.app.pop_navigation_stack();
+      }
+      ActiveSonarrBlock::ManualEpisodeSearch => {
+        self
+          .app
+          .push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt.into());
+      }
+      ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt => {
+        if self.app.data.sonarr_data.prompt_confirm {
+          let SonarrRelease {
+            guid, indexer_id, ..
+          } = self
+            .app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_ref()
+            .unwrap()
+            .episode_details_modal
+            .as_ref()
+            .unwrap()
+            .episode_releases
+            .current_selection();
+          let episode_id = self
+            .app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_ref()
+            .unwrap()
+            .episodes
+            .current_selection()
+            .id;
+          let params = SonarrReleaseDownloadBody {
+            guid: guid.clone(),
+            indexer_id: *indexer_id,
+            episode_id: Some(episode_id),
+            ..SonarrReleaseDownloadBody::default()
+          };
+          self.app.data.sonarr_data.prompt_confirm_action =
+            Some(SonarrEvent::DownloadRelease(params));
+        }
+
+        self.app.pop_navigation_stack();
+      }
+      _ => (),
+    }
+  }
+
+  fn handle_esc(&mut self) {
+    match self.active_sonarr_block {
+      ActiveSonarrBlock::EpisodeDetails
+      | ActiveSonarrBlock::EpisodeFile
+      | ActiveSonarrBlock::EpisodeHistory
+      | ActiveSonarrBlock::ManualEpisodeSearch => {
+        self.app.pop_navigation_stack();
+        self
+          .app
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_mut()
+          .unwrap()
+          .episode_details_modal = None;
+      }
+      ActiveSonarrBlock::EpisodeHistoryDetails => {
+        self.app.pop_navigation_stack();
+      }
+      ActiveSonarrBlock::AutomaticallySearchEpisodePrompt
+      | ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt => {
+        self.app.pop_navigation_stack();
+        self.app.data.sonarr_data.prompt_confirm = false;
+      }
+      _ => (),
+    }
+  }
+
+  fn handle_char_key_event(&mut self) {
+    let key = self.key;
+    match self.active_sonarr_block {
+      ActiveSonarrBlock::EpisodeDetails
+      | ActiveSonarrBlock::EpisodeHistory
+      | ActiveSonarrBlock::EpisodeFile
+      | ActiveSonarrBlock::ManualEpisodeSearch => match self.key {
+        _ if self.key == DEFAULT_KEYBINDINGS.refresh.key => {
+          self
+            .app
+            .pop_and_push_navigation_stack(self.active_sonarr_block.into());
+        }
+        _ if self.key == DEFAULT_KEYBINDINGS.auto_search.key => {
+          self
+            .app
+            .push_navigation_stack(ActiveSonarrBlock::AutomaticallySearchEpisodePrompt.into());
+        }
+        _ => (),
+      },
+      ActiveSonarrBlock::AutomaticallySearchEpisodePrompt
+        if key == DEFAULT_KEYBINDINGS.confirm.key =>
+      {
+        self.app.data.sonarr_data.prompt_confirm = true;
+        self.app.data.sonarr_data.prompt_confirm_action =
+          Some(SonarrEvent::TriggerAutomaticEpisodeSearch(None));
+
+        self.app.pop_navigation_stack();
+      }
+      ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt
+        if key == DEFAULT_KEYBINDINGS.confirm.key =>
+      {
+        if self.app.data.sonarr_data.prompt_confirm {
+          let SonarrRelease {
+            guid, indexer_id, ..
+          } = self
+            .app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_ref()
+            .unwrap()
+            .episode_details_modal
+            .as_ref()
+            .unwrap()
+            .episode_releases
+            .current_selection();
+          let episode_id = self
+            .app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_ref()
+            .unwrap()
+            .episodes
+            .current_selection()
+            .id;
+          let params = SonarrReleaseDownloadBody {
+            guid: guid.clone(),
+            indexer_id: *indexer_id,
+            episode_id: Some(episode_id),
+            ..SonarrReleaseDownloadBody::default()
+          };
+          self.app.data.sonarr_data.prompt_confirm_action =
+            Some(SonarrEvent::DownloadRelease(params));
+        }
+
+        self.app.pop_navigation_stack();
+      }
+      _ => (),
+    }
+  }
+}

src/handlers/sonarr_handlers/library/episode_details_handler_tests.rs

@@ -0,0 +1,771 @@
+#[cfg(test)]
+mod tests {
+  use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+  use crate::app::App;
+  use crate::handlers::sonarr_handlers::library::episode_details_handler::EpisodeDetailsHandler;
+  use crate::handlers::KeyEventHandler;
+  use crate::models::servarr_data::sonarr::modals::EpisodeDetailsModal;
+  use crate::models::servarr_data::sonarr::sonarr_data::sonarr_test_utils::utils::create_test_sonarr_data;
+  use crate::models::servarr_data::sonarr::sonarr_data::{
+    ActiveSonarrBlock, EPISODE_DETAILS_BLOCKS,
+  };
+  use crate::models::sonarr_models::SonarrReleaseDownloadBody;
+  use crate::models::stateful_table::StatefulTable;
+  use rstest::rstest;
+  use strum::IntoEnumIterator;
+
+  mod test_handle_left_right_actions {
+    use super::*;
+    use crate::event::Key;
+    use pretty_assertions::assert_eq;
+    use rstest::rstest;
+
+    #[rstest]
+    fn test_left_right_prompt_toggle(
+      #[values(
+        ActiveSonarrBlock::AutomaticallySearchEpisodePrompt,
+        ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+      #[values(Key::Left, Key::Right)] key: Key,
+    ) {
+      let mut app = App::default();
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+
+      EpisodeDetailsHandler::with(key, &mut app, active_sonarr_block, None).handle();
+
+      assert!(app.data.sonarr_data.prompt_confirm);
+
+      EpisodeDetailsHandler::with(key, &mut app, active_sonarr_block, None).handle();
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+    }
+
+    #[rstest]
+    #[case(ActiveSonarrBlock::EpisodeDetails, ActiveSonarrBlock::EpisodeHistory)]
+    #[case(ActiveSonarrBlock::EpisodeHistory, ActiveSonarrBlock::EpisodeFile)]
+    #[case(ActiveSonarrBlock::EpisodeFile, ActiveSonarrBlock::ManualEpisodeSearch)]
+    #[case(
+      ActiveSonarrBlock::ManualEpisodeSearch,
+      ActiveSonarrBlock::EpisodeDetails
+    )]
+    fn test_episode_details_tabs_left_right_action(
+      #[case] left_block: ActiveSonarrBlock,
+      #[case] right_block: ActiveSonarrBlock,
+      #[values(true, false)] is_ready: bool,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(ActiveSonarrBlock::SeasonDetails.into());
+      app.is_loading = is_ready;
+      app.push_navigation_stack(right_block.into());
+      app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_mut()
+        .unwrap()
+        .episode_details_modal
+        .as_mut()
+        .unwrap()
+        .episode_details_tabs
+        .index = app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_tabs
+        .tabs
+        .iter()
+        .position(|tab_route| tab_route.route == right_block.into())
+        .unwrap_or_default();
+
+      EpisodeDetailsHandler::with(DEFAULT_KEYBINDINGS.left.key, &mut app, right_block, None)
+        .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        app
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_tabs
+          .get_active_route()
+      );
+      assert_eq!(app.get_current_route(), left_block.into());
+
+      EpisodeDetailsHandler::with(DEFAULT_KEYBINDINGS.right.key, &mut app, left_block, None)
+        .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        app
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_tabs
+          .get_active_route()
+      );
+      assert_eq!(app.get_current_route(), right_block.into());
+    }
+  }
+
+  mod test_handle_submit {
+    use super::*;
+    use crate::event::Key;
+    use crate::models::stateful_table::StatefulTable;
+    use crate::network::sonarr_network::SonarrEvent;
+    use pretty_assertions::assert_eq;
+
+    const SUBMIT_KEY: Key = DEFAULT_KEYBINDINGS.submit.key;
+
+    #[test]
+    fn test_episode_history_submit() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+
+      EpisodeDetailsHandler::with(
+        SUBMIT_KEY,
+        &mut app,
+        ActiveSonarrBlock::EpisodeHistory,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::EpisodeHistoryDetails.into()
+      );
+    }
+
+    #[test]
+    fn test_episode_history_submit_no_op_when_episode_history_is_empty() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_mut()
+        .unwrap()
+        .episode_details_modal
+        .as_mut()
+        .unwrap()
+        .episode_history = StatefulTable::default();
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeHistory.into());
+
+      EpisodeDetailsHandler::with(
+        SUBMIT_KEY,
+        &mut app,
+        ActiveSonarrBlock::EpisodeHistory,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::EpisodeHistory.into()
+      );
+    }
+
+    #[test]
+    fn test_episode_history_submit_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeHistory.into());
+
+      EpisodeDetailsHandler::with(
+        SUBMIT_KEY,
+        &mut app,
+        ActiveSonarrBlock::EpisodeHistory,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::EpisodeHistory.into()
+      );
+    }
+
+    #[rstest]
+    #[case(
+      ActiveSonarrBlock::AutomaticallySearchEpisodePrompt,
+      SonarrEvent::TriggerAutomaticEpisodeSearch(None)
+    )]
+    fn test_episode_details_prompt_confirm_submit(
+      #[case] prompt_block: ActiveSonarrBlock,
+      #[case] expected_action: SonarrEvent,
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.data.sonarr_data.prompt_confirm = true;
+      app.push_navigation_stack(active_sonarr_block.into());
+      app.push_navigation_stack(prompt_block.into());
+
+      EpisodeDetailsHandler::with(SUBMIT_KEY, &mut app, prompt_block, None).handle();
+
+      assert!(app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.get_current_route(), active_sonarr_block.into());
+      assert_eq!(
+        app.data.sonarr_data.prompt_confirm_action,
+        Some(expected_action)
+      );
+    }
+
+    #[test]
+    fn test_manual_episode_search_confirm_prompt_confirm_submit() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.data.sonarr_data.prompt_confirm = true;
+      app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearch.into());
+      app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt.into());
+
+      EpisodeDetailsHandler::with(
+        SUBMIT_KEY,
+        &mut app,
+        ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt,
+        None,
+      )
+      .handle();
+
+      assert!(app.data.sonarr_data.prompt_confirm);
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::ManualEpisodeSearch.into()
+      );
+      assert_eq!(
+        app.data.sonarr_data.prompt_confirm_action,
+        Some(SonarrEvent::DownloadRelease(SonarrReleaseDownloadBody {
+          guid: String::new(),
+          indexer_id: 0,
+          episode_id: Some(0),
+          ..SonarrReleaseDownloadBody::default()
+        }))
+      );
+    }
+
+    #[rstest]
+    fn test_episode_details_prompt_decline_submit(
+      #[values(
+        ActiveSonarrBlock::AutomaticallySearchEpisodePrompt,
+        ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt
+      )]
+      prompt_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+      app.push_navigation_stack(prompt_block.into());
+
+      EpisodeDetailsHandler::with(SUBMIT_KEY, &mut app, prompt_block, None).handle();
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::EpisodeDetails.into()
+      );
+      assert_eq!(app.data.sonarr_data.prompt_confirm_action, None);
+    }
+
+    #[test]
+    fn test_manual_episode_search_submit() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearch.into());
+
+      EpisodeDetailsHandler::with(
+        SUBMIT_KEY,
+        &mut app,
+        ActiveSonarrBlock::ManualEpisodeSearch,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt.into()
+      );
+    }
+
+    #[test]
+    fn test_manual_episode_search_submit_no_op_when_not_ready() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.is_loading = true;
+      app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearch.into());
+
+      EpisodeDetailsHandler::with(
+        SUBMIT_KEY,
+        &mut app,
+        ActiveSonarrBlock::ManualEpisodeSearch,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::ManualEpisodeSearch.into()
+      );
+    }
+  }
+
+  mod test_handle_esc {
+    use super::*;
+    use crate::event::Key;
+    use pretty_assertions::assert_eq;
+
+    const ESC_KEY: Key = DEFAULT_KEYBINDINGS.esc.key;
+
+    #[test]
+    fn test_episode_history_details_block_esc() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeHistory.into());
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeHistoryDetails.into());
+
+      EpisodeDetailsHandler::with(
+        ESC_KEY,
+        &mut app,
+        ActiveSonarrBlock::EpisodeHistoryDetails,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::EpisodeHistory.into()
+      );
+    }
+
+    #[rstest]
+    fn test_episode_details_prompts_esc(
+      #[values(
+        ActiveSonarrBlock::AutomaticallySearchEpisodePrompt,
+        ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt
+      )]
+      prompt_block: ActiveSonarrBlock,
+      #[values(true, false)] is_ready: bool,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.is_loading = is_ready;
+      app.data.sonarr_data.prompt_confirm = true;
+      app.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+      app.push_navigation_stack(prompt_block.into());
+
+      EpisodeDetailsHandler::with(ESC_KEY, &mut app, prompt_block, None).handle();
+
+      assert!(!app.data.sonarr_data.prompt_confirm);
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::EpisodeDetails.into()
+      );
+    }
+
+    #[rstest]
+    fn test_episode_details_tabs_esc(
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(ActiveSonarrBlock::SeasonDetails.into());
+      app.push_navigation_stack(active_sonarr_block.into());
+
+      EpisodeDetailsHandler::with(ESC_KEY, &mut app, active_sonarr_block, None).handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::SeasonDetails.into()
+      );
+      assert!(app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_modal
+        .is_none());
+    }
+  }
+
+  mod test_handle_key_char {
+    use super::*;
+    use crate::models::servarr_data::sonarr::sonarr_data::sonarr_test_utils::utils::create_test_sonarr_data;
+    use crate::network::sonarr_network::SonarrEvent;
+    use pretty_assertions::assert_eq;
+
+    #[rstest]
+    fn test_auto_search_key(
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(active_sonarr_block.into());
+
+      EpisodeDetailsHandler::with(
+        DEFAULT_KEYBINDINGS.auto_search.key,
+        &mut app,
+        active_sonarr_block,
+        None,
+      )
+      .handle();
+
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::AutomaticallySearchEpisodePrompt.into()
+      );
+    }
+
+    #[rstest]
+    fn test_auto_search_key_no_op_when_not_ready(
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.is_loading = true;
+      app.push_navigation_stack(active_sonarr_block.into());
+
+      EpisodeDetailsHandler::with(
+        DEFAULT_KEYBINDINGS.auto_search.key,
+        &mut app,
+        active_sonarr_block,
+        None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), active_sonarr_block.into());
+    }
+
+    #[rstest]
+    fn test_refresh_key(
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.push_navigation_stack(active_sonarr_block.into());
+      app.is_routing = false;
+
+      EpisodeDetailsHandler::with(
+        DEFAULT_KEYBINDINGS.refresh.key,
+        &mut app,
+        active_sonarr_block,
+        None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), active_sonarr_block.into());
+      assert!(app.is_routing);
+    }
+
+    #[rstest]
+    fn test_refresh_key_no_op_when_not_ready(
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.is_loading = true;
+      app.push_navigation_stack(active_sonarr_block.into());
+      app.is_routing = false;
+
+      EpisodeDetailsHandler::with(
+        DEFAULT_KEYBINDINGS.refresh.key,
+        &mut app,
+        active_sonarr_block,
+        None,
+      )
+      .handle();
+
+      assert_eq!(app.get_current_route(), active_sonarr_block.into());
+      assert!(!app.is_routing);
+    }
+
+    #[rstest]
+    fn test_episode_details_prompt_confirm_confirm_key(
+      #[values(
+        ActiveSonarrBlock::EpisodeDetails,
+        ActiveSonarrBlock::EpisodeHistory,
+        ActiveSonarrBlock::EpisodeFile,
+        ActiveSonarrBlock::ManualEpisodeSearch
+      )]
+      active_sonarr_block: ActiveSonarrBlock,
+    ) {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.data.sonarr_data.prompt_confirm = true;
+      app.push_navigation_stack(active_sonarr_block.into());
+      app.push_navigation_stack(ActiveSonarrBlock::AutomaticallySearchEpisodePrompt.into());
+
+      EpisodeDetailsHandler::with(
+        DEFAULT_KEYBINDINGS.confirm.key,
+        &mut app,
+        ActiveSonarrBlock::AutomaticallySearchEpisodePrompt,
+        None,
+      )
+      .handle();
+
+      assert!(app.data.sonarr_data.prompt_confirm);
+      assert_eq!(app.get_current_route(), active_sonarr_block.into());
+      assert_eq!(
+        app.data.sonarr_data.prompt_confirm_action,
+        Some(SonarrEvent::TriggerAutomaticEpisodeSearch(None))
+      );
+    }
+
+    #[test]
+    fn test_episode_details_manual_search_confirm_prompt_confirm_confirm_key() {
+      let mut app = App::default();
+      app.data.sonarr_data = create_test_sonarr_data();
+      app.data.sonarr_data.prompt_confirm = true;
+      app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearch.into());
+      app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt.into());
+
+      EpisodeDetailsHandler::with(
+        DEFAULT_KEYBINDINGS.confirm.key,
+        &mut app,
+        ActiveSonarrBlock::ManualEpisodeSearchConfirmPrompt,
+        None,
+      )
+        .handle();
+
+      assert!(app.data.sonarr_data.prompt_confirm);
+      assert_eq!(
+        app.get_current_route(),
+        ActiveSonarrBlock::ManualEpisodeSearch.into()
+      );
+      assert_eq!(
+        app.data.sonarr_data.prompt_confirm_action,
+        Some(SonarrEvent::DownloadRelease(SonarrReleaseDownloadBody {
+          guid: String::new(),
+          indexer_id: 0,
+          episode_id: Some(0),
+          ..SonarrReleaseDownloadBody::default()
+        }))
+      );
+    }
+  }
+
+  #[test]
+  fn test_episode_details_handler_accepts() {
+    ActiveSonarrBlock::iter().for_each(|active_sonarr_block| {
+      if EPISODE_DETAILS_BLOCKS.contains(&active_sonarr_block) {
+        assert!(EpisodeDetailsHandler::accepts(active_sonarr_block));
+      } else {
+        assert!(!EpisodeDetailsHandler::accepts(active_sonarr_block));
+      }
+    });
+  }
+
+  #[test]
+  fn test_episode_details_handler_is_not_ready_when_loading() {
+    let mut app = App::default();
+    app.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+    app.is_loading = true;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveSonarrBlock::EpisodeDetails,
+      None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_episode_details_handler_is_not_ready_when_season_details_modal_is_empty() {
+    let mut app = App::default();
+    app.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+    app.is_loading = false;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveSonarrBlock::EpisodeDetails,
+      None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_episode_details_handler_is_not_ready_when_episode_details_modal_is_empty() {
+    let mut app = App::default();
+    app.data.sonarr_data = create_test_sonarr_data();
+    app
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_mut()
+      .unwrap()
+      .episode_details_modal = None;
+    app.push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+    app.is_loading = false;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveSonarrBlock::EpisodeDetails,
+      None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_episode_details_handler_is_not_ready_when_episode_history_table_is_empty() {
+    let mut app = App::default();
+    app.data.sonarr_data = create_test_sonarr_data();
+    app
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_mut()
+      .unwrap()
+      .episode_details_modal
+      .as_mut()
+      .unwrap()
+      .episode_history = StatefulTable::default();
+    app.push_navigation_stack(ActiveSonarrBlock::EpisodeHistory.into());
+    app.is_loading = false;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveSonarrBlock::EpisodeHistory,
+      None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[test]
+  fn test_episode_details_handler_is_not_ready_when_episode_releases_table_is_empty() {
+    let mut app = App::default();
+    app.data.sonarr_data = create_test_sonarr_data();
+    app
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_mut()
+      .unwrap()
+      .episode_details_modal
+      .as_mut()
+      .unwrap()
+      .episode_releases = StatefulTable::default();
+    app.push_navigation_stack(ActiveSonarrBlock::ManualEpisodeSearch.into());
+    app.is_loading = false;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      ActiveSonarrBlock::ManualEpisodeSearch,
+      None,
+    );
+
+    assert!(!handler.is_ready());
+  }
+
+  #[rstest]
+  fn test_episode_details_handler_is_ready_with_empty_tables_for_details_and_file_routes(
+    #[values(ActiveSonarrBlock::EpisodeDetails, ActiveSonarrBlock::EpisodeFile)]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::default();
+    app.data.sonarr_data = create_test_sonarr_data();
+    app
+      .data
+      .sonarr_data
+      .season_details_modal
+      .as_mut()
+      .unwrap()
+      .episode_details_modal = Some(EpisodeDetailsModal::default());
+    app.push_navigation_stack(active_sonarr_block.into());
+    app.is_loading = false;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      active_sonarr_block,
+      None,
+    );
+
+    assert!(handler.is_ready());
+  }
+
+  #[rstest]
+  fn test_episode_details_handler_is_ready(
+    #[values(
+      ActiveSonarrBlock::EpisodeDetails,
+      ActiveSonarrBlock::EpisodeFile,
+      ActiveSonarrBlock::EpisodeHistory,
+      ActiveSonarrBlock::ManualEpisodeSearch
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    let mut app = App::default();
+    app.data.sonarr_data = create_test_sonarr_data();
+    app.push_navigation_stack(active_sonarr_block.into());
+    app.is_loading = false;
+
+    let handler = EpisodeDetailsHandler::with(
+      DEFAULT_KEYBINDINGS.esc.key,
+      &mut app,
+      active_sonarr_block,
+      None,
+    );
+
+    assert!(handler.is_ready());
+  }
+}

src/handlers/sonarr_handlers/library/library_handler_tests.rs

@@ -10,7 +10,7 @@ mod tests {
   use crate::event::Key;
   use crate::handlers::sonarr_handlers::library::{series_sorting_options, LibraryHandler};
   use crate::handlers::KeyEventHandler;
-  use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, ADD_SERIES_BLOCKS, DELETE_SERIES_BLOCKS, EDIT_SERIES_BLOCKS, LIBRARY_BLOCKS, SEASON_DETAILS_BLOCKS, SERIES_DETAILS_BLOCKS};
+  use crate::models::servarr_data::sonarr::sonarr_data::{ActiveSonarrBlock, ADD_SERIES_BLOCKS, DELETE_SERIES_BLOCKS, EDIT_SERIES_BLOCKS, EPISODE_DETAILS_BLOCKS, LIBRARY_BLOCKS, SEASON_DETAILS_BLOCKS, SERIES_DETAILS_BLOCKS};
   use crate::models::sonarr_models::{Series, SeriesStatus, SeriesType};
   use crate::test_handler_delegation;
 
@@ -567,6 +567,26 @@ mod tests {
     );
   }
 
+  #[rstest]
+  fn test_delegates_episode_details_blocks_to_season_details_handler(
+    #[values(
+      ActiveSonarrBlock::EpisodeDetails,
+      ActiveSonarrBlock::EpisodeHistory,
+      ActiveSonarrBlock::AutomaticallySearchEpisodePrompt,
+      ActiveSonarrBlock::EpisodeHistoryDetails,
+      ActiveSonarrBlock::ManualEpisodeSearch,
+      ActiveSonarrBlock::ManualEpisodeSearchSortPrompt,
+      ActiveSonarrBlock::DeleteEpisodeFilePrompt,
+    )]
+    active_sonarr_block: ActiveSonarrBlock,
+  ) {
+    test_handler_delegation!(
+      LibraryHandler,
+      ActiveSonarrBlock::Series,
+      active_sonarr_block
+    );
+  }
+
   #[rstest]
   fn test_delegates_edit_series_blocks_to_edit_series_handler(
     #[values(
@@ -793,6 +813,7 @@ mod tests {
     library_handler_blocks.extend(EDIT_SERIES_BLOCKS);
     library_handler_blocks.extend(SERIES_DETAILS_BLOCKS);
     library_handler_blocks.extend(SEASON_DETAILS_BLOCKS);
+    library_handler_blocks.extend(EPISODE_DETAILS_BLOCKS);
 
     ActiveSonarrBlock::iter().for_each(|active_sonarr_block| {
       if library_handler_blocks.contains(&active_sonarr_block) {

src/handlers/sonarr_handlers/library/mod.rs

@@ -22,6 +22,7 @@ use crate::{
 
 use super::handle_change_tab_left_right_keys;
 use crate::app::key_binding::DEFAULT_KEYBINDINGS;
+use crate::handlers::sonarr_handlers::library::episode_details_handler::EpisodeDetailsHandler;
 use crate::handlers::sonarr_handlers::library::season_details_handler::SeasonDetailsHandler;
 use crate::handlers::sonarr_handlers::library::series_details_handler::SeriesDetailsHandler;
 use crate::handlers::table_handler::TableHandlingConfig;
@@ -34,6 +35,7 @@ mod delete_series_handler;
 mod library_handler_tests;
 mod series_details_handler;
 mod season_details_handler;
+mod episode_details_handler;
 
 pub(super) struct LibraryHandler<'a, 'b> {
   key: Key,
@@ -81,6 +83,10 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for LibraryHandler<'a, '
           SeasonDetailsHandler::with(self.key, self.app, self.active_sonarr_block, self.context)
             .handle();
         }
+        _ if EpisodeDetailsHandler::accepts(self.active_sonarr_block) => {
+          EpisodeDetailsHandler::with(self.key, self.app, self.active_sonarr_block, self.context)
+            .handle();
+        }
         _ => self.handle_key_event(),
       }
     }
@@ -92,6 +98,7 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for LibraryHandler<'a, '
       || EditSeriesHandler::accepts(active_block)
       || SeriesDetailsHandler::accepts(active_block)
       || SeasonDetailsHandler::accepts(active_block)
+      || EpisodeDetailsHandler::accepts(active_block)
       || LIBRARY_BLOCKS.contains(&active_block)
   }
 

src/handlers/sonarr_handlers/library/season_details_handler.rs

@@ -409,7 +409,7 @@ impl<'a, 'b> KeyEventHandler<'a, 'b, ActiveSonarrBlock> for SeasonDetailsHandler
   }
 }
 
-fn releases_sorting_options() -> Vec<SortOption<SonarrRelease>> {
+pub(in crate::handlers::sonarr_handlers::library) fn releases_sorting_options() -> Vec<SortOption<SonarrRelease>> {
   vec![
     SortOption {
       name: "Source",

src/network/sonarr_network.rs

@@ -1542,6 +1542,28 @@ impl<'a, 'b> Network<'a, 'b> {
 
     self
       .handle_request::<(), Episode>(request_props, |episode_response, mut app| {
+        if app.cli_mode {
+          app.data.sonarr_data.season_details_modal = Some(SeasonDetailsModal::default());
+        }
+
+        if app
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_mut()
+          .expect("Season details modal is empty")
+          .episode_details_modal
+          .is_none()
+        {
+          app
+            .data
+            .sonarr_data
+            .season_details_modal
+            .as_mut()
+            .unwrap()
+            .episode_details_modal = Some(EpisodeDetailsModal::default());
+        }
+        
         let Episode {
           id,
           title,
@@ -1559,8 +1581,8 @@ impl<'a, 'b> Network<'a, 'b> {
         } else {
           String::new()
         };
-        let mut episode_details_modal = EpisodeDetailsModal {
+        let episode_details_modal = app.data.sonarr_data.season_details_modal.as_mut().unwrap().episode_details_modal.as_mut().unwrap();
-          episode_details: ScrollableText::with_string(formatdoc!(
+          episode_details_modal.episode_details = ScrollableText::with_string(formatdoc!(
             "
             Title: {}
             Season: {season_number}
@@ -1570,9 +1592,7 @@ impl<'a, 'b> Network<'a, 'b> {
             Description: {}",
             title,
             overview.unwrap_or_default(),
-          )),
+          ));
-          ..EpisodeDetailsModal::default()
-        };
         if let Some(file) = episode_file {
           let size = convert_to_gb(file.size);
           episode_details_modal.file_details = formatdoc!(
@@ -1624,16 +1644,6 @@ impl<'a, 'b> Network<'a, 'b> {
             );
           }
         };
-
-        if !app.cli_mode {
-          app
-            .data
-            .sonarr_data
-            .season_details_modal
-            .as_mut()
-            .expect("Season details modal is empty")
-            .episode_details_modal = Some(episode_details_modal);
-        }
       })
       .await
   }

src/network/sonarr_network_tests.rs

@@ -3147,6 +3147,122 @@ mod test {
 
   #[tokio::test]
   async fn test_handle_get_episode_details_event() {
+    let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
+    let (async_server, app_arc, _server) = mock_servarr_api(
+      RequestMethod::Get,
+      None,
+      Some(serde_json::from_str(EPISODE_JSON).unwrap()),
+      None,
+      SonarrEvent::GetEpisodeDetails(None),
+      Some("/1"),
+      None,
+    )
+    .await;
+    let mut episode_details_modal = EpisodeDetailsModal::default();
+    episode_details_modal.episode_details_tabs.next();
+    let mut season_details_modal = SeasonDetailsModal::default();
+    season_details_modal.episodes.set_items(vec![episode()]);
+    season_details_modal.episode_details_modal = Some(episode_details_modal);
+    app_arc.lock().await.data.sonarr_data.season_details_modal = Some(season_details_modal);
+    app_arc
+      .lock()
+      .await
+      .push_navigation_stack(ActiveSonarrBlock::EpisodeDetails.into());
+    let mut network = Network::new(&app_arc, CancellationToken::new(), Client::new());
+
+    if let SonarrSerdeable::Episode(episode) = network
+      .handle_sonarr_event(SonarrEvent::GetEpisodeDetails(None))
+      .await
+      .unwrap()
+    {
+      async_server.assert_async().await;
+      assert!(app_arc
+        .lock()
+        .await
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_modal
+        .is_some());
+      assert_eq!(
+        app_arc
+          .lock()
+          .await
+          .data
+          .sonarr_data
+          .season_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_modal
+          .as_ref()
+          .unwrap()
+          .episode_details_tabs
+          .get_active_route(),
+        ActiveSonarrBlock::EpisodeHistory.into()
+      );
+      assert_eq!(episode, response);
+
+      let app = app_arc.lock().await;
+      let episode_details_modal = app
+        .data
+        .sonarr_data
+        .season_details_modal
+        .as_ref()
+        .unwrap()
+        .episode_details_modal
+        .as_ref()
+        .unwrap();
+      assert_str_eq!(
+        episode_details_modal.episode_details.get_text(),
+        formatdoc!(
+          "Title: Something cool
+          Season: 1
+          Episode Number: 1
+          Air Date: 2024-02-10 07:28:45 UTC
+          Status: Downloaded
+          Description: Okay so this one time at band camp..."
+        )
+      );
+      assert_str_eq!(
+        episode_details_modal.file_details,
+        formatdoc!(
+          "Relative Path: /season 1/episode 1.mkv
+          Absolute Path: /nfs/tv/series/season 1/episode 1.mkv
+          Size: 3.30 GB
+          Language: English
+          Date Added: 2024-02-10 07:28:45 UTC"
+        )
+      );
+      assert_str_eq!(
+        episode_details_modal.audio_details,
+        formatdoc!(
+          "Bitrate: 0
+          Channels: 7.1
+          Codec: AAC
+          Languages: eng
+          Stream Count: 1"
+        )
+      );
+      assert_str_eq!(
+        episode_details_modal.video_details,
+        formatdoc!(
+          "Bit Depth: 10
+          Bitrate: 0
+          Codec: x265
+          FPS: 23.976
+          Resolution: 1920x1080
+          Scan Type: Progressive
+          Runtime: 23:51
+          Subtitles: English"
+        )
+      );
+    }
+  }
+
+  #[tokio::test]
+  async fn test_handle_get_episode_details_event_empty_episode_details_modal() {
     let response: Episode = serde_json::from_str(EPISODE_JSON).unwrap();
     let (async_server, app_arc, _server) = mock_servarr_api(
       RequestMethod::Get,