jay-compositor 1.15.0

use crate::utils::errorfmt::ErrorFmt;
use std::error::Error;
use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Formatter;
use std::mem;

pub type TestResult<T = ()> = Result<T, TestError>;

pub struct TestError {
    error: Box<dyn Error + 'static>,
    source: Option<Box<TestError>>,
}

impl TestError {
    pub fn new<D: Display + 'static>(d: D) -> Self {
        Self {
            error: Box::new(DisplayError { msg: d }),
            source: None,
        }
    }
}

#[derive(Debug)]
#[repr(transparent)]
pub struct TestErrorError(pub TestError);

impl From<TestError> for TestErrorError {
    fn from(value: TestError) -> Self {
        Self(value)
    }
}

impl Display for TestErrorError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.0, f)
    }
}

impl Error for TestErrorError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        let v: Option<&TestError> = self.0.source.as_deref();
        v.map(|v| unsafe { mem::transmute::<&TestError, &TestErrorError>(v) as _ })
    }
}

struct DisplayError<T: Display> {
    msg: T,
}

impl<T: Display> Debug for DisplayError<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.msg, f)
    }
}

impl<T: Display> Display for DisplayError<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.msg, f)
    }
}

impl<T: Display> Error for DisplayError<T> {}

impl Debug for TestError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("TestError")
            .field("error", &self.error)
            .field("source", &self.source)
            .finish()
    }
}

impl Display for TestError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let mut e_prev = self;
        let mut e_opt = Some(self);
        let mut first = true;
        while let Some(e) = e_opt {
            if first {
                write!(f, "{}", e.error)?;
                first = false;
            } else {
                write!(f, ": {}", e.error)?;
            }
            e_prev = e;
            e_opt = e.source.as_deref();
        }
        if let Some(e) = e_prev.error.source() {
            write!(f, ": ")?;
            ErrorFmt(e).fmt(f)?;
        }
        Ok(())
    }
}

impl<T: Error + 'static> From<T> for TestError {
    fn from(error: T) -> Self {
        Self {
            error: Box::new(error),
            source: None,
        }
    }
}

pub trait TestErrorExt {
    type Context;

    fn with_context<T, F>(self, f: F) -> Self::Context
    where
        T: Display + 'static,
        F: FnOnce() -> T;
}

impl<T, E> TestErrorExt for Result<T, E>
where
    E: StdError,
{
    type Context = Result<T, TestError>;

    fn with_context<D, F>(self, f: F) -> Self::Context
    where
        D: Display + 'static,
        F: FnOnce() -> D,
    {
        match self {
            Ok(v) => Ok(v),
            Err(e) => Err(e.with_context(f())),
        }
    }
}

pub trait StdError: 'static {
    fn with_context<D: Display + 'static>(self, d: D) -> TestError;
}

impl<E: Error + 'static> StdError for E {
    fn with_context<D: Display + 'static>(self, d: D) -> TestError {
        TestError {
            error: Box::new(DisplayError { msg: d }),
            source: Some(Box::new(self.into())),
        }
    }
}

impl StdError for TestError {
    fn with_context<D: Display + 'static>(self, d: D) -> TestError {
        TestError {
            error: Box::new(DisplayError { msg: d }),
            source: Some(Box::new(self)),
        }
    }
}

macro_rules! bail {
    ($($tt:tt)*) => {{
        let msg = format!($($tt)*);
        return Err(crate::it::test_error::TestError::new(msg).into());
    }}
}