use std::str::FromStr;

use smallvec::SmallVec;

use crate::Time;

/// Errors that can occur when parsing dates.
#[derive(Debug, Clone)]
#[allow(missing_docs)]
pub enum Error {
    RelativeTimeConversion,
    InvalidDateString { input: String },
    InvalidDate(std::num::TryFromIntError),
    MissingCurrentTime,
}

impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::RelativeTimeConversion => write!(f, "Could not convert a duration into a date"),
            Error::InvalidDateString { input } => write!(f, "Date string can not be parsed: {input}"),
            Error::InvalidDate(err) => write!(f, "The heat-death of the universe happens before this date: {err}"),
            Error::MissingCurrentTime => write!(f, "Current time is missing but required to handle relative dates."),
        }
    }
}

impl std::error::Error for Error {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Error::InvalidDate(err) => Some(err),
            _ => None,
        }
    }
}

/// A wrapper around `exn::Exn<Error>` that implements `std::error::Error`.
///
/// This type is returned by functions that integrate with external APIs requiring `std::error::Error`,
/// while internally using exn for context-aware error tracking.
#[derive(Debug)]
pub struct ParseError(exn::Exn<Error>);

impl ParseError {
    /// Create a ParseError from an exn error.
    pub fn from_exn(exn: exn::Exn<Error>) -> Self {
        Self(exn)
    }

    /// Get a reference to the underlying error.
    pub fn as_error(&self) -> &Error {
        self.0.as_error()
    }
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.0, f)
    }
}

impl std::error::Error for ParseError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        Some(self.0.as_error())
    }
}

impl From<exn::Exn<Error>> for ParseError {
    fn from(exn: exn::Exn<Error>) -> Self {
        Self(exn)
    }
}

/// A container for just enough bytes to hold the largest-possible [`time`](Time) instance.
/// It's used in conjunction with
#[derive(Default, Clone)]
pub struct TimeBuf {
    buf: SmallVec<[u8; Time::MAX.size()]>,
}

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 {
        // SAFETY: We know that serialized times are pure ASCII, a subset of UTF-8.
        //         `buf` and `len` are written only by time-serialization code.
        let time_bytes = self.buf.as_slice();
        #[allow(unsafe_code)]
        unsafe {
            std::str::from_utf8_unchecked(time_bytes)
        }
    }

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

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 buf.buf)
            .expect("write to memory of just the right size cannot fail");
        buf.as_str()
    }
}

impl FromStr for Time {
    type Err = ParseError;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        crate::parse_header(s)
            .ok_or_else(|| Error::InvalidDateString { input: s.into() })
            .map_err(|e| ParseError::from_exn(exn::Exn::from(e)))
    }
}

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