[package]
name = "qsu"
version = "0.2.0"
edition = "2021"
license = "0BSD"
categories = [ "asynchronous" ]
keywords = [ "service", "systemd", "winsvc" ]
repository = "https://repos.qrnch.tech/pub/qsu"
description = "Service subsystem wrapper."
rust-version = "1.56"

systemd = ["dep:sd-notify"]
rocket = ["rt", "dep:rocket", "tokio"]
rt = []
tokio = ["rt", "tokio/macros", "tokio/rt-multi-thread", "tokio/signal"]
wait-for-debugger = ["dep:dbgtools-win"]

[dependencies]
apperr = { version = "0.2.0" }
async-trait = { version = "0.1.77" }
chrono = { version = "0.4.31" }
clap = { version = "4.4.14", optional = true, features = [
  "derive", "env", "string", "wrap_help"
] }
env_logger = { version = "0.10.1" }
futures = { version = "0.3.30" }

use std::{fmt, io};

#[derive(Debug)]
pub enum Error {
  IO(String),
  Qsu(String)
}

impl std::error::Error for Error {}
impl apperr::Blessed for Error {}

impl fmt::Display for Error {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    match self {
      Error::IO(s) => {
        write!(f, "I/O error; {}", s)
      }

    matches!(self, Error::App(_))
  }

  /// Attempt to convert [`Error`] into application-specific error.
  ///
  /// If it's not an `Error::App()` nor can be downcast to type `E`, the error
  /// will be returned back as an `Err()`.
  pub fn try_into_apperr<E>(self) -> Result<E, Error>
  where
    E: std::error::Error + apperr::Blessed + 'static
  {
    match self {
      Error::App(e) => match e.try_into_inner::<E>() {
        Ok(e) => Ok(e),
        Err(e) => Err(Error::App(e))
      },
      e => Err(e)
    }
  }

  /// Unwrap application-specific error from an [`Error`].
  ///
  /// # Panic
  /// Panics if `Error` variant is not `Error::App()`.
  pub fn unwrap_apperr<E>(self) -> E
  where
    E: std::error::Error + apperr::Blessed + 'static
  {
    let Ok(e) = self.try_into_apperr::<E>() else {
      panic!("Unable to unwrap error E");
    };
    e
  }

  pub fn bad_format<S: ToString>(s: S) -> Self {

//!
//! Presumably the application has it's own `Error` type.  To allow the
//! callbacks to return application-defined errors using the regular question
//! mark, it may be helpful to add the following error conversion to the error
//! module:
//!
//! ```
//! use std::fmt;
//!
//! // Application-specific Error type
//! #[derive(Debug)]
//! enum Error {
//!   // .. application-defined error variants
//! }
//! impl fmt::Display for Error {
//!   fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
//!     Ok(())
//!   }
//! }
//! impl std::error::Error for Error {}
//! impl apperr::Blessed for Error {}
//!
//! impl From<Error> for qsu::AppErr {
//!   fn from(err: Error) -> qsu::AppErr {
//!     qsu::AppErr::new(err)
//!   }
//! }
//! ```

use std::{fmt, io};

#[derive(Debug)]
pub enum Error {
  Hello(String),
  IO(String),
  Qsu(String)
}

impl std::error::Error for Error {}
impl apperr::Blessed for Error {}

impl Error {
  pub fn hello(msg: impl ToString) -> Self {
    Error::Hello(msg.to_string())
  }
}

# Change log

## [Unreleased]

### Added

### Changed

- Use apperr 0.2.0, which introduces trait bounds to the `AppErr::new(E)` to
  make it more difficult to pass the wrong type to it.

### Removed

---

## [0.1.0] - 2024-01-10