//! Error types for supervisor operations.

use thiserror::Error;
use jsonrpsee::types::{ErrorObject, ErrorObjectOwned};

/// Result type for supervisor operations
pub type SupervisorResult<T> = Result<T, SupervisorError>;

/// Errors that can occur during supervisor operations
#[derive(Debug, Error)]
pub enum SupervisorError {
    #[error("Runner '{runner_id}' not found")]
    RunnerNotFound { runner_id: String },
    
    #[error("Runner '{runner_id}' is already registered")]
    RunnerAlreadyRegistered { runner_id: String },
    
    #[error("Job '{job_id}' not found")]
    JobNotFound { job_id: String },
    
    #[error("Failed to queue job for runner '{runner_id}': {reason}")]
    QueueError { runner_id: String, reason: String },
    
    #[error("Configuration error: {reason}")]
    ConfigError { reason: String },
    
    #[error("Invalid secret or API key: {0}")]
    InvalidSecret(String),
    
    #[error("Authentication error: {message}")]
    AuthenticationError { message: String },
    
    #[error("Insufficient permissions: {message}")]
    PermissionDenied { message: String },
    
    #[error("Redis error: {source}")]
    RedisError {
        #[from]
        source: redis::RedisError,
    },
    
    #[error("Job error: {source}")]
    JobError {
        #[from]
        source: hero_job::JobError,
    },
    
    #[error("Job client error: {source}")]
    JobClientError {
        #[from]
        source: hero_job_client::ClientError,
    },
    
    #[error("IO error: {source}")]
    IoError {
        #[from]
        source: std::io::Error,
    },
    
    #[error("Osiris client error: {0}")]
    OsirisError(String),
}

/// Implement conversion from SupervisorError → RPC ErrorObject
impl From<SupervisorError> for ErrorObject<'static> {
    fn from(err: SupervisorError) -> Self {
        ErrorObject::owned(
            -32603, // Internal error code
            format!("Supervisor error: {err}"),
            None::<()>,
        )
    }
}