// SPDX-License-Identifier: BSD-2-Clause

/*

 * Copyright © The libcoap-rs Contributors, all rights reserved.

 * This file is part of the libcoap-rs project, see the README file for

 * general information on this project and the NOTICE.md and LICENSE files

 * for information regarding copyright ownership and terms of use.

 *

 * context.rs - CoAP context related code.

 */

//! Module containing context-internal types and traits.

use core::ffi::c_uint;

#[cfg(feature = "dtls-pki")]

use libcoap_sys::coap_context_set_pki_root_cas;

use libcoap_sys::{

    coap_add_resource, coap_can_exit, coap_context_get_csm_max_message_size, coap_context_get_csm_timeout,

    coap_context_get_max_handshake_sessions, coap_context_get_max_idle_sessions, coap_context_get_session_timeout,

    coap_context_set_block_mode, coap_context_set_csm_max_message_size, coap_context_set_csm_timeout,

    coap_context_set_keepalive, coap_context_set_max_handshake_sessions, coap_context_set_max_idle_sessions,

    coap_context_set_session_timeout, coap_context_t, coap_event_t, coap_event_t_COAP_EVENT_BAD_PACKET,

    coap_event_t_COAP_EVENT_DTLS_CLOSED, coap_event_t_COAP_EVENT_DTLS_CONNECTED, coap_event_t_COAP_EVENT_DTLS_ERROR,

    coap_event_t_COAP_EVENT_DTLS_RENEGOTIATE, coap_event_t_COAP_EVENT_KEEPALIVE_FAILURE,

    coap_event_t_COAP_EVENT_MSG_RETRANSMITTED, coap_event_t_COAP_EVENT_OSCORE_DECODE_ERROR,

    coap_event_t_COAP_EVENT_OSCORE_DECRYPTION_FAILURE, coap_event_t_COAP_EVENT_OSCORE_INTERNAL_ERROR,

    coap_event_t_COAP_EVENT_OSCORE_NOT_ENABLED, coap_event_t_COAP_EVENT_OSCORE_NO_PROTECTED_PAYLOAD,

    coap_event_t_COAP_EVENT_OSCORE_NO_SECURITY, coap_event_t_COAP_EVENT_PARTIAL_BLOCK,

    coap_event_t_COAP_EVENT_SERVER_SESSION_DEL, coap_event_t_COAP_EVENT_SERVER_SESSION_NEW,

    coap_event_t_COAP_EVENT_SESSION_CLOSED, coap_event_t_COAP_EVENT_SESSION_CONNECTED,

    coap_event_t_COAP_EVENT_SESSION_FAILED, coap_event_t_COAP_EVENT_TCP_CLOSED, coap_event_t_COAP_EVENT_TCP_CONNECTED,

    coap_event_t_COAP_EVENT_TCP_FAILED, coap_event_t_COAP_EVENT_WS_CLOSED, coap_event_t_COAP_EVENT_WS_CONNECTED,

    coap_event_t_COAP_EVENT_WS_PACKET_SIZE, coap_event_t_COAP_EVENT_XMIT_BLOCK_FAIL, coap_free_context,

    coap_get_app_data, coap_io_process, coap_new_context, coap_proto_t, coap_proto_t_COAP_PROTO_DTLS,

    coap_proto_t_COAP_PROTO_TCP, coap_proto_t_COAP_PROTO_UDP, coap_register_event_handler,

    coap_register_response_handler, coap_set_app_data, coap_startup_with_feature_checks, COAP_BLOCK_SINGLE_BODY,

    COAP_BLOCK_USE_LIBCOAP, COAP_IO_WAIT,

};

use std::ffi::CStr;

#[cfg(feature = "dtls-pki")]

use std::ffi::CString;

#[cfg(feature = "dtls")]

use std::ptr::NonNull;

use std::{any::Any, ffi::c_void, fmt::Debug, net::SocketAddr, ops::Sub, sync::Once, time::Duration};

#[cfg(all(feature = "dtls-pki", unix))]

use std::{os::unix::ffi::OsStrExt, path::Path};

#[cfg(any(feature = "dtls-rpk", feature = "dtls-pki"))]

use crate::crypto::pki_rpk::ServerPkiRpkCryptoContext;

#[cfg(feature = "dtls-psk")]

use crate::crypto::psk::ServerPskContext;

use crate::{

    error::{ContextConfigurationError, EndpointCreationError, IoProcessError, MulticastGroupJoinError},

    event::{event_handler_callback, CoapEventHandler},

    mem::{CoapLendableFfiRcCell, CoapLendableFfiWeakCell, DropInnerExclusively},

    resource::{CoapResource, UntypedCoapResource},

    session::{session_response_handler, CoapServerSession, CoapSession},

    transport::CoapEndpoint,

};

//TODO: New feature?

use libcoap_sys::coap_join_mcast_group_intf;

static COAP_STARTUP_ONCE: Once = Once::new();

#[inline(always)]

#[derive(Debug)]

struct CoapContextInner<'a> {

    /// Reference to the raw context this context wraps around.

    raw_context: *mut coap_context_t,

    /// A list of endpoints that this context is currently associated with.

    endpoints: Vec<CoapEndpoint>,

    /// A list of resources associated with this context.

    resources: Vec<Box<dyn UntypedCoapResource>>,

    /// A list of server-side sessions that are currently active.

    server_sessions: Vec<CoapServerSession<'a>>,

    /// The event handler responsible for library-user side handling of events.

    event_handler: Option<Box<dyn CoapEventHandler>>,

    /// PSK context for encrypted server-side sessions.

    #[cfg(feature = "dtls-psk")]

    psk_context: Option<ServerPskContext<'a>>,

    /// PKI context for encrypted server-side sessions.

    #[cfg(any(feature = "dtls-pki", feature = "dtls-rpk"))]

    pki_rpk_context: Option<ServerPkiRpkCryptoContext<'a>>,

}

/// A CoAP Context — container for general state and configuration information relating to CoAP

///

/// The equivalent to the [coap_context_t] type in libcoap.

#[derive(Debug)]

pub struct CoapContext<'a> {

    inner: CoapLendableFfiRcCell<CoapContextInner<'a>>,

}

impl<'a> CoapContext<'a> {

    /// Creates a new context.

    ///

    /// # Errors

    /// Returns an error if the underlying libcoap library was unable to create a new context

    /// (probably an allocation error?).

    /// Restores a CoapContext from its raw counterpart.

    ///

    /// # Safety

    /// Provided pointer must point to as valid instance of a raw context whose application data

    /// points to a `*mut CoapLendableFfiWeakCell<CoapContextInner>`.

    /// Handle an incoming event provided by libcoap.

        // Call event handler for event.

            // Variant names are named by bindgen, we have no influence on this.

            // Ref: https://github.com/rust-lang/rust/issues/39371

            #[allow(non_upper_case_globals)]

                coap_event_t_COAP_EVENT_SERVER_SESSION_NEW => {

                    } else {

                    }

                },

                coap_event_t_COAP_EVENT_SERVER_SESSION_DEL => {

                    } else {

                    }

                },

                coap_event_t_COAP_EVENT_OSCORE_DECRYPTION_FAILURE => {

                },

                coap_event_t_COAP_EVENT_OSCORE_NO_PROTECTED_PAYLOAD => {

                },

            }

        // For server-side sessions: Ensure that server-side session wrappers are either kept in memory or dropped when needed.

            // Variant names are named by bindgen, we have no influence on this.

            // Ref: https://github.com/rust-lang/rust/issues/39371

            #[allow(non_upper_case_globals)]

            }

    /// Sets the server-side cryptography information provider.

    ///

    /// # Errors

    ///

    /// Returns [`ContextConfigurationError::Unknown`] if the call to the underlying libcoap library

    /// function fails and [`ContextConfigurationError::CryptoContextAlreadySet`] if the PSK context

    /// has already been set previously.

    #[cfg(feature = "dtls-psk")]

        }

    /// Sets the server-side cryptography information provider.

    ///

    /// # Errors

    ///

    /// Returns [`ContextConfigurationError::Unknown`] if the call to the underlying libcoap library

    /// function fails and [`ContextConfigurationError::CryptoContextAlreadySet`] if the PSK context

    /// has already been set previously.

    #[cfg(any(feature = "dtls-pki", feature = "dtls-rpk"))]

        }

    /// Convenience wrapper around [`set_pki_root_cas`](CoapContext::set_pki_root_cas) that can be

    /// provided with any type that implements `AsRef<Path>`.

    ///

    /// `ca_file` should be the full path of a PEM-encoded file containing all root CAs to be used

    /// or `None`, `ca_dir` should be a directory path containing PEM-encoded CA certificates to

    /// be used or `None`.

    ///

    /// As not all implementations of [`OsString`] (which is the basis of [`Path`]) provide

    /// conversions to non-zero byte sequences, this function is only available on Unix.

    /// On other operating systems, perform manual conversion of paths into [`CString`] and call

    /// [`set_pki_root_cas`](CoapContext::set_pki_root_cas) directly instead.

    ///

    /// See the Rust standard library documentation on [FFI conversions](https://doc.rust-lang.org/std/ffi/index.html#conversions])

    /// and the [`OsString` type](https://doc.rust-lang.org/std/ffi/struct.OsString.html) for more

    /// information.

    ///

    /// # Errors

    /// Will return [`ContextConfigurationError::Unknown`] if the call to the underlying libcoap

    /// function fails (indicating an error in either libcoap or the underlying TLS library).

    #[cfg(all(feature = "dtls-pki", unix))]

            // Unix paths never contain null bytes, so we can unwrap here.

            // Unix paths never contain null bytes, so we can unwrap here.

    /// Sets the path to a CA certificate file and/or a directory of CA certificate files that

    /// should be used as this context's default root CA information.

    ///

    /// `ca_file` should be the full path of a PEM-encoded file containing all root CAs to be used

    /// or `None`, `ca_dir` should be a directory path containing PEM-encoded CA certificates to

    /// be used or `None`.

    ///

    /// # Errors

    /// Will return [`ContextConfigurationError::Unknown`] if the call to the underlying libcoap

    /// function fails (indicating an error in either libcoap or the underlying TLS library).

    #[cfg(feature = "dtls-pki")]

        } else {

        }

}

impl CoapContext<'_> {

    /// Performs a controlled shutdown of the CoAP context.

    ///

    /// This will perform all still outstanding IO operations until [coap_can_exit()] confirms that

    /// the context has no more outstanding IO and can be dropped without interrupting sessions.

        // Send remaining packets until we can cleanly shutdown.

        // SAFETY: Provided context is always valid as an invariant of this struct.

    /// Store reference to the endpoint

    /// Creates a new UDP endpoint that is bound to the given address.

    /// Creates a new TCP endpoint that is bound to the given address.

    #[cfg(feature = "tcp")]

    /// Creates a new DTLS endpoint that is bound to the given address.

    ///

    /// Note that in order to actually connect to DTLS clients, you need to set a crypto provider

    /// using [CoapContext::set_psk_context] and/or [CoapContext::set_pki_rpk_context].

    #[cfg(feature = "dtls")]

    /// Joins a multicast group.

    ///

    /// `groupname` is usually a multicast IP address, while `ifname` is the used interface.

    /// If `ifname` is set to `None`, the first appropriate interface will be chosen by the operating system.

    // /// TODO

    // #[cfg(all(feature = "tcp", dtls))]

    // pub fn add_endpoint_tls(&mut self, _addr: SocketAddr) -> Result<(), EndpointCreationError> {

    //     todo!()

    //     // TODO: self.add_endpoint(addr, coap_proto_t_COAP_PROTO_TLS)

    // }

    /// Adds the given resource to the resource pool of this context.

    /// Performs currently outstanding IO operations, waiting for a maximum duration of `timeout`.

    ///

    /// This is the function where most of the IO operations made using this library are actually

    /// executed. It is recommended to call this function in a loop for as long as the CoAP context

    /// is used.

        // Round up the duration if it is not a clean number of seconds.

        } else {

            // If no timeout is set, wait indefinitely.

        };

    /// Return the duration that idle server-side sessions are kept alive if they are not referenced

    /// or used anywhere else.

    /// Set the duration that idle server-side sessions are kept alive if they are not referenced or

    /// used anywhere else.

    ///

    /// # Panics

    /// Panics if the provided duration is too large to be provided to libcoap (larger than a

    /// [libc::c_uint]).

    /// Returns the maximum number of server-side sessions that can concurrently be in a handshake

    /// state.

    ///

    /// If this number is exceeded, no new handshakes will be accepted.

    /// Sets the maximum number of server-side sessions that can concurrently be in a handshake

    /// state.

    ///

    /// If this number is exceeded, no new handshakes will be accepted.

    /// Returns the maximum number of idle server-side sessions for this context.

    ///

    /// If this number is exceeded, the oldest unreferenced session will be freed.

    /// Sets the maximum number of idle server-side sessions for this context.

    ///

    /// If this number is exceeded, the oldest unreferenced session will be freed.

    /// Returns the maximum size for Capabilities and Settings Messages

    ///

    /// CSMs are used in CoAP over TCP as specified in

    /// [RFC 8323, Section 5.3](https://datatracker.ietf.org/doc/html/rfc8323#section-5.3).

    /// Sets the maximum size for Capabilities and Settings Messages

    ///

    /// CSMs are used in CoAP over TCP as specified in

    /// [RFC 8323, Section 5.3](https://datatracker.ietf.org/doc/html/rfc8323#section-5.3).

    /// Returns the timeout for Capabilities and Settings Messages

    ///

    /// CSMs are used in CoAP over TCP as specified in

    /// [RFC 8323, Section 5.3](https://datatracker.ietf.org/doc/html/rfc8323#section-5.3).

    /// Sets the timeout for Capabilities and Settings Messages

    ///

    /// CSMs are used in CoAP over TCP as specified in

    /// [RFC 8323, Section 5.3](https://datatracker.ietf.org/doc/html/rfc8323#section-5.3).

    ///

    /// # Panics

    /// Panics if the provided timeout is too large for libcoap (> [u32::MAX]).

    /// Sets the number of seconds to wait before sending a CoAP keepalive message for idle

    /// sessions.

    ///

    /// If the provided value is None, CoAP-level keepalive messages will be disabled.

    ///

    /// # Panics

    /// Panics if the provided duration is too large to be provided to libcoap (larger than a

    /// [libc::c_uint]).

    /// Returns a reference to the raw context contained in this struct.

    ///

    /// # Safety

    /// In general, you should not do anything that would interfere with the safe functions of this

    /// struct.

    /// Most notably, this includes the following:

    /// - Associating raw resources with the context and not removing them before the context is

    ///   dropped (may cause segfaults on drop).

    /// - Associating raw sessions that have a reference count != 0 when the CoapContext is dropped

    ///   (will cause an abort on drop)

    /// - Calling `coap_free_context()` on this context (for obvious reasons, this will probably

    ///   cause a segfault if you don't immediately [std::mem::forget()] the CoapContext and never

    ///   use anything related to the context again, but why would you do that?)

    // Kept here for consistency, even though it is unused.

    #[allow(unused)]

    /// Returns a mutable reference to the raw context contained in this struct.

    ///

    /// # Safety

    /// In general, you should not do anything that would interfere with the safe functions of this

    /// struct.

    /// Most notably, this includes the following:

    /// - Associating raw resources with the context and not removing them before the context is

    ///   dropped (may cause segfaults on drop).

    /// - Associating raw sessions that have a reference count != 0 when the CoapContext is dropped

    ///   (will cause an abort on drop)

    /// - Calling `coap_free_context()` on this context (for obvious reasons, this will probably

    ///   cause a segfault if you don't immediately [std::mem::forget()] the CoapContext and never

    ///   use anything related to the context again, but why would you do that?)

    // TODO coap_session_get_by_peer

}

impl Drop for CoapContextInner<'_> {

        // Clear endpoints because coap_free_context() would free their underlying raw structs.

}