use std::ptr::NonNull;

use crate::{

    Error,

    capture::{Capture, Dead},

    linktype::Linktype,

    raw,

};

#[cfg(libpcap_1_5_0)]

use crate::capture::Precision;

impl Capture<Dead> {

    /// Creates a "fake" capture handle for the given link type.

        ))

    /// Creates a "fake" capture handle for the given link type and timestamp precision.

    #[cfg(libpcap_1_5_0)]

        #[cfg(windows)]

        if !raw::has_dead_precision() {

            return Err(Error::EntrypointNotFound(

                "pcap_open_dead_with_tstamp_precision",

            ));

        }

        };

        ))

}

#[cfg(test)]

mod tests {

    #[cfg(libpcap_1_5_0)]

    use mockall::predicate;

    use crate::raw::testmod::{RAWMTX, as_pcap_t};

    use super::*;

    #[test]

    fn test_dead() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

        let ctx = raw::pcap_open_dead_context();

        ctx.expect().return_once_st(move |_, _, _| pcap);

        let ctx = raw::pcap_close_context();

        ctx.expect()

            .withf_st(move |ptr| *ptr == pcap)

            .return_once(|_| {});

        let result = Capture::dead(Linktype::ETHERNET);

        assert!(result.is_ok());

    }

    #[test]

    #[cfg(libpcap_1_5_0)]

    fn test_dead_with_precision() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

        #[cfg(windows)]

        let ctx = raw::has_dead_precision_context();

        #[cfg(windows)]

        ctx.expect().return_once(|| true);

        let ctx = raw::pcap_open_dead_with_tstamp_precision_context();

        ctx.expect()

            .with(

                predicate::always(),

                predicate::always(),

                predicate::always(),

                predicate::eq(1),

            )

            .return_once_st(move |_, _, _, _| pcap);

        let ctx = raw::pcap_close_context();

        ctx.expect()

            .withf_st(move |ptr| *ptr == pcap)

            .return_once(|_| {});

        let result = Capture::dead_with_precision(Linktype::ETHERNET, Precision::Nano);

        assert!(result.is_ok());

    }

    #[test]

    #[cfg(all(windows, libpcap_1_5_0))]

    fn test_dead_precision_missing() {

        let _m = RAWMTX.lock();

        let ctx = raw::has_dead_precision_context();

        ctx.expect().return_once(|| false);

        let result = Capture::dead_with_precision(Linktype::ETHERNET, Precision::Nano);

        assert!(matches!(result, Err(Error::EntrypointNotFound(_))));

    }

}