//! The PAM conversation and associated Stuff.

use crate::pam_ffi::{BinaryResponseInner, NulError, TextResponseInner};
use std::num::TryFromIntError;
use std::ops::Deref;
use std::result::Result as StdResult;

/// An owned text response to a PAM conversation.
///
/// It points to a value on the C heap.
#[repr(C)]
struct TextResponse(*mut TextResponseInner);

impl TextResponse {
    /// Creates a text response.
    pub fn new(text: impl AsRef<str>) -> StdResult<Self, NulError> {
        TextResponseInner::alloc(text).map(Self)
    }
}

impl Deref for TextResponse {
    type Target = TextResponseInner;
    fn deref(&self) -> &Self::Target {
        // SAFETY: We allocated this ourselves, or it was provided by PAM.
        unsafe { &*self.0 }
    }
}

impl Drop for TextResponse {
    /// Frees an owned response.
    fn drop(&mut self) {
        // SAFETY: We allocated this ourselves, or it was provided by PAM.
        unsafe { TextResponseInner::free(self.0) }
    }
}

/// An owned binary response to a PAM conversation.
///
/// It points to a value on the C heap.
#[repr(C)]
struct BinaryResponse(*mut BinaryResponseInner);

impl BinaryResponse {
    /// Creates a binary response with the given data.
    pub fn new(data: impl AsRef<[u8]>, data_type: u8) -> StdResult<Self, TryFromIntError> {
        BinaryResponseInner::alloc(data, data_type).map(Self)
    }
}

impl Deref for BinaryResponse {
    type Target = BinaryResponseInner;
    fn deref(&self) -> &Self::Target {
        // SAFETY: We allocated this ourselves, or it was provided by PAM.
        unsafe { &*self.0 }
    }
}

impl Drop for BinaryResponse {
    /// Frees an owned response.
    fn drop(&mut self) {
        // SAFETY: We allocated this ourselves, or it was provided by PAM.
        unsafe { BinaryResponseInner::free(self.0) }
    }
}

#[cfg(test)]
mod test {
    use super::{BinaryResponse, TextResponse};

    #[test]
    fn test_text_response() {
        let resp = TextResponse::new("it's a-me!").unwrap();
        assert_eq!("it's a-me!", resp.contents().to_str().unwrap());
    }
    #[test]
    fn test_binary_response() {
        let data = [123, 210, 55];
        let resp = BinaryResponse::new(&data, 99).unwrap();
        assert_eq!(&data, resp.contents());
    }
}