use crate::meta_plugin::{BaseMetaPlugin, MetaPlugin, MetaPluginType};
use std::process;

#[derive(Debug, Clone, Default)]
pub struct KeepPidMetaPlugin {
    is_finalized: bool,
    base: BaseMetaPlugin,
}

impl KeepPidMetaPlugin {
    /// Creates a new `KeepPidMetaPlugin` instance.
    ///
    /// # Arguments
    ///
    /// * `_options` - Optional configuration options for the plugin (unused in this implementation).
    /// * `outputs` - Optional output mappings for metadata.
    ///
    /// # Returns
    ///
    /// A new instance of `KeepPidMetaPlugin`.
    pub fn new(
        _options: Option<std::collections::HashMap<String, serde_yaml::Value>>,
        outputs: Option<std::collections::HashMap<String, serde_yaml::Value>>,
    ) -> KeepPidMetaPlugin {
        let mut base = BaseMetaPlugin::new();

        // Set default outputs
        let default_outputs = &["keep_pid"];
        base.initialize_plugin(default_outputs, &_options, &outputs);

        KeepPidMetaPlugin {
            is_finalized: false,
            base,
        }
    }
}

impl MetaPlugin for KeepPidMetaPlugin {
    /// Checks if the plugin has been finalized.
    ///
    /// # Returns
    ///
    /// `true` if finalized, `false` otherwise.
    fn is_finalized(&self) -> bool {
        self.is_finalized
    }

    /// Sets the finalized state of the plugin.
    ///
    /// # Arguments
    ///
    /// * `finalized` - The new finalized state.
    fn set_finalized(&mut self, finalized: bool) {
        self.is_finalized = finalized;
    }

    /// Finalizes the plugin, processing any remaining data if needed.
    ///
    /// # Returns
    ///
    /// A `MetaPluginResponse` with empty metadata and finalized state set to `true`.
    fn finalize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
        // If already finalized, don't process again
        if self.is_finalized {
            return crate::meta_plugin::MetaPluginResponse {
                metadata: Vec::new(),
                is_finalized: true,
            };
        }

        // Mark as finalized
        self.is_finalized = true;

        crate::meta_plugin::MetaPluginResponse {
            metadata: Vec::new(),
            is_finalized: true,
        }
    }

    /// Updates the plugin with new data chunk.
    ///
    /// # Arguments
    ///
    /// * `_data` - The data chunk (unused in this implementation).
    ///
    /// # Returns
    ///
    /// A `MetaPluginResponse` with empty metadata and finalized state.
    fn update(&mut self, _data: &[u8]) -> crate::meta_plugin::MetaPluginResponse {
        // If already finalized, don't process more data
        if self.is_finalized {
            return crate::meta_plugin::MetaPluginResponse {
                metadata: Vec::new(),
                is_finalized: true,
            };
        }

        crate::meta_plugin::MetaPluginResponse {
            metadata: Vec::new(),
            is_finalized: false,
        }
    }

    /// Returns the type of this meta plugin.
    ///
    /// # Returns
    ///
    /// `MetaPluginType::KeepPid`.
    fn meta_type(&self) -> MetaPluginType {
        MetaPluginType::KeepPid
    }

    /// Initializes the plugin and captures the process PID.
    ///
    /// Retrieves the current process ID and adds it to metadata.
    /// Marks the plugin as finalized after one run.
    ///
    /// # Returns
    ///
    /// * `MetaPluginResponse` - Response with PID metadata and finalized state.
    fn initialize(&mut self) -> crate::meta_plugin::MetaPluginResponse {
        // If already finalized, don't process again
        if self.is_finalized {
            return crate::meta_plugin::MetaPluginResponse {
                metadata: Vec::new(),
                is_finalized: true,
            };
        }

        let mut metadata = Vec::new();
        let pid = process::id().to_string();

        // Use process_metadata_outputs to handle output mapping
        if let Some(meta_data) = crate::meta_plugin::process_metadata_outputs(
            "keep_pid",
            serde_yaml::Value::String(pid),
            self.base.outputs(),
        ) {
            metadata.push(meta_data);
        }

        // Mark as finalized since this plugin only needs to run once
        self.is_finalized = true;

        crate::meta_plugin::MetaPluginResponse {
            metadata,
            is_finalized: true,
        }
    }

    /// Returns a reference to the outputs mapping.
    ///
    /// # Returns
    ///
    /// A reference to the `HashMap` of outputs.
    fn outputs(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
        self.base.outputs()
    }

    /// Returns a mutable reference to the outputs mapping.
    ///
    /// # Returns
    ///
    /// A mutable reference to the `HashMap` of outputs.
    fn outputs_mut(
        &mut self,
    ) -> anyhow::Result<&mut std::collections::HashMap<String, serde_yaml::Value>> {
        Ok(self.base.outputs_mut())
    }

    /// Returns the default output names for this plugin.
    ///
    /// # Returns
    ///
    /// Vector containing "keep_pid".
    fn default_outputs(&self) -> Vec<String> {
        vec!["keep_pid".to_string()]
    }

    /// Returns a reference to the options mapping.
    ///
    /// # Returns
    ///
    /// A reference to the `HashMap` of options.
    fn options(&self) -> &std::collections::HashMap<String, serde_yaml::Value> {
        self.base.options()
    }

    /// Returns a mutable reference to the options mapping.
    ///
    /// # Returns
    ///
    /// A mutable reference to the `HashMap` of options.
    fn options_mut(
        &mut self,
    ) -> anyhow::Result<&mut std::collections::HashMap<String, serde_yaml::Value>> {
        Ok(self.base.options_mut())
    }
}
use crate::meta_plugin::register_meta_plugin;

// Register the plugin at module initialization time
#[ctor::ctor]
fn register_keep_pid_plugin() {
    register_meta_plugin(MetaPluginType::KeepPid, |options, outputs| {
        Box::new(KeepPidMetaPlugin::new(options, outputs))
    });
}