use std::{io, path::Path};

use crate::bstr::BString;
use gix_features::progress::{Count, NestedProgress, Progress};

/// The amount of validation to bypass when removing a linked worktree.
#[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
pub enum Force {
    /// Refuse to remove a dirty worktree or one containing initialized submodules.
    #[default]
    Never,
    /// Discard changes and initialized submodules, but retain locked worktrees.
    DiscardChanges,
    /// Also override a worktree lock.
    OverrideLock,
}

impl Force {
    fn discards_changes(self) -> bool {
        !matches!(self, Force::Never)
    }
}

/// A resolved linked worktree ready for inspection or removal.
pub struct Target<'repo> {
    proxy: crate::worktree::Proxy<'repo>,
    base: std::path::PathBuf,
}

impl Target<'_> {
    /// Return the checkout directory, whether or not it is currently accessible.
    pub fn base(&self) -> &Path {
        &self.base
    }

    /// Open this worktree's repository, even if its checkout is currently inaccessible.
    pub fn repository(&self) -> Result<crate::Repository, crate::open::Error> {
        self.proxy.clone().into_repo_with_possibly_inaccessible_worktree()
    }

    /// Validate and remove this linked worktree.
    pub fn remove<P>(self, force: Force, mut progress: P) -> Result<(), Error>
    where
        P: NestedProgress,
        P::SubProgress: NestedProgress + 'static,
    {
        let Target { proxy, base: work_dir } = self;
        let mut validation = progress.add_child("validate");
        validation.init(Some(1), gix_features::progress::count("worktree"));
        let git_dir = proxy.git_dir().to_owned();
        let ignore_case = proxy.parent.config.ignore_case;

        if proxy.is_locked() && force != Force::OverrideLock {
            return Err(Error::Locked {
                path: work_dir,
                reason: proxy.lock_reason(),
            });
        }

        match std::fs::symlink_metadata(&work_dir) {
            Err(err) if gix_fs::io_err::is_not_found(err.kind(), err.raw_os_error()) => {}
            Err(err) => return Err(Error::WorktreeLocation(err)),
            Ok(_) => {
                validate_backlink(&work_dir, &git_dir, ignore_case)?;
                if !force.discards_changes() {
                    let linked_repo = proxy
                        .into_repo_with_possibly_inaccessible_worktree()
                        .map_err(Error::OpenWorktreeRepo)?;
                    if has_populated_submodule(&linked_repo)? {
                        return Err(Error::ContainsSubmodule { path: work_dir });
                    }
                    let status = validation.add_child("status");
                    let mut iter = linked_repo
                        .status(status)?
                        .untracked_files(crate::status::UntrackedFiles::Files)
                        .index_worktree_submodules(crate::status::Submodule::AsConfigured { check_dirty: true })
                        .into_iter(Vec::new())?;
                    match iter.next() {
                        Some(Ok(_)) => return Err(Error::Dirty { path: work_dir }),
                        Some(Err(err)) => return Err(err.into()),
                        None => {}
                    }
                }
            }
        }
        validation.inc();
        drop(validation);

        gix_worktree::remove::remove(work_dir, git_dir, progress)?;
        Ok(())
    }
}

/// The error returned by [`Repository::remove_worktree()`][crate::Repository::remove_worktree()].
#[derive(Debug, thiserror::Error)]
#[expect(missing_docs)]
pub enum Error {
    #[error("The worktree name or path cannot be empty")]
    EmptyTarget,
    #[error("Could not list linked worktrees")]
    WorktreeListing(#[source] io::Error),
    #[error("Could not read the location of a linked worktree")]
    WorktreeLocation(#[source] io::Error),
    #[error("Could not resolve worktree path '{path}'")]
    ResolvePath {
        path: std::path::PathBuf,
        #[source]
        source: gix_path::realpath::Error,
    },
    #[error("'{target}' is not a registered worktree", target = target.display())]
    NotFound { target: std::path::PathBuf },
    #[error("'{target}' is ambiguous and matches {candidates:?}", target = target.display())]
    Ambiguous {
        target: std::path::PathBuf,
        candidates: Vec<std::path::PathBuf>,
    },
    #[error("The main worktree '{path}' cannot be removed", path = path.display())]
    MainWorktree { path: std::path::PathBuf },
    #[error("The worktree '{path}' is locked{reason}", path = path.display(), reason = display_reason(.reason.as_ref()))]
    Locked {
        path: std::path::PathBuf,
        reason: Option<BString>,
    },
    #[error("Could not read the .git file at '{path}'", path = path.display())]
    ReadBacklink {
        path: std::path::PathBuf,
        #[source]
        source: gix_discover::path::from_gitdir_file::Error,
    },
    #[error("Could not resolve the private Git directory '{path}'", path = path.display())]
    ResolveGitDir {
        path: std::path::PathBuf,
        #[source]
        source: gix_path::realpath::Error,
    },
    #[error("The .git file at '{path}' points to '{actual}', not '{expected}'", path = path.display(), actual = actual.display(), expected = expected.display())]
    BacklinkMismatch {
        path: std::path::PathBuf,
        expected: std::path::PathBuf,
        actual: std::path::PathBuf,
    },
    #[error("Could not open the linked worktree repository")]
    OpenWorktreeRepo(#[source] crate::open::Error),
    #[error("The worktree '{path}' contains an initialized submodule", path = path.display())]
    ContainsSubmodule { path: std::path::PathBuf },
    #[error("Could not open the linked worktree index")]
    OpenIndex(#[from] crate::worktree::open_index::Error),
    #[error("Could not prepare status for the linked worktree")]
    Status(#[from] crate::status::Error),
    #[error("Could not inspect the linked worktree status")]
    StatusIter(#[from] crate::status::into_iter::Error),
    #[error("Could not inspect a linked worktree status item")]
    StatusItem(#[from] crate::status::iter::Error),
    #[error("The worktree '{path}' contains modified or untracked files", path = path.display())]
    Dirty { path: std::path::PathBuf },
    #[error(transparent)]
    Remove(#[from] gix_worktree::remove::Error),
}

impl crate::Repository {
    /// Resolve `target`, which may be a worktree path or a unique trailing path suffix, for later inspection and removal.
    ///
    /// The main worktree cannot be prepared for removal. The returned target can be opened with
    /// [`Target::repository()`] before it is consumed by [`Target::remove()`].
    pub fn prepare_remove_worktree(&self, target: impl AsRef<Path>) -> Result<Target<'_>, Error> {
        resolve(self, target.as_ref())
    }

    /// Remove the linked worktree matching `target`, which may be its path or a unique trailing path suffix.
    ///
    /// The main worktree cannot be removed. By default, modified or untracked files and initialized submodules
    /// prevent removal. [`Force::DiscardChanges`] permits both, while a locked worktree additionally requires
    /// [`Force::OverrideLock`]. The worktree's attached branch, if any, is retained.
    ///
    /// This method may remove the linked worktree represented by `self`. Callers doing so should leave the
    /// checkout before removal, particularly on Windows where a process working directory can prevent deletion.
    pub fn remove_worktree<P>(&self, target: impl AsRef<Path>, force: Force, progress: P) -> Result<(), Error>
    where
        P: NestedProgress,
        P::SubProgress: NestedProgress + 'static,
    {
        self.prepare_remove_worktree(target)?.remove(force, progress)
    }
}

enum Match<'repo> {
    Main(std::path::PathBuf),
    Linked(Target<'repo>),
}

fn resolve<'repo>(repo: &'repo crate::Repository, target: &Path) -> Result<Target<'repo>, Error> {
    if target.as_os_str().is_empty() {
        return Err(Error::EmptyTarget);
    }
    let main = repo
        .main_repo()
        .map_err(Error::OpenWorktreeRepo)?
        .workdir()
        .map(Path::to_owned);
    let ignore_case = repo.config.ignore_case;
    let mut linked = Vec::new();
    for proxy in repo.worktrees().map_err(Error::WorktreeListing)? {
        let Ok(base) = proxy.base() else { continue };
        linked.push(Target { proxy, base });
    }

    let mut suffix_matches = Vec::new();
    if let Some(path) = main.as_ref()
        && path_ends_with(path, target, ignore_case)
    {
        suffix_matches.push(Match::Main(path.clone()));
    }
    for candidate in &linked {
        if path_ends_with(&candidate.base, target, ignore_case) {
            suffix_matches.push(Match::Linked(Target {
                proxy: candidate.proxy.clone(),
                base: candidate.base.clone(),
            }));
        }
    }
    if suffix_matches.len() == 1 {
        return match suffix_matches.pop().expect("exactly one match") {
            Match::Main(path) => Err(Error::MainWorktree { path }),
            Match::Linked(candidate) => Ok(candidate),
        };
    }

    let resolved_target = gix_path::realpath(target).map_err(|source| Error::ResolvePath {
        path: target.to_owned(),
        source,
    })?;
    let mut exact_matches = Vec::new();
    if let Some(path) = main {
        let resolved = gix_path::realpath(&path).map_err(|source| Error::ResolvePath {
            path: path.clone(),
            source,
        })?;
        if path_eq(&resolved, &resolved_target, ignore_case) {
            exact_matches.push(Match::Main(path));
        }
    }
    for candidate in linked {
        let resolved = gix_path::realpath(&candidate.base).map_err(|source| Error::ResolvePath {
            path: candidate.base.clone(),
            source,
        })?;
        if path_eq(&resolved, &resolved_target, ignore_case) {
            exact_matches.push(Match::Linked(candidate));
        }
    }

    match exact_matches.len() {
        0 if suffix_matches.is_empty() => Err(Error::NotFound {
            target: target.to_owned(),
        }),
        0 => Err(Error::Ambiguous {
            target: target.to_owned(),
            candidates: suffix_matches
                .into_iter()
                .map(|candidate| match candidate {
                    Match::Main(path) => path,
                    Match::Linked(candidate) => candidate.base,
                })
                .collect(),
        }),
        1 => match exact_matches.pop().expect("exactly one match") {
            Match::Main(path) => Err(Error::MainWorktree { path }),
            Match::Linked(candidate) => Ok(candidate),
        },
        _ => Err(Error::Ambiguous {
            target: target.to_owned(),
            candidates: exact_matches
                .into_iter()
                .map(|candidate| match candidate {
                    Match::Main(path) => path,
                    Match::Linked(candidate) => candidate.base,
                })
                .collect(),
        }),
    }
}

fn validate_backlink(work_dir: &Path, git_dir: &Path, ignore_case: bool) -> Result<(), Error> {
    let path = work_dir.join(gix_discover::DOT_GIT_DIR);
    let actual = gix_discover::path::from_gitdir_file(&path).map_err(|source| Error::ReadBacklink {
        path: path.clone(),
        source,
    })?;
    let actual = gix_path::realpath(&actual).map_err(|source| Error::ResolveGitDir {
        path: actual.clone(),
        source,
    })?;
    let expected = gix_path::realpath(git_dir).map_err(|source| Error::ResolveGitDir {
        path: git_dir.to_owned(),
        source,
    })?;
    if !path_eq(&actual, &expected, ignore_case) {
        return Err(Error::BacklinkMismatch { path, expected, actual });
    }
    Ok(())
}

fn path_eq(left: &Path, right: &Path, ignore_case: bool) -> bool {
    left.components().count() == right.components().count() && path_ends_with(left, right, ignore_case)
}

fn path_ends_with(path: &Path, suffix: &Path, ignore_case: bool) -> bool {
    if !ignore_case {
        return path.ends_with(suffix);
    }
    let mut path = path.components().rev();
    suffix.components().rev().all(|suffix| {
        path.next().is_some_and(|path| {
            path.as_os_str()
                .as_encoded_bytes()
                .eq_ignore_ascii_case(suffix.as_os_str().as_encoded_bytes())
        })
    })
}

fn has_populated_submodule(repo: &crate::Repository) -> Result<bool, Error> {
    if repo.git_dir().join("modules").is_dir() {
        return Ok(true);
    }
    let index = repo.index_or_empty()?;
    Ok(index.entries().iter().any(|entry| {
        entry.mode == gix_index::entry::Mode::COMMIT
            && repo.workdir().is_some_and(|work_dir| {
                work_dir
                    .join(gix_path::from_bstr(entry.path(&index)))
                    .join(".git")
                    .exists()
            })
    }))
}

fn display_reason(reason: Option<&BString>) -> String {
    reason.map_or_else(String::new, |reason| format!(": {reason}"))
}