//! Library for implement Radicle CI adapters in Rust.

//! The types in this module are meant to be useful for anyone writing
//! a Radicle CI adapter in Rust. The broker/adapter interface and
//! protocol does not require the adapter to use Rust.

#![deny(missing_docs)]

use std::{
    fmt,
    fs::{File, OpenOptions},
    hash::{Hash, Hasher},
    io::{BufRead, BufReader, Read, Write},
    path::{Path, PathBuf},
    process::Command,
};

use nonempty::{NonEmpty, nonempty};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use time::{OffsetDateTime, macros::format_description};
use uuid::Uuid;

use radicle::{Profile, git::Oid, identity::Did, node::Alias, patch::RevisionId};
pub use radicle::{
    cob::patch::PatchId,
    prelude::{NodeId, RepoId},
};
pub use radicle_surf::Commit;

/// The type of a run identifier. For maximum generality, this is a
/// string rather than an integer.
///
/// # Example
/// ```rust
/// use radicle_ci_adapter::RunId;
/// let id = RunId::from("abracadabra");
/// println!("{}", id.to_string());
/// ```
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct RunId {
    id: String,
}

impl Default for RunId {
    fn default() -> Self {
        Self {
            id: Uuid::new_v4().to_string(),
        }
    }
}

impl Hash for RunId {
    fn hash<H: Hasher>(&self, h: &mut H) {
        self.id.hash(h);
    }
}

impl From<&str> for RunId {
    fn from(id: &str) -> Self {
        Self { id: id.into() }
    }
}

impl TryFrom<Value> for RunId {
    type Error = ();
    fn try_from(id: Value) -> Result<Self, Self::Error> {
        match id {
            Value::String(s) => Ok(Self::from(s.as_str())),
            _ => Err(()),
        }
    }
}

impl fmt::Display for RunId {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        write!(f, "{}", self.id)
    }
}

impl RunId {
    /// Return representation of identifier as a string slice.
    pub fn as_str(&self) -> &str {
        &self.id
    }
}

/// The result of a CI run.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum RunResult {
    /// CI run was successful.
    Success,

    /// CI run failed.
    Failure,
}

impl fmt::Display for RunResult {
    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
        match self {
            Self::Failure => write!(f, "failure"),
            Self::Success => write!(f, "success"),
        }
    }
}

/// A request message sent by the broker to its adapter child process.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "request")]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum Request {
    /// Trigger a run.
    Trigger {
        /// Common fields for all message variants.
        #[serde(flatten)]
        common: EventCommonFields,

        /// The push event, if any. `branch` may tag name if tag event.
        #[serde(flatten)]
        push: Option<PushEvent>,

        /// The patch event, if any.
        #[serde(flatten)]
        patch: Option<PatchEvent>,
    },
}

impl Request {
    /// Repository that the event concerns.
    pub fn repo(&self) -> RepoId {
        match self {
            Self::Trigger {
                common,
                push: _,
                patch: _,
            } => common.repository.id,
        }
    }

    /// Return the commit the event concerns. In other words, the
    /// commit that CI should run against.
    pub fn commit(&self) -> Result<Oid, AdapterLibError> {
        match self {
            Self::Trigger {
                common: _,
                push,
                patch,
            } => {
                if let Some(push) = push {
                    if let Some(oid) = push.commits.first() {
                        Ok(*oid)
                    } else {
                        Err(AdapterLibError::NoCommits)
                    }
                } else if let Some(patch) = patch {
                    if let Some(oid) = patch.patch.commits.first() {
                        Ok(*oid)
                    } else {
                        Err(AdapterLibError::NoCommits)
                    }
                } else {
                    Err(AdapterLibError::UnknownRequest)
                }
            }
        }
    }

    /// Serialize the request as a pretty JSON, including the newline.
    /// This is meant for the broker to use.
    pub fn to_json_pretty(&self) -> Result<String, AdapterLibError> {
        serde_json::to_string_pretty(&self).map_err(AdapterLibError::serialize_request)
    }

    /// Serialize the request as a single-line JSON, including the
    /// newline. This is meant for the broker to use.
    pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<(), AdapterLibError> {
        let mut line = serde_json::to_string(&self).map_err(AdapterLibError::serialize_request)?;
        line.push('\n');
        writer
            .write(line.as_bytes())
            .map_err(AdapterLibError::WriteRequest)?;
        Ok(())
    }

    /// Read a request from a reader. This is meant for the adapter to
    /// use.
    pub fn from_reader<R: Read>(reader: R) -> Result<Self, AdapterLibError> {
        let mut line = String::new();
        let mut r = BufReader::new(reader);
        r.read_line(&mut line).map_err(AdapterLibError::ReadLine)?;
        let req: Self = serde_json::from_slice(line.as_bytes())
            .map_err(AdapterLibError::deserialize_request)?;
        Ok(req)
    }

    /// Parse a request from a string. This is meant for tests to use.
    pub fn try_from_str(s: &str) -> Result<Self, AdapterLibError> {
        let req: Self =
            serde_json::from_slice(s.as_bytes()).map_err(AdapterLibError::deserialize_request)?;
        Ok(req)
    }
}

impl fmt::Display for Request {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            serde_json::to_string(&self).map_err(|_| fmt::Error)?
        )
    }
}

/// Type of event.
#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum EventType {
    /// A push event to a branch.
    Push,

    /// A new or changed patch.
    Patch,

    /// A new or changed tag.
    Tag,
}

/// Common fields in all variations of a [`Request`] message.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EventCommonFields {
    /// Version of the request message.
    pub version: usize,

    /// The type of the event.
    pub event_type: EventType,

    /// The repository the event is related to.
    pub repository: Repository,
}

/// A push event.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PushEvent {
    /// The author of the change.
    pub pusher: Author,

    /// The commit on which the change is based.
    pub before: Oid,

    /// FIXME
    pub after: Oid,

    /// The branch where the push occurred.
    pub branch: String,

    /// The commits in the change.
    pub commits: Vec<Oid>,
}

/// An event related to a Radicle patch object.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PatchEvent {
    /// What action has happened to the patch.
    pub action: PatchAction,

    /// Metadata about the patch.
    pub patch: Patch,
}

/// What action has happened to the patch?
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PatchAction {
    /// Patch has been created.
    Created,

    /// Patch has been updated.
    Updated,
}

#[cfg(test)]
impl PatchAction {
    /// Action name.
    pub fn as_str(&self) -> &str {
        match self {
            Self::Created => "created",
            Self::Updated => "updated",
        }
    }
}

impl TryFrom<&str> for PatchAction {
    type Error = AdapterLibError;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        match value {
            "created" => Ok(Self::Created),
            "updated" => Ok(Self::Updated),
            _ => Err(Self::Error::UnknownPatchAction(value.into())),
        }
    }
}

/// Fields in a [`Request`] message describing the repository
/// concerned.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Repository {
    /// The unique repository id.
    pub id: RepoId,

    /// The name of the repository.
    pub name: String,

    /// A description of the repository.
    pub description: String,

    /// Is it a private repository?
    pub private: bool,

    /// The default branch in the repository: the branch that gets
    /// updated when a change is merged.
    pub default_branch: String,

    /// The delegates of the repository: those who can actually merge
    /// the change.
    pub delegates: Vec<Did>,
}

/// Fields describing the author of a change.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Author {
    /// The DID of the author. This is guaranteed to be unique.
    pub id: Did,

    /// The alias, or name, of the author. This need not be unique.
    pub alias: Option<Alias>,
}

impl std::fmt::Display for Author {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.id)?;
        if let Some(alias) = &self.alias {
            write!(f, " ({alias})")?;
        }
        Ok(())
    }
}

/// The state of a patch.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct State {
    /// State of the patch.
    pub status: String,

    /// FIXME.
    pub conflicts: Vec<(RevisionId, Oid)>,
}

/// Revision of a patch.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Revision {
    /// FIXME.
    pub id: Oid,

    /// Author of the revision.
    pub author: Author,

    /// Description of the revision.
    pub description: String,

    /// Base commit on which the revision of the patch should be
    /// applied.
    pub base: Oid,

    /// FIXME.
    pub oid: Oid,

    /// Time stamp of the revision.
    pub timestamp: u64,
}

impl std::fmt::Display for Revision {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.id)
    }
}

/// Metadata about a Radicle patch.
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Patch {
    /// The patch id.
    pub id: Oid,

    /// The author of the patch.
    pub author: Author,

    /// The title of the patch.
    pub title: String,

    /// The state of the patch.
    pub state: State,

    /// The commit preceding the patch.
    pub before: Oid,

    /// FIXME.
    pub after: Oid,

    /// The list of commits in the patch.
    pub commits: Vec<Oid>,

    /// FIXME.
    pub target: Oid,

    /// Labels assigned to the patch.
    pub labels: Vec<String>,

    /// Who're in charge of the patch.
    pub assignees: Vec<Did>,

    /// List of revisions of the patch.
    pub revisions: Vec<Revision>,
}

/// A response message from the adapter child process to the broker.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename_all = "snake_case")]
#[serde(tag = "response")]
pub enum Response {
    /// A CI run has been triggered.
    Triggered {
        /// The identifier for the CI run assigned by the adapter.
        run_id: RunId,

        /// Optional informational URL for the run.
        info_url: Option<String>,
    },

    /// A CI run has finished.
    Finished {
        /// The result of a CI run.
        result: RunResult,
    },
}

impl Response {
    /// Create a `Response::Triggered` message without an info URL.
    pub fn triggered(run_id: RunId) -> Self {
        Self::Triggered {
            run_id,
            info_url: None,
        }
    }

    /// Create a `Response::Triggered` message with an info URL.
    pub fn triggered_with_url(run_id: RunId, url: &str) -> Self {
        Self::Triggered {
            run_id,
            info_url: Some(url.into()),
        }
    }

    /// Create a `Response::Finished` message.
    pub fn finished(result: RunResult) -> Self {
        Self::Finished { result }
    }

    /// Does the message indicate a result for the CI run?
    pub fn result(&self) -> Option<&RunResult> {
        if let Self::Finished { result } = self {
            Some(result)
        } else {
            None
        }
    }

    /// Serialize a response as a single-line JSON, including the
    /// newline. This is meant for the adapter to use.
    pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<(), AdapterLibError> {
        let mut line = serde_json::to_string(&self).map_err(AdapterLibError::serialize_response)?;
        line.push('\n');
        writer
            .write(line.as_bytes())
            .map_err(AdapterLibError::WriteResponseToHandle)?;
        Ok(())
    }

    /// Serialize the response as a pretty JSON, including the newline.
    /// This is meant for the broker to use.
    pub fn to_json_pretty(&self) -> Result<String, AdapterLibError> {
        serde_json::to_string_pretty(&self).map_err(AdapterLibError::serialize_response)
    }

    /// Read a response from a reader. This is meant for the broker to
    /// use.
    pub fn from_reader<R: Read + BufRead>(reader: &mut R) -> Result<Option<Self>, AdapterLibError> {
        let mut line = String::new();
        let mut r = BufReader::new(reader);
        let n = r.read_line(&mut line).map_err(AdapterLibError::ReadLine)?;
        if n == 0 {
            // Child's stdout was closed.
            Ok(None)
        } else {
            let req: Self = serde_json::from_slice(line.as_bytes())
                .map_err(AdapterLibError::deserialize_response)?;
            Ok(Some(req))
        }
    }

    /// Read a response from a string slice. This is meant for the
    /// broker to use.
    #[allow(clippy::should_implement_trait)]
    pub fn from_str(line: &str) -> Result<Self, AdapterLibError> {
        let req: Self = serde_json::from_slice(line.as_bytes())
            .map_err(AdapterLibError::deserialize_response)?;
        Ok(req)
    }
}

/// All possible errors from the CI broker messages.
#[derive(Debug, thiserror::Error)]
pub enum AdapterLibError {
    /// [`RequestBuilder`] does not have profile set.
    #[error("RequestBuilder must have profile set")]
    NoProfile,

    /// [`RequestBuilder`] does not have event set.
    #[error("RequestBuilder must have broker event set")]
    NoEvent,

    /// [`RequestBuilder`] does not have event handler set.
    #[error("RequestBuilder has no event handler set")]
    NoEventHandler,

    /// CI event was not set for [`RequestBuilder`].
    #[error("programming error: CI event was not set for request builder")]
    CiEventNotSet,

    /// Request message lacks commits to run CI on.
    #[error("unacceptable request message: lacks Git commits to run CI on")]
    NoCommits,

    /// Request message is neither a "push" nor a "patch"
    #[error("unacceptable request message: neither 'push' nor 'patch'")]
    UnknownRequest,

    /// Failed to serialize a request message as JSON. This should
    /// never happen and likely indicates a programming failure.
    #[error("failed to serialize a request into JSON to a file handle")]
    SerializeRequest(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Failed to serialize a response message as JSON. This should never
    /// happen and likely indicates a programming failure.
    #[error("failed to serialize a request into JSON to a file handle")]
    SerializeResponse(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Failed to write the serialized request message to an open file.
    #[error("failed to write JSON to file handle")]
    WriteRequest(#[source] std::io::Error),

    /// Failed to write the serialized response message to an open
    /// file.
    #[error("failed to write JSON to file handle")]
    WriteResponseToHandle(#[source] std::io::Error),

    /// Failed to read a line of JSON from an open file.
    #[error("failed to read line from file handle")]
    ReadLine(#[source] std::io::Error),

    /// Failed to parse JSON as a request or a response.
    #[error("failed to read a JSON request from a file handle")]
    DeserializeRequest(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Failed to parse JSON as a response or a response.
    #[error("failed to read a JSON response from a file handle")]
    DeserializeResponse(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Error retrieving context to generate trigger.
    #[error("could not generate trigger from event")]
    Trigger,

    /// Error looking up the patch COB.
    #[error("could look up patch COB {0}: not found?")]
    PatchCob(PatchId),

    /// Error looking up latest revision for a patch COB.
    #[error("failed to look up latest revision for patch {0}")]
    LatestPatchRevision(PatchId),

    /// Error from Radicle repository.
    #[error("error from Radicle repository")]
    RepositoryError(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Error from Radicle COB.
    #[error("error from Radicle collaborative object")]
    CobStoreError(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Error from `radicle-surf` crate.
    #[error("error from radicle-surf")]
    RadicleSurfError(#[source] Box<dyn std::error::Error + Send + 'static>),

    /// Trying to create a PatchAction from an invalid value.
    #[error("invalid patch action {0:?}")]
    UnknownPatchAction(String),

    /// Can't load Radicle profile.
    #[error("failed to load Radicle profile")]
    Profile(#[source] radicle::profile::Error),

    /// Can't run command and capture its output.
    #[error("failed to run command {0}")]
    Command(&'static str, #[source] std::io::Error),

    /// Admin log error.
    #[error(transparent)]
    AdminLog(#[from] LogError),
}

impl AdapterLibError {
    fn serialize_request(err: serde_json::Error) -> Self {
        Self::SerializeRequest(Box::new(err))
    }

    fn serialize_response(err: serde_json::Error) -> Self {
        Self::SerializeResponse(Box::new(err))
    }

    fn deserialize_request(err: serde_json::Error) -> Self {
        Self::DeserializeRequest(Box::new(err))
    }

    fn deserialize_response(err: serde_json::Error) -> Self {
        Self::DeserializeResponse(Box::new(err))
    }
}

/// Exit code to indicate we didn't get one from the process.
pub const NO_EXIT: i32 = 999;

/// Read a request from stdin.
pub fn read_request() -> Result<Request, AdapterLibError> {
    Request::from_reader(std::io::stdin())
}

// Write response to stdout.
fn write_response(resp: &Response) -> Result<(), AdapterLibError> {
    resp.to_writer(std::io::stdout())
}

/// Write a "triggered" response to stdout.
pub fn write_triggered(run_id: &RunId, info_url: Option<&str>) -> Result<(), AdapterLibError> {
    let response = if let Some(url) = info_url {
        Response::triggered_with_url(run_id.clone(), url)
    } else {
        Response::triggered(run_id.clone())
    };
    write_response(&response)?;
    Ok(())
}

/// Write a message indicating failure to stdout.
pub fn write_failed() -> Result<(), AdapterLibError> {
    write_response(&Response::Finished {
        result: RunResult::Failure,
    })?;
    Ok(())
}

/// Write a message indicating success to stdout.
pub fn write_succeeded() -> Result<(), AdapterLibError> {
    write_response(&Response::Finished {
        result: RunResult::Success,
    })?;
    Ok(())
}

/// Get sources from the local node.
pub fn get_sources(
    adminlog: &mut AdminLog,
    dry_run: bool,
    repoid: RepoId,
    commit: Oid,
    src: &Path,
) -> Result<(), AdapterLibError> {
    let profile = Profile::load().map_err(AdapterLibError::Profile)?;
    let storage = profile.storage.path();
    let repo_path = storage.join(repoid.canonical());

    git_clone(adminlog, dry_run, &repo_path, src)?;
    git_checkout(adminlog, dry_run, commit, src)?;

    Ok(())
}

/// Run `git clone` for the repository.
fn git_clone(
    adminlog: &mut AdminLog,
    dry_run: bool,
    repo_path: &Path,
    src: &Path,
) -> Result<(), AdapterLibError> {
    let repo_path = repo_path.to_string_lossy();
    let src = src.to_string_lossy();
    runcmd(
        adminlog,
        dry_run,
        &nonempty!["git", "clone", &repo_path, &src],
        Path::new("."),
    )?;
    Ok(())
}

// Check out the requested commit.
fn git_checkout(
    adminlog: &mut AdminLog,
    dry_run: bool,
    commit: Oid,
    src: &Path,
) -> Result<(), AdapterLibError> {
    runcmd(
        adminlog,
        dry_run,
        &nonempty!["git", "config", "advice.detachedHead", "false"],
        src,
    )?;
    let commit = commit.to_string();
    runcmd(
        adminlog,
        dry_run,
        &nonempty!["git", "checkout", &commit],
        src,
    )?;
    Ok(())
}

/// Run a program.
pub fn runcmd(
    adminlog: &mut AdminLog,
    dry_run: bool,
    argv: &NonEmpty<&str>,
    cwd: &Path,
) -> Result<(i32, Vec<u8>), AdapterLibError> {
    if dry_run {
        adminlog
            .writeln(&format!("runcmd: pretend to run: argv={argv:?}"))
            .map_err(AdapterLibError::AdminLog)?;
        return Ok((0, vec![]));
    }

    adminlog.writeln(&format!("runcmd: argv={argv:?}"))?;
    let output = Command::new("bash")
        .arg("-c")
        .arg(r#""$@" 2>&1"#)
        .arg("--")
        .args(argv)
        .current_dir(cwd)
        .output()
        .map_err(|err| AdapterLibError::Command("bash", err))?;

    let exit = output.status.code().unwrap_or(NO_EXIT);
    adminlog.writeln(&format!("runcmd: exit={exit}"))?;

    if exit != 0 {
        indented(adminlog, "stdout", &output.stdout);
        indented(adminlog, "stderr", &output.stderr);
    }

    Ok((exit, output.stdout))
}

/// Log a string with every line indented.
pub fn indented(adminlog: &mut AdminLog, msg: &str, bytes: &[u8]) {
    if !bytes.is_empty() {
        adminlog.writeln(&format!("{msg}:")).ok();
        let text = String::from_utf8_lossy(bytes);
        for line in text.lines() {
            adminlog.writeln(&format!("    {line}")).ok();
        }
    }
}

/// A log for the administrator, whose duty it is to keep the
/// software running.
#[derive(Debug, Default)]
pub struct AdminLog {
    filename: Option<PathBuf>,
    file: Option<File>,
    stderr: bool,
    buffer: Option<Vec<u8>>,
}

impl AdminLog {
    /// Create an admin log that doesn't write to a file, and
    /// neither to stderr.
    pub fn null() -> Self {
        Self::default()
    }

    /// Create an admin log that writes to stderr.
    pub fn stderr() -> Self {
        Self {
            filename: None,
            file: None,
            stderr: true,
            buffer: None,
        }
    }

    /// Capture output into a buffer.
    pub fn capture() -> Self {
        Self {
            filename: None,
            file: None,
            stderr: false,
            buffer: Some(vec![]),
        }
    }

    /// Return current buffer created by `capture`.
    pub fn capture_buffer(&self) -> Option<&[u8]> {
        self.buffer.as_deref()
    }

    /// Create an admin log that writes to a named file.
    pub fn open(filename: &Path) -> Result<Self, LogError> {
        let file = OpenOptions::new()
            .append(true)
            .create(true)
            .open(filename)
            .map_err(|e| LogError::OpenLogFile(filename.into(), e))?;
        Ok(Self {
            filename: Some(filename.into()),
            file: Some(file),
            stderr: false,
            buffer: None,
        })
    }

    /// Write a line to the admin log.
    pub fn writeln(&mut self, text: &str) -> Result<(), LogError> {
        self.write("[")?;
        self.write(&now()?)?;
        self.write("] ")?;
        self.write(text)?;
        self.write("\n")?;
        Ok(())
    }

    fn write(&mut self, msg: &str) -> Result<(), LogError> {
        if let Some(file) = &mut self.file {
            #[allow(clippy::unwrap_used)] // we know it's OK
            file.write_all(msg.as_bytes())
                .map_err(|e| LogError::WriteLogFile(self.filename.clone().unwrap(), e))?;
        } else if self.stderr {
            std::io::stderr()
                .write_all(msg.as_bytes())
                .map_err(LogError::WriteLogStderr)?;
        } else if let Some(buf) = self.buffer.as_mut() {
            buf.extend_from_slice(msg.as_bytes());
        }
        Ok(())
    }
}

fn now() -> Result<String, LogError> {
    let fmt = format_description!("[year]-[month]-[day] [hour]:[minute]:[second]Z");
    OffsetDateTime::now_utc()
        .format(fmt)
        .map_err(LogError::TimeFormat)
}

/// Possible errors from using the admin log.
#[derive(Debug, thiserror::Error)]
pub enum LogError {
    /// Can't open named file.
    #[error("failed to open log file {0}")]
    OpenLogFile(PathBuf, #[source] std::io::Error),

    /// Can't write to file.
    #[error("failed to write to log file {0}")]
    WriteLogFile(PathBuf, #[source] std::io::Error),

    /// Can't write to file.
    #[error("failed to write to log file {0}")]
    WriteLogStderr(#[source] std::io::Error),

    /// Can' format time stamp.
    #[error("failed to format time stamp")]
    TimeFormat(#[source] time::error::Format),
}
