//! An error type for [C Tor](crate::keystore::ctor) keystores.

use crate::KeystoreError;

use crate::keystore::fs_utils;

use tor_error::{ErrorKind, HasKind};

use tor_hscrypto::pk::HsIdParseError;

use tor_key_forge::KeystoreItemType;

use std::path::PathBuf;

use std::sync::Arc;

/// An error returned by a C Tor

/// [`Keystore`](crate::Keystore) implementation.

#[derive(thiserror::Error, Debug, Clone)]

pub(crate) enum CTorKeystoreError {

    /// An error that occurred while accessing the filesystem.

    #[error("{0}")]

    Filesystem(#[from] fs_utils::FilesystemError),

    /// Found a malformed.

    #[error("Key {path} is malformed")]

    MalformedKey {

        /// The path of the key.

        path: PathBuf,

        /// The underlying error.

        #[source]

        err: MalformedKeyError,

    },

    /// An unsupported operation.

    #[error("Operation not supported: {action}")]

    NotSupported {

        /// The action we were trying to perform.

        action: &'static str,

    },

    /// Key type and specifier mismatch.

    #[error("Invalid item type {item_type:?} for {item}")]

    InvalidKeystoreItemType {

        /// The item type.

        item_type: KeystoreItemType,

        /// The item we tried to access.

        item: String,

    },

    /// An internal error.

    #[error("Internal error")]

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

}

/// Encountered a malformed C Tor key.

#[derive(thiserror::Error, Debug, Clone)]

pub(crate) enum MalformedKeyError {

    /// A malformed hidden service key.

    #[error("{0}")]

    Service(#[from] MalformedServiceKeyError),

    /// A malformed hidden service client key.

    #[error("{0}")]

    Client(#[from] MalformedClientKeyError),

}

/// Encountered a malformed C Tor service key.

#[derive(thiserror::Error, Debug, Clone)]

pub(crate) enum MalformedServiceKeyError {

    /// Found a key with an invalid tag

    #[error("invalid key length: {len} (expected {expected_len})")]

    InvalidKeyLen {

        /// The length of the invalid key.

        len: usize,

        /// The expected length of this key.

        expected_len: usize,

    },

    /// Found a key with an invalid tag

    #[error("invalid tag: {tag:?} (expected {expected_tag:?})")]

    InvalidTag {

        /// The invalid tag.

        tag: Vec<u8>,

        /// The expected value of the tag.

        expected_tag: Vec<u8>,

    },

    /// Found an entry that cannot be recognized as a key

    /// (i.e.: a key that doesn't provide a valid

    /// [`CTorPath`](crate::CTorPath))

    #[error("unrecognized key")]

    NotAKey,

    /// Found an invalid ed25519 public key

    #[error("invalid ed25519 public key")]

    Ed25519Public(#[from] Arc<signature::Error>),

    /// Found an invalid ed25519 keypair

    //

    // Note: this error doesn't have any context, because we use

    // ed25519::ExpandedKeypair::from_secret_key_bytes to parse the key,

    // which returns `None` if the key can't be parsed

    // (so we don't have any information about what actually went wrong).

    #[error("invalid ed25519 keypair")]

    Ed25519Keypair,

    /// An internal error.

    #[error("Internal error")]

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

}

/// Encountered a malformed C Tor client key.

#[derive(thiserror::Error, Debug, Clone)]

pub(crate) enum MalformedClientKeyError {

    /// The auth type is not "descriptor".

    #[error("Invalid auth type {0}")]

    InvalidAuthType(String),

    /// The key type is not "x25519".

    #[error("Invalid key type {0}")]

    InvalidKeyType(String),

    /// The key is not in the `<auth-type>:x25519:<base32-encoded-public-key>` format.

    #[error("Invalid key format")]

    InvalidFormat,

    /// The encoded key material is invalid.

    #[error("Invalid key material")]

    InvalidKeyMaterial,

    /// Base32 decoding failed.

    #[error("Invalid base32 in client key")]

    InvalidBase32(#[from] data_encoding::DecodeError),

    /// Failed to parse the HsId.

    #[error("Invalid HsId client key")]

    InvalidHsId(#[from] HsIdParseError),

}

impl KeystoreError for CTorKeystoreError {}

impl HasKind for CTorKeystoreError {

        use CTorKeystoreError as KE;

        }

}

impl From<CTorKeystoreError> for crate::Error {

}