use std::io;
use std::str::FromStr;

use crate::{Error, Time};

/// A container for just enough bytes to hold the largest possible serialization of a [`Time`].
#[derive(Default, Clone)]
pub struct TimeBuf {
    /// One past the last byte written into `buf`.
    end_idx: usize,
    /// Fixed storage large enough for the widest raw time serialization.
    buf: [u8; Time::MIN.size()],
}

/// Adapter to make [`TimeBuf`] writable only while `Time::to_str()` serializes into it.
///
/// This keeps [`TimeBuf`] as plain reusable storage: callers can inspect the finished bytes through
/// [`TimeBuf::as_str()`], but cannot append arbitrary bytes or leave it in a partially-written state.
struct TimeBufWriter<'a>(&'a mut TimeBuf);

impl io::Write for TimeBufWriter<'_> {
    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
        let idx = self.0.end_idx;
        let end_idx = idx
            .checked_add(buf.len())
            .ok_or_else(|| io::Error::from(io::ErrorKind::OutOfMemory))?;
        if end_idx > Time::MIN.size() {
            return Err(io::Error::from(io::ErrorKind::StorageFull));
        }
        self.0.buf[idx..end_idx].copy_from_slice(buf);
        self.0.end_idx = end_idx;
        Ok(buf.len())
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

impl TimeBuf {
    /// Represent this instance as standard string, serialized in a format compatible with
    /// signature fields in Git commits, also known as anything parseable as [raw format](function::parse_header()).
    pub fn as_str(&self) -> &str {
        // Time serializes as ASCII, which is a subset of UTF-8.
        let time_bytes = &self.buf[..self.end_idx];
        std::str::from_utf8(time_bytes).expect("time serializes as valid UTF-8")
    }

    /// Clear the previous content.
    fn clear(&mut self) {
        self.end_idx = 0;
    }
}

impl Time {
    /// Serialize this instance into `buf`, exactly as it would appear in the header of a Git commit,
    /// and return `buf` as `&str` for easy consumption.
    pub fn to_str<'a>(&self, buf: &'a mut TimeBuf) -> &'a str {
        buf.clear();
        self.write_to(&mut TimeBufWriter(buf))
            .expect("write to memory of just the right size cannot fail");
        buf.as_str()
    }
}

impl FromStr for Time {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        crate::parse_header(s).ok_or_else(|| Error::new_with_input("invalid time", s))
    }
}

pub(crate) mod function;
mod git;
mod raw;
mod relative;