terminals-core 0.1.0

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SDKError {
    pub kind: String,
    pub message: String,
}

impl SDKError {
    pub fn new(kind: impl Into<String>, message: impl Into<String>) -> Self {
        Self {
            kind: kind.into(),
            message: message.into(),
        }
    }
}

pub enum SDKResult<T> {
    Ok(T),
    Err(SDKError),
}

impl<T> SDKResult<T> {
    pub fn ok(value: T) -> Self {
        Self::Ok(value)
    }
    pub fn err(error: SDKError) -> Self {
        Self::Err(error)
    }
    pub fn is_ok(&self) -> bool {
        matches!(self, Self::Ok(_))
    }
    pub fn unwrap(self) -> T {
        match self {
            Self::Ok(v) => v,
            Self::Err(e) => panic!("SDKResult::unwrap on Err: {}", e.message),
        }
    }
    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> SDKResult<U> {
        match self {
            Self::Ok(v) => SDKResult::Ok(f(v)),
            Self::Err(e) => SDKResult::Err(e),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ok_result() {
        let r: SDKResult<i32> = SDKResult::ok(42);
        assert!(r.is_ok());
        assert_eq!(r.unwrap(), 42);
    }

    #[test]
    fn test_err_result() {
        let r: SDKResult<i32> = SDKResult::err(SDKError::new("test", "something failed"));
        assert!(!r.is_ok());
    }

    #[test]
    fn test_map() {
        let r: SDKResult<i32> = SDKResult::ok(21);
        let mapped = r.map(|x| x * 2);
        assert_eq!(mapped.unwrap(), 42);
    }
}