use std::{borrow::Cow, io};

use anyhow::{anyhow, bail};
use gix::bstr::BStr;

use crate::{repository::PathsOrPatterns, OutputFormat};

pub mod query {
    use std::ffi::OsString;

    use crate::OutputFormat;

    pub struct Options {
        pub format: OutputFormat,
        pub overrides: Vec<OsString>,
        pub show_ignore_patterns: bool,
        pub statistics: bool,
    }
}

pub fn query(
    repo: gix::Repository,
    input: PathsOrPatterns,
    mut out: impl io::Write,
    mut err: impl io::Write,
    query::Options {
        overrides,
        format,
        show_ignore_patterns,
        statistics,
    }: query::Options,
) -> anyhow::Result<()> {
    if format != OutputFormat::Human {
        bail!("JSON output isn't implemented yet");
    }

    let index = repo.index()?;
    let mut cache = repo.excludes(
        &index,
        Some(gix::ignore::Search::from_overrides(overrides.into_iter())),
        Default::default(),
    )?;

    match input {
        PathsOrPatterns::Paths(paths) => {
            for path in paths {
                let is_dir = gix::path::from_bstr(Cow::Borrowed(path.as_ref()))
                    .metadata()
                    .ok()
                    .map(|m| m.is_dir());
                let entry = cache.at_entry(path.as_slice(), is_dir)?;
                let match_ = entry
                    .matching_exclude_pattern()
                    .and_then(|m| (show_ignore_patterns || !m.pattern.is_negative()).then_some(m));
                print_match(match_, path.as_ref(), &mut out)?;
            }
        }
        PathsOrPatterns::Patterns(patterns) => {
            let mut pathspec_matched_something = false;
            let mut pathspec = repo.pathspec(
                patterns.iter(),
                repo.work_dir().is_some(),
                &index,
                gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping.adjust_for_bare(repo.is_bare()),
            )?;

            for (path, _entry) in pathspec
                .index_entries_with_paths(&index)
                .ok_or_else(|| anyhow!("Pathspec didn't yield any entry"))?
            {
                pathspec_matched_something = true;
                let entry = cache.at_entry(path, Some(false))?;
                let match_ = entry
                    .matching_exclude_pattern()
                    .and_then(|m| (show_ignore_patterns || !m.pattern.is_negative()).then_some(m));
                print_match(match_, path, &mut out)?;
            }

            if !pathspec_matched_something {
                // TODO(borrowchk): this shouldn't be necessary at all, but `pathspec` stays borrowed mutably for some reason.
                //                  It's probably due to the strange lifetimes of `index_entries_with_paths()`.
                let pathspec = repo.pathspec(
                    patterns.iter(),
                    repo.work_dir().is_some(),
                    &index,
                    gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping
                        .adjust_for_bare(repo.is_bare()),
                )?;
                for pattern in pathspec.search().patterns() {
                    let path = pattern.path();
                    let entry = cache.at_entry(
                        path,
                        pattern
                            .signature
                            .contains(gix::pathspec::MagicSignature::MUST_BE_DIR)
                            .into(),
                    )?;
                    let match_ = entry
                        .matching_exclude_pattern()
                        .and_then(|m| (show_ignore_patterns || !m.pattern.is_negative()).then_some(m));
                    print_match(match_, path, &mut out)?;
                }
            }
        }
    }

    if let Some(stats) = statistics.then(|| cache.take_statistics()) {
        out.flush()?;
        writeln!(err, "{stats:#?}").ok();
    }
    Ok(())
}

fn print_match(
    m: Option<gix::ignore::search::Match<'_>>,
    path: &BStr,
    mut out: impl std::io::Write,
) -> std::io::Result<()> {
    match m {
        Some(m) => writeln!(
            out,
            "{}:{}:{}\t{}",
            m.source.map(std::path::Path::to_string_lossy).unwrap_or_default(),
            m.sequence_number,
            m.pattern,
            path
        ),
        None => writeln!(out, "::\t{path}"),
    }
}