use ::std::{*,
    borrow::Cow,
    convert::Infallible,
    ffi::{
        CStr,
        CString,
    },
};

#[derive(Debug)]
pub
struct InnerNullError {
    pub null_position: usize,
}

impl error::Error for InnerNullError {}
impl fmt::Display for InnerNullError {
    fn fmt (
        self: &'_ Self,
        stream: &'_ mut fmt::Formatter<'_>,
    ) -> fmt::Result
    {
        write!(stream, concat!(
            "Conversion to C string failed: ",
            "inner null byte at position {}.",
        ), self.null_position)
    }
}

pub trait Str<'a> {
    type Err : error::Error;

    fn try_into_cstr (
        self: Self
    ) -> Result<Cow<'a, CStr>, Self::Err>;
}

impl<'a> Str<'a> for &'a CStr {
    type Err = Infallible;

    #[inline]
    fn try_into_cstr (
        self: Self
    ) -> Result<Cow<'a, CStr>, Self::Err>
    {
        Ok(self.into())
    }
}

impl<'a> Str<'a> for String {
    type Err = InnerNullError;

    fn try_into_cstr (
        self: Self
    ) -> Result<Cow<'a, CStr>, Self::Err>
    {
        match CString::new(self) {
            | Ok(c_string) => Ok(c_string.into()),
            | Err(nul_error) => Err(InnerNullError {
                null_position: nul_error.nul_position(),
            }),
        }
    }
}

impl<'a> Str<'a> for &'a str {
    type Err = InnerNullError;

    fn try_into_cstr (
        self: Self
    ) -> Result<Cow<'a, CStr>, Self::Err>
    {
        match self.bytes().position(|x| x == b'\0') {
            | None
            => unsafe {
                Ok(CString::from_vec_unchecked(
                    self.bytes()
                        .chain(iter::once(b'\0'))
                        .collect()
                ).into())
            },

            | Some(null_position)
                if null_position == self.len() - 1
            => unsafe {
                Ok(CStr::from_bytes_with_nul_unchecked(
                    self.as_bytes()
                ).into())
            },

            | Some(null_position)
            => {
                Err(InnerNullError {
                    null_position,
                })
            },
        }
    }
}

fn puts<'s> (s: impl Str<'s>)
{
    let c_str =
        s   .try_into_cstr()
            .unwrap_or_else(|err| panic!("{}", err))
    ;
    unsafe {
        ::libc::puts(c_str.as_ptr());
    }
}

fn main ()
{
    puts("Hello, World!"); // to_owned()
    puts("Hello, World!".to_string()); // push()
    puts("Hello, World!\0"); // cast
    puts("Hell\0, World!"); // panic with nice error message
}