use crate::{borrowed, spanned, Span};
use bstr::{BStr, ByteSlice};

#[derive(Clone, PartialOrd, PartialEq, Ord, Eq)]
pub(crate) enum Token {
    Section(spanned::Section),
    Entry(spanned::Entry),
    Comment(spanned::Comment),
}

impl Token {
    pub fn as_entry(&self) -> Option<&spanned::Entry> {
        match self {
            Token::Entry(v) => Some(v),
            _ => None,
        }
    }
    pub fn as_section(&self) -> Option<&spanned::Section> {
        match self {
            Token::Section(v) => Some(v),
            _ => None,
        }
    }
}

/// The entry point into reading and writing git config files.
///
/// After reading a configuration file its contents is stored verbatim and indexed to allow retrieval
/// of sections and entry values on demand. These are returned as [`borrowed`] items, which are read-only but
/// can be transformed into editable items.
#[derive(Clone, PartialOrd, PartialEq, Ord, Eq)]
pub struct File {
    buf: Vec<u8>,
    /// A config file as parsed into tokens, where each [`Token`] is one of the three relevant items in git config files.
    tokens: Vec<Token>, // but how do we get fast lookups and proper value lookup based on decoded values?
                        // On the fly is easier, otherwise we have to deal with a lookup cache of sorts and
                        // many more allocations up front (which might be worth it only once we have measurements).
                        // Cow<'a, _> would bind to our buffer so the cache can't be in this type.
                        // Probably it could be the 'Config' type which handles multiple files and treats them as one,
                        // and only if there is any need.
}

impl File {
    pub(crate) fn bytes_at(&self, span: Span) -> &BStr {
        &self.buf[span.to_range()].as_bstr()
    }

    pub(crate) fn token(&self, index: usize) -> &Token {
        &self.tokens[index]
    }
}

impl File {
    /// Returns an iterator over all sections and sub-sections of the configuration file.
    ///
    /// Note that every entry must be part of a section, that is global entries/key-value pairs are not allowed.
    pub fn sections(&self) -> impl Iterator<Item = borrowed::Section<'_>> {
        self.tokens
            .iter()
            .enumerate()
            .filter_map(move |(index, t)| t.as_section().map(|_| borrowed::Section { parent: self, index }))
    }
}

impl<'a> borrowed::Section<'a> {
    /// Returns an iterator over all entries in a section.
    pub fn entries(&self) -> impl Iterator<Item = borrowed::Entry<'_>> {
        struct Iter<'a> {
            inner: Option<&'a [Token]>,
            parent: &'a File,
            index: usize,
            offset: usize,
        }
        impl<'a> Iterator for Iter<'a> {
            type Item = borrowed::Entry<'a>;

            fn next(&mut self) -> Option<Self::Item> {
                match self.inner.as_ref() {
                    Some(s) => {
                        let r = loop {
                            break match s.get(self.index) {
                                None | Some(Token::Section(_)) => {
                                    self.inner = None;
                                    None
                                }
                                Some(Token::Entry(_)) => Some(borrowed::Entry {
                                    parent: self.parent,
                                    index: self.index + self.offset,
                                }),
                                Some(Token::Comment(_)) => continue,
                            };
                        };
                        self.index += 1;
                        r
                    }
                    None => None,
                }
            }
        }
        let start_of_entries = self.index + 1;
        Iter {
            inner: self.parent.tokens.get(start_of_entries..),
            parent: self.parent,
            index: 0,
            offset: start_of_entries,
        }
    }
}

mod edit;
pub use edit::Edits;