//! Plugin system error types.

use thiserror::Error;

/// Plugin system errors.
#[derive(Debug, Error)]
pub enum PluginError {
    /// Plugin manifest is invalid or missing required fields.
    #[error("Invalid manifest: {0}")]
    InvalidManifest(String),

    /// Plugin script has syntax errors.
    #[error("Script error in {plugin}: {message}")]
    ScriptError { plugin: String, message: String },

    /// Plugin execution hit safety limits.
    #[error("Safety limit exceeded in {plugin}: {message}")]
    SafetyLimitExceeded { plugin: String, message: String },

    /// Plugin is missing required function.
    #[error("Plugin {plugin} missing required function: {function}")]
    MissingFunction { plugin: String, function: String },

    /// Plugin returned invalid data.
    #[error("Invalid return value from {plugin}: {message}")]
    InvalidReturn { plugin: String, message: String },

    /// File I/O error.
    #[error("File error: {0}")]
    FileError(String),

    /// Plugin directory not found.
    #[error("Plugin directory not found: {0}")]
    DirectoryNotFound(String),

    /// Plugin not found by ID.
    #[error("Plugin not found: {0}")]
    PluginNotFound(String),

    /// Capability not granted.
    #[error("Permission denied: {plugin} lacks capability {capability}")]
    PermissionDenied { plugin: String, capability: String },

    /// Plugin reload requested capabilities beyond what was previously approved.
    #[error("Capability escalation in {plugin}: new capabilities requested: {details}")]
    CapabilityEscalation { plugin: String, details: String },

    /// Import parse error.
    #[error("Import parse error: {0}")]
    ImportError(String),

    /// Core error wrapper.
    #[error("Core error: {0}")]
    Core(#[from] goingson_core::CoreError),
}

impl PluginError {
    /// Creates a script error for a specific plugin.
    #[tracing::instrument(skip_all)]
    pub fn script(plugin: impl Into<String>, message: impl Into<String>) -> Self {
        PluginError::ScriptError {
            plugin: plugin.into(),
            message: message.into(),
        }
    }

    /// Creates a safety limit error.
    #[tracing::instrument(skip_all)]
    pub fn safety_limit(plugin: impl Into<String>, message: impl Into<String>) -> Self {
        PluginError::SafetyLimitExceeded {
            plugin: plugin.into(),
            message: message.into(),
        }
    }

    /// Creates a missing function error.
    #[tracing::instrument(skip_all)]
    pub fn missing_function(plugin: impl Into<String>, function: impl Into<String>) -> Self {
        PluginError::MissingFunction {
            plugin: plugin.into(),
            function: function.into(),
        }
    }

    /// Creates an invalid return value error.
    #[tracing::instrument(skip_all)]
    pub fn invalid_return(plugin: impl Into<String>, message: impl Into<String>) -> Self {
        PluginError::InvalidReturn {
            plugin: plugin.into(),
            message: message.into(),
        }
    }

    /// Creates a permission denied error.
    #[tracing::instrument(skip_all)]
    pub fn permission_denied(plugin: impl Into<String>, capability: impl Into<String>) -> Self {
        PluginError::PermissionDenied {
            plugin: plugin.into(),
            capability: capability.into(),
        }
    }

    /// Creates a capability escalation error.
    pub fn capability_escalation(plugin: impl Into<String>, details: impl Into<String>) -> Self {
        PluginError::CapabilityEscalation {
            plugin: plugin.into(),
            details: details.into(),
        }
    }
}

/// Result type for plugin operations.
pub type Result<T> = std::result::Result<T, PluginError>;