dprint 0.60.1

use std::collections::HashMap;
use std::path::Path;
use std::path::PathBuf;
use std::rc::Rc;
use std::time::SystemTime;

use sys_traits::FsMetadata;
use sys_traits::FsMetadataValue;

use crate::environment::DirEntry;
use crate::environment::Environment;
use crate::utils::escape_glob_text;

/// Lifted from the Deno code.
/// Copyright 2018-2024 the Deno authors. MIT license.
/// Resolved gitignore for a directory.
pub struct DirGitIgnores {
  current: Option<Rc<ignore::gitignore::Gitignore>>,
  parent: Option<Rc<DirGitIgnores>>,
}

impl DirGitIgnores {
  pub fn is_ignored(&self, path: &Path, is_dir: bool) -> bool {
    let mut is_ignored = false;
    if let Some(parent) = &self.parent {
      is_ignored = parent.is_ignored(path, is_dir);
    }
    if let Some(current) = &self.current {
      match current.matched(path, is_dir) {
        ignore::Match::None => {}
        ignore::Match::Ignore(_) => {
          is_ignored = true;
        }
        ignore::Match::Whitelist(_) => {
          is_ignored = false;
        }
      }
    }
    is_ignored
  }
}

/// Resolves the lines of git's global excludes file when global gitignore
/// support is opted into via the `DPRINT_GLOBAL_GITIGNORE` environment variable.
/// Returns an empty list when disabled or when no global excludes file exists.
pub fn resolve_global_gitignore_lines(environment: &impl Environment) -> Vec<String> {
  if !global_gitignore_enabled(environment) {
    return Vec::new();
  }
  let Some(path) = environment.global_gitignore_path() else {
    return Vec::new();
  };
  match environment.maybe_read_file(&path) {
    Ok(Some(text)) => text.lines().map(|line| line.to_string()).collect(),
    Ok(None) => Vec::new(), // no global excludes file present
    Err(err) => {
      log_debug!(environment, "Failed reading global gitignore '{}': {:#}", path.display(), err);
      Vec::new()
    }
  }
}

fn global_gitignore_enabled(environment: &impl Environment) -> bool {
  match environment.env_var("DPRINT_GLOBAL_GITIGNORE") {
    Some(value) => {
      let value = value.to_string_lossy();
      let value = value.trim();
      value == "1" || value.eq_ignore_ascii_case("true")
    }
    None => false,
  }
}

/// Whether `.gitignore` and `.git` are present in a directory the caller has
/// already listed. Providing this lets resolution skip file system calls for
/// files it can already tell are absent.
#[derive(Clone, Copy, Default)]
pub struct DirEntriesHint {
  pub has_gitignore: bool,
  pub has_git: bool,
}

impl DirEntriesHint {
  /// Derives a hint from an already-read directory listing.
  pub fn from_dir_entries(entries: &[DirEntry]) -> Self {
    let mut hint = DirEntriesHint {
      has_git: false,
      has_gitignore: false,
    };
    for entry in entries {
      let name = match entry {
        // `.gitignore` is a file and `.git` is usually a directory (a file in worktrees)
        DirEntry::Directory(path) => path.file_name().and_then(|f| f.to_str()),
        DirEntry::File { name, .. } => name.to_str(),
      };
      match name {
        Some(".gitignore") => hint.has_gitignore = true,
        Some(".git") => hint.has_git = true,
        _ => continue,
      }
      if hint.has_gitignore && hint.has_git {
        break; // nothing left to learn
      }
    }
    hint
  }
}

#[derive(Default)]
pub struct GitIgnoreTreeOptions {
  /// Paths that should override what's in the gitignore.
  pub include_paths: Vec<PathBuf>,
  /// Lines from git's global excludes file, applied at the repository root with
  /// the lowest precedence. Empty unless global gitignore support is opted into.
  pub global_gitignore_lines: Vec<String>,
  /// Whether to remember the state of the files each directory's gitignore was
  /// resolved from so `refresh_for_file` can detect when they change. This is
  /// for a tree that outlives a single run (ex. in the language server) and
  /// it's off by default because of what it costs: a stat of `.git` and of
  /// `.gitignore` for a directory, plus one of `.git/info/exclude` at a
  /// repository root, when the directory is resolved and again for each
  /// resolved ancestor directory on every `refresh_for_file` call.
  pub detect_changes: bool,
}

/// Resolves gitignores in a directory tree taking into account
/// ancestor gitignores that may be found in a directory.
pub struct GitIgnoreTree<TEnvironment> {
  environment: TEnvironment,
  ignores: HashMap<PathBuf, CachedDir>,
  options: GitIgnoreTreeOptions,
}

impl<TEnvironment: Environment> GitIgnoreTree<TEnvironment> {
  pub fn new(environment: TEnvironment, options: GitIgnoreTreeOptions) -> Self {
    Self {
      environment,
      ignores: Default::default(),
      options,
    }
  }

  /// Resolves the gitignore for the children of a directory the caller has
  /// already listed, passing a hint so resolution can avoid redundant reads.
  pub fn get_resolved_git_ignore_for_dir_children(&mut self, dir_path: &Path, hint: DirEntriesHint) -> Option<Rc<DirGitIgnores>> {
    self.get_resolved_git_ignore_inner(dir_path, Some(hint))
  }

  pub fn get_resolved_git_ignore_for_file(&mut self, file_path: &Path) -> Option<Rc<DirGitIgnores>> {
    let dir_path = file_path.parent()?;
    self.get_resolved_git_ignore_inner(dir_path, None)
  }

  /// Drops what was resolved for the file's ancestor directories when a
  /// `.gitignore`, `.git/info/exclude` or `.git` that it was resolved from has
  /// since been changed, added or removed, so the next resolution reads the
  /// files again. Does nothing unless the `detect_changes` option is set.
  ///
  /// This stats the files of each previously resolved ancestor directory up to
  /// the repository root and only reads a file again when its modified time or
  /// size differs, so it's cheap enough to do before every lookup.
  pub fn refresh_for_file(&mut self, file_path: &Path) {
    if !self.options.detect_changes {
      return;
    }
    let mut stale_dir = None;
    for dir_path in file_path.ancestors().skip(1) {
      // a directory that hasn't been resolved gets resolved from the file
      // system on lookup, but its ancestors might be resolved and out of date
      let Some(snapshot) = self.ignores.get(dir_path).and_then(|cached| cached.snapshot.as_ref()) else {
        continue;
      };
      let current_snapshot = self.take_dir_snapshot(dir_path);
      if *snapshot != current_snapshot {
        stale_dir = Some(dir_path);
      }
      if current_snapshot.has_git {
        break; // resolution doesn't look above the repository root
      }
    }
    if let Some(stale_dir) = stale_dir {
      // descendants hold onto what was resolved for their ancestors
      self.ignores.retain(|dir_path, _| !dir_path.starts_with(stale_dir));
    }
  }

  fn get_resolved_git_ignore_inner(&mut self, dir_path: &Path, hint: Option<DirEntriesHint>) -> Option<Rc<DirGitIgnores>> {
    let maybe_resolved = self.ignores.get(dir_path).map(|cached| cached.resolved.clone());
    if let Some(resolved) = maybe_resolved {
      resolved
    } else {
      let cached = self.resolve_gitignore_in_dir(dir_path, hint);
      let resolved = cached.resolved.clone();
      self.ignores.insert(dir_path.to_owned(), cached);
      resolved
    }
  }

  fn resolve_gitignore_in_dir(&mut self, dir_path: &Path, hint: Option<DirEntriesHint>) -> CachedDir {
    // take this before reading the files so a change made while resolving
    // is seen as a change the next time
    let snapshot = self.options.detect_changes.then(|| self.take_dir_snapshot(dir_path));
    // a directory containing `.git` is the root of a repository, so don't
    // search for gitignores above it
    let is_repo_root = match (&snapshot, hint) {
      (Some(snapshot), _) => snapshot.has_git,
      (None, Some(hint)) => hint.has_git,
      (None, None) => self.environment.path_exists(dir_path.join(".git")),
    };
    let parent = if is_repo_root {
      None
    } else {
      // ancestors aren't part of the caller's listing, so resolve them without a hint
      dir_path.parent().and_then(|parent| self.get_resolved_git_ignore_inner(parent, None))
    };
    let current = self.resolve_current_gitignore(dir_path, is_repo_root, hint);
    let resolved = if parent.is_none() && current.is_none() {
      None
    } else {
      Some(Rc::new(DirGitIgnores { current, parent }))
    };
    CachedDir { resolved, snapshot }
  }

  fn resolve_current_gitignore(&self, dir_path: &Path, is_repo_root: bool, hint: Option<DirEntriesHint>) -> Option<Rc<ignore::gitignore::Gitignore>> {
    // skip the read when the caller's listing already shows there's no `.gitignore`
    let maybe_has_gitignore = hint.map(|h| h.has_gitignore).unwrap_or(true);
    let gitignore_text = if maybe_has_gitignore {
      self.environment.read_file(dir_path.join(".gitignore")).ok()
    } else {
      None
    };
    // git also reads `.git/info/exclude` at the repository root, treating it
    // like an uncommitted `.gitignore` there (https://git-scm.com/docs/gitignore).
    // Only the repo root can have this file, so avoid the read everywhere else.
    let exclude_text = if is_repo_root {
      self.environment.read_file(dir_path.join(".git").join("info").join("exclude")).ok()
    } else {
      None
    };
    // git's global excludes file applies repository-wide, so resolve it at the
    // repo root where it becomes the parent of every descendant directory
    let global_lines: &[String] = if is_repo_root { self.options.global_gitignore_lines.as_slice() } else { &[] };
    if gitignore_text.is_none() && exclude_text.is_none() && global_lines.is_empty() {
      return None;
    }

    let mut builder = ignore::gitignore::GitignoreBuilder::new(dir_path);
    // git's precedence is global excludes < `.git/info/exclude` < `.gitignore`,
    // and the last matching pattern wins, so add them in that order
    for line in global_lines {
      builder.add_line(None, line).ok()?;
    }
    if let Some(text) = &exclude_text {
      for line in text.lines() {
        builder.add_line(None, line).ok()?;
      }
    }
    if let Some(text) = &gitignore_text {
      for line in text.lines() {
        builder.add_line(None, line).ok()?;
      }
    }
    // override the gitignore contents to include these paths (escaping so a
    // path with glob characters in its name matches literally)
    for path in &self.options.include_paths {
      if let Ok(suffix) = path.strip_prefix(dir_path) {
        let suffix = escape_glob_text(&suffix.to_string_lossy().replace('\\', "/"));
        let _ignore = builder.add_line(None, &format!("!/{}", suffix));
        if !suffix.ends_with('/') {
          let _ignore = builder.add_line(None, &format!("!/{}/", suffix));
        }
      }
    }
    let gitignore = builder.build().ok()?;
    Some(Rc::new(gitignore))
  }

  fn take_dir_snapshot(&self, dir_path: &Path) -> DirSnapshot {
    let git_path = dir_path.join(".git");
    // not `path_exists` because that would debug log on every refresh
    let has_git = self.environment.fs_metadata(&git_path).is_ok();
    DirSnapshot {
      has_git,
      gitignore: self.take_file_snapshot(&dir_path.join(".gitignore")),
      // only read at the repository root
      exclude: if has_git {
        self.take_file_snapshot(&git_path.join("info").join("exclude"))
      } else {
        None
      },
    }
  }

  fn take_file_snapshot(&self, file_path: &Path) -> Option<FileSnapshot> {
    let metadata = self.environment.fs_metadata(file_path).ok()?;
    Some(FileSnapshot {
      modified: metadata.modified().ok(),
      len: metadata.len(),
    })
  }
}

/// What was resolved for a directory.
struct CachedDir {
  resolved: Option<Rc<DirGitIgnores>>,
  /// Only set when detecting changes.
  snapshot: Option<DirSnapshot>,
}

/// State of the files a directory's gitignore gets resolved from, which
/// is compared to detect when the directory needs to be resolved again.
#[derive(PartialEq, Eq)]
struct DirSnapshot {
  has_git: bool,
  /// `None` when there's no `.gitignore` in the directory.
  gitignore: Option<FileSnapshot>,
  /// `None` when there's no `.git/info/exclude` in the directory.
  exclude: Option<FileSnapshot>,
}

#[derive(PartialEq, Eq)]
struct FileSnapshot {
  modified: Option<SystemTime>,
  len: u64,
}

#[cfg(test)]
mod test {
  use crate::environment::TestEnvironment;

  use super::*;

  #[test]
  fn git_ignore_tree() {
    let env = TestEnvironment::new();
    env.write_file("/.gitignore", "file.txt").unwrap();
    env.mk_dir_all("/sub_dir/sub_dir").unwrap();
    env.write_file("/sub_dir/.gitignore", "data.txt").unwrap();
    env.write_file("/sub_dir/sub_dir/.gitignore", "!file.txt\nignore.txt").unwrap();
    let mut ignore_tree = GitIgnoreTree::new(env, GitIgnoreTreeOptions::default());
    let mut run_test = |path: &str, expected: bool| {
      let path = PathBuf::from(path);
      let gitignore = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
      assert_eq!(gitignore.is_ignored(&path, /* is_dir */ false), expected, "Path: {}", path.display());
    };
    run_test("/file.txt", true);
    run_test("/other.txt", false);
    run_test("/data.txt", false);
    run_test("/sub_dir/file.txt", true);
    run_test("/sub_dir/other.txt", false);
    run_test("/sub_dir/data.txt", true);
    run_test("/sub_dir/sub_dir/file.txt", false); // unignored up here
    run_test("/sub_dir/sub_dir/sub_dir/file.txt", false);
    run_test("/sub_dir/sub_dir/sub_dir/ignore.txt", true);
    run_test("/sub_dir/sub_dir/ignore.txt", true);
    run_test("/sub_dir/ignore.txt", false);
    run_test("/ignore.txt", false);
  }

  #[test]
  fn honours_git_info_exclude() {
    let env = TestEnvironment::new();
    env.write_file("/.gitignore", "from_gitignore.txt").unwrap();
    env.mk_dir_all("/.git/info").unwrap();
    env.write_file("/.git/info/exclude", "from_exclude.txt\n!unexclude.txt").unwrap();
    env.mk_dir_all("/sub_dir").unwrap();
    let mut ignore_tree = GitIgnoreTree::new(env, GitIgnoreTreeOptions::default());
    let mut run_test = |path: &str, expected: bool| {
      let path = PathBuf::from(path);
      let gitignore = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
      assert_eq!(gitignore.is_ignored(&path, /* is_dir */ false), expected, "Path: {}", path.display());
    };
    run_test("/from_gitignore.txt", true);
    run_test("/from_exclude.txt", true);
    // patterns in `.git/info/exclude` apply to descendant directories too
    run_test("/sub_dir/from_exclude.txt", true);
    run_test("/other.txt", false);
  }

  #[test]
  fn global_gitignore_is_lowest_precedence() {
    let env = TestEnvironment::new();
    // a `.git` dir makes `/` the repo root, where the global excludes apply
    env.mk_dir_all("/.git").unwrap();
    env.write_file("/.git/HEAD", "").unwrap();
    env.write_file("/.gitignore", "from_gitignore.txt\n!from_global.txt").unwrap();
    env.mk_dir_all("/sub").unwrap();
    let global_gitignore_lines = vec!["from_global.txt".to_string(), "*.log".to_string()];
    let mut ignore_tree = GitIgnoreTree::new(
      env,
      GitIgnoreTreeOptions {
        global_gitignore_lines,
        ..Default::default()
      },
    );
    let mut run_test = |path: &str, expected: bool| {
      let path = PathBuf::from(path);
      let gitignore = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
      assert_eq!(gitignore.is_ignored(&path, /* is_dir */ false), expected, "Path: {}", path.display());
    };
    // ignored by the global excludes file
    run_test("/from_global.txt", false); // re-included by the closer `.gitignore`
    run_test("/debug.log", true); // global pattern, applies to descendants too
    run_test("/sub/debug.log", true);
    // ignored by the repo `.gitignore`
    run_test("/from_gitignore.txt", true);
    run_test("/other.txt", false);
  }

  #[test]
  fn refresh_detects_changed_added_and_removed_gitignores() {
    let env = TestEnvironment::new();
    env.set_fs_time(1000);
    env.mk_dir_all("/sub_dir/nested").unwrap();
    env.mk_dir_all("/other_dir").unwrap();
    env.write_file("/.gitignore", "a.txt").unwrap();
    let mut ignore_tree = new_change_detecting_tree(&env);
    let mut assert_ignored = |path: &str, expected: bool| {
      let path = PathBuf::from(path);
      ignore_tree.refresh_for_file(&path);
      let is_ignored = ignore_tree
        .get_resolved_git_ignore_for_file(&path)
        .map(|gitignore| gitignore.is_ignored(&path, /* is_dir */ false))
        .unwrap_or(false);
      assert_eq!(is_ignored, expected, "Path: {}", path.display());
    };
    assert_ignored("/a.txt", true);
    assert_ignored("/b.txt", false);
    assert_ignored("/sub_dir/nested/a.txt", true);
    assert_ignored("/other_dir/b.txt", false);

    // changed to text of the same length, so only the modified time differs
    env.set_fs_time(2000);
    env.write_file("/.gitignore", "b.txt").unwrap();
    assert_ignored("/a.txt", false);
    assert_ignored("/b.txt", true);
    // directories that weren't asked about since the change
    assert_ignored("/sub_dir/nested/a.txt", false);
    assert_ignored("/other_dir/b.txt", true);

    // changed without the modified time changing, so only the length differs
    env.write_file("/.gitignore", "b.txt\nc.txt").unwrap();
    assert_ignored("/sub_dir/c.txt", true);

    // added in a directory that was resolved as not having one
    env.write_file("/sub_dir/.gitignore", "!b.txt").unwrap();
    assert_ignored("/sub_dir/nested/b.txt", false);
    assert_ignored("/other_dir/b.txt", true);

    // removed
    env.remove_file("/sub_dir/.gitignore").unwrap();
    assert_ignored("/sub_dir/nested/b.txt", true);
    env.remove_file("/.gitignore").unwrap();
    assert_ignored("/sub_dir/nested/b.txt", false);
    assert_ignored("/b.txt", false);
  }

  #[test]
  fn refresh_detects_git_dir_and_info_exclude_changes() {
    let env = TestEnvironment::new();
    env.mk_dir_all("/repo/sub_dir").unwrap();
    env.write_file("/.gitignore", "a.txt").unwrap();
    let mut ignore_tree = new_change_detecting_tree(&env);
    let mut assert_ignored = |path: &str, expected: bool| {
      let path = PathBuf::from(path);
      ignore_tree.refresh_for_file(&path);
      let is_ignored = ignore_tree
        .get_resolved_git_ignore_for_file(&path)
        .map(|gitignore| gitignore.is_ignored(&path, /* is_dir */ false))
        .unwrap_or(false);
      assert_eq!(is_ignored, expected, "Path: {}", path.display());
    };
    assert_ignored("/repo/sub_dir/a.txt", true);

    // the directory becomes a repository root, so gitignores above it no longer apply
    env.mk_dir_all("/repo/.git/info").unwrap();
    assert_ignored("/repo/sub_dir/a.txt", false);
    assert_ignored("/repo/sub_dir/b.txt", false);

    env.write_file("/repo/.git/info/exclude", "b.txt").unwrap();
    assert_ignored("/repo/sub_dir/b.txt", true);
    env.write_file("/repo/.git/info/exclude", "other.txt").unwrap();
    assert_ignored("/repo/sub_dir/b.txt", false);

    // and back to not being a repository root
    env.remove_dir_all("/repo/.git").unwrap();
    assert_ignored("/repo/sub_dir/a.txt", true);
  }

  #[test]
  fn refresh_keeps_what_was_resolved_when_nothing_changed() {
    let env = TestEnvironment::new();
    env.mk_dir_all("/sub_dir").unwrap();
    env.write_file("/.gitignore", "a.txt").unwrap();
    let path = PathBuf::from("/sub_dir/a.txt");

    let mut ignore_tree = new_change_detecting_tree(&env);
    let first = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
    ignore_tree.refresh_for_file(&path);
    let second = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
    assert!(Rc::ptr_eq(&first, &second));

    // not detecting changes is the default, where a refresh does nothing
    let mut ignore_tree = GitIgnoreTree::new(env.clone(), GitIgnoreTreeOptions::default());
    let first = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
    env.write_file("/.gitignore", "other.txt").unwrap();
    ignore_tree.refresh_for_file(&path);
    let second = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
    assert!(Rc::ptr_eq(&first, &second));
  }

  #[test]
  fn git_info_exclude_without_gitignore() {
    // a repo with only `.git/info/exclude` and no `.gitignore` should still be honoured
    let env = TestEnvironment::new();
    env.mk_dir_all("/.git/info").unwrap();
    env.write_file("/.git/info/exclude", "ignored.txt").unwrap();
    let mut ignore_tree = GitIgnoreTree::new(env, GitIgnoreTreeOptions::default());
    let path = PathBuf::from("/ignored.txt");
    let gitignore = ignore_tree.get_resolved_git_ignore_for_file(&path).unwrap();
    assert!(gitignore.is_ignored(&path, /* is_dir */ false));
  }

  fn new_change_detecting_tree(env: &TestEnvironment) -> GitIgnoreTree<TestEnvironment> {
    GitIgnoreTree::new(
      env.clone(),
      GitIgnoreTreeOptions {
        detect_changes: true,
        ..Default::default()
      },
    )
  }
}