//! `.oxyattributes` (spec §19): per-path attributes in gitattributes syntax.
//! Each line is `pattern attr...` where an attribute is `binary`, `text`
//! (or `-binary`), `eol=lf`, `eol=crlf`, `nocompress`, or `lockable`. A
//! pattern without a slash matches a basename anywhere below the file's
//! directory; one with a slash is anchored to that directory. Later rules
//! override earlier ones per attribute.

use globset::{Glob, GlobMatcher};
use std::collections::BTreeMap;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Eol {
    Lf,
    Crlf,
}

/// The attributes in force for one path.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct Attrs {
    /// `Some(true)` forces opaque, `Some(false)` forces text (absent NUL bytes).
    pub binary: Option<bool>,
    pub eol: Option<Eol>,
    pub nocompress: bool,
    pub lockable: bool,
}

struct Rule {
    matcher: GlobMatcher,
    attrs: Vec<(String, Option<String>)>,
}

#[derive(Default)]
pub struct Attributes {
    rules: Vec<Rule>,
}

impl Attributes {
    /// Add the rules of one `.oxyattributes` file living in `dir` (`""` for the root).
    pub fn add_file(&mut self, dir: &str, text: &str) {
        for line in text.lines() {
            let line = line.trim();
            if line.is_empty() || line.starts_with('#') {
                continue;
            }
            let mut parts = line.split_whitespace();
            let Some(pattern) = parts.next() else {
                continue;
            };
            let attrs: Vec<(String, Option<String>)> = parts
                .map(|a| match a.split_once('=') {
                    Some((k, v)) => (k.to_string(), Some(v.to_string())),
                    None => (a.to_string(), None),
                })
                .collect();
            let anchored = pattern.contains('/');
            let core = pattern.trim_start_matches('/');
            let full = match (dir.is_empty(), anchored) {
                (true, true) => core.to_string(),
                (true, false) => format!("**/{core}"),
                (false, true) => format!("{dir}/{core}"),
                (false, false) => format!("{dir}/**/{core}"),
            };
            if let Ok(g) = Glob::new(&full) {
                self.rules.push(Rule {
                    matcher: g.compile_matcher(),
                    attrs,
                });
            }
        }
    }

    /// Build from every `.oxyattributes` in `files` (path → content).
    pub fn from_files<'a>(files: impl IntoIterator<Item = (&'a str, &'a [u8])>) -> Attributes {
        let mut sorted: BTreeMap<&str, &[u8]> = BTreeMap::new();
        for (p, c) in files {
            if p == ".oxyattributes" || p.ends_with("/.oxyattributes") {
                sorted.insert(p, c);
            }
        }
        let mut out = Attributes::default();
        // Shallower files first so deeper ones override.
        let mut entries: Vec<(&str, &[u8])> = sorted.into_iter().collect();
        entries.sort_by_key(|(p, _)| p.matches('/').count());
        for (p, c) in entries {
            let dir = p
                .strip_suffix(".oxyattributes")
                .unwrap_or("")
                .trim_end_matches('/');
            out.add_file(dir, &String::from_utf8_lossy(c));
        }
        out
    }

    pub fn lookup(&self, path: &str) -> Attrs {
        let mut a = Attrs::default();
        for r in &self.rules {
            if !r.matcher.is_match(path) {
                continue;
            }
            for (k, v) in &r.attrs {
                match (k.as_str(), v.as_deref()) {
                    ("binary", None) => a.binary = Some(true),
                    ("-binary", None) | ("text", None) => a.binary = Some(false),
                    ("eol", Some("lf")) => a.eol = Some(Eol::Lf),
                    ("eol", Some("crlf")) => a.eol = Some(Eol::Crlf),
                    ("-eol", None) => a.eol = None,
                    ("nocompress", None) => a.nocompress = true,
                    ("-nocompress", None) => a.nocompress = false,
                    ("lockable", None) => a.lockable = true,
                    ("-lockable", None) => a.lockable = false,
                    _ => {}
                }
            }
        }
        a
    }

    pub fn is_empty(&self) -> bool {
        self.rules.is_empty()
    }
}

/// `\r\n` → `\n`, as stored for `eol=` files.
pub fn normalize_eol(bytes: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(bytes.len());
    let mut i = 0;
    while i < bytes.len() {
        if bytes[i] == b'\r' && bytes.get(i + 1) == Some(&b'\n') {
            i += 1;
            continue;
        }
        out.push(bytes[i]);
        i += 1;
    }
    out
}

/// `\n` → `\r\n` (lines already ending in `\r\n` are left alone).
pub fn to_crlf(bytes: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(bytes.len() + bytes.len() / 16);
    let mut prev = 0u8;
    for &b in bytes {
        if b == b'\n' && prev != b'\r' {
            out.push(b'\r');
        }
        out.push(b);
        prev = b;
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parsing_and_precedence() {
        let a = Attributes::from_files([
            (".oxyattributes", &b"*.png binary nocompress\n*.txt eol=lf\ndocs/*.txt eol=crlf\nmodels/** lockable\n"[..]),
            ("src/.oxyattributes", &b"*.dat binary\ngen.txt -eol\n"[..]),
            ("README.md", &b"not attributes"[..]),
        ]);
        assert_eq!(
            a.lookup("a/b/logo.png"),
            Attrs {
                binary: Some(true),
                eol: None,
                nocompress: true,
                lockable: false
            }
        );
        assert_eq!(a.lookup("notes.txt").eol, Some(Eol::Lf));
        assert_eq!(a.lookup("docs/notes.txt").eol, Some(Eol::Crlf));
        assert!(a.lookup("models/x/y.bin").lockable);
        assert_eq!(a.lookup("src/deep/x.dat").binary, Some(true));
        assert_eq!(a.lookup("other/x.dat").binary, None);
        assert_eq!(a.lookup("src/gen.txt").eol, None, "deeper file overrides");
        assert_eq!(a.lookup("src/other.txt").eol, Some(Eol::Lf));
        assert_eq!(a.lookup("plain"), Attrs::default());
    }

    #[test]
    fn eol_conversions() {
        assert_eq!(normalize_eol(b"a\r\nb\nc\r\n"), b"a\nb\nc\n");
        assert_eq!(to_crlf(b"a\nb\r\nc\n"), b"a\r\nb\r\nc\r\n");
        assert_eq!(normalize_eol(&to_crlf(b"x\ny\n")), b"x\ny\n");
    }
}