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

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

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

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,
            repo.ignore_pattern_parser()?,
        )),
        Default::default(),
    )?;

    let paths: Box<dyn Iterator<Item = gix::bstr::BString>> = match input {
        PathsOrPatterns::Paths(paths) => paths,
        PathsOrPatterns::Patterns(paths) => Box::new(paths.into_iter()),
    };
    for path in paths {
        let mode = gix::path::from_bstr(Cow::Borrowed(path.as_ref()))
            .metadata()
            .ok()
            .map(|m| is_dir_to_mode(m.is_dir()))
            .or_else(|| path.ends_with(b"/").then_some(gix::index::entry::Mode::DIR));
        let query_path = repo.normalize_path(&path)?;
        let entry = cache.at_entry(query_path.as_bstr(), mode)?;
        let match_ = entry
            .matching_exclude_pattern()
            .filter(|m| show_ignore_patterns || !m.pattern.is_negative());
        print_match_unless_tracked(match_, &index, query_path.as_bstr(), path.as_ref(), &mut out)?;
    }

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

fn print_match_unless_tracked(
    match_: Option<gix::ignore::search::Match<'_>>,
    index: &gix::index::State,
    query_path: &BStr,
    display_path: &BStr,
    out: impl std::io::Write,
) -> std::io::Result<()> {
    print_match(match_.filter(|_| !is_tracked(index, query_path)), display_path, out)
}

fn is_tracked(index: &gix::index::State, path: &BStr) -> bool {
    let path = path.trim_end_with(|b| b == '/').as_bstr();
    index.entry_by_path(path).is_some() || index.path_is_directory(path)
}

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}"),
    }
}