use std::fmt::Display;

use serde::{Deserialize, Serialize};

#[derive(Debug, thiserror::Error, Deserialize, Serialize)]
pub enum InstanceError {
    #[error("registration failed")]
    RegistrationFailure,
    #[error("authentication failed")]
    AuthenticationFailed,
}

#[derive(Debug, thiserror::Error, Serialize, Deserialize)]
pub enum RepositoryError {}

#[derive(Debug, thiserror::Error, Deserialize, Serialize)]
pub enum UserError {}

#[derive(Debug, thiserror::Error, Serialize, Deserialize)]
pub enum GetValueError {
    #[error("invalid object")]
    InvalidObject,
}

#[derive(Debug, thiserror::Error)]
#[error("unauthorized")]
pub struct UnauthorizedError;

#[derive(Debug, thiserror::Error)]
pub enum OperationError<B> {
    #[error("the operation was handled but an error occurred")]
    Operation(#[from] B),
    #[error("an internal error occurred: {0:?}")]
    Internal(anyhow::Error),
    #[error("the operation was unhandled or unrecognized")]
    Unhandled,
}

pub trait IntoInternalError<T>: Sized {
    fn as_internal_error<B>(self) -> Result<T, OperationError<B>>;

    fn as_internal_error_with_context<B, C>(self, context: C) -> Result<T, OperationError<B>>
    where
        C: Display + Send + Sync + 'static,
    {
        let internal_error = self.as_internal_error::<B>();

        match internal_error {
            Ok(success) => Ok(success),
            Err(OperationError::Internal(internal)) => {
                Err(OperationError::Internal(internal.context(context)))
            }
            _ => unreachable!(),
        }
    }
}

impl<E: Into<anyhow::Error>, T> IntoInternalError<T> for Result<T, E> {
    fn as_internal_error<B>(self) -> Result<T, OperationError<B>> {
        match self {
            Ok(success) => Ok(success),
            Err(err) => Err(OperationError::Internal(err.into())),
        }
    }
}

impl<B> OperationError<B> {
    pub fn into_network(self) -> NetworkOperationError<B> {
        match self {
            OperationError::Operation(operation_error) => {
                NetworkOperationError::Operation(operation_error)
            }
            OperationError::Internal(_) => NetworkOperationError::Internal,
            OperationError::Unhandled => NetworkOperationError::Unhandled,
        }
    }
}

#[derive(Debug, thiserror::Error)]
#[error("an extractor failed with an error {0}")]
pub struct ExtractorError<E: Into<anyhow::Error>>(#[from] pub E);

impl<T, E: Into<anyhow::Error>> IntoInternalError<T> for ExtractorError<E> {
    fn as_internal_error<B>(self) -> Result<T, OperationError<B>> {
        todo!()
    }
}

#[derive(Serialize, Deserialize, Debug, thiserror::Error)]
pub enum NetworkOperationError<B> {
    #[error("the operation was handled but an error occurred")]
    Operation(#[from] B),
    #[error("internal error")]
    Internal,
    #[error("the operation was unhandled or unrecognized")]
    Unhandled,
}