#[cfg(test)]
mod tests {
  use crate::app::App;
  use crate::models::stateful_list::StatefulList;
  use crate::models::stateful_table::SortOption;
  use crate::models::{HorizontallyScrollableText, Scrollable};
  use crate::ui::utils::borderless_block;
  use crate::ui::widgets::managarr_table::ManagarrTable;
  use pretty_assertions::assert_eq;
  use ratatui::layout::Constraint;
  use ratatui::text::Text;
  use ratatui::widgets::{Cell, Row};
  use std::sync::atomic::AtomicUsize;

  #[test]
  fn test_managarr_table_new() {
    let items = vec!["item1", "item2", "item3"];
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    );

    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
    assert_eq!(managarr_table.constraints, Vec::new());
    assert_eq!(managarr_table.block, borderless_block());
    assert_eq!(managarr_table.margin, 0);
    assert!(!managarr_table.is_loading);
    assert!(managarr_table.highlight_rows);
    assert!(!managarr_table.is_sorting);
    assert!(!managarr_table.is_searching);
    assert!(!managarr_table.search_produced_empty_results);
    assert!(!managarr_table.is_filtering);
    assert!(!managarr_table.filter_produced_empty_results);
    assert_eq!(managarr_table.search_box_content_length, 0);
    assert_eq!(managarr_table.search_box_offset, 0);
    assert_eq!(managarr_table.filter_box_content_length, 0);
    assert_eq!(managarr_table.filter_box_offset, 0);
  }

  #[test]
  fn test_managarr_table_new_search_box_populated() {
    let items = vec!["item1", "item2", "item3"];
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());
    let horizontally_scrollable_test = HorizontallyScrollableText {
      text: "test".to_owned(),
      offset: AtomicUsize::new(3),
    };
    app.data.radarr_data.movies.search = Some(horizontally_scrollable_test);

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    );

    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
    assert_eq!(managarr_table.constraints, Vec::new());
    assert_eq!(managarr_table.block, borderless_block());
    assert_eq!(managarr_table.margin, 0);
    assert!(!managarr_table.is_loading);
    assert!(managarr_table.highlight_rows);
    assert!(!managarr_table.is_sorting);
    assert!(!managarr_table.is_searching);
    assert!(!managarr_table.search_produced_empty_results);
    assert!(!managarr_table.is_filtering);
    assert!(!managarr_table.filter_produced_empty_results);
    assert_eq!(managarr_table.search_box_content_length, 4);
    assert_eq!(managarr_table.search_box_offset, 3);
    assert_eq!(managarr_table.filter_box_content_length, 0);
    assert_eq!(managarr_table.filter_box_offset, 0);
  }

  #[test]
  fn test_managarr_table_new_filter_box_populated() {
    let items = vec!["item1", "item2", "item3"];
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());
    let horizontally_scrollable_test = HorizontallyScrollableText {
      text: "test".to_owned(),
      offset: AtomicUsize::new(3),
    };
    app.data.radarr_data.movies.filter = Some(horizontally_scrollable_test);

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    );

    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
    assert_eq!(managarr_table.constraints, Vec::new());
    assert_eq!(managarr_table.block, borderless_block());
    assert_eq!(managarr_table.margin, 0);
    assert!(!managarr_table.is_loading);
    assert!(managarr_table.highlight_rows);
    assert!(!managarr_table.is_sorting);
    assert!(!managarr_table.is_searching);
    assert!(!managarr_table.search_produced_empty_results);
    assert!(!managarr_table.is_filtering);
    assert!(!managarr_table.filter_produced_empty_results);
    assert_eq!(managarr_table.search_box_content_length, 0);
    assert_eq!(managarr_table.search_box_offset, 0);
    assert_eq!(managarr_table.filter_box_content_length, 4);
    assert_eq!(managarr_table.filter_box_offset, 3);
  }

  #[test]
  fn test_managarr_table_headers() {
    let items = vec!["item1", "item2", "item3"];
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());
    let headers = ["column 1", "column 2"];

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    )
    .headers(headers);

    assert_eq!(managarr_table.table_headers, headers);
    assert_eq!(managarr_table.constraints, Vec::new());
    assert_eq!(managarr_table.block, borderless_block());
    assert_eq!(managarr_table.margin, 0);
    assert!(!managarr_table.is_loading);
    assert!(managarr_table.highlight_rows);
    assert!(!managarr_table.is_sorting);
    assert!(!managarr_table.is_searching);
    assert!(!managarr_table.search_produced_empty_results);
    assert!(!managarr_table.is_filtering);
    assert!(!managarr_table.filter_produced_empty_results);
    assert_eq!(managarr_table.search_box_content_length, 0);
    assert_eq!(managarr_table.search_box_offset, 0);
    assert_eq!(managarr_table.filter_box_content_length, 0);
    assert_eq!(managarr_table.filter_box_offset, 0);
  }

  #[test]
  fn test_managarr_table_constraints() {
    let items = vec!["item1", "item2", "item3"];
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());
    let constraints = [Constraint::Length(1), Constraint::Fill(1)];

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    )
    .constraints(constraints);

    assert_eq!(managarr_table.constraints, constraints);
    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
    assert_eq!(managarr_table.block, borderless_block());
    assert_eq!(managarr_table.margin, 0);
    assert!(!managarr_table.is_loading);
    assert!(managarr_table.highlight_rows);
    assert!(!managarr_table.is_sorting);
    assert!(!managarr_table.is_searching);
    assert!(!managarr_table.search_produced_empty_results);
    assert!(!managarr_table.is_filtering);
    assert!(!managarr_table.filter_produced_empty_results);
    assert_eq!(managarr_table.search_box_content_length, 0);
    assert_eq!(managarr_table.search_box_offset, 0);
    assert_eq!(managarr_table.filter_box_content_length, 0);
    assert_eq!(managarr_table.filter_box_offset, 0);
  }

  #[test]
  fn test_managarr_table_parse_headers() {
    let items = vec!["item1", "item2", "item3"];
    let mut sort_list = StatefulList::default();
    sort_list.set_items(vec![
      SortOption {
        name: "column 1",
        cmp_fn: None,
      },
      SortOption {
        name: "column 2",
        cmp_fn: None,
      },
    ]);
    sort_list.scroll_down();
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());
    app.data.radarr_data.movies.sort = Some(sort_list);
    let headers = ["column 1", "column 2"];

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    )
    .headers(headers);

    assert_eq!(
      managarr_table.parse_headers(),
      vec![Text::from("column 1"), Text::from("column 2 ▼")]
    );
  }

  #[test]
  fn test_managarr_table_parse_headers_ascending() {
    let items = vec!["item1", "item2", "item3"];
    let mut sort_list = StatefulList::default();
    sort_list.set_items(vec![
      SortOption {
        name: "column 1",
        cmp_fn: None,
      },
      SortOption {
        name: "column 2",
        cmp_fn: None,
      },
    ]);
    sort_list.scroll_down();
    let mut app = App::test_default();
    app.data.radarr_data.movies.set_items(items.clone().into_iter().map(|s| {
      let mut movie = crate::models::radarr_models::Movie::default();
      movie.title = crate::models::HorizontallyScrollableText::from(s);
      movie
    }).collect());
    app.data.radarr_data.movies.sort = Some(sort_list);
    app.data.radarr_data.movies.sort_asc = true;
    let headers = ["column 1", "column 2"];

    let managarr_table = ManagarrTable::new(
      &mut app,
      |app| Some(&mut app.data.radarr_data.movies),
      |movie: &crate::models::radarr_models::Movie| Row::new(vec![Cell::new(movie.title.to_string())]),
    )
    .headers(headers);

    assert_eq!(
      managarr_table.parse_headers(),
      vec![Text::from("column 1"), Text::from("column 2 ▲")]
    );
  }
}