//! Error module for `tor-dirserver`.

use thiserror::Error;

use tor_netdoc::parse2::VerifyFailed;

/// Indicates that an error variant is fatal.

///

/// A fatal error means that the application should abort execution and may

/// not retry again in the future.

///

/// This trait should only be implemented for error variants where some error

/// variants are fatal and others are not.  In other words: An error where all

/// variants are either fatal or non-fatal does not qualify for this trait.

// TODO DIRMIRROR: Move this to tor_error.

pub(crate) trait IsFatal: std::error::Error {

    /// Checks whether the current error is considered to be fatal.

    fn is_fatal(&self) -> bool;

}

/// An error while performing a request at a directory authority.

#[derive(Debug, Error)]

#[non_exhaustive]

pub(crate) enum AuthorityRequestError {

    /// TCP connection to the endpoint failed.

    #[error("tcp connection error: {0}")]

    TcpConnect(std::io::Error),

    /// [`tor_dirclient`] failed at performing the request.

    ///

    /// This usually indicates some failures in HTTP/1.0, such as the response

    /// not being valid HTTP/1.0; although Tor generally has some specialities

    /// here and there with regard to this, hence why we have dirclient in the

    /// first place.

    #[error("dirclient error: {0}")]

    Request(Box<tor_dirclient::RequestFailedError>),

    /// A response does not make semantic sense.

    ///

    /// This for example may include cases where we got more netdocs than we

    /// requested for.

    #[error("response error: {0}")]

    Response(&'static str),

    /// A request led to no progress being made.

    ///

    /// This is the case if the response only consists of netdocs we did not

    /// request or no netdocs at all, leading to no progress.

    ///

    /// The correct error handling strategy for this case is to pick a different

    /// endpoint, as the current one is either not useful for us anymore or

    /// is maliciously tricking us into something that should not happen.

    #[error("request resulted in no progress")]

    NoRequestedDocumentsReturned,

    /// An internal error.

    #[error("internal error")]

    Bug(#[from] tor_error::Bug),

}

impl From<tor_dirclient::RequestFailedError> for AuthorityRequestError {

}

impl IsFatal for AuthorityRequestError {

    /// The [`AuthorityRequestError`] is considered to be fatal.

    ///

    /// Right now, the following variants are considered to be fatal:

    /// * [`AuthorityRequestError::Bug`]

}

/// An error while interacting with a database.

///

/// This error should be returned by all functions that interact with the

/// database in one way or another.

#[derive(Debug, Error)]

#[non_exhaustive]

pub(crate) enum DatabaseError {

    /// A low-level SQLite error has occurred, which can have a basically

    /// infinite amount of reasons, all of them outlined in the actual SQLite

    /// and [`rusqlite`] documentation.

    #[error("low-level rusqlite error: {0}")]

    LowLevel(#[from] rusqlite::Error),

    /// This is an application level error meaning that the database can be

    /// successfully accessed but its content implies it is of a schema version

    /// we do not support.

    ///

    /// Keep in mind that an unrecognized schema is not equal to no schema.

    /// In the latter case we actually initialize the database, whereas in the

    /// previous one, we fail early in order to not corrupt an existing database.

    /// Future versions of this crate should continue with this promise in order

    /// to ensure forward compatibility.

    #[error("incompatible schema version: {version}")]

    IncompatibleSchema {

        /// The incompatible schema version found in the database.

        version: String,

    },

    /// Interaction with our database pool, [`r2d2`], has failed.

    ///

    /// Unlike other database pools, this error is fairly straightforward and

    /// may only be obtained in the cases in which we try to obtain a connection

    /// handle from the pool.  Notably, it does not fail if, for example,

    /// the low-level [`rusqlite`] has a failure.

    #[error("pool error: {0}")]

    Pool(#[from] r2d2::Error),

    /// An internal error.

    #[error("Internal error")]

    Bug(#[from] tor_error::Bug),

}

/// An error related to an operation in the dirmirror FSM.

//

// TODO: Rename this to MirrorOperationError.

#[derive(Debug, Error)]

#[non_exhaustive]

pub(crate) enum OperationError {

    /// Request to a directory authority failed.

    #[error("authority request error: {0}")]

    AuthorityRequest(#[from] AuthorityRequestError),

    /// Access to the database failed for good.

    #[error("database error: {0}")]

    Database(#[from] DatabaseError),

    /// Verificaton of a network document has failed.

    ///

    /// This also includes checks for timeliness.

    ///

    /// We do not consider this fatal but simply discard the unverified network

    /// document.

    #[error("verification error: {0}")]

    VerifyFailed(#[from] VerifyFailed),

    /// An internal error.

    #[error("Internal error")]

    Bug(#[from] tor_error::Bug),

}

impl IsFatal for OperationError {

    /// The [`OperationError`] is considered to be fatal.

    ///

    /// Right now, the following variants are considered to be fatal:

    /// * [`OperationError::Database`]

    /// * [`OperationError::Bug`]

    /// * [`OperationError::AuthorityRequest`] if [`IsFatal`]

        }

}