use super::deepl::translate;
use crate::modules::router::translate::deepl::language_code_to_language_name;

pub fn module<S>(
  context: &windmark::context::HookContext,
  response: &mut windmark::response::Response,
  language: S,
) -> Result<(), serde_json::Error>
where
  S: Into<String> + AsRef<str>,
{
  let lines = response
    .content
    .lines()
    .map(ToString::to_string)
    .collect::<Vec<String>>();
  let mut preformatted = false;
  let mut saved_lines = std::collections::HashMap::new();
  let mut fully_translated = Vec::new();

  for (i, line) in &mut lines.iter().enumerate() {
    if line == "```" {
      preformatted = !preformatted;
    }

    if line.starts_with("=>") {
      if let Some(germ::ast::Node::Link {
        to,
        text,
      }) = germ::ast::Ast::from_string(line).inner().first()
      {
        saved_lines.insert(
          i,
          format!(
            "=> {to}?translate={}{}",
            language.as_ref(),
            text.clone().map_or_else(String::new, |text| {
              format!(
                " {}",
                translate(&text, language.as_ref())
                  .map_or(text, |text| text.text()),
              )
            })
          ),
        );
      }
    } else if preformatted {
      saved_lines.insert(i, line.to_string());
    }
  }

  let translated = translate(&response.content, language.as_ref())?;

  for (i, line) in translated.text().lines().enumerate() {
    if saved_lines.contains_key(&i) {
      fully_translated.push(saved_lines.get(&i).unwrap().to_string());
    } else {
      fully_translated.push(line.to_string());
    }
  }

  response.content = format!(
    "This content has been translated from {} to {}.\n\n=> {} View \
     Original\n\n{}",
    language_code_to_language_name(
      &translated.detected_source_language().to_lowercase()
    ),
    language_code_to_language_name(&language.as_ref().to_lowercase()),
    context
      .url
      .to_string()
      .replace(&format!("translate={}", language.as_ref()), ""),
    fully_translated.join("\n")
  );
  response.languages = Some(vec![language.into()]);
  response.character_set = Some({
    let mut encoding_detector = chardetng::EncodingDetector::new();

    encoding_detector.feed(response.content.as_bytes(), true);

    encoding_detector.guess(None, true).name().to_string()
  });

  Ok(())
}