// 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.

 *

 * session/mod.rs - Types relating to generic CoAP sessions.

 */

use std::{

    any::Any,

    borrow::BorrowMut,

    cell::{Ref, RefMut},

    collections::{HashMap, VecDeque},

    marker::PhantomData,

    net::{SocketAddr, ToSocketAddrs},

    rc::Rc,

};

use libcoap_sys::{

    coap_context_t, coap_fixed_point_t, coap_mid_t, coap_new_message_id, coap_pdu_get_token, coap_pdu_t,

    coap_response_t, coap_response_t_COAP_RESPONSE_FAIL, coap_response_t_COAP_RESPONSE_OK, coap_send,

    coap_session_get_ack_random_factor, coap_session_get_ack_timeout, coap_session_get_addr_local,

    coap_session_get_addr_remote, coap_session_get_ifindex, coap_session_get_max_retransmit, coap_session_get_proto,

    coap_session_get_state, coap_session_get_type, coap_session_init_token, coap_session_max_pdu_size,

    coap_session_new_token, coap_session_send_ping, coap_session_set_ack_random_factor, coap_session_set_ack_timeout,

    coap_session_set_max_retransmit, coap_session_set_mtu, coap_session_state_t,

    coap_session_state_t_COAP_SESSION_STATE_CONNECTING, coap_session_state_t_COAP_SESSION_STATE_CSM,

    coap_session_state_t_COAP_SESSION_STATE_ESTABLISHED, coap_session_state_t_COAP_SESSION_STATE_HANDSHAKE,

    coap_session_state_t_COAP_SESSION_STATE_NONE, coap_session_t, coap_session_type_t_COAP_SESSION_TYPE_CLIENT,

    coap_session_type_t_COAP_SESSION_TYPE_HELLO, coap_session_type_t_COAP_SESSION_TYPE_NONE,

    coap_session_type_t_COAP_SESSION_TYPE_SERVER,

};

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

use libcoap_sys::{coap_session_get_psk_hint, coap_session_get_psk_identity, coap_session_get_psk_key};

use self::sealed::{CoapSessionCommonInternal, CoapSessionInnerProvider};

pub use self::{client::CoapClientSession, server::CoapServerSession};

use crate::{

    error::{MessageConversionError, SessionGetAppDataError},

    message::{request::CoapRequest, response::CoapResponse, CoapMessage, CoapMessageCommon},

    protocol::CoapToken,

    types::{CoapAddress, CoapMessageId, CoapProtocol, IfIndex, MaxRetransmit},

};

pub mod client;

pub mod server;

/// Representation of the states that a session can be in.

#[repr(u32)]

pub enum CoapSessionState {

    None = coap_session_state_t_COAP_SESSION_STATE_NONE as u32,

    Connecting = coap_session_state_t_COAP_SESSION_STATE_CONNECTING as u32,

    Handshake = coap_session_state_t_COAP_SESSION_STATE_HANDSHAKE as u32,

    Csm = coap_session_state_t_COAP_SESSION_STATE_CSM as u32,

    Established = coap_session_state_t_COAP_SESSION_STATE_ESTABLISHED as u32,

}

impl From<coap_session_state_t> for CoapSessionState {

        }

}

mod sealed {

    use super::*;

    /// Internal Trait for types that can provide a Ref(Mut) to CoapSessionInner instances.

    /// Implemented by the different session types ([CoapClientSession] and [CoapServerSession])

    pub trait CoapSessionInnerProvider<'a> {

        /// Provide a Ref to the instance of [CoapSessionInner] contained in this type.

        fn inner_ref<'b>(&'b self) -> Ref<'b, CoapSessionInner<'a>>;

        /// Provide a RefMut to the instance of [CoapSessionInner] contained in this type.

        fn inner_mut<'b>(&'b self) -> RefMut<'b, CoapSessionInner<'a>>;

    }

    /// Functions common between all sessions that should not be public.

    ///

    /// This trait does not have any mandatory functions and will be automatically implemented for

    /// all types that implement [CoapSessionInnerProvider].

    pub trait CoapSessionCommonInternal<'a>: CoapSessionInnerProvider<'a> {

    }

    impl<'a, T: CoapSessionInnerProvider<'a>> CoapSessionCommonInternal<'a> for T {}

}

/// Trait for functions that are common between client and server sessions.

pub trait CoapSessionCommon<'a>: CoapSessionCommonInternal<'a> {

    /// Returns the application specific data stored alongside this session.

    /// Sets the application-specific data stored alongside this session.

    /// Clears the application-specific data stored alongside this session.

    /// Returns the Ack-Random-Factor used by libcoap.

    ///

    /// The returned value is a tuple consisting of an integer and a fractional part, where the

    /// fractional part is a value from 0-999 and represents the first three digits after the comma.

    /// Sets the Ack-Random-Factor used by libcoap.

    /// Returns the current value of the Acknowledgement Timeout for this session (in seconds).

    ///

    /// The returned value is a tuple consisting of an integer and a fractional part, where the

    /// fractional part is a value from 0-999 and represents the first three digits after the comma.

    /// Sets the value of the Acknowledgement Timeout for this session.

    /// Returns the local address for this session.

    /// Returns the remote address for this session.

    /// Returns the interface index for this session.

    /// Returns the maximum number of retransmissions for this session.

    /// Sets the maximum number of retransmissions for this session.

    /// Returns the underlying transport protocol used for this session.

    /// Returns the current PSK hint for this session.

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

    /// Returns the current PSK identity for this session.

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

    /// Returns the current PSK key for this session.

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

    /// Returns the current state of this session.

    #[must_use = "getting the current session state without using it is a no-op"]

    /// Initializes the initial token value used by libcoap for this session.

    ///

    /// This value will be used as the token and incremented for each message sent through this

    /// session that does not already have a token set.

    /// Returns the maximum size of a PDU for this session.

    /// Sets the maximum size of a PDU for this session.

    /// Returns the next message ID that should be used for this session.

    /// Returns the next token that should be used for requests.

    /// Send a ping message to the remote peer.

    /// Send the given message-like object to the peer.

    ///

    /// # Errors

    /// Returns a [MessageConversionError] if the supplied object cannot be converted to a message.

        // SAFETY: Provided session pointer being valid is an invariant of CoapSessionInner,

        // raw pdu should be valid as we got it from `into_raw_pdu()`.

    /// Sends the given CoapRequest, returning a CoapRequestHandle that can be used to poll the

    /// request for completion.

    ///

    /// # Errors

    /// Returns a [MessageConversionError] if the given Request could not be converted into a raw

    /// message.

    /// Polls whether the request for the given handle already has pending responses.

    ///

    /// Returns an iterator over all responses associated with the request.

    ///

    /// # Panics

    ///

    /// Panics if the provided handle does not refer to a valid token, i.e., because it belongs to

    /// a different session.

    /// Returns whether this session waits for the provided token.

    /// Stops listening for responses to this request handle.

    ///

    /// Any future responses to the request associated with this handle will be responded to with an

    /// RST message.

    /// Returns a mutable reference to the underlying raw session.

    ///

    /// # Safety

    /// Do not do anything that would interfere with the functionality of this wrapper.

    /// Most importantly, *do not* free the session yourself.

    /// Returns a reference to the underlying raw session.

    ///

    /// # Safety

    /// Do not do anything that would interfere with the functionality of this wrapper.

    /// Most importantly, *do not* free the session yourself.

}

impl<'a, T: CoapSessionCommonInternal<'a>> CoapSessionCommon<'a> for T {}

#[derive(Debug)]

/// The representation of a CoAP session.

///

/// This enum only provides functionality that is common between clients and servers (by

/// implementing [CoapSessionCommon]). If you require functionality specific to client- or

/// server-side sessions, match this enum on the required session type.

pub enum CoapSession<'a> {

    Client(CoapClientSession<'a>),

    Server(CoapServerSession<'a>),

}

impl<'a> CoapSessionInnerProvider<'a> for CoapSession<'a> {

        }

        }

}

impl<'a> CoapSession<'a> {

    /// Restores a CoapSession from its raw counterpart.

    ///

    /// Note that it is not possible to statically infer the lifetime of the created session from

    /// the raw pointer, i.e., the session will be created with an arbitrary lifetime.

    /// Therefore, callers of this function should ensure that the created session instance does not

    /// outlive the context it is bound to.

    /// Failing to do so will result in a panic/abort in the context destructor as it is unable to

    /// claim exclusive ownership of the session.

    ///

    /// # Panics

    ///

    /// Panics if the given pointer is a null pointer.

    ///

    /// # Safety

    /// The provided pointer must be valid, the provided session's app data must be a valid argument

    /// to [`CoapFfiRcCell<CoapClientSessionInner>::clone_raw_rc`](crate::mem::CoapFfiRcCell::clone_raw_rc)

    /// or [`CoapFfiRcCell<CoapServerSessionInner>::clone_raw_rc`](crate::mem::CoapFfiRcCell::clone_raw_rc)

    /// (depending on the session type).

            coap_session_type_t_COAP_SESSION_TYPE_SERVER | coap_session_type_t_COAP_SESSION_TYPE_HELLO => {

            },

        }

}

impl<'a> From<CoapClientSession<'a>> for CoapSession<'a> {

}

impl<'a> From<CoapServerSession<'a>> for CoapSession<'a> {

}

impl PartialEq for CoapSession<'_> {

        }

}

impl Eq for CoapSession<'_> {}

/// Inner part of the representation of a CoapSession.

///

/// For internal use only, this is only public because of some limitations in Rusts type system

/// (as we would leak a private type).

#[derive(Debug)]

#[doc(hidden)]

pub struct CoapSessionInner<'a> {

    raw_session: *mut coap_session_t,

    app_data: Option<Rc<dyn Any>>,

    received_responses: HashMap<CoapToken, VecDeque<CoapResponse>>,

    _context_lifetime_marker: PhantomData<&'a coap_context_t>,

}

impl CoapSessionInner<'_> {

    /// Initializes a new session from its raw counterpart.

    ///

    /// Callers of this function should probably also insert themselves into the `app_data` pointer

    /// of the raw session to allow later retrieval (as is done for `CoapClientSession` and

    /// `CoapServerSession`.

    ///

    /// # Safety

    /// Provided pointer must point to a valid raw_session.

    ///

    /// Note that the chosen lifetime for the inner session is arbitrarily, so you should ensure

    /// that the CoapSessionInner instance does not outlive the underlying session.

    /// To do so, you probably want to increase the reference counter of the session by one and

    /// never provide values of this session with a lifetime that exceeds the one of the

    /// [CoapContext] this session is bound to.

}

/// A handle returned by CoAP sessions upon sending a request.

///

/// Can be used in calls to [CoapSessionCommon::poll_handle()] to check for responses to the sent

/// request.

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

pub struct CoapRequestHandle {

    _mid: CoapMessageId,

    token: CoapToken,

}

impl CoapRequestHandle {

}

// This is fine, we don't read the C-type struct, we return it.

    } else {

    }