use std::iter;

use ratatui::layout::{Alignment, Constraint, Layout, Rect};
use ratatui::style::{Style, Stylize};
use ratatui::text::{Line, Span, Text};
use ratatui::widgets::{Cell, ListItem, Paragraph, Row, Wrap};
use ratatui::Frame;

use crate::app::App;
use crate::models::radarr_models::{Credit, MovieHistoryItem, Release, ReleaseField};
use crate::models::servarr_data::radarr::radarr_data::{ActiveRadarrBlock, MOVIE_DETAILS_BLOCKS};
use crate::models::Route;
use crate::ui::radarr_ui::library::draw_library;
use crate::ui::styles::ManagarrStyle;
use crate::ui::utils::{
  borderless_block, get_width_from_percentage, layout_block_bottom_border, layout_block_top_border,
};
use crate::ui::{
  draw_drop_down_popup, draw_large_popup_over, draw_prompt_box, draw_prompt_box_with_content,
  draw_prompt_popup_over, draw_selectable_list, draw_small_popup_over, draw_table, draw_tabs,
  loading, DrawUi, TableProps,
};
use crate::utils::convert_to_gb;

#[cfg(test)]
#[path = "movie_details_ui_tests.rs"]
mod movie_details_ui_tests;

pub(super) struct MovieDetailsUi;

impl DrawUi for MovieDetailsUi {
  fn accepts(route: Route) -> bool {
    if let Route::Radarr(active_radarr_block, _) = route {
      return MOVIE_DETAILS_BLOCKS.contains(&active_radarr_block);
    }

    false
  }

  fn draw(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
    if let Route::Radarr(active_radarr_block, context_option) = *app.get_current_route() {
      let draw_movie_info_popup = |f: &mut Frame<'_>, app: &mut App<'_>, popup_area: Rect| {
        let content_area = draw_tabs(
          f,
          popup_area,
          "Movie Info",
          &app.data.radarr_data.movie_info_tabs,
        );

        match context_option.unwrap_or(active_radarr_block) {
          ActiveRadarrBlock::AutomaticallySearchMoviePrompt => draw_prompt_popup_over(
            f,
            app,
            content_area,
            draw_movie_info,
            draw_search_movie_prompt,
          ),
          ActiveRadarrBlock::UpdateAndScanPrompt => draw_prompt_popup_over(
            f,
            app,
            content_area,
            draw_movie_info,
            draw_update_and_scan_prompt,
          ),
          ActiveRadarrBlock::ManualSearchSortPrompt => draw_drop_down_popup(
            f,
            app,
            content_area,
            draw_movie_info,
            |f, app, content_area| {
              draw_selectable_list(
                f,
                content_area,
                &mut app
                  .data
                  .radarr_data
                  .movie_details_modal
                  .as_mut()
                  .unwrap()
                  .movie_releases_sort,
                |sort_option| ListItem::new(sort_option.to_string()),
              )
            },
          ),
          ActiveRadarrBlock::ManualSearchConfirmPrompt => draw_small_popup_over(
            f,
            app,
            content_area,
            draw_movie_info,
            draw_manual_search_confirm_prompt,
          ),
          _ => draw_movie_info(f, app, content_area),
        }
      };

      draw_large_popup_over(f, app, area, draw_library, draw_movie_info_popup);
    }
  }
}

fn draw_movie_info(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  if let Route::Radarr(active_radarr_block, _) =
    app.data.radarr_data.movie_info_tabs.get_active_route()
  {
    match active_radarr_block {
      ActiveRadarrBlock::FileInfo => draw_file_info(f, app, area),
      ActiveRadarrBlock::MovieDetails => draw_movie_details(f, app, area),
      ActiveRadarrBlock::MovieHistory => draw_movie_history(f, app, area),
      ActiveRadarrBlock::Cast => draw_movie_cast(f, app, area),
      ActiveRadarrBlock::Crew => draw_movie_crew(f, app, area),
      ActiveRadarrBlock::ManualSearch => draw_movie_releases(f, app, area),
      _ => (),
    }
  }
}

fn draw_search_movie_prompt(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  draw_prompt_box(
    f,
    area,
    "Automatic Movie Search",
    format!(
      "Do you want to trigger an automatic search of your indexers for the movie: {}?",
      app.data.radarr_data.movies.current_selection().title
    )
    .as_str(),
    app.data.radarr_data.prompt_confirm,
  );
}

fn draw_update_and_scan_prompt(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  draw_prompt_box(
    f,
    area,
    "Update and Scan",
    format!(
      "Do you want to trigger an update and disk scan for the movie: {}?",
      app.data.radarr_data.movies.current_selection().title
    )
    .as_str(),
    app.data.radarr_data.prompt_confirm,
  );
}

fn draw_file_info(f: &mut Frame<'_>, app: &App<'_>, area: Rect) {
  match app.data.radarr_data.movie_details_modal.as_ref() {
    Some(movie_details_modal)
      if !movie_details_modal.file_details.is_empty() && !app.is_loading =>
    {
      let file_info = movie_details_modal.file_details.to_owned();
      let audio_details = movie_details_modal.audio_details.to_owned();
      let video_details = movie_details_modal.video_details.to_owned();
      let [file_details_title_area, file_details_area, audio_details_title_area, audio_details_area, video_details_title_area, video_details_area] =
        Layout::vertical([
          Constraint::Length(2),
          Constraint::Length(5),
          Constraint::Length(1),
          Constraint::Length(6),
          Constraint::Length(1),
          Constraint::Length(7),
        ])
        .areas(area);

      let file_details_title_paragraph =
        Paragraph::new("File Details".bold()).block(layout_block_top_border());
      let audio_details_title_paragraph =
        Paragraph::new("Audio Details".bold()).block(borderless_block());
      let video_details_title_paragraph =
        Paragraph::new("Video Details".bold()).block(borderless_block());

      let file_details = Text::from(file_info);
      let audio_details = Text::from(audio_details);
      let video_details = Text::from(video_details);

      let file_details_paragraph = Paragraph::new(file_details)
        .block(layout_block_bottom_border())
        .wrap(Wrap { trim: false });
      let audio_details_paragraph = Paragraph::new(audio_details)
        .block(layout_block_bottom_border())
        .wrap(Wrap { trim: false });
      let video_details_paragraph = Paragraph::new(video_details)
        .block(borderless_block())
        .wrap(Wrap { trim: false });

      f.render_widget(file_details_title_paragraph, file_details_title_area);
      f.render_widget(file_details_paragraph, file_details_area);
      f.render_widget(audio_details_title_paragraph, audio_details_title_area);
      f.render_widget(audio_details_paragraph, audio_details_area);
      f.render_widget(video_details_title_paragraph, video_details_title_area);
      f.render_widget(video_details_paragraph, video_details_area);
    }
    _ => loading(f, layout_block_top_border(), area, app.is_loading),
  }
}

fn draw_movie_details(f: &mut Frame<'_>, app: &App<'_>, area: Rect) {
  let block = layout_block_top_border();

  match app.data.radarr_data.movie_details_modal.as_ref() {
    Some(movie_details_modal) if !app.is_loading => {
      let movie_details = &movie_details_modal.movie_details;
      let download_status = movie_details
        .items
        .iter()
        .find(|&line| line.starts_with("Status: "))
        .unwrap()
        .split(": ")
        .collect::<Vec<&str>>()[1];
      let text = Text::from(
        movie_details
          .items
          .iter()
          .map(|line| {
            let split = line.split(':').collect::<Vec<&str>>();
            let title = format!("{}:", split[0]);
            let style = style_from_download_status(download_status);

            Line::from(vec![
              title.bold().style(style),
              Span::styled(split[1..].join(":"), style),
            ])
          })
          .collect::<Vec<Line<'_>>>(),
      );

      let paragraph = Paragraph::new(text)
        .block(block)
        .wrap(Wrap { trim: false })
        .scroll((movie_details.offset, 0));

      f.render_widget(paragraph, area);
    }
    _ => loading(
      f,
      block,
      area,
      app.is_loading || app.data.radarr_data.movie_details_modal.is_none(),
    ),
  }
}

fn draw_movie_history(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  if let Some(movie_details_modal) = app.data.radarr_data.movie_details_modal.as_mut() {
    let current_selection = if movie_details_modal.movie_history.items.is_empty() {
      MovieHistoryItem::default()
    } else {
      movie_details_modal
        .movie_history
        .current_selection()
        .clone()
    };

    draw_table(
      f,
      area,
      layout_block_top_border(),
      TableProps {
        content: Some(&mut movie_details_modal.movie_history),
        wrapped_content: None,
        table_headers: vec!["Source Title", "Event Type", "Languages", "Quality", "Date"],
        constraints: vec![
          Constraint::Percentage(34),
          Constraint::Percentage(17),
          Constraint::Percentage(14),
          Constraint::Percentage(14),
          Constraint::Percentage(21),
        ],
        help: app
          .data
          .radarr_data
          .movie_info_tabs
          .get_active_tab_contextual_help(),
      },
      |movie_history_item| {
        let MovieHistoryItem {
          source_title,
          quality,
          languages,
          date,
          event_type,
        } = movie_history_item;

        movie_history_item.source_title.scroll_left_or_reset(
          get_width_from_percentage(area, 34),
          current_selection == *movie_history_item,
          app.tick_count % app.ticks_until_scroll == 0,
        );

        Row::new(vec![
          Cell::from(source_title.to_string()),
          Cell::from(event_type.to_owned()),
          Cell::from(
            languages
              .iter()
              .map(|language| language.name.to_owned())
              .collect::<Vec<String>>()
              .join(","),
          ),
          Cell::from(quality.quality.name.to_owned()),
          Cell::from(date.to_string()),
        ])
        .success()
      },
      app.is_loading,
      true,
    );
  }
}

fn draw_movie_cast(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  draw_table(
    f,
    area,
    layout_block_top_border(),
    TableProps {
      content: Some(
        &mut app
          .data
          .radarr_data
          .movie_details_modal
          .as_mut()
          .unwrap()
          .movie_cast,
      ),
      wrapped_content: None,
      constraints: iter::repeat(Constraint::Ratio(1, 2)).take(2).collect(),
      table_headers: vec!["Cast Member", "Character"],
      help: app
        .data
        .radarr_data
        .movie_info_tabs
        .get_active_tab_contextual_help(),
    },
    |cast_member| {
      let Credit {
        person_name,
        character,
        ..
      } = cast_member;

      Row::new(vec![
        Cell::from(person_name.to_owned()),
        Cell::from(character.clone().unwrap_or_default()),
      ])
      .success()
    },
    app.is_loading,
    true,
  );
}

fn draw_movie_crew(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  draw_table(
    f,
    area,
    layout_block_top_border(),
    TableProps {
      content: Some(
        &mut app
          .data
          .radarr_data
          .movie_details_modal
          .as_mut()
          .unwrap()
          .movie_crew,
      ),
      wrapped_content: None,
      constraints: iter::repeat(Constraint::Ratio(1, 3)).take(3).collect(),
      table_headers: vec!["Crew Member", "Job", "Department"],
      help: app
        .data
        .radarr_data
        .movie_info_tabs
        .get_active_tab_contextual_help(),
    },
    |crew_member| {
      let Credit {
        person_name,
        job,
        department,
        ..
      } = crew_member;

      Row::new(vec![
        Cell::from(person_name.to_owned()),
        Cell::from(job.clone().unwrap_or_default()),
        Cell::from(department.clone().unwrap_or_default()),
      ])
      .success()
    },
    app.is_loading,
    true,
  );
}

fn draw_movie_releases(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  let (current_selection, is_empty, sort_ascending) =
    match app.data.radarr_data.movie_details_modal.as_ref() {
      Some(movie_details_modal) if !movie_details_modal.movie_releases.items.is_empty() => (
        movie_details_modal
          .movie_releases
          .current_selection()
          .clone(),
        movie_details_modal.movie_releases.items.is_empty(),
        movie_details_modal.sort_ascending,
      ),
      _ => (Release::default(), true, None),
    };
  let current_route = *app.get_current_route();
  let mut table_headers_vec = vec![
    "Source".to_owned(),
    "Age".to_owned(),
    "⛔".to_owned(),
    "Title".to_owned(),
    "Indexer".to_owned(),
    "Size".to_owned(),
    "Peers".to_owned(),
    "Language".to_owned(),
    "Quality".to_owned(),
  ];

  if let Some(ascending) = sort_ascending {
    let direction = if ascending { " ▲" } else { " ▼" };

    match app
      .data
      .radarr_data
      .movie_details_modal
      .as_ref()
      .unwrap()
      .movie_releases_sort
      .current_selection()
    {
      ReleaseField::Source => table_headers_vec[0].push_str(direction),
      ReleaseField::Age => table_headers_vec[1].push_str(direction),
      ReleaseField::Rejected => table_headers_vec[2].push_str(direction),
      ReleaseField::Title => table_headers_vec[3].push_str(direction),
      ReleaseField::Indexer => table_headers_vec[4].push_str(direction),
      ReleaseField::Size => table_headers_vec[5].push_str(direction),
      ReleaseField::Peers => table_headers_vec[6].push_str(direction),
      ReleaseField::Language => table_headers_vec[7].push_str(direction),
      ReleaseField::Quality => table_headers_vec[8].push_str(direction),
    }
  }

  draw_table(
    f,
    area,
    layout_block_top_border(),
    TableProps {
      content: Some(
        &mut app
          .data
          .radarr_data
          .movie_details_modal
          .as_mut()
          .unwrap()
          .movie_releases,
      ),
      wrapped_content: None,
      constraints: vec![
        Constraint::Length(9),
        Constraint::Length(10),
        Constraint::Length(5),
        Constraint::Percentage(30),
        Constraint::Percentage(18),
        Constraint::Length(12),
        Constraint::Length(12),
        Constraint::Percentage(7),
        Constraint::Percentage(10),
      ],
      table_headers: table_headers_vec.iter().map(|s| &**s).collect(),
      help: app
        .data
        .radarr_data
        .movie_info_tabs
        .get_active_tab_contextual_help(),
    },
    |release| {
      let Release {
        protocol,
        age,
        title,
        indexer,
        size,
        rejected,
        seeders,
        leechers,
        languages,
        quality,
        ..
      } = release;
      let age = format!("{age} days");
      title.scroll_left_or_reset(
        get_width_from_percentage(area, 30),
        current_selection == *release
          && current_route != ActiveRadarrBlock::ManualSearchConfirmPrompt.into(),
        app.tick_count % app.ticks_until_scroll == 0,
      );
      let size = convert_to_gb(*size);
      let rejected_str = if *rejected { "⛔" } else { "" };
      let peers = if seeders.is_none() || leechers.is_none() {
        Text::from("")
      } else {
        let seeders = seeders.clone().unwrap().as_u64().unwrap();
        let leechers = leechers.clone().unwrap().as_u64().unwrap();

        decorate_peer_style(
          seeders,
          leechers,
          Text::from(format!("{seeders} / {leechers}")),
        )
      };

      let language = if languages.is_some() {
        languages.clone().unwrap()[0].name.clone()
      } else {
        String::new()
      };
      let quality = quality.quality.name.clone();

      Row::new(vec![
        Cell::from(protocol.clone()),
        Cell::from(age),
        Cell::from(rejected_str),
        Cell::from(title.to_string()),
        Cell::from(indexer.clone()),
        Cell::from(format!("{size:.1} GB")),
        Cell::from(peers),
        Cell::from(language),
        Cell::from(quality),
      ])
      .primary()
    },
    app.is_loading || is_empty,
    true,
  );
}

fn draw_manual_search_confirm_prompt(f: &mut Frame<'_>, app: &mut App<'_>, area: Rect) {
  let current_selection = app
    .data
    .radarr_data
    .movie_details_modal
    .as_ref()
    .unwrap()
    .movie_releases
    .current_selection();
  let title = if current_selection.rejected {
    "Download Rejected Release"
  } else {
    "Download Release"
  };
  let prompt = if current_selection.rejected {
    format!(
      "Do you really want to download the rejected release: {}?",
      &current_selection.title.text
    )
  } else {
    format!(
      "Do you want to download the release: {}?",
      &current_selection.title.text
    )
  };

  if current_selection.rejected {
    let mut lines_vec = vec![Line::from("Rejection reasons: ".primary().bold())];
    let mut rejections_spans = current_selection
      .rejections
      .clone()
      .unwrap_or_default()
      .iter()
      .map(|item| Line::from(format!("• {item}").primary().bold()))
      .collect::<Vec<Line<'_>>>();
    lines_vec.append(&mut rejections_spans);

    let content_paragraph = Paragraph::new(lines_vec)
      .block(borderless_block())
      .wrap(Wrap { trim: false })
      .alignment(Alignment::Left);

    draw_prompt_box_with_content(
      f,
      area,
      title,
      &prompt,
      Some(content_paragraph),
      app.data.radarr_data.prompt_confirm,
    );
  } else {
    draw_prompt_box(f, area, title, &prompt, app.data.radarr_data.prompt_confirm);
  }
}

fn style_from_download_status(download_status: &str) -> Style {
  match download_status {
    "Downloaded" => Style::new().success(),
    "Awaiting Import" => Style::new().awaiting_import(),
    "Downloading" => Style::new().warning(),
    "Missing" => Style::new().failure(),
    _ => Style::new().success(),
  }
}

fn decorate_peer_style(seeders: u64, leechers: u64, text: Text<'_>) -> Text<'_> {
  if seeders == 0 {
    text.failure()
  } else if seeders < leechers {
    text.warning()
  } else {
    text.success()
  }
}