use std::{ffi::CString, path::Path, pin::Pin, ptr};

use smile::{
    autocxx::{c_int, c_void, cxx::let_cxx_string, WithinBox},
    ffi::DSL_network,
};

use crate::{
    errors::{CIntExt, Result},
    traits::ToDslValue,
};

use super::{BayesianNetworkAlgorithm, InfluenceDiagramAlgorithm};

/// A Bayesian Network.
pub struct Network {
    pub(super) dsl_network: Pin<Box<DSL_network>>,
}

impl PartialEq for Network {
    fn eq(&self, other: &Self) -> bool {
        // TODO: compare nodes, arcs, beliefs, and all other network properties
        true
    }
}

impl Eq for Network {}

impl Network {
    /// Create a new uninitialized network.
    pub fn new_uninitialized() -> Self {
        let dsl_network = DSL_network::new().within_box();
        Self { dsl_network }
    }

    /// Create a new network from an XDSL string.
    ///
    /// Example usage:
    /// ```rust
    /// # use nice_smile::network::Network;
    /// # use nice_smile::errors::Result;
    /// # fn try_main() -> Result<()> {
    /// # let mut network1 = Network::new_uninitialized();
    /// # let xdsl = network1.to_xdsl_string()?;
    /// let network = Network::from_xdsl_string(&xdsl)?;
    /// # assert!(network == network1);
    /// assert_ne!(xdsl, "".to_string());
    /// # Ok(()) }
    /// ```
    pub fn from_xdsl_string(xdsl_string: impl AsRef<str>) -> Result<Self> {
        let mut network = Self::new_uninitialized();
        let null_void_ptr: *mut c_void = ptr::null_mut();

        unsafe {
            network
                .dsl_network
                .as_mut()
                .ReadString(CString::new(xdsl_string.as_ref())?.as_ptr(), null_void_ptr)
                .into_result()?
        }

        Ok(network)
    }

    /// Export the network to an XDSL string.
    ///
    /// Example usage:
    /// ```rust
    /// # use nice_smile::network::Network;
    /// # use nice_smile::errors::Result;
    /// # fn try_main() -> Result<()> {
    /// let mut network = Network::new_uninitialized();
    /// let xdsl = network.to_xdsl_string()?;
    /// assert_ne!(xdsl, "".to_string());
    /// # Ok(()) }
    /// ```
    pub fn to_xdsl_string(&mut self) -> Result<String> {
        let null_void_ptr: *mut c_void = ptr::null_mut();

        let_cxx_string!(xdsl = "");
        unsafe {
            self.dsl_network
                .as_mut()
                .WriteString(xdsl.as_mut(), null_void_ptr)
                .into_result()?;
        }

        Ok(xdsl.to_string())
    }

    /// Read a network from a file.
    ///
    /// The file type is determined automaticaly by the file_path extension.
    /// For the supported file types list, refer to the [smile::ffi::DSL_network::ReadFile].
    pub fn read_from_file(file_path: impl AsRef<Path>) -> Result<Network> {
        let mut network = Network::new_uninitialized();

        let null_void_ptr: *mut c_void = ptr::null_mut();
        let file_path =
            CString::new(file_path.as_ref().to_string_lossy().into_owned().as_str())?.as_ptr();

        unsafe {
            network
                .dsl_network
                .as_mut()
                .ReadFile(file_path, c_int(0), null_void_ptr)
                .into_result()?;
        }

        Ok(network)
    }

    /// Write the network to a file.
    ///
    /// The file type is determined automaticaly by the file_path extension.
    /// For the supported file types list, refer to the [smile::ffi::DSL_network::ReadFile].
    pub fn write_to_file(&mut self, file_path: impl AsRef<Path>) -> Result<()> {
        let null_void_ptr: *mut c_void = ptr::null_mut();

        let file_path =
            CString::new(file_path.as_ref().to_string_lossy().into_owned().as_str())?.as_ptr();

        unsafe {
            self.dsl_network
                .as_mut()
                .WriteFile(file_path, c_int(0), null_void_ptr)
                .into_result()
        }
    }

    /// Executes inference algorithm to update node values. Returns DSL_OKAY on success, or a negative error code on failure.
    pub fn update_beliefs(&mut self) -> Result<()> {
        self.dsl_network.as_mut().UpdateBeliefs().into_result()
    }

    /// Invalidates values in all nodes of the [Network].
    pub fn invalidate_all_beliefs(&mut self) -> Result<()> {
        self.dsl_network
            .as_mut()
            .InvalidateAllBeliefs()
            .into_result()
    }

    /// Sets the immediate update flag.
    ///
    /// If the flag is set to `true`, [Self::update_beliefs] will be called after changes in the network structure, parameters or evidence.
    pub fn is_update_immediate(&self) -> bool {
        self.dsl_network.as_ref().IsUpdateImmediate()
    }

    /// Returns the update immediate flag.
    ///
    /// For more information, refer to the [Self::is_update_immediate].
    pub fn set_update_immediate(&mut self, immediate: bool) {
        self.dsl_network.as_mut().SetUpdateImmediate(immediate);
    }

    /// Sets the algorithm used for inference in Bayesian networks.
    pub fn set_bayesian_network_algorithm(&mut self, algorithm: BayesianNetworkAlgorithm) {
        self.dsl_network
            .as_mut()
            .SetDefaultBNAlgorithm(algorithm.to_dsl_value());
    }

    /// Sets the algorithm used for inference in influence diagrams.
    pub fn set_influence_diagram_algorithm(&mut self, algorithm: InfluenceDiagramAlgorithm) {
        self.dsl_network
            .as_mut()
            .SetDefaultIDAlgorithm(algorithm.to_dsl_value());
    }

    // TODO: CalcProbEvidence
}

impl Clone for Network {
    /// Clone the network.
    /// ```rust
    /// # use nice_smile::network::Network;
    /// let network1 = Network::new_uninitialized();
    /// // TODO: add nodes to the network
    /// let network2 = network1.clone();
    /// assert!(network1 == network2);
    /// ```
    fn clone(&self) -> Self {
        let mut network = Self::new_uninitialized();
        network
            .dsl_network
            .as_mut()
            .Copy(&self.dsl_network, c_int(0));

        network
    }
}