#![forbid(unsafe_code)]
#![deny(rust_2018_idioms)]

use bstr::{BStr, BString};

#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
pub enum State<'a> {
    /// The attribute is listed, or has the special value 'true'
    Set,
    /// The attribute has the special value 'false', or was prefixed with a `-` sign.
    Unset,
    /// The attribute is set to the given value, which followed the `=` sign.
    /// Note that values can be empty.
    #[cfg_attr(feature = "serde1", serde(borrow))]
    Value(&'a BStr),
    /// The attribute isn't mentioned with a given path or is explicitly set to `Unspecified` using the `!` sign.
    Unspecified,
}

/// A grouping of lists of patterns while possibly keeping associated to their base path.
///
/// Patterns with base path are queryable relative to that base, otherwise they are relative to the repository root.
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
pub struct MatchGroup<T: match_group::Tag> {
    /// A list of pattern lists, each representing a patterns from a file or specified by hand, in the order they were
    /// specified in.
    ///
    /// During matching, this order is reversed.
    pub patterns: Vec<PatternList<T>>,
}

/// A list of patterns with an optional names, for matching against it.
#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
pub struct PatternList<T: match_group::Tag> {
    /// Patterns and their associated data in the order they were loaded in or specified.
    ///
    /// During matching, this order is reversed.
    pub patterns: Vec<(git_glob::Pattern, T::Value)>,

    /// The path at which the patterns are located in a format suitable for matches, or `None` if the patterns
    /// are relative to the worktree root.
    base: Option<BString>,
}

mod match_group {
    use crate::{MatchGroup, PatternList};
    use std::ffi::OsString;
    use std::path::PathBuf;

    /// A marker trait to identify the type of a description.
    pub trait Tag: Clone + PartialEq + Eq + std::fmt::Debug + std::hash::Hash + Ord + PartialOrd {
        /// The value associated with a pattern.
        type Value: PartialEq + Eq + std::fmt::Debug + std::hash::Hash + Ord + PartialOrd + Clone;
    }

    /// Identify ignore patterns.
    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
    pub struct Ignore;
    impl Tag for Ignore {
        type Value = ();
    }

    /// Identify patterns with attributes.
    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
    pub struct Attributes;
    impl Tag for Attributes {
        /// TODO: identify the actual value, should be name/State pairs, but there is the question of storage.
        type Value = ();
    }

    impl MatchGroup<Ignore> {
        /// See [PatternList::<Ignore>::from_overrides()] for details.
        pub fn from_overrides(patterns: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
            MatchGroup {
                patterns: vec![PatternList::<Ignore>::from_overrides(patterns)],
            }
        }
    }

    impl PatternList<Ignore> {
        /// Parse a list of patterns, using slashes as path separators
        pub fn from_overrides(patterns: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
            PatternList {
                patterns: patterns
                    .into_iter()
                    .map(Into::into)
                    .filter_map(|pattern| {
                        let pattern = git_features::path::into_bytes(PathBuf::from(pattern)).ok()?;
                        git_glob::parse(pattern.as_ref()).map(|p| (p, ()))
                    })
                    .collect(),
                base: None,
            }
        }
    }
}
pub use match_group::{Attributes, Ignore, Tag};

pub type Files = MatchGroup<Attributes>;
pub type IgnoreFiles = MatchGroup<Ignore>;

pub mod parse;

pub fn parse(buf: &[u8]) -> parse::Lines<'_> {
    parse::Lines::new(buf)
}