//! Internal: Declare an Error type for tor-bytes

use std::borrow::Cow;

use std::num::NonZeroUsize;

use derive_deftly::{Deftly, define_derive_deftly};

use safelog::Sensitive;

use thiserror::Error;

use tor_error::{Bug, into_internal};

define_derive_deftly! {

    /// `impl PartialEq for Error`

    PartialEqForError expect items:

    impl PartialEq for $ttype {

            match (self, other) {

              $(

                ${when not(vmeta(never_eq))}

                #[allow(deprecated)]

                (${vpat fprefix=a_}, ${vpat fprefix=b_}) => {

                  $(

                    if $<a_ $fname> != $<b_ $fname> { return false; }

                  )

                    return true;

                },

              )

                (_, _) => false,

            }

        }

    }

}

/// Error type for decoding Tor objects from bytes.

//

// TODO(nickm): This error type could use a redesign: it doesn't do a good job

// of preserving context.  At the least it should say what kind of object it

// found any given problem in.

#[derive(Error, Debug, Clone, Deftly)]

#[derive_deftly(PartialEqForError)]

#[non_exhaustive]

pub enum Error {

    /// Something was truncated

    ///

    /// It might be an inner data structure, or the outer message being parsed.

    #[deprecated(since = "0.22.0", note = "Use Reader::incomplete_error instead.")]

    #[error("something was truncated (maybe inner structure, maybe outer message)")]

    Truncated,

    /// Tried to read something, but we didn't find enough bytes.

    ///

    /// This can means that the outer object is truncated.

    /// Possibly we need to read more and try again,

    ///

    /// This error is only returned by [`Reader`](crate::Reader)s created with

    /// [`from_possibly_incomplete_slice`](crate::Reader::from_possibly_incomplete_slice).

    ///

    /// # Do not directly construct this variant

    ///

    /// It is usually a bug to explicitly construct this variant.

    /// Use [`Reader::incomplete_error`](crate::Reader::incomplete_error) instead.

    ///

    /// In tests using

    /// [`Reader::from_slice_for_test`](crate::Reader::from_slice_for_test),

    /// use [`Error::new_incomplete_for_test`].

    #[error("Object truncated (or not fully present), at least {deficit} more bytes needed")]

    Incomplete {

        /// Lower bound on number of additional bytes needed

        deficit: Sensitive<NonZeroUsize>,

    },

    /// Called Reader::should_be_exhausted(), but found bytes anyway.

    #[error("Extra bytes at end of object")]

    ExtraneousBytes,

    /// Invalid length value

    #[error("Object length too large to represent as usize")]

    BadLengthValue,

    /// An attempt to parse an object failed for some reason related to its

    /// contents.

    #[deprecated(since = "0.6.2", note = "Use InvalidMessage instead.")]

    #[error("Bad object: {0}")]

    BadMessage(&'static str),

    /// An attempt to parse an object failed for some reason related to its

    /// contents.

    ///

    /// # General case, more specific variants also exist

    ///

    /// This variant is used when encountering parsing trouble

    /// for which there is no more specific variant.

    ///

    /// Other variants can occur when deserialising malformed messages.

    /// for example (but not necessarily only):

    /// [`ExtraneousBytes`](Error::ExtraneousBytes),

    /// [`MissingData`](Error::MissingData), and

    /// [`BadLengthValue`](Error::BadLengthValue).

    #[error("Bad object: {0}")]

    InvalidMessage(Cow<'static, str>),

    /// The message contains data which is too short (perhaps in an inner counted section)

    ///

    /// # Usually, do not directly construct this variant

    ///

    /// It is often a bug to explicitly construct this variant.

    /// Consider [`Reader::incomplete_error`](crate::Reader::incomplete_error) instead.

    ///

    /// (It can be appropriate in test cases,

    /// or during bespoke parsing of an inner substructure.)

    #[error("message (or inner portion) too short")]

    MissingData,

    /// A parsing error that should never happen.

    ///

    /// We use this one in lieu of calling assert() and expect() and

    /// unwrap() from within parsing code.

    #[error("Internal error")]

    #[deftly(never_eq)] // an internal error is equal to nothing, not even itself.

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

    /// Using for reader.rs::take_until_with_limit

    /// If we reach the limit before finding the terminator, we return this error.

    #[error("Reached limit of {limit} bytes while searching for terminator 0x{terminator:02x}")]

    LimitExceeded {

        /// Maximum number of bytes that were allowed to read

        limit: usize,

        /// The terminator byte we were looking for

        terminator: u8,

    },

}

impl Error {

    /// Make an [`Error::Incomplete`] with a specified deficit

    ///

    /// Suitable for use in tests.

    ///

    /// # Panics

    ///

    /// Panics if the specified `deficit` is zero.

}

/// Error type for encoding Tor objects to bytes.

#[derive(Error, Debug, Clone)]

#[non_exhaustive]

pub enum EncodeError {

    /// We tried to encode an object with an attached length, but the length was

    /// too large to encode in the available space.

    #[error("Object length too large to encode")]

    BadLengthValue,

    /// A parsing error that should never happen.

    ///

    /// We use this variant instead of calling assert() and expect() and

    /// unwrap() from within encoding implementations.

    #[error("Internal error")]

    Bug(#[from] Bug),

}

impl EncodeError {

    /// Converts this error into a [`Bug`]

    ///

    /// Use when any encoding error is a bug.

    //

    // TODO: should this be a `From` impl or would that be too error-prone?

    #[deprecated(note = "please use the `From<EncodeError>` trait for `Bug` instead")]

        }

}

// This trait is used to convert any encoding error into a bug

impl From<EncodeError> for Bug {

        }

}