gc_plugin_abi 0.1.0

use super::errors::GCMockingError;
use super::gateway_instance_ctx::{GCGatewayMockInstanceCtx, GetLastDatapointValueIntercept, LogIntercept, PublishDatapointValueIntercept};
use super::gateway_mock::GCGatewayMock;
use crate::{GCDatapoint, GCPluginInstance};
use serde_json::Value;

/// Builder for the GCGatewayMock
///
/// This builder allows to configure the plugin and setup callbacks for intercepting communications between the plugin
/// and the core.
///
/// # Example
/// ```rust
/// # use gc_plugin_abi::testing::{GCGatewayMockBuilder, GCGatewayMock};
/// # use gc_plugin_abi::{GCDatapoint, GCPluginInterface, GCPluginInstance, GCPluginInfo, GCBorrowedDatapointValue};
/// # use std::ffi::CString;
/// # use std::sync::Arc;
/// # use std::sync::atomic::{AtomicBool, Ordering};
/// # use gc_plugin_abi::gc_plugin;
/// #
/// # #[gc_plugin]
/// # pub struct ExamplePlugin<'a> {
/// #     plugin_interface: &'a GCPluginInterface,
/// # }
/// # impl<'a> ExamplePlugin<'a> {
/// #    pub fn new(plugin_interface: &'a GCPluginInterface) -> Self {
/// #        Self {
/// #            plugin_interface: plugin_interface,
/// #        }
/// #    }
/// # }
/// #
/// # impl<'a> GCPluginInstance<'a> for ExamplePlugin<'a> {
/// #
/// #     // Entrypoint which contains the interface to communicate with the core gateway
/// #     fn init(plugin_interface: &'a GCPluginInterface) -> Box<Self> {
/// #         let state = Box::new(ExamplePlugin::new(plugin_interface));
/// #         state
/// #     }
/// #
/// #     fn get_plugin_info() -> GCPluginInfo {
/// #         GCPluginInfo::new("ExamplePlugin", "0.1.0", "0", 0)
/// #     }
/// #
/// #     // Receive datapoint by subscription
/// #     fn receive_datapoint(&self, _data_value: GCBorrowedDatapointValue) -> bool {
/// #         // Handle incoming datapoint
/// #         true
/// #     }
/// # }
///
/// const CONFIG: &str = r#"
/// {
///     "host": "localhost:9877"
/// }
/// "#;
///
/// let mut mock_builder = GCGatewayMockBuilder::new();
///
/// // Set the plugin configuration
/// mock_builder.set_config(CONFIG.to_string()).unwrap();
///
/// // Add a datapoint subscribed by the plugin
/// mock_builder.add_subscribed_datapoint(GCDatapoint::new(0, "example_name", "example_description", "example_unit"));
///
/// // Start the plugin
/// let gateway_mock: GCGatewayMock<ExamplePlugin> = mock_builder.start().unwrap();
/// ```
///
/// This simple example starts a plugin with a specific config and a single datapoint subscribed.
pub struct GCGatewayMockBuilder {
    pub(super) own_datapoints: Vec<GCDatapoint>,
    pub(super) subscribed_datapoints: Vec<GCDatapoint>,

    pub(super) core_ctx: Box<GCGatewayMockInstanceCtx>,
    pub(super) config: Box<Value>,
    pub(super) log_level: gc_abi::GCLogLevel,
}

impl Default for GCGatewayMockBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl GCGatewayMockBuilder {
    pub fn new() -> Self {
        Self {
            own_datapoints: Vec::new(),
            subscribed_datapoints: Vec::new(),
            core_ctx: GCGatewayMockInstanceCtx::new(),
            config: Box::new(serde_json::Value::Null),
            log_level: gc_abi::GCLogLevel::DEBUG,
        }
    }

    /// Add a datapoint to the list of datapoints owned by the plugin
    pub fn add_own_datapoint(&mut self, datapoint: GCDatapoint) -> &mut Self {
        self.own_datapoints.push(datapoint);
        self
    }

    /// Add a datapoint to the list of datapoints subscribed by the plugin
    pub fn add_subscribed_datapoint(&mut self, datapoint: GCDatapoint) -> &mut Self {
        self.subscribed_datapoints.push(datapoint);
        self
    }
    /// Set the log level for the plugin
    pub fn set_log_level(&mut self, level: gc_abi::GCLogLevel) -> &mut Self {
        self.log_level = level;
        self
    }

    /// Set the plugin configuration
    ///
    /// This should be whatever goes within the ```plugin_specific_config``` field.
    /// ## Example
    ///
    /// ```rust
    /// use serde::Serialize;
    /// use gc_plugin_abi::testing::GCGatewayMockBuilder;
    ///
    /// /// Config loaded by the plugin
    /// #[derive(Serialize)]
    /// struct MyConfig {
    ///    example_field: u16,
    /// }
    ///
    /// let string_config = "{\"example_field\": 42}";
    ///
    /// let builder = GCGatewayMockBuilder::new()
    ///    .set_config(string_config.to_string());
    /// ```
    pub fn set_config(&mut self, config: String) -> Result<&mut Self, GCMockingError> {
        self.config = Box::new(serde_json::from_str(&config)?);
        Ok(self)
    }

    /// Set a callback to be called whenever a datapoint is published
    ///
    /// Multiple calls to this function will overwrite the previous callback.
    ///
    /// # Example:
    /// ```rust
    /// use gc_plugin_abi::testing::{GCGatewayMockBuilder, GCGatewayMock};
    /// use gc_plugin_abi::GCDatapointValue;
    /// use std::sync::Arc;
    /// use std::sync::atomic::{AtomicBool, Ordering};
    ///
    /// let assert_called = Arc::new(AtomicBool::new(false));
    ///
    /// let mut mock_builder = GCGatewayMockBuilder::new();
    /// mock_builder.set_publish_datapoint_value_callback(Box::new(move |value: &GCDatapointValue| {
    ///     assert_called.store(true, Ordering::SeqCst);
    ///     return true;
    /// }));
    /// ```
    pub fn set_publish_datapoint_value_callback(&mut self, callback: Box<PublishDatapointValueIntercept>) -> &mut Self {
        self.core_ctx.publish_datapoint_callback = callback;
        self
    }

    /// Set a callback to be called whenever a log message is generated
    ///
    /// Multiple calls to this function will overwrite the previous callback.
    ///
    /// # Example:
    /// ```rust
    /// use gc_plugin_abi::testing::{GCGatewayMockBuilder, GCGatewayMock};
    /// use gc_plugin_abi::GCDatapointValue;
    /// use std::sync::Arc;
    /// use std::sync::atomic::{AtomicBool, Ordering};
    ///
    /// let assert_called = Arc::new(AtomicBool::new(false));
    ///
    /// let mut mock_builder = GCGatewayMockBuilder::new();
    /// mock_builder.set_log_callback(Box::new(move |level, line| {
    ///     assert_called.store(true, Ordering::SeqCst);
    /// }));
    /// ```
    pub fn set_log_callback(&mut self, callback: Box<LogIntercept>) -> &mut Self {
        self.core_ctx.log_callback = callback;
        self
    }

    /// Set a callback to be called whenever the last value of a datapoint is requested
    ///
    /// Multiple calls to this function will overwrite the previous callback.
    ///
    /// # Example:
    /// ```rust
    /// use gc_plugin_abi::testing::{GCGatewayMockBuilder, GCGatewayMock};
    /// use gc_plugin_abi::{GCDatapointValue, GCDatapointID, GCDatapointValueQuality};
    /// use std::sync::Arc;
    /// use std::sync::atomic::{AtomicBool, Ordering};
    ///
    /// let assert_called = Arc::new(AtomicBool::new(false));
    ///
    /// let mut mock_builder = GCGatewayMockBuilder::new();
    /// mock_builder.set_get_last_datapoint_value_callback(Box::new(move |id: GCDatapointID| {
    ///     assert_called.store(true, Ordering::SeqCst);
    ///     return GCDatapointValue::new_boolean(id, 0, false, GCDatapointValueQuality::new_good());
    /// }));
    /// ```
    pub fn set_get_last_datapoint_value_callback(&mut self, callback: Box<GetLastDatapointValueIntercept>) -> &mut Self {
        self.core_ctx.get_last_datapoint_callback = callback;
        self
    }

    /// Start the plugin
    pub fn start<'a, T: GCPluginInstance<'a>>(self) -> Result<GCGatewayMock<'a, T>, GCMockingError> {
        let mut mock = GCGatewayMock::new(self)?;
        mock.start()?;
        Ok(mock)
    }

    /// Build the GCGatewayMock
    pub fn build<'a, T: GCPluginInstance<'a>>(self) -> Result<GCGatewayMock<'a, T>, GCMockingError> {
        GCGatewayMock::new(self)
    }
}