motorcortex_rust/client/

request.rs

use crate::client::{receive_message, Parameters};
use crate::connection::{ConnectionManager, ConnectionOptions};
use crate::msg::{
    get_hash, get_hash_size, CreateGroupMsg, GetParameterListMsg,
    GetParameterMsg, GetParameterTreeHashMsg, GetParameterTreeMsg, GroupStatusMsg, Hash, LoginMsg, LogoutMsg,
    ParameterListMsg, ParameterMsg, ParameterTreeMsg, RemoveGroupMsg, SetParameterListMsg, SetParameterMsg,
    StatusCode, StatusMsg,
};
use crate::parameter_value::{
    decode_parameter_value, encode_parameter_value, GetParameterTuple, GetParameterValue,
    SetParameterTuple, SetParameterValue,
};
use crate::ParameterTree;

use prost::{DecodeError, Message};

/// Represents a request client that manages socket-based connections
/// and interacts with the server.
pub struct Request {
    connection_data: ConnectionManager,
    /// Client's local representation of the parameter hierarchy.
    parameter_tree: ParameterTree,
}

impl Request {
    /// Creates a new `Request` instance with uninitialized members.
    pub fn new() -> Self {
        let sock = unsafe {
            let mut sock: nng_c_sys::nng_socket = std::mem::zeroed();
            nng_c_sys::nng_req0_open(&mut sock);
            sock
        };
        Self {
            connection_data: ConnectionManager::new(sock),
            parameter_tree: ParameterTree::new(),
        }
    }

    /// Establishes a connection to a specified server URL using the given configuration options.
    ///
    /// # Arguments:
    /// * `url` - The server's address (e.g., "tcp://127.0.0.1:5555").
    /// * `connection_options` - The connection settings, including TLS certificate and timeouts.
    ///
    /// # Returns:
    /// * `Ok(())` if the connection is successful.
    /// * `Err(String)` with the error message if the operation fails.
    pub fn connect(
        &mut self,
        url: &str,
        connection_options: ConnectionOptions,
    ) -> Result<(), String> {
        self.connection_data.connect(url, connection_options)
    }

    /// Disconnects the current connection and frees the associated resources.
    ///
    /// # Returns:
    /// * `Ok(())` if the disconnection is successful.
    /// * `Err(String)` with the error message if the operation fails.
    pub fn disconnect(&mut self) -> Result<(), String> {
        self.connection_data.disconnect()
    }

    /// Sends a login message to the server with the specified username and password.
    ///
    /// # Arguments:
    /// * `username` - The username to authenticate with.
    /// * `password` - The password for authentication.
    ///
    /// # Returns:
    /// * `Ok(StatusCode)` - The status code representing the login response.
    /// * `Err(String)` - An error message if the login fails.
    pub fn login(&self, username: String, password: String) -> Result<StatusCode, String> {
        let login_msg = LoginMsg {
            header: None,
            login: username,
            password,
        };

        let buffer = Self::encode_with_hash(&login_msg)
            .map_err(|e| format!("Failed to encode LoginMsg: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(&self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive status message".to_string())?;
        let msg = Self::decode_status_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode status message: {:?}", e))?;

        Ok(StatusCode::try_from(msg.status).unwrap())
    }

    /// Sends a logout message to the server.
    ///
    /// # Returns:
    /// * `Ok(StatusCode)` - The status code representing the logout response.
    /// * `Err(String)` - An error message if the logout fails.
    pub fn logout(&self) -> Result<StatusCode, String> {
        let logout_msg = LogoutMsg { header: None };

        let buffer = Self::encode_with_hash(&logout_msg)
            .map_err(|e| format!("Failed to encode LogoutMsg: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(&self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive status message".to_string())?;
        let msg = Self::decode_status_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode status message: {:?}", e))?;

        Ok(StatusCode::try_from(msg.status).unwrap())
    }

    /// Requests and updates the client's parameter tree from the server.
    ///
    /// # Returns:
    /// * `Ok(StatusCode)` - The status code indicating the result of the request.
    /// * `Err(String)` - An error message if the request fails.
    pub fn request_parameter_tree(&mut self) -> Result<StatusCode, String> {
        match self.get_parameter_tree() {
            Ok((status_code, parameter_tree)) => {
                self.parameter_tree = parameter_tree;
                Ok(status_code)
            }
            Err(e) => Err(e),
        }
    }

    /// Updates a specific parameter on the server with the provided value.
    ///
    /// # Arguments:
    /// * `path` - The hierarchical path to the parameter being updated.
    /// * `value` - The new value for the parameter. Must implement `SetParameterValue`.
    ///
    /// # Returns:
    /// * `Ok(StatusCode)` - The status code after setting the parameter.
    /// * `Err(String)` - An error message if the update fails.
    pub fn set_parameter<V>(&self, path: &str, value: V) -> Result<StatusCode, String>
    where
        V: SetParameterValue + Default + PartialEq,
    {
        let data_type = self
            .parameter_tree
            .get_parameter_data_type(&path)
            .ok_or((
                StatusCode::WrongParameterPath,
                format!("Parameter data type not found for path: {}", path),
            ))
            .unwrap();

        let msg = SetParameterMsg {
            header: None,
            offset: None,
            path: path.to_string(),
            value: encode_parameter_value(data_type, &value),
        };

        let buffer = Self::encode_with_hash(&msg)
            .map_err(|e| format!("Failed to encode SetParameter: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive status message".to_string())?;
        let msg = Self::decode_status_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode status message: {:?}", e))?;

        Ok(StatusCode::try_from(msg.status).unwrap())
    }

    pub fn set_parameters<T>(&self, paths: Vec<&str>, values: T) -> Result<StatusCode, String>
    where
        T: SetParameterTuple,
    {
        let mut msg = SetParameterListMsg {
            header: None,
            params: Vec::new(),
        };

        let mut i = 0;
        for path in paths {
            let data_type = self
                .parameter_tree
                .get_parameter_data_type(&path)
                .ok_or((
                    StatusCode::WrongParameterPath,
                    format!("Parameter data type not found for path: {}", path),
                ))
                .unwrap();

            msg.params.push(SetParameterMsg {
                header: None,
                offset: None,
                path: path.to_string(),
                value: T::get_tuple_element(&values, i, data_type)?,
            });
            i = i + 1
        }

        let buffer = Self::encode_with_hash(&msg)
            .map_err(|e| format!("Failed to encode SetParameterList: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive status message".to_string())?;
        let msg = Self::decode_status_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode status message: {:?}", e))?;

        Ok(StatusCode::try_from(msg.status).unwrap())
    }

    /// Retrieves the value of a parameter from the server for the given path.
    ///
    /// # Arguments:
    /// * `path` - The hierarchical path of the parameter to retrieve.
    ///
    /// # Type Parameters:
    /// * `V` - The expected value type of the parameter. This type must implement the `GetParameterValue` trait
    ///         to properly decode the parameter's value from the server response.
    ///
    /// # Returns:
    /// * `Ok(V)` - The parameter value successfully retrieved and decoded into the type `V`.
    /// * `Err(String)` - An error message if the retrieval or decoding fails.
    ///
    /// # Errors:
    /// This function will return an error if:
    /// * The parameter's data type cannot be identified.
    /// * The path to the parameter is invalid or non-existent.
    /// * There is an issue encoding the request or decoding the response from the server.
    ///
    pub fn get_parameter<V>(&self, path: &str) -> Result<V, String>
    where
        V: GetParameterValue + Default,
    {
        let data_type = self
            .parameter_tree
            .get_parameter_data_type(&path)
            .ok_or((
                StatusCode::WrongParameterPath,
                format!("Parameter data type not found for path: {}", path),
            ))
            .unwrap();

        let msg = GetParameterMsg {
            header: None,
            path: path.to_string(),
        };

        let buffer = Self::encode_with_hash(&msg)
            .map_err(|e| format!("Failed to encode GetParameter: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive parameter message".to_string())?;
        let msg = Self::decode_parameter_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode parameter message: {:?}", e))?;

        Ok(decode_parameter_value(data_type, &msg.value))
    }

    pub fn get_parameters<T>(&self, paths: Vec<&str>) -> Result<T, String>
    where
        T: GetParameterTuple,
    {
        let mut msg = GetParameterListMsg {
            header: None,
            params: Vec::new(),
        };

        for path in paths {
            // data_types.push(
            //     self.parameter_tree
            //         .get_parameter_data_type(&path)
            //         .ok_or((
            //             StatusCode::WrongParameterPath,
            //             format!("Parameter data type not found for path: {}", path),
            //         ))
            //         .unwrap(),
            // );
            msg.params.push(GetParameterMsg {
                header: None,
                path: path.to_string(),
            })
        }

        let buffer = Self::encode_with_hash(&msg)
            .map_err(|e| format!("Failed to encode GetParameterList: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive parameter list message".to_string())?;
        let msg = Self::decode_message::<ParameterListMsg>(buf.as_slice())
            .map_err(|e| format!("Failed to decode parameter list message: {:?}", e))?;

        let combined_iterator = msg.params.iter().map(|parameter| {
            (
                &parameter.info.as_ref().unwrap().data_type,
                parameter.value.as_slice(),
            )
        });

        T::get_parameters(combined_iterator)
    }

    /// Retrieves the server's parameter tree.
    ///
    /// This function sends a `GetParameterTreeMsg` request to the server and decodes the response
    /// into a `ParameterTree` object along with a status code indicating the result.
    ///
    /// # Returns:
    /// * `Ok((StatusCode, ParameterTree))` - A tuple containing the status code and the retrieved `ParameterTree`.
    /// * `Err(String)` - An error message if retrieving or decoding the parameter tree fails.
    pub fn get_parameter_tree(&self) -> Result<(StatusCode, ParameterTree), String> {
        let get_parameter_tree = GetParameterTreeMsg { header: None };
        let buffer = Self::encode_with_hash(&get_parameter_tree)
            .map_err(|e| format!("Failed to encode GetParameterTreeMsg: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive parameter tree message".to_string())?;
        let msg = Self::decode_parameter_tree_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode parameter tree message: {:?}", e))?;

        match ParameterTree::from_message(msg) {
            Some(parameter_tree) => Ok((StatusCode::Ok, parameter_tree)),
            None => Err("Failed to create ParameterTree: Invalid status code.".to_string()),
        }
    }

    pub fn get_parameter_tree_hash(&self) -> Result<u32, String> {
        let get_parameter_tree_hash = GetParameterTreeHashMsg { header: None };
        let buffer = Self::encode_with_hash(&get_parameter_tree_hash)
            .map_err(|e| format!("Failed to encode GetParameterTreeHashMsg: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive parameter tree hash message".to_string())?;
        let msg = Self::decode_message::<ParameterTreeMsg>(buf.as_slice())
            .map_err(|e| format!("Failed to decode parameter tree message: {:?}", e))?;

        Ok(msg.hash)
    }

    pub fn create_group<I>(
        &self,
        parameters: I,
        group_name: &str,
        frequency_divider: u32,
    ) -> Result<GroupStatusMsg, String>
    where
        I: Parameters,
    {
        let create_group_msg = CreateGroupMsg {
            header: None,
            frq_divider: frequency_divider,
            alias: group_name.to_string(),
            paths: parameters.into_vec(),
        };
        let buffer = Self::encode_with_hash(&create_group_msg)
            .map_err(|e| format!("Failed to encode CreateGroupMsg: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive group status message".to_string())?;
        let msg = Self::decode_message::<GroupStatusMsg>(buf.as_slice())
            .map_err(|e| format!("Failed to decode group status message: {:?}", e))?;

        Ok(msg)
    }

    pub fn remove_group(&self, group_name: &str) -> Result<StatusCode, String> {
        let remove_group_msg = RemoveGroupMsg {
            header: None,
            alias: group_name.to_string(),
        };
        let buffer = Self::encode_with_hash(&remove_group_msg)
            .map_err(|e| format!("Failed to encode RemoveGroupMsg: {:?}", e))?;
        self.send_message(&buffer)?;

        let buf = receive_message(self.connection_data.sock.as_ref().unwrap())
            .map_err(|_| "Failed to receive status message".to_string())?;
        let msg = Self::decode_status_msg(buf.as_slice())
            .map_err(|e| format!("Failed to decode status message: {:?}", e))?;

        if msg.status == StatusCode::Ok as i32 {
            Ok(StatusCode::Ok)
        } else {
            Err("Failed to remove group".to_string())
        }
    }

    /// Encodes a message with its associated hash into a byte buffer for transport.
    ///
    /// # Arguments:
    /// * `message` - The message to encode. Must implement `prost::Message` and `Hash`.
    ///
    /// # Returns:
    /// * `Ok(Vec<u8>)` - The encoded message as a byte buffer.
    /// * `Err(String)` - An error message if encoding fails.
    fn encode_with_hash<M: Message + Hash>(message: &M) -> Result<Vec<u8>, String> {
        let mut buffer: Vec<u8> = Vec::new();
        buffer.extend(get_hash::<M>().to_le_bytes());
        message
            .encode(&mut buffer)
            .map_err(|e| format!("Failed to encode message: {:?}", e))?;

        Ok(buffer)
    }

    /// Decodes a byte slice into a specific Protobuf message type.
    ///
    /// # Arguments:
    /// * `reply_slice` - The received byte slice containing the message data.
    ///
    /// # Returns:
    /// * `Ok(T)` - The decoded message of type `T`.
    /// * `Err(DecodeError)` - An error if decoding fails.
    pub fn decode_message<T: Message + Default + Hash>(
        reply_slice: &[u8],
    ) -> Result<T, DecodeError> {
        let hash_size = get_hash_size();

        // Verify the provided slice is large enough to contain the hash
        if hash_size > reply_slice.len() {
            return Err(DecodeError::new("Invalid message length, hash missing"));
        }

        // Extract the hash from the slice
        let provided_hash = u32::from_le_bytes(
            reply_slice[..hash_size]
                .try_into()
                .map_err(|_| DecodeError::new("Failed to extract hash"))?,
        );

        // Validate the provided hash against the expected one for the generic type T
        if provided_hash != get_hash::<T>() {
            return Err(DecodeError::new("Invalid message hash"));
        }

        // Decode the rest of the slice into a Protobuf message
        let decode_slice = &reply_slice[hash_size..];
        T::decode(decode_slice)
    }

    /// Decodes a `ParameterTreeMsg` from a byte slice.
    ///
    /// This is a helper function for decoding parameter tree messages sent from the server.
    ///
    /// # Arguments:
    /// * `reply_slice` - The received buffer containing the encoded `ParameterTreeMsg`.
    ///
    /// # Returns:
    /// * `Ok(ParameterTreeMsg)` - The decoded parameter tree message.
    /// * `Err(DecodeError)` - An error if the decoding fails.
    fn decode_parameter_tree_msg(reply_slice: &[u8]) -> Result<ParameterTreeMsg, DecodeError> {
        Self::decode_message::<ParameterTreeMsg>(reply_slice)
    }

    /// Decodes a `StatusMsg` from a received response slice.
    ///
    /// This is a helper function for decoding `StatusMsg` responses from the server.
    ///
    /// # Arguments:
    /// * `reply_slice` - The received buffer containing the encoded `StatusMsg`.
    ///
    /// # Returns:
    /// * `Ok(StatusMsg)` - The decoded status message.
    /// * `Err(DecodeError)` - An error if decoding the `StatusMsg` fails.
    fn decode_status_msg(reply_slice: &[u8]) -> Result<StatusMsg, DecodeError> {
        Self::decode_message::<StatusMsg>(reply_slice)
    }

    fn decode_parameter_msg(reply_slice: &[u8]) -> Result<ParameterMsg, DecodeError> {
        Self::decode_message::<ParameterMsg>(reply_slice)
    }

    /// Sends the provided data buffer to the server using the NNG socket.
    ///
    /// This function sends a message buffer over the active NNG socket connection.
    ///
    /// # Arguments:
    /// * `buffer` - A byte slice containing the message to send.
    ///
    /// # Returns:
    /// * `Ok(())` - If the message was successfully sent.
    /// * `Err(String)` - If sending the message fails.
    fn send_message(&self, buffer: &[u8]) -> Result<(), String> {
        unsafe {
            // Create raw pointer for the buffer
            let data_ptr = buffer.as_ptr() as *mut std::ffi::c_void;
            let data_len = buffer.len();

            // Use nng_send API
            let sock = self
                .connection_data
                .sock
                .ok_or("Socket is not available. Connect first.")?;
            let rv = nng_c_sys::nng_send(sock, data_ptr, data_len, 0);

            // Check if the send operation was successful
            if rv != 0 {
                return Err(format!(
                    "Failed to send message via NNG. Error code: {}",
                    rv
                ));
            }
        }

        Ok(())
    }
}