use anyhow::anyhow;
use indoc::formatdoc;
use log::{debug, error};
use reqwest::{RequestBuilder, StatusCode};
use serde::de::DeserializeOwned;
use tokio::sync::MutexGuard;

use crate::app::{App, RadarrConfig};
use crate::models::radarr_models::{
  Collection, Credit, CreditType, DiskSpace, DownloadsResponse, Movie, MovieHistoryItem,
  QualityProfile, SystemStatus,
};
use crate::models::ScrollableText;
use crate::network::utils::get_movie_status;
use crate::network::{utils, Network, NetworkEvent};
use crate::utils::{convert_runtime, convert_to_gb};

#[derive(Debug, Eq, PartialEq)]
pub enum RadarrEvent {
  DeleteMovie,
  GetCollections,
  GetDownloads,
  GetMovies,
  GetMovieCredits,
  GetMovieDetails,
  GetMovieHistory,
  GetOverview,
  GetQualityProfiles,
  GetStatus,
  HealthCheck,
}

#[derive(Clone)]
enum RequestMethod {
  GET,
  DELETE,
}

struct RequestProps<T> {
  pub resource: String,
  pub method: RequestMethod,
  pub body: Option<T>,
}

impl RadarrEvent {
  const fn resource(self) -> &'static str {
    match self {
      RadarrEvent::GetCollections => "/collection",
      RadarrEvent::GetDownloads => "/queue",
      RadarrEvent::GetMovies | RadarrEvent::GetMovieDetails | RadarrEvent::DeleteMovie => "/movie",
      RadarrEvent::GetMovieCredits => "/credit",
      RadarrEvent::GetMovieHistory => "/history/movie",
      RadarrEvent::GetOverview => "/diskspace",
      RadarrEvent::GetQualityProfiles => "/qualityprofile",
      RadarrEvent::GetStatus => "/system/status",
      RadarrEvent::HealthCheck => "/health",
    }
  }
}

impl From<RadarrEvent> for NetworkEvent {
  fn from(radarr_event: RadarrEvent) -> Self {
    NetworkEvent::Radarr(radarr_event)
  }
}

impl<'a> Network<'a> {
  pub async fn handle_radarr_event(&self, radarr_event: RadarrEvent) {
    match radarr_event {
      RadarrEvent::GetCollections => {
        self
          .get_collections(RadarrEvent::GetCollections.resource().to_owned())
          .await
      }
      RadarrEvent::HealthCheck => {
        self
          .get_healthcheck(RadarrEvent::HealthCheck.resource().to_owned())
          .await
      }
      RadarrEvent::GetOverview => {
        self
          .get_diskspace(RadarrEvent::GetOverview.resource().to_owned())
          .await
      }
      RadarrEvent::GetStatus => {
        self
          .get_status(RadarrEvent::GetStatus.resource().to_owned())
          .await
      }
      RadarrEvent::GetMovies => {
        self
          .get_movies(RadarrEvent::GetMovies.resource().to_owned())
          .await
      }
      RadarrEvent::DeleteMovie => {
        self
          .delete_movie(RadarrEvent::DeleteMovie.resource().to_owned())
          .await
      }
      RadarrEvent::GetMovieCredits => {
        self
          .get_credits(RadarrEvent::GetMovieCredits.resource().to_owned())
          .await
      }
      RadarrEvent::GetMovieDetails => {
        self
          .get_movie_details(RadarrEvent::GetMovieDetails.resource().to_owned())
          .await
      }
      RadarrEvent::GetMovieHistory => {
        self
          .get_movie_history(RadarrEvent::GetMovieHistory.resource().to_owned())
          .await
      }
      RadarrEvent::GetDownloads => {
        self
          .get_downloads(RadarrEvent::GetDownloads.resource().to_owned())
          .await
      }
      RadarrEvent::GetQualityProfiles => {
        self
          .get_quality_profiles(RadarrEvent::GetQualityProfiles.resource().to_owned())
          .await
      }
    }
  }

  async fn get_healthcheck(&self, resource: String) {
    if let Err(e) = self
      .call_radarr_api::<()>(RequestProps {
        resource,
        method: RequestMethod::GET,
        body: None::<()>,
      })
      .await
      .send()
      .await
    {
      error!("Healthcheck failed. {:?}", e);
      self.app.lock().await.handle_error(anyhow!(e));
    }
  }

  async fn get_diskspace(&self, resource: String) {
    type RequestType = Vec<DiskSpace>;
    self
      .handle_request::<RequestType>(
        RequestProps {
          resource,
          method: RequestMethod::GET,
          body: None::<RequestType>,
        },
        |disk_space_vec, mut app| {
          app.data.radarr_data.disk_space_vec = disk_space_vec;
        },
      )
      .await;
  }

  async fn get_status(&self, resource: String) {
    self
      .handle_request::<SystemStatus>(
        RequestProps {
          resource,
          method: RequestMethod::GET,
          body: None::<SystemStatus>,
        },
        |system_status, mut app| {
          app.data.radarr_data.version = system_status.version;
          app.data.radarr_data.start_time = system_status.start_time;
        },
      )
      .await;
  }

  async fn get_movies(&self, resource: String) {
    type RequestType = Vec<Movie>;
    self
      .handle_request::<RequestType>(
        RequestProps {
          resource,
          method: RequestMethod::GET,
          body: None::<RequestType>,
        },
        |movie_vec, mut app| app.data.radarr_data.movies.set_items(movie_vec),
      )
      .await;
  }

  async fn get_movie_details(&self, resource: String) {
    let movie_id = self.extract_movie_id().await;
    self
      .handle_request::<Movie>(
        RequestProps {
          resource: format!("{}/{}", resource, movie_id),
          method: RequestMethod::GET,
          body: None::<Movie>,
        },
        |movie_response, mut app| {
          let Movie {
            id,
            title,
            year,
            overview,
            path,
            studio,
            has_file,
            quality_profile_id,
            size_on_disk,
            genres,
            runtime,
            ratings,
            movie_file,
            collection,
            ..
          } = movie_response;
          let (hours, minutes) = convert_runtime(runtime.as_u64().unwrap());
          let size = convert_to_gb(size_on_disk.as_u64().unwrap());
          let quality_profile = app
            .data
            .radarr_data
            .quality_profile_map
            .get(&quality_profile_id.as_u64().unwrap())
            .unwrap()
            .to_owned();
          let imdb_rating = if let Some(rating) = ratings.imdb {
            if let Some(value) = rating.value.as_f64() {
              format!("{:.1}", value)
            } else {
              "".to_owned()
            }
          } else {
            "".to_owned()
          };

          let tmdb_rating = if let Some(rating) = ratings.tmdb {
            if let Some(value) = rating.value.as_f64() {
              format!("{}%", (value * 10f64).ceil())
            } else {
              "".to_owned()
            }
          } else {
            "".to_owned()
          };

          let rotten_tomatoes_rating = if let Some(rating) = ratings.rotten_tomatoes {
            if let Some(value) = rating.value.as_u64() {
              format!("{}%", value)
            } else {
              "".to_owned()
            }
          } else {
            "".to_owned()
          };

          let status = get_movie_status(has_file, &app.data.radarr_data.downloads.items, id);
          let collection = collection.unwrap_or_default();

          app.data.radarr_data.movie_details = ScrollableText::with_string(formatdoc!(
            "Title: {}
          Year: {}
          Runtime: {}h {}m
          Collection: {}
          Status: {}
          Description: {}
          TMDB: {}
          IMDB: {}
          Rotten Tomatoes: {}
          Quality Profile: {}
          Size: {:.2} GB
          Path: {}
          Studio: {}
          Genres: {}",
            title,
            year,
            hours,
            minutes,
            collection.title,
            status,
            overview,
            tmdb_rating,
            imdb_rating,
            rotten_tomatoes_rating,
            quality_profile,
            size,
            path,
            studio,
            genres.join(", ")
          ));

          if let Some(file) = movie_file {
            app.data.radarr_data.file_details = formatdoc!(
              "Relative Path: {}
              Absolute Path: {}
              Size: {:.2} GB
              Date Added: {}",
              file.relative_path,
              file.path,
              size,
              file.date_added
            );

            let media_info = file.media_info;

            app.data.radarr_data.audio_details = formatdoc!(
              "Bitrate: {}
              Channels: {:.1}
              Codec: {}
              Languages: {}
              Stream Count: {}",
              media_info.audio_bitrate.as_u64().unwrap(),
              media_info.audio_channels.as_f64().unwrap(),
              media_info.audio_codec.unwrap_or_default(),
              media_info.audio_languages.unwrap_or_default(),
              media_info.audio_stream_count.as_u64().unwrap()
            );

            app.data.radarr_data.video_details = formatdoc!(
              "Bit Depth: {}
              Bitrate: {}
              Codec: {}
              FPS: {}
              Resolution: {}
              Scan Type: {}
              Runtime: {}",
              media_info.video_bit_depth.as_u64().unwrap(),
              media_info.video_bitrate.as_u64().unwrap(),
              media_info.video_codec,
              media_info.video_fps.as_f64().unwrap(),
              media_info.resolution,
              media_info.scan_type,
              media_info.run_time
            );
          }
        },
      )
      .await;
  }

  async fn get_movie_history(&self, resource: String) {
    type RequestType = Vec<MovieHistoryItem>;
    self
      .handle_request::<RequestType>(
        RequestProps {
          resource: self.append_movie_id_param(&resource).await,
          method: RequestMethod::GET,
          body: None::<RequestType>,
        },
        |movie_history_vec, mut app| {
          let mut reversed_movie_history_vec = movie_history_vec.to_vec();
          reversed_movie_history_vec.reverse();
          app
            .data
            .radarr_data
            .movie_history
            .set_items(reversed_movie_history_vec)
        },
      )
      .await;
  }

  async fn get_collections(&self, resource: String) {
    type RequestType = Vec<Collection>;
    self
      .handle_request::<RequestType>(
        RequestProps {
          resource,
          method: RequestMethod::GET,
          body: None::<RequestType>,
        },
        |collections_vec, mut app| {
          app.data.radarr_data.collections.set_items(collections_vec);
        },
      )
      .await;
  }

  async fn get_downloads(&self, resource: String) {
    self
      .handle_request::<DownloadsResponse>(
        RequestProps {
          resource,
          method: RequestMethod::GET,
          body: None::<DownloadsResponse>,
        },
        |queue_response, mut app| {
          app
            .data
            .radarr_data
            .downloads
            .set_items(queue_response.records);
        },
      )
      .await
  }

  async fn get_quality_profiles(&self, resource: String) {
    type RequestType = Vec<QualityProfile>;
    self
      .handle_request::<RequestType>(
        RequestProps {
          resource,
          method: RequestMethod::GET,
          body: None::<RequestType>,
        },
        |quality_profiles, mut app| {
          app.data.radarr_data.quality_profile_map = quality_profiles
            .iter()
            .map(|profile| (profile.id.as_u64().unwrap(), profile.name.clone()))
            .collect();
        },
      )
      .await;
  }

  async fn get_credits(&self, resource: String) {
    type RequestType = Vec<Credit>;
    self
      .handle_request::<RequestType>(
        RequestProps {
          resource: self.append_movie_id_param(&resource).await,
          method: RequestMethod::GET,
          body: None::<RequestType>,
        },
        |credit_vec, mut app| {
          let cast_vec: Vec<Credit> = credit_vec
            .iter()
            .cloned()
            .filter(|credit| credit.credit_type == CreditType::Cast)
            .collect();
          let crew_vec: Vec<Credit> = credit_vec
            .iter()
            .cloned()
            .filter(|credit| credit.credit_type == CreditType::Crew)
            .collect();

          app.data.radarr_data.movie_cast.set_items(cast_vec);
          app.data.radarr_data.movie_crew.set_items(crew_vec);
        },
      )
      .await;
  }

  async fn delete_movie(&self, resource: String) {
    let movie_id = self.extract_movie_id().await;
    self
      .handle_request::<()>(
        RequestProps {
          resource: format!("{}/{}", resource, movie_id),
          method: RequestMethod::DELETE,
          body: None::<()>,
        },
        |_, _| (),
      )
      .await;
  }

  async fn call_radarr_api<T>(&self, request_props: RequestProps<T>) -> RequestBuilder {
    let RequestProps {
      resource,
      method,
      body,
    } = request_props;
    debug!("Creating RequestBuilder for resource: {:?}", resource);
    let app = self.app.lock().await;
    let RadarrConfig {
      host,
      port,
      api_token,
    } = &app.config.radarr;
    let uri = format!(
      "http://{}:{}/api/v3{}",
      host,
      port.unwrap_or(7878),
      resource
    );

    match method {
      RequestMethod::GET => app.client.get(uri).header("X-Api-Key", api_token),
      RequestMethod::DELETE => app.client.delete(uri).header("X-Api-Key", api_token),
    }
  }

  async fn handle_request<T>(
    &self,
    request_props: RequestProps<T>,
    mut app_update_fn: impl FnMut(T, MutexGuard<App>),
  ) where
    T: DeserializeOwned,
  {
    let method = request_props.method.clone();
    match self.call_radarr_api(request_props).await.send().await {
      Ok(response) => match method {
        RequestMethod::GET => match utils::parse_response::<T>(response).await {
          Ok(value) => {
            let app = self.app.lock().await;
            app_update_fn(value, app);
          }
          Err(e) => {
            error!("Failed to parse response! {:?}", e);
            self.app.lock().await.handle_error(anyhow!(e));
          }
        },
        RequestMethod::DELETE => {
          if response.status() != StatusCode::OK {
            error!(
              "Received the following code for delete operation: {:?}",
              response.status()
            );
            self.app.lock().await.handle_error(anyhow!(
              "Received a non 200 OK response for delete operation"
            ));
          }
        }
      },
      Err(e) => {
        error!("Failed to send request. {:?}", e);
        self.app.lock().await.handle_error(anyhow!(e));
      }
    }
  }

  async fn extract_movie_id(&self) -> u64 {
    if !self
      .app
      .lock()
      .await
      .data
      .radarr_data
      .filtered_movies
      .items
      .is_empty()
    {
      self
        .app
        .lock()
        .await
        .data
        .radarr_data
        .filtered_movies
        .current_selection()
        .id
        .clone()
        .as_u64()
        .unwrap()
    } else {
      self
        .app
        .lock()
        .await
        .data
        .radarr_data
        .movies
        .current_selection()
        .id
        .clone()
        .as_u64()
        .unwrap()
    }
  }

  async fn append_movie_id_param(&self, resource: &str) -> String {
    let movie_id = self.extract_movie_id().await;
    format!("{}?movieId={}", resource.to_owned(), movie_id.to_owned())
  }
}