use crate::OutputFormat;

#[derive(Default, Copy, Clone)]
pub enum FindRepository {
    #[default]
    NonBare,
    All,
}

pub struct Options {
    pub debug: bool,
    pub format: OutputFormat,
    pub execute: bool,
    pub ignored: bool,
    pub precious: bool,
    pub directories: bool,
    pub repositories: bool,
    pub pathspec_matches_result: bool,
    pub skip_hidden_repositories: Option<FindRepository>,
    pub find_untracked_repositories: FindRepository,
}
pub(crate) mod function {
    use std::{borrow::Cow, path::Path};

    use anyhow::bail;
    use gix::{
        bstr::{BString, ByteSlice},
        dir::{
            EntryRef,
            entry::{Kind, Status},
            walk,
            walk::{EmissionMode::CollapseDirectory, ForDeletionMode::*},
        },
    };

    use crate::{
        OutputFormat,
        repository::clean::{FindRepository, Options},
    };

    pub fn clean(
        repo: gix::Repository,
        out: &mut dyn std::io::Write,
        err: &mut dyn std::io::Write,
        patterns: Vec<BString>,
        Options {
            debug,
            format,
            mut execute,
            ignored,
            precious,
            directories,
            repositories,
            skip_hidden_repositories,
            find_untracked_repositories,
            pathspec_matches_result,
        }: Options,
    ) -> anyhow::Result<()> {
        if format != OutputFormat::Human {
            bail!("JSON output isn't implemented yet");
        }
        let Some(workdir) = repo.workdir() else {
            bail!("Need a worktree to clean, this is a bare repository");
        };

        let index = repo.index_or_empty()?;
        let pathspec_for_dirwalk = !pathspec_matches_result;
        let has_patterns = !patterns.is_empty();
        let mut collect = InterruptibleCollect::default();
        let collapse_directories = CollapseDirectory;
        let options = repo
            .dirwalk_options()?
            .emit_pruned(true)
            .for_deletion(if (ignored || precious) && directories {
                match skip_hidden_repositories {
                    Some(FindRepository::NonBare) => Some(FindNonBareRepositoriesInIgnoredDirectories),
                    Some(FindRepository::All) => Some(FindRepositoriesInIgnoredDirectories),
                    None => Some(Default::default()),
                }
            } else {
                Some(Default::default())
            })
            .classify_untracked_bare_repositories(matches!(find_untracked_repositories, FindRepository::All))
            .emit_untracked(collapse_directories)
            .emit_ignored(Some(collapse_directories))
            .empty_patterns_match_prefix(true)
            .emit_empty_directories(true);
        repo.dirwalk(
            &index,
            if pathspec_for_dirwalk {
                patterns.clone()
            } else {
                Vec::new()
            },
            &gix::interrupt::IS_INTERRUPTED,
            options,
            &mut collect,
        )?;

        let mut pathspec = pathspec_matches_result
            .then(|| {
                repo.pathspec(
                    true,
                    patterns,
                    true,
                    &index,
                    gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping,
                )
            })
            .transpose()?;
        let prefix = repo.prefix()?.unwrap_or(Path::new(""));
        let entries = collect.inner.into_entries_by_path();
        let mut entries_to_clean = 0;
        let mut skipped_directories = 0;
        let mut skipped_ignored = 0;
        let mut skipped_precious = 0;
        let mut skipped_repositories = 0;
        let mut pruned_entries = 0;
        let mut saw_ignored_directory = false;
        let mut saw_untracked_directory = false;
        for (mut entry, dir_status) in entries.into_iter() {
            if dir_status.is_some() {
                if debug {
                    writeln!(
                        err,
                        "DBG: prune '{}' {:?} as parent dir is used instead",
                        entry.rela_path, entry.status
                    )
                    .ok();
                }
                continue;
            }

            let pathspec_includes_entry = match pathspec.as_mut() {
                None => entry
                    .pathspec_match
                    .is_some_and(|m| m != gix::dir::entry::PathspecMatch::Excluded),
                Some(pathspec) => pathspec
                    .pattern_matching_relative_path(entry.rela_path.as_bstr(), entry.disk_kind.map(|k| k.is_dir()))
                    .is_some_and(|m| !m.is_excluded()),
            };
            pruned_entries += usize::from(!pathspec_includes_entry);
            if !pathspec_includes_entry && debug {
                writeln!(err, "DBG: prune '{}'", entry.rela_path).ok();
            }
            if entry.status.is_pruned() || !pathspec_includes_entry {
                continue;
            }

            let keep = match entry.status {
                Status::Pruned => {
                    unreachable!("BUG: we skipped these above")
                }
                Status::Tracked => {
                    unreachable!("BUG: tracked aren't emitted")
                }
                Status::Ignored(gix::ignore::Kind::Expendable) => {
                    skipped_ignored += usize::from(!ignored);
                    ignored
                }
                Status::Ignored(gix::ignore::Kind::Precious) => {
                    skipped_precious += usize::from(!precious);
                    precious
                }
                Status::Untracked => true,
            };
            if entry.disk_kind.is_none() {
                entry.disk_kind = workdir
                    .join(gix::path::from_bstr(entry.rela_path.as_bstr()))
                    .symlink_metadata()
                    .ok()
                    .map(|e| e.file_type().into());
            }
            let Some(mut disk_kind) = entry.disk_kind else {
                if debug {
                    writeln!(err, "DBG: ignoring unreadable entry at '{}' ", entry.rela_path).ok();
                }
                continue;
            };
            if !keep {
                if debug {
                    writeln!(err, "DBG: prune '{}' as -x or -p is missing", entry.rela_path).ok();
                }
                continue;
            }

            if disk_kind == gix::dir::entry::Kind::Directory
                && gix::discover::is_git(&workdir.join(gix::path::from_bstr(entry.rela_path.as_bstr()))).is_ok()
            {
                if debug {
                    writeln!(err, "DBG: upgraded directory '{}' to bare repository", entry.rela_path).ok();
                }
                disk_kind = gix::dir::entry::Kind::Repository;
            }

            match disk_kind {
                Kind::Untrackable => {
                    if debug {
                        writeln!(err, "DBG: skipped untrackable entry at '{}'", entry.rela_path).ok();
                    }
                    continue;
                }
                Kind::File | Kind::Symlink => {}
                Kind::Directory => {
                    if !directories {
                        skipped_directories += 1;
                        if debug {
                            writeln!(err, "DBG: prune '{}' as -d is missing", entry.rela_path).ok();
                        }
                        continue;
                    }
                }
                Kind::Repository => {
                    if !repositories {
                        skipped_repositories += 1;
                        if debug {
                            writeln!(err, "DBG: skipped repository at '{}'", entry.rela_path)?;
                        }
                        continue;
                    }
                }
            }

            let is_ignored = matches!(entry.status, gix::dir::entry::Status::Ignored(_));
            let entry_path = gix::path::from_bstr(entry.rela_path);
            let display_path = gix::path::relativize_with_prefix(&entry_path, prefix);
            if disk_kind == gix::dir::entry::Kind::Directory {
                saw_ignored_directory |= is_ignored;
                saw_untracked_directory |= entry.status == gix::dir::entry::Status::Untracked;
            }

            if gix::interrupt::is_triggered() {
                execute = false;
            }
            let mut may_remove_this_entry = execute;
            writeln!(
                out,
                "{maybe}{suffix} {}{} {status}",
                display_path.display(),
                if disk_kind.is_dir() { "/" } else { Default::default() },
                status = match entry.status {
                    Status::Ignored(kind) => {
                        Cow::Owned(format!(
                            "({})",
                            match kind {
                                gix::ignore::Kind::Precious => "💲",
                                gix::ignore::Kind::Expendable => "🗑️",
                            }
                        ))
                    }
                    Status::Untracked => {
                        "".into()
                    }
                    status =>
                        if debug {
                            format!("(DBG: {status:?})").into()
                        } else {
                            "".into()
                        },
                },
                maybe = if entry.property == Some(gix::dir::entry::Property::EmptyDirectoryAndCWD) {
                    may_remove_this_entry = false;
                    if execute {
                        "Refusing to remove empty current working directory"
                    } else {
                        "Would refuse to remove empty current working directory"
                    }
                } else if execute {
                    "removing"
                } else {
                    "WOULD remove"
                },
                suffix = match disk_kind {
                    Kind::Untrackable => unreachable!("always skipped earlier"),
                    Kind::Directory if entry.property == Some(gix::dir::entry::Property::EmptyDirectory) => {
                        " empty"
                    }
                    Kind::Repository => {
                        " repository"
                    }
                    Kind::File | Kind::Symlink | Kind::Directory => {
                        ""
                    }
                },
            )?;

            if may_remove_this_entry {
                let path = workdir.join(entry_path);
                if disk_kind.is_dir() {
                    std::fs::remove_dir_all(path)?;
                } else {
                    std::fs::remove_file(path)?;
                }
            } else {
                entries_to_clean += 1;
            }
        }
        if !execute {
            let mut messages = Vec::new();
            messages.extend((skipped_directories > 0).then(|| {
                format!(
                    "Skipped {skipped_directories} {directories} - show with -d",
                    directories = plural("directory", "directories", skipped_directories)
                )
            }));
            messages.extend((skipped_repositories > 0).then(|| {
                format!(
                    "Skipped {skipped_repositories} {repositories} - show with -r",
                    repositories = plural("repository", "repositories", skipped_repositories)
                )
            }));
            messages.extend((skipped_ignored > 0).then(|| {
                format!(
                    "Skipped {skipped_ignored} expendable {entries} - show with -x",
                    entries = plural("entry", "entries", skipped_ignored)
                )
            }));
            messages.extend((skipped_precious > 0).then(|| {
                format!(
                    "Skipped {skipped_precious} precious {entries} - show with -p",
                    entries = plural("entry", "entries", skipped_precious)
                )
            }));
            messages.extend((pruned_entries > 0 && has_patterns).then(|| {
                format!(
                    "try to adjust your pathspec to reveal some of the {pruned_entries} pruned {entries} - show with --debug",
                    entries = plural("entry", "entries", pruned_entries)
                )
            }));
            let make_msg = || -> String {
                if messages.is_empty() {
                    return String::new();
                }
                messages.join("; ")
            };
            let wrap_in_parens = |msg: String| if msg.is_empty() { msg } else { format!(" ({msg})") };
            if entries_to_clean > 0 {
                let mut wrote_nl = false;
                let msg = make_msg();
                let mut msg = if msg.is_empty() { None } else { Some(msg) };
                if saw_ignored_directory && skip_hidden_repositories.is_none() {
                    writeln!(err).ok();
                    wrote_nl = true;
                    writeln!(
                        err,
                        "WARNING: would remove repositories hidden inside ignored directories - use --skip-hidden-repositories to skip{}",
                        wrap_in_parens(msg.take().unwrap_or_default())
                    )?;
                }
                if saw_untracked_directory && matches!(find_untracked_repositories, FindRepository::NonBare) {
                    if !wrote_nl {
                        writeln!(err).ok();
                        wrote_nl = true;
                    }
                    writeln!(
                        err,
                        "WARNING: would remove repositories hidden inside untracked directories - use --find-untracked-repositories to find{}",
                        wrap_in_parens(msg.take().unwrap_or_default())
                    )?;
                }
                if let Some(msg) = msg.take() {
                    if !wrote_nl {
                        writeln!(err).ok();
                    }
                    writeln!(err, "{msg}").ok();
                }
            } else {
                writeln!(err, "Nothing to clean{}", wrap_in_parens(make_msg()))?;
            }
            if gix::interrupt::is_triggered() {
                writeln!(err, "Result may be incomplete as it was interrupted")?;
            }
        }
        Ok(())
    }

    fn plural<'a>(one: &'a str, many: &'a str, number: usize) -> &'a str {
        if number == 1 { one } else { many }
    }

    #[derive(Default)]
    struct InterruptibleCollect {
        inner: gix::dir::walk::delegate::Collect,
    }

    impl gix::dir::walk::Delegate for InterruptibleCollect {
        fn emit(&mut self, entry: EntryRef<'_>, collapsed_directory_status: Option<Status>) -> walk::Action {
            let res = self.inner.emit(entry, collapsed_directory_status);
            if gix::interrupt::is_triggered() {
                return std::ops::ControlFlow::Break(());
            }
            res
        }
    }
}