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

 *

 * resource.rs - Types for converting between libcoap and Rust data structures.

 */

//! Types required for conversion between libcoap C library abstractions and Rust types.

use core::ffi::c_ushort;

use std::{

    ffi::{CStr, CString},

    fmt::{Debug, Display, Formatter},

    marker::PhantomPinned,

    mem::MaybeUninit,

    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs},

    os::raw::c_int,

    pin::Pin,

    str::FromStr,

};

use libcoap_sys::{

    c_stdlib::{in6_addr, in_addr, sa_family_t, sockaddr_in, sockaddr_in6, socklen_t, AF_INET, AF_INET6},

    coap_address_t, coap_delete_optlist, coap_mid_t, coap_proto_t, coap_proto_t_COAP_PROTO_DTLS,

    coap_proto_t_COAP_PROTO_NONE, coap_proto_t_COAP_PROTO_TCP, coap_proto_t_COAP_PROTO_TLS,

    coap_proto_t_COAP_PROTO_UDP, coap_split_proxy_uri, coap_split_uri, coap_str_const_t, coap_string_equal,

    coap_uri_into_optlist, coap_uri_scheme_t, coap_uri_scheme_t_COAP_URI_SCHEME_COAP,

    coap_uri_scheme_t_COAP_URI_SCHEME_COAPS, coap_uri_scheme_t_COAP_URI_SCHEME_COAPS_TCP,

    coap_uri_scheme_t_COAP_URI_SCHEME_COAPS_WS, coap_uri_scheme_t_COAP_URI_SCHEME_COAP_TCP,

    coap_uri_scheme_t_COAP_URI_SCHEME_COAP_WS, coap_uri_scheme_t_COAP_URI_SCHEME_HTTP,

    coap_uri_scheme_t_COAP_URI_SCHEME_HTTPS, coap_uri_t, COAP_URI_SCHEME_SECURE_MASK,

};

use num_derive::FromPrimitive;

use num_traits::FromPrimitive;

#[cfg(feature = "url")]

use url::Url;

use crate::{context::ensure_coap_started, error::UriParsingError, message::CoapOption, protocol::UriPort};

/// Interface index used internally by libcoap to refer to an endpoint.

pub type IfIndex = c_int;

/// Value for maximum retransmits.

pub type MaxRetransmit = c_ushort;

/// Identifier for a CoAP message.

pub type CoapMessageId = coap_mid_t;

/// Internal wrapper for the raw coap_address_t type, mainly used for conversion between types.

pub(crate) struct CoapAddress(coap_address_t);

impl CoapAddress {

    /// Returns a reference to the underlying raw [coap_address_t].

    /// Returns a mutable reference to the underlying [coap_address_t].

    ///

    /// Because there are some invariants that must be kept with regards to the underlying

    /// [coap_address_t], this function is unsafe.

    /// If you want to get the coap_address_t safely, use [into_raw_address()](CoapAddress::into_raw_address()).

    ///

    /// # Safety

    /// The underlying [coap_address_t] must always refer to a valid instance of sockaddr_in or

    /// sockaddr_in6, and [coap_address_t::size] must always be the correct size of the sockaddr

    /// in the [coap_address_t::addr] field.

    // Kept for consistency

    #[allow(dead_code)]

    /// Converts this address into the corresponding raw [coap_address_t](libcoap_sys::coap_address_t)

    // Kept for consistency

    #[allow(dead_code)]

}

impl ToSocketAddrs for CoapAddress {

    type Iter = std::option::IntoIter<SocketAddr>;

        // SAFETY: That the underlying value of addr is a valid sockaddr is an invariant, the only

        // way the value could be invalid is if as_mut_coap_address_t() (an unsafe function) is used

        // incorrectly.

            AF_INET => {

                // SAFETY: Validity of addr is an invariant, and we checked that the type of the

                // underlying sockaddr is actually sockaddr_in.

            },

            AF_INET6 => {

                // SAFETY: Validity of addr is an invariant, and we checked that the type of the

                // underlying sockaddr is actually sockaddr_in6.

            },

            // This should not happen as long as the invariants are kept.

        };

}

impl From<SocketAddr> for CoapAddress {

                }

            },

                }

            },

        }

}

#[doc(hidden)]

impl From<coap_address_t> for CoapAddress {

}

#[doc(hidden)]

impl From<&coap_address_t> for CoapAddress {

}

/// Representation for a URI scheme that can be used in CoAP (proxy) requests.

#[repr(u32)]

pub enum CoapUriScheme {

    Coap = coap_uri_scheme_t_COAP_URI_SCHEME_COAP as u32,

    Coaps = coap_uri_scheme_t_COAP_URI_SCHEME_COAPS as u32,

    CoapTcp = coap_uri_scheme_t_COAP_URI_SCHEME_COAP_TCP as u32,

    CoapsTcp = coap_uri_scheme_t_COAP_URI_SCHEME_COAPS_TCP as u32,

    Http = coap_uri_scheme_t_COAP_URI_SCHEME_HTTP as u32,

    Https = coap_uri_scheme_t_COAP_URI_SCHEME_HTTPS as u32,

    CoapWs = coap_uri_scheme_t_COAP_URI_SCHEME_COAP_WS as u32,

    CoapsWs = coap_uri_scheme_t_COAP_URI_SCHEME_COAPS_WS as u32,

}

impl CoapUriScheme {

}

impl FromStr for CoapUriScheme {

    type Err = UriParsingError;

        }

}

impl Display for CoapUriScheme {

        })

}

impl From<coap_uri_scheme_t> for CoapUriScheme {

}

impl From<CoapProtocol> for CoapUriScheme {

        }

}

/// Representation of a URI for CoAP requests, responses or proxy URIs.

///

/// See https://datatracker.ietf.org/doc/html/rfc7252#section-6 for a description of how a URI

/// should look like.

///

/// # Examples

/// The easiest way to instantiate a request or location CoAP URI is by parsing a string (either

/// using the [FromStr] implementation or using [CoapUri::try_from_str]):

/// ```

/// use libcoap_rs::types::{CoapUri, CoapUriScheme};

///

/// let uri: CoapUri = "coap://example.com:4711/foo/bar?answer=42".parse()?;

/// assert_eq!(uri.scheme(), Some(CoapUriScheme::Coap));

/// # Result::<(), UriParsingError>::Ok(())

/// Alternatively, a [CoapUri] may be constructed from its parts using [CoapUri::new] or

/// [CoapUri::new_relative] or from a [Url] (requires the `url` feature), refer to the method level

/// documentation for more information.

///

/// If you want to create a proxy URI, refer to the method-level documentation [CoapUri::new_proxy],

/// [CoapUri::try_from_str_proxy] or [CoapUri::try_from_url_proxy].

///

/// # Note on URI Length Limits

///

/// Due to [the specified limits](https://datatracker.ietf.org/doc/html/rfc7252#section-5.10)

/// of CoAP option lengths, the URI path components, query components, and hostnames for a URI must not

/// exceed 255 bytes each, i.e. a full path with more than 255 bytes is fine, but each individual

/// path segment must be smaller than 255 bytes.

///

/// For proxy URIs, there is a length limit of 255 bytes for the scheme.

/// As we use the Uri-* options for encoding proxy URIs instead of the Proxy-Uri option (as

/// specified in [RFC 7252, section 5.10.2](https://datatracker.ietf.org/doc/html/rfc7252#section-5.10.2)),

/// the above limits regarding path and query components also apply here.

#[derive(Debug)]

pub struct CoapUri {

    is_proxy: bool,

    raw_uri: coap_uri_t,

    uri_str: Pin<Box<CoapUriInner>>,

}

#[derive(Debug)]

struct CoapUriInner(CString, PhantomPinned);

impl CoapUri {

    /// Creates a new [CoapUri] for use as a request or location URI from its constituent parts.

    ///

    /// # Errors

    /// May fail if the provided fields do not represent a valid relative URI or if the arguments

    /// exceed maximum lengths (see the struct level documentation).

    ///

    /// # Examples

    /// ```

    /// use libcoap_rs::types::{CoapUri, CoapUriScheme};

    ///

    /// let uri: CoapUri = CoapUri::new(

    /// assert_eq!(uri.scheme(), Some(CoapUriScheme::Coap));

    /// # Result::<(), UriParsingError>::Ok(())

        // SAFETY: coap_split_uri is one of the allowed functions.

    /// Creates a new [CoapUri] for use as a proxy URI from its constituent parts.

    ///

    /// # Errors

    /// May fail if the provided fields do not represent a valid relative URI or if the arguments

    /// exceed maximum lengths (see the struct level documentation).

    /// # Examples

    /// ```

    /// use libcoap_rs::types::{CoapUri, CoapUriScheme};

    ///

    /// let uri: CoapUri = CoapUri::new_proxy(

    /// assert_eq!(uri.scheme(), Some(CoapUriScheme::Coap));

    /// # Result::<(), UriParsingError>::Ok(())

        // SAFETY: coap_split_proxy_uri is one of the allowed functions.

    /// Attempts to convert the provided `path` and `query` into a relative [CoapUri] suitable as a

    /// request/location URI.

    ///

    /// # Errors

    /// May fail if the provided `path` and `query` do not represent a valid relative URI or if the

    /// arguments exceed maximum lengths (see the struct level documentation).

    ///

    /// # Examples

    /// ```

    /// use libcoap_rs::types::{CoapUri, CoapUriScheme};

    ///

    /// let uri: CoapUri = CoapUri::new_relative(

    /// assert_eq!(uri.scheme(), None);

    /// # Result::<(), UriParsingError>::Ok(())

    /// Attempts to convert the provided `uri_str` into a [CoapUri] suitable as a request/location

    /// URI.

    ///

    /// # Errors

    /// May fail if the provided `uri_str` is not a valid URI or if the URI components exceed

    /// maximum lengths (see the struct level documentation).

    ///

    /// # Examples

    /// ```

    /// use libcoap_rs::types::{CoapUri, CoapUriScheme};

    ///

    /// let uri: CoapUri = CoapUri::try_from_str("coap://example.com:4711/foo/bar?answer=42")?;

    /// assert_eq!(uri.scheme(), Some(CoapUriScheme::Coap));

    /// # Result::<(), UriParsingError>::Ok(())

    /// Attempts to convert the provided `uri_str` into a [CoapUri] suitable as a proxy URI.

    ///

    /// # Errors

    /// May fail if the provided `uri_str` is not a valid proxy URI or if the URI components exceed

    /// maximum lengths (see the struct level documentation).

    ///

    /// # Examples

    /// ```

    /// use libcoap_rs::types::{CoapUri, CoapUriScheme};

    ///

    /// let uri: CoapUri = CoapUri::try_from_str_proxy("coap://example.com:4711/foo/bar?answer=42")?;

    /// assert_eq!(uri.scheme(), Some(CoapUriScheme::Coap));

    /// # Result::<(), UriParsingError>::Ok(())

    /// Attempts to convert a [Url] into a [CoapUri].

    ///

    /// # Errors

    /// May fail if the provided Url is not a valid URI supported by libcoap or if the URI

    /// components exceed maximum lengths (see the struct level documentation).

    #[cfg(feature = "url")]

    pub fn try_from_url(url: &Url) -> Result<CoapUri, UriParsingError> {

        Self::try_from_str(url.as_str())

    }

    /// Attempts to convert a [Url] into a proxy [CoapUri].

    ///

    /// # Errors

    /// May fail if the provided Url is not a valid proxy URI supported by libcoap or if the URI

    /// components exceed maximum lengths (see the struct level documentation).

    #[cfg(feature = "url")]

    pub fn try_from_url_proxy(url: &Url) -> Result<CoapUri, UriParsingError> {

        Self::try_from_str_proxy(url.as_str())

    }

    /// Returns the scheme part of this URI.

    /// Returns the host part of this URI.

    /// Returns the port of this URI (if provided).

        }

    /// Returns the URI path part of this URI.

    /// Returns the host part of this URI.

    /// Returns whether this URI is a proxy URI.

    /// Converts the given URI into a `Vec` of [CoapOption]s that can be added to a

    /// [crate::message::CoapMessage].

            // We have already parsed this URI. If converting it into options fails, something went

            // terribly wrong.

        // SAFETY: optlist has been set by coap_uri_into_options, which has not returned an error.

    /// Provides a reference to the raw [coap_uri_t] struct represented by this [CoapUri].

    ///

    /// Note that while obtaining this struct and reading the fields is safe (which is why this

    /// method is safe), modifying the referenced URI parts by (unsafely) dereferencing and mutating

    /// the `const` pointers inside is not.

    /// Converts the given `raw_uri` to a new [CoapUri] instance.

    ///

    /// This method will create a copy of the provided URI, i.e. `raw_uri` will remain valid and not

    /// be owned by the created [CoapUri] instance.

    ///

    /// # Safety

    ///

    /// The provided `raw_uri` must point to a valid instance of [coap_uri_t].

    /// In particular, the provided pointers for the URI components must also be valid.

    ///

    /// # Panics

    ///

    /// Panics if the provided `raw_uri` is null or the provided URI contains a null byte.

    /// Create an instance of [CoapUri] with the given `uri_str`, but don't parse the value, i.e.

    /// the resulting `raw_uri` is not set correctly.

    /// Create and parse a URI from a CString.

    ///

    /// # Safety

    ///

    /// parsing_fn must be either coap_split_uri or coap_split_proxy_uri.

        {

    /// Constructs a CString representing the given URI parts in a form parsable by libcoap.

        // Reconstruct string for scheme.

        } else {

        };

        }

        // The host is index 1 in the parts list

}

impl PartialEq for CoapUri {

            // SAFETY: After construction the fields of self.raw_uri always reference the

            //         corresponding parts of the underlying string, which is pinned. Therefore, the

            //         pointer and length are valid for the lifetime of this struct.

            && unsafe {

        }

}

impl Eq for CoapUri {}

impl Clone for CoapUri {

}

#[cfg(feature = "url")]

impl TryFrom<&Url> for CoapUri {

    type Error = UriParsingError;

    fn try_from(value: &Url) -> Result<Self, Self::Error> {

        CoapUri::try_from_url(value)

    }

}

impl FromStr for CoapUri {

    type Err = UriParsingError;

}

impl Display for CoapUri {

}

/// Transport protocols that can be used with libcoap.

#[repr(u32)]

#[non_exhaustive]

pub enum CoapProtocol {

    None = coap_proto_t_COAP_PROTO_NONE as u32,

    Udp = coap_proto_t_COAP_PROTO_UDP as u32,

    Dtls = coap_proto_t_COAP_PROTO_DTLS as u32,

    Tcp = coap_proto_t_COAP_PROTO_TCP as u32,

    Tls = coap_proto_t_COAP_PROTO_TLS as u32,

}

impl CoapProtocol {

        }

}

#[doc(hidden)]

impl From<coap_proto_t> for CoapProtocol {

}

impl Display for CoapProtocol {

        })

}

// TODO the following functions should probably return a result and use generics.

// Kept for consistency

#[allow(unused)]

// Kept for consistency

#[allow(unused)]