use std::ffi::CString;

use std::mem;

use crate::{

    Error,

    capture::{Active, Capture, Inactive, Warning},

    device::Device,

    raw,

};

#[cfg(libpcap_1_5_0)]

use crate::capture::Precision;

impl Capture<Inactive> {

    /// Opens a capture handle for a device. You can pass a `Device` or an `&str` device

    /// name here. The handle is inactive, but can be activated via `.open()`.

    ///

    /// # Example

    /// ```

    /// use pcap::*;

    ///

    /// // Usage 1: Capture from a single owned device

    /// let dev: Device = pcap::Device::lookup()

    ///     .expect("device lookup failed")

    ///     .expect("no device available");

    /// let cap1 = Capture::from_device(dev);

    ///

    /// // Usage 2: Capture from an element of device list.

    /// let list: Vec<Device> = pcap::Device::list().unwrap();

    /// let cap2 = Capture::from_device(list[0].clone());

    ///

    /// // Usage 3: Capture from `&str` device name

    /// let cap3 = Capture::from_device("eth0");

    /// ```

    /// Activates an inactive capture created from `Capture::from_device()` or returns an error.

    ///

    /// libpcap activates the capture but warns about it when it cannot honor every request,

    /// such as on a device with no promiscuous mode. The capture is usable, so a warning is not

    /// an error; [`Capture::warning`] is where it can be read.

        // A warning leaves a message of its own, and no call between pcap_create and here

        // writes the error buffer, so its contents belong to this warning.

        // Now that the handle is active, `pcap_setmintocopy` will take the value that

        // `immediate_mode` left behind.

        #[cfg(windows)]

        if let Some(size) = capture.min_to_copy {

            capture

                .check_err(unsafe { raw::pcap_setmintocopy(capture.handle.as_ptr(), size) == 0 })?;

        }

    /// Set the read timeout for the Capture. By default, this is 0, so it will block indefinitely.

    /// Set the timestamp type to be used by a capture device.

    ///

    /// # Errors

    ///

    /// If the capture device does not support the timestamp type, an error will be returned.

    #[cfg(libpcap_1_2_1)]

        #[cfg(windows)]

        if !raw::has_tstamp_type() {

            return Err(Error::EntrypointNotFound("pcap_set_tstamp_type"));

        }

        // libpcap leaves the error buffer alone here. All it reports is whether the device

        // claims to support the type, so there is no message to pass on.

    /// Set promiscuous mode on or off. By default, this is off.

    /// Set immediate mode on or off. By default, this is off.

    ///

    /// Note that in WinPcap, immediate mode is set by passing a 0 argument to `min_to_copy`.

    /// Immediate mode will be unset if `min_to_copy` is later called with a non-zero argument.

    /// Immediate mode is unset by resetting `min_to_copy` to the WinPcap default possibly changing

    /// a previously set value. When using `min_to_copy`, it is best to avoid `immediate_mode`.

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

        // Prior to 1.5.0 when `pcap_set_immediate_mode` was introduced, the necessary steps to set

        // immediate mode were more complicated, depended on the OS, and in some configurations had

        // to be set on an active capture. See

        // https://www.tcpdump.org/manpages/pcap_set_immediate_mode.3pcap.html. Since we do not

        // expect pre-1.5.0 version on unix systems in the wild, those cases are simply ignored.

        // Without `pcap_set_immediate_mode`, immediate mode is a `pcap_setmintocopy` of 0,

        // which pcap takes only once the handle has been activated, so leave the value for

        // `open`.

        #[cfg(windows)]

        if !raw::has_immediate_mode() || !cfg!(libpcap_1_5_0) {

            let mut capture = self;

            capture.min_to_copy = Some(if to {

                0

            } else {

                raw::WINPCAP_MINTOCOPY_DEFAULT

            });

            return capture;

        }

        #[cfg(libpcap_1_5_0)]

        unsafe {

        };

    /// Set want_pktap to true or false. The default is maintained by libpcap.

    #[cfg(all(libpcap_1_5_3, target_os = "macos"))]

    pub fn want_pktap(self, to: bool) -> Capture<Inactive> {

        unsafe { raw::pcap_set_want_pktap(self.handle.as_ptr(), to as _) };

        self

    }

    /// Set rfmon mode on or off. The default is maintained by pcap.

    #[cfg(not(windows))]

    /// Set the buffer size for incoming packet data.

    ///

    /// The default is 1000000. This should always be larger than the snaplen.

    /// Set the timestamp precision returned in captures.

    ///

    /// # Errors

    ///

    /// If the capture device does not support the timestamp precision, an error will be returned.

    #[cfg(libpcap_1_5_0)]

        #[cfg(windows)]

        if !raw::has_tstamp_precision() {

            return Err(Error::EntrypointNotFound("pcap_set_tstamp_precision"));

        }

        // libpcap leaves the error buffer alone here. All it reports is whether the device

        // claims to support the precision, so there is no message to pass on.

    /// Set the snaplen size (the maximum length of a packet captured into the buffer).

    /// Useful if you only want certain headers, but not the entire packet.

    ///

    /// The default is 65535.

}

#[repr(i32)]

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

/// Timestamp types

///

/// Not all systems and interfaces will necessarily support all of these. They are described in

/// more detail in [pcap-tstamp(7)](https://www.tcpdump.org/manpages/pcap-tstamp.7.html).

///

/// Note that timestamps synchronized with the system clock can go backwards, as the system clock

/// can go backwards.  If a clock is not in sync with the system clock, that could be because the

/// system clock isn't keeping accurate time, because the other clock isn't keeping accurate time,

/// or both.

///

/// Note that host-provided timestamps generally correspond to the time when the timestamping

/// code sees the packet; this could be some unknown amount of time after the first or last bit of

/// the packet is received by the network adapter, due to batching of interrupts for packet

/// arrival, queueing delays, etc..

pub enum TimestampType {

    /// Timestamps are provided by the host machine, rather than by the capture device.

    ///

    /// The characteristics of the timestamp are unknown.

    Host = 0,

    /// A timestamp provided by the host machine that is low precision but relatively cheap to

    /// fetch.

    ///

    /// It is taken from the system clock, so it is synchronized with the times you would fetch

    /// from system calls.

    HostLowPrec = 1,

    /// A timestamp provided by the host machine that is high precision. It might be more expensive

    /// to fetch than [`TimestampType::HostLowPrec`].

    ///

    /// From libpcap 1.10.0 on it is synchronized with the system clock. Before that it might or

    /// might not have been.

    HostHighPrec = 2,

    /// A high-precision timestamp supplied by the capture device.

    ///

    /// The timestamp is synchronized with the system clock.

    Adapter = 3,

    /// A high-precision timestamp supplied by the capture device.

    ///

    /// The timestamp is not synchronized with the system clock.

    AdapterUnsynced = 4,

    /// A timestamp provided by the host machine that is high precision. It might be more expensive

    /// to fetch than [`TimestampType::HostLowPrec`].

    ///

    /// The timestamp is not synchronized with the system clock.

    #[cfg(libpcap_1_10_0)]

    HostHighPrecUnsynced = 5,

}

#[cfg(test)]

mod tests {

    use crate::{

        capture::testmod::test_capture,

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

    };

    use super::*;

    #[test]

    fn test_from_device() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

        let ctx = raw::pcap_create_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_device("some_device");

        assert!(result.is_ok());

    }

    #[test]

    fn test_from_device_error() {

        let _m = RAWMTX.lock();

        let ctx = raw::pcap_create_context();

        ctx.expect().return_once_st(|_, _, _| std::ptr::null_mut());

        let result = Capture::from_device("some_device");

        assert!(result.is_err());

    }

    #[test]

    fn test_open() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_activate_context();

        ctx.expect()

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

            .return_once(|_| 0);

        let capture = capture.open().unwrap();

        assert_eq!(capture.warning(), None);

    }

    #[test]

    fn test_open_warning() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        // A device with no promiscuous mode is activated all the same.

        let ctx = raw::pcap_activate_context();

        ctx.expect()

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

            .return_once(|_| raw::PCAP_WARNING_PROMISC_NOTSUP);

        let _err = geterr_expect(pcap);

        let capture = capture.open().unwrap();

        assert_eq!(

            capture.warning(),

            Some(&Warning {

                code: crate::WarningCode::PromiscuousModeNotSupported,

                message: "oh oh".to_string(),

            })

        );

    }

    #[test]

    fn test_open_status_error() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_activate_context();

        ctx.expect()

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

            .return_once(|_| raw::PCAP_ERROR_PERM_DENIED);

        let _err = geterr_expect(pcap);

        let error = capture.open().err().unwrap();

        assert_eq!(

            error,

            Error::PcapErrorCode(crate::ErrorCode::PermissionDenied, "oh oh".to_string())

        );

    }

    #[test]

    fn test_open_error() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_activate_context();

        ctx.expect()

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

            .return_once(|_| -1);

        let _err = geterr_expect(pcap);

        let result = capture.open();

        assert!(result.is_err());

    }

    #[test]

    fn test_timeout() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_set_timeout_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let _capture = capture.timeout(5);

    }

    #[test]

    #[cfg(libpcap_1_2_1)]

    fn test_timstamp_type() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        #[cfg(windows)]

        let has_ctx = raw::has_tstamp_type_context();

        #[cfg(windows)]

        has_ctx.expect().times(2).returning(|| true);

        let ctx = raw::pcap_set_tstamp_type_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let capture = capture.tstamp_type(TimestampType::Host).unwrap();

        let ctx = raw::pcap_set_tstamp_type_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| raw::PCAP_WARNING_TSTAMP_TYPE_NOTSUP);

        assert_eq!(

            capture.tstamp_type(TimestampType::Adapter).err().unwrap(),

            Error::UnsupportedTimestampType

        );

        // For code coverage of the derive line.

        assert_ne!(TimestampType::Host, TimestampType::HostLowPrec);

        assert_ne!(TimestampType::Host, TimestampType::HostHighPrec);

        #[cfg(libpcap_1_10_0)]

        assert_ne!(

            TimestampType::HostHighPrec,

            TimestampType::HostHighPrecUnsynced

        );

    }

    #[test]

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

    fn test_timestamp_type_missing() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::has_tstamp_type_context();

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

        let result = capture.tstamp_type(TimestampType::Host);

        assert!(matches!(

            result,

            Err(Error::EntrypointNotFound("pcap_set_tstamp_type"))

        ));

    }

    #[test]

    fn test_promisc() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_set_promisc_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let _capture = capture.promisc(true);

    }

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

    struct ImmediateModeExpect(

        raw::__pcap_set_immediate_mode::Context,

        raw::__has_immediate_mode::Context,

    );

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

    struct ImmediateModeExpect(raw::__pcap_set_immediate_mode::Context);

    #[cfg(libpcap_1_5_0)]

    fn immediate_mode_expect(pcap: *mut raw::pcap_t) -> ImmediateModeExpect {

        let ctx = raw::pcap_set_immediate_mode_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        #[cfg(windows)]

        {

            let has_ctx = raw::has_immediate_mode_context();

            has_ctx.checkpoint();

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

            ImmediateModeExpect(ctx, has_ctx)

        }

        #[cfg(not(windows))]

        ImmediateModeExpect(ctx)

    }

    #[test]

    #[cfg(libpcap_1_5_0)]

    fn test_immediate_mode() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let _ctx = immediate_mode_expect(pcap);

        let capture = capture.immediate_mode(true);

        let _ctx = immediate_mode_expect(pcap);

        let _capture = capture.immediate_mode(false);

    }

    // A library without pcap_set_immediate_mode takes the value through pcap_setmintocopy

    // instead, and only once the handle is active.

    #[cfg(windows)]

    fn winpcap_open_expect(

        pcap: *mut raw::pcap_t,

        size: i32,

        ret: libc::c_int,

    ) -> (

        raw::__pcap_activate::Context,

        raw::__pcap_setmintocopy::Context,

    ) {

        let activate = raw::pcap_activate_context();

        activate.checkpoint();

        activate

            .expect()

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

            .return_once(|_| 0);

        let mintocopy = raw::pcap_setmintocopy_context();

        mintocopy.checkpoint();

        mintocopy

            .expect()

            .withf_st(move |arg1, arg2| *arg1 == pcap && *arg2 == size)

            .return_once(move |_, _| ret);

        (activate, mintocopy)

    }

    #[test]

    #[cfg(windows)]

    fn test_immediate_mode_winpcap() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let has_ctx = raw::has_immediate_mode_context();

        has_ctx.expect().times(2).returning(|| false);

        let capture = capture.immediate_mode(false).immediate_mode(true);

        let _ctx = winpcap_open_expect(pcap, 0, 0);

        assert!(capture.open().is_ok());

    }

    #[test]

    #[cfg(windows)]

    fn test_immediate_mode_winpcap_off() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let has_ctx = raw::has_immediate_mode_context();

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

        let capture = capture.immediate_mode(false);

        let _ctx = winpcap_open_expect(pcap, raw::WINPCAP_MINTOCOPY_DEFAULT, 0);

        assert!(capture.open().is_ok());

    }

    #[test]

    #[cfg(windows)]

    fn test_immediate_mode_winpcap_error() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let has_ctx = raw::has_immediate_mode_context();

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

        let capture = capture.immediate_mode(true);

        let _ctx = winpcap_open_expect(pcap, 0, -1);

        let _err = geterr_expect(pcap);

        assert!(capture.open().is_err());

    }

    #[test]

    #[cfg(all(libpcap_1_5_3, target_os = "macos"))]

    fn test_want_pktap() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_set_want_pktap_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let _capture = capture.want_pktap(true);

    }

    #[test]

    #[cfg(not(windows))]

    fn test_rfmon() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_set_rfmon_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let _capture = capture.rfmon(true);

    }

    #[test]

    fn test_buffer_size() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_set_buffer_size_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let _capture = capture.buffer_size(10);

    }

    #[test]

    #[cfg(libpcap_1_5_0)]

    fn test_precision() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        #[cfg(windows)]

        let has_ctx = raw::has_tstamp_precision_context();

        #[cfg(windows)]

        has_ctx.expect().times(2).returning(|| true);

        let ctx = raw::pcap_set_tstamp_precision_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let capture = capture.precision(Precision::Nano).unwrap();

        let ctx = raw::pcap_set_tstamp_precision_context();

        ctx.checkpoint();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| raw::PCAP_ERROR_TSTAMP_PRECISION_NOTSUP);

        assert_eq!(

            capture.precision(Precision::Nano).err().unwrap(),

            Error::UnsupportedTimestampPrecision

        );

    }

    #[test]

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

    fn test_precision_missing() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::has_tstamp_precision_context();

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

        let result = capture.precision(Precision::Nano);

        assert!(matches!(

            result,

            Err(Error::EntrypointNotFound("pcap_set_tstamp_precision"))

        ));

    }

    #[test]

    fn test_snaplen() {

        let _m = RAWMTX.lock();

        let mut dummy: isize = 777;

        let pcap = as_pcap_t(&mut dummy);

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

        let capture = test_capture.capture;

        let ctx = raw::pcap_set_snaplen_context();

        ctx.expect()

            .withf_st(move |arg1, _| *arg1 == pcap)

            .return_once(|_, _| 0);

        let _capture = capture.snaplen(10);

    }

}