use anyhow::{Context, Result, bail};
use gix::{bstr::BString, config::AsKey};
use std::io::Write as _;

use crate::OutputFormat;

/// List all files which contributed sections to the resolved configuration, in precedence order.
pub fn list_files(
    repo: gix::Repository,
    overrides: Vec<BString>,
    format: OutputFormat,
    mut out: impl std::io::Write,
) -> Result<()> {
    if format != OutputFormat::Human {
        bail!("Only human output format is supported at the moment");
    }
    let repo = gix::open_opts(repo.git_dir(), repo.open_options().clone().cli_overrides(overrides))?;
    let config = repo.config_snapshot();
    let mut seen = std::collections::BTreeSet::new();
    for meta in config.sections().map(|section| section.meta()).chain([config.meta()]) {
        let Some(path) = meta.path.as_ref() else {
            continue;
        };
        if seen.insert(path) {
            if meta.level == 0 {
                writeln!(out, "{}\t{{ source={:?} }}", path.display(), meta.source)?;
            } else {
                writeln!(
                    out,
                    "{}\t{{ source={:?}, include-level={} }}",
                    path.display(),
                    meta.source,
                    meta.level
                )?;
            }
        }
    }
    Ok(())
}

pub fn show(
    repo: gix::Repository,
    filters: Vec<BString>,
    overrides: Vec<BString>,
    format: OutputFormat,
    mut out: impl std::io::Write,
) -> Result<()> {
    if format != OutputFormat::Human {
        bail!("Only human output format is supported at the moment");
    }
    let repo = gix::open_opts(repo.git_dir(), repo.open_options().clone().cli_overrides(overrides))?;
    let config = repo.config_snapshot();
    if let Some(frontmatter) = config.frontmatter() {
        for event in frontmatter {
            event.write_to(&mut out)?;
        }
    }
    let filters: Vec<_> = filters.into_iter().map(Filter::new).collect();
    let mut last_meta = None;
    let mut it = config.sections_and_postmatter().peekable();
    while let Some((section, matter)) = it.next() {
        if !filters.is_empty() && !filters.iter().any(|filter| filter.matches_section(&section)) {
            continue;
        }

        let meta = section.meta();
        if last_meta != Some(meta) {
            write_meta(meta, &mut out)?;
        }
        last_meta = Some(meta);

        section.write_to(&mut out)?;
        for event in matter {
            event.write_to(&mut out)?;
        }
        if it
            .peek()
            .is_some_and(|(next_section, _)| next_section.header().name() != section.header().name())
        {
            writeln!(&mut out)?;
        }
    }
    Ok(())
}

/// Format the git configuration file at `in_file`, or the repository-local configuration if `in_file`
/// is `None`, writing the result back in place, to `out_file`, or to `out` (stdout) respectively.
pub fn fmt(
    repo: Option<gix::Repository>,
    in_file: Option<std::path::PathBuf>,
    out_file: Option<std::path::PathBuf>,
    in_place: bool,
    mut out: impl std::io::Write,
) -> Result<()> {
    if in_place && out_file.is_some() {
        bail!("Cannot combine --in-place with an explicit output file");
    }
    let source = match in_file {
        Some(path) => path,
        None => repo
            .context("Formatting the repository-local configuration requires being in a repository")?
            .common_dir()
            .join("config"),
    };
    let lock = in_place
        .then(|| {
            gix::lock::File::acquire_to_update_resource(&source, gix::lock::acquire::Fail::Immediately, None)
                .with_context(|| format!("Could not lock configuration file at '{}'", source.display()))
        })
        .transpose()?;
    let input = std::fs::read(&source)
        .with_context(|| format!("Could not read configuration file at '{}'", source.display()))?;
    let formatted = gix::config::format::normalize(&input, Default::default())?;
    match (lock, out_file) {
        (Some(mut lock), _) => {
            lock.write_all(&formatted)
                .with_context(|| format!("Could not write formatted configuration to '{}.lock'", source.display()))?;
            lock.commit()
                .map_err(|err| err.error)
                .with_context(|| format!("Could not commit formatted configuration to '{}'", source.display()))?;
        }
        (None, Some(path)) => std::fs::write(&path, &formatted)
            .with_context(|| format!("Could not write formatted configuration to '{}'", path.display()))?,
        (None, None) => out.write_all(&formatted)?,
    }
    Ok(())
}

struct Filter {
    name: String,
    subsection: Option<BString>,
}

impl Filter {
    fn new(input: BString) -> Self {
        match (&input).try_as_key() {
            Some(key) => Filter {
                name: key.section_name.into(),
                subsection: key.subsection_name.map(ToOwned::to_owned),
            },
            None => Filter {
                name: input.to_string(),
                subsection: None,
            },
        }
    }

    fn matches_section(&self, section: &gix::config::file::SectionRef<'_>) -> bool {
        let ignore_case = gix::glob::wildmatch::Mode::IGNORE_CASE;

        if !gix::glob::wildmatch(self.name.as_bytes().into(), section.header().name(), ignore_case) {
            return false;
        }
        match (self.subsection.as_deref(), section.header().subsection_name()) {
            (Some(filter), Some(name)) => {
                if !gix::glob::wildmatch(filter.as_slice().into(), name, ignore_case) {
                    return false;
                }
            }
            (None, _) => {}
            (Some(_), None) => return false,
        }
        true
    }
}

fn write_meta(meta: &gix::config::file::Metadata, out: &mut impl std::io::Write) -> std::io::Result<()> {
    writeln!(
        out,
        "# From '{}' ({:?}{}{})",
        meta.path
            .as_deref()
            .map_or_else(|| "memory".into(), |p| p.display().to_string()),
        meta.source,
        if meta.level != 0 {
            format!(", include level {}", meta.level)
        } else {
            Default::default()
        },
        if meta.trust != gix::sec::Trust::Full {
            ", untrusted"
        } else {
            Default::default()
        }
    )
}