use super::directory::index::IndexStrategy;
use crate::config::{ContentDispositionConfig, PathConfig, PathMatcherConfig, ServerConfig};
use actix_web::http::header::{self, DispositionType, HeaderMap};
use regex::Regex;
use snafu::{ResultExt, Snafu};
use std::{
  collections::HashMap,
  convert::{TryFrom, TryInto},
  fmt::Debug,
  path::{Path, PathBuf},
};

#[derive(Snafu, Debug)]
pub enum Error {
  #[snafu(display("Failed to parse the Mime type."))]
  ParseMime { source: mime::FromStrError },
  #[snafu(display("Failed to parse the header name: {}", name))]
  ParseHeaderName {
    source: header::InvalidHeaderName,
    name: String,
  },
  #[snafu(display("Failed to parse the header value: {}", value))]
  ParseHeaderValue {
    source: header::InvalidHeaderValue,
    value: String,
  },
  #[snafu(display("Failed to compile the Regex pattern: {}", pattern))]
  InvalidRegexPattern {
    pattern: String,
    source: regex::Error,
  },
}

type Result<T, E = Error> = std::result::Result<T, E>;

#[derive(Clone, Debug)]
enum PathMatcher {
  Static { path: PathBuf },
  Prefix { prefix: String },
  Regex { regex: Regex },
}

impl PathMatcher {
  pub fn matches_path<P: AsRef<Path>>(&self, input_path: P) -> bool {
    let input_path = input_path.as_ref();

    match self {
      Self::Static { path } => input_path.eq(path),
      Self::Prefix { prefix } => input_path.starts_with(prefix),
      Self::Regex { regex } => match input_path.to_str() {
        Some(raw_input_path) => regex.is_match(raw_input_path),
        None => false,
      },
    }
  }
}

impl TryFrom<&PathMatcherConfig> for PathMatcher {
  type Error = Error;

  fn try_from(config: &PathMatcherConfig) -> Result<Self, Self::Error> {
    Ok(match config {
      PathMatcherConfig::StaticMatcher { path } => PathMatcher::Static {
        path: PathBuf::from(path.clone()),
      },
      PathMatcherConfig::PrefixMatcher { prefix } => PathMatcher::Prefix {
        prefix: prefix.clone(),
      },
      PathMatcherConfig::RegexMatcher { pattern } => PathMatcher::Regex {
        regex: Regex::new(pattern).context(InvalidRegexPattern {
          pattern: pattern.clone(),
        })?,
      },
    })
  }
}

#[derive(Clone)]
pub struct PathContext {
  matcher: Option<PathMatcher>,
  mime_disposition: Option<HashMap<mime::Mime, DispositionType>>,
  set_etag: Option<bool>,
  set_last_modified: Option<bool>,
  index_strategy: Option<IndexStrategy>,
  headers: Option<HeaderMap>,
  not_found_path: Option<PathBuf>,
}

impl PathContext {
  pub fn matches_path<P: AsRef<Path>>(&self, input_path: P) -> bool {
    if let Some(matcher) = &self.matcher {
      matcher.matches_path(input_path)
    } else {
      true
    }
  }

  /// Combines the configuration entries on this context with another.
  ///
  /// Useful for overlaying configurations. e.g. Defaults + Configuration.
  pub fn merge(&self, other: &Self) -> Self {
    PathContext {
      matcher: other.matcher.clone(),
      mime_disposition: other
        .mime_disposition
        .clone()
        .or_else(|| self.mime_disposition.clone()),
      set_etag: other.set_etag.or(self.set_etag),
      set_last_modified: other.set_last_modified.or(self.set_last_modified),
      index_strategy: other
        .index_strategy
        .clone()
        .or_else(|| self.index_strategy.clone()),
      headers: other.headers.clone().or_else(|| self.headers.clone()),
      not_found_path: other
        .not_found_path
        .clone()
        .or_else(|| self.not_found_path.clone()),
    }
  }

  pub fn get_mime_disposition(&self) -> &Option<HashMap<mime::Mime, DispositionType>> {
    &self.mime_disposition
  }

  pub fn get_index_strategy_or_default(&self) -> &IndexStrategy {
    if let Some(index_strategy) = &self.index_strategy {
      index_strategy
    } else {
      &IndexStrategy::NoIndex
    }
  }

  pub fn get_use_etag_or_default(&self) -> bool {
    self.set_etag.unwrap_or(true)
  }

  pub fn get_use_last_modifiedor_default(&self) -> bool {
    self.set_last_modified.unwrap_or(true)
  }

  pub fn append_headers_to_map(&self, header_map: &mut HeaderMap) {
    if let Some(headers) = &self.headers {
      for (header_name, header_value) in headers.iter() {
        if header_map.contains_key(header_name) {
          log::warn!(
            "Unable to replace header '{}' since it was already set.",
            header_name
          );
        } else {
          header_map.insert(header_name.clone(), header_value.clone());
        }
      }
    }
  }

  pub fn get_not_found_path(&self) -> &Option<PathBuf> {
    &self.not_found_path
  }
}

impl Debug for PathContext {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    write!(f, "PathContext (Matcher: {:?})", self.matcher)
  }
}

impl TryFrom<&PathConfig> for PathContext {
  type Error = Error;

  fn try_from(config: &PathConfig) -> Result<Self, Error> {
    let mime_disposition = try_get_mime_disposition(&config.mime_disposition)?;
    let headers = try_get_headers(&config.headers)?;

    let matcher = (&config.matcher).try_into()?;

    Ok(PathContext {
      matcher: Some(matcher),
      mime_disposition,
      index_strategy: config.index_strategy.clone().map(|x| x.into()),
      set_etag: config.set_etag,
      set_last_modified: config.set_last_modified,
      headers,
      not_found_path: config.not_found_path.clone(),
    })
  }
}

impl TryFrom<&ServerConfig> for PathContext {
  type Error = Error;

  fn try_from(config: &ServerConfig) -> Result<Self, Error> {
    let mime_disposition = try_get_mime_disposition(&config.mime_disposition)?;
    let headers = try_get_headers(&config.headers)?;

    Ok(PathContext {
      matcher: None,
      mime_disposition,
      index_strategy: config.index_strategy.clone().map(|x| x.into()),
      set_etag: config.set_etag,
      set_last_modified: config.set_last_modified,
      headers,
      not_found_path: config.not_found_path.clone(),
    })
  }
}

fn try_get_mime_disposition(
  mime_disposition: &Option<HashMap<String, ContentDispositionConfig>>,
) -> Result<Option<HashMap<mime::Mime, DispositionType>>> {
  Ok(if let Some(mime_disposition) = mime_disposition {
    let mut new_mime_disposition = HashMap::new();

    for (key, value) in mime_disposition.iter() {
      new_mime_disposition.insert(
        key.clone().parse().context(ParseMime)?,
        match value {
          ContentDispositionConfig::Inline => DispositionType::Inline,
          ContentDispositionConfig::Attachment => DispositionType::Attachment,
        },
      );
    }

    Some(new_mime_disposition)
  } else {
    None
  })
}

fn try_get_headers(headers: &Option<HashMap<String, String>>) -> Result<Option<HeaderMap>> {
  Ok(if let Some(headers) = headers {
    let mut new_headers = HeaderMap::new();

    for (name, value) in headers {
      new_headers.insert(
        name
          .parse()
          .context(ParseHeaderName { name: name.clone() })?,
        value.parse().context(ParseHeaderValue {
          value: value.clone(),
        })?,
      );
    }

    Some(new_headers)
  } else {
    None
  })
}

#[cfg(test)]
mod tests {
  use super::PathMatcher;
  use regex::Regex;

  #[test]
  fn test_static_path_matcher() {
    assert!(PathMatcher::Static {
      path: "hello/world.png".into(),
    }
    .matches_path("hello/world.png"),);

    assert!(!PathMatcher::Static {
      path: "hello/world.tar.gz".into(),
    }
    .matches_path("hello/world.png"),);
  }

  #[test]
  fn test_prefix_path_matcher() {
    assert!(PathMatcher::Prefix {
      prefix: "hello/".into(),
    }
    .matches_path("hello/world.png"),);

    assert!(!PathMatcher::Prefix {
      prefix: "hello/bye".into(),
    }
    .matches_path("hello/world.png"),);
  }

  #[test]
  fn test_regex_path_matcher() {
    assert!(Regex::new(r"\.png$").unwrap().is_match("hello/world.png"),);

    assert!(Regex::new(r"\.(js|css|png|jpg|jpeg|gif|ico)$")
      .unwrap()
      .is_match("hello/world.png"),);

    assert!(!PathMatcher::Regex {
      regex: Regex::new(r"\.png$").unwrap(),
    }
    .matches_path("hello/world.tar.gz"),);
  }
}