use std::path::Path;

#[cfg(not(windows))]

use std::os::unix::io::RawFd;

use crate::{

    Error,

    capture::{Capture, Offline},

    path_to_cstring, raw,

};

#[cfg(libpcap_1_5_0)]

use crate::capture::Precision;

#[cfg(not(windows))]

use crate::capture::activated::open_raw_fd;

impl Capture<Offline> {

    /// Opens an offline capture handle from a pcap dump file, given a path.

    ///

    /// On Windows a path outside ASCII needs `init(CharEncoding::Utf8)` first. The path always

    /// reaches libpcap as UTF-8, but until that call libpcap reads it in the local code page,

    /// which on most systems is not UTF-8: the name gets mangled and the file is not found.

    /// Opens an offline capture handle from a pcap dump file, given a path.

    /// Takes an additional precision argument specifying the timestamp precision desired.

    ///

    /// On Windows a path outside ASCII needs `init(CharEncoding::Utf8)` first. The path always

    /// reaches libpcap as UTF-8, but until that call libpcap reads it in the local code page,

    /// which on most systems is not UTF-8: the name gets mangled and the file is not found.

    #[cfg(libpcap_1_5_0)]

        #[cfg(windows)]

        if !raw::has_offline_precision() {

            raw::require_library()?;

            return Err(Error::EntrypointNotFound(

                "pcap_open_offline_with_tstamp_precision",

            ));

        }

    /// Opens an offline capture handle from a pcap dump file, given a file descriptor.

    ///

    /// # Safety

    ///

    /// Unsafe, because the returned Capture assumes it is the sole owner of the file descriptor.

    #[cfg(not(windows))]

    /// Opens an offline capture handle from a pcap dump file, given a file descriptor. Takes an

    /// additional precision argument specifying the timestamp precision desired.

    ///

    /// # Safety

    ///

    /// Unsafe, because the returned Capture assumes it is the sole owner of the file descriptor.

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

    /// Get the major version number of the pcap dump file format.

    /// Get the minor version number of the pcap dump file format.

    /// Get the (major, minor) version number of the pcap dump file format.

}

#[cfg(test)]

mod tests {

    #[cfg(libpcap_1_5_0)]

    use mockall::predicate;

    use crate::{

        capture::testmod::test_capture,

        raw::testmod::{RAWMTX, as_pcap_t},

    };

    use super::*;

    #[test]

    fn test_from_file() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

        let ctx = raw::pcap_open_offline_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::from_file("path/to/nowhere");

        assert!(result.is_ok());

    }

    #[test]

    #[cfg(libpcap_1_5_0)]

    fn test_from_file_with_precision() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

        #[cfg(windows)]

        let ctx = raw::has_offline_precision_context();

        #[cfg(windows)]

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

        let ctx = raw::pcap_open_offline_with_tstamp_precision_context();

        ctx.expect()

            .with(

                predicate::always(),

                predicate::always(),

                predicate::eq(1),

                predicate::always(),

            )

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

        let ctx = raw::pcap_close_context();

        ctx.expect()

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

            .return_once(|_| {});

        let result = Capture::from_file_with_precision("path/to/nowhere", Precision::Nano);

        assert!(result.is_ok());

    }

    #[test]

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

    fn test_from_file_precision_missing() {

        let _m = RAWMTX.lock();

        let ctx = raw::has_offline_precision_context();

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

        let result = Capture::from_file_with_precision("path/to/nowhere", Precision::Nano);

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

    }

    #[test]

    fn test_version() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

        let ctx = raw::pcap_major_version_context();

        ctx.expect()

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

            .return_once(|_| 5);

        let ctx = raw::pcap_minor_version_context();

        ctx.expect()

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

            .return_once(|_| 7);

        let test_capture = test_capture::<Offline>(pcap);

        let capture = test_capture.capture;

        assert_eq!(capture.version(), (5, 7));

    }

}