imbalanced-core 0.1.0

// imbalanced-core/src/traits.rs
use ndarray::{Array1, Array2, ArrayView1, ArrayView2};
use std::marker::PhantomData;

/// Error type for resampling operations
#[derive(Debug, Clone)]
pub enum ResamplingError {
    /// Invalid input data
    InvalidInput(String),
    /// Insufficient samples for resampling
    InsufficientSamples,
    /// Configuration error
    ConfigError(String),
    /// Computation error
    ComputationError(String),
}

impl std::fmt::Display for ResamplingError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ResamplingError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
            ResamplingError::InsufficientSamples => write!(f, "Insufficient samples for resampling"),
            ResamplingError::ConfigError(msg) => write!(f, "Configuration error: {}", msg),
            ResamplingError::ComputationError(msg) => write!(f, "Computation error: {}", msg),
        }
    }
}

impl std::error::Error for ResamplingError {}

/// Performance hint for consciousness-aligned optimization
#[derive(Debug, Clone, Copy)]
pub enum PerformanceHint {
    /// Prefer cache-friendly access patterns
    CacheFriendly,
    /// Use SIMD when possible
    Vectorize,
    /// Parallelize operations
    Parallel,
    /// Use GPU acceleration if available
    GpuAccelerated,
}

/// Collection of performance hints
#[derive(Debug, Clone, Default)]
pub struct PerformanceHints {
    hints: Vec<PerformanceHint>,
}

impl PerformanceHints {
    /// Create new performance hints
    pub fn new() -> Self {
        Self::default()
    }
    
    /// Add a performance hint
    pub fn with_hint(mut self, hint: PerformanceHint) -> Self {
        self.hints.push(hint);
        self
    }
    
    /// Check if hint is present
    pub fn has_hint(&self, hint: PerformanceHint) -> bool {
        self.hints.iter().any(|&h| std::mem::discriminant(&h) == std::mem::discriminant(&hint))
    }
}

/// Zero-cost abstraction for resampling strategies
pub trait ResamplingStrategy: Send + Sync {
    /// Input data type
    type Input;
    /// Output data type  
    type Output;
    /// Configuration type for this strategy
    type Config;
    
    /// Resample the input data to balance class distribution
    fn resample(
        &self,
        x: ArrayView2<f64>,
        y: ArrayView1<i32>,
        config: &Self::Config,
    ) -> Result<(Array2<f64>, Array1<i32>), ResamplingError>;
    
    /// Consciousness-aligned performance hints
    fn performance_hints(&self) -> PerformanceHints {
        PerformanceHints::default()
    }
}

/// Type-state pattern for compile-time correctness
/// Uninitialized state
pub struct Uninitialized;
/// Configured state
pub struct Configured;
/// Fitted state  
pub struct Fitted;

/// Type-safe resampler with compile-time state checking
pub struct Resampler<Strategy, State> {
    strategy: Strategy,
    _state: PhantomData<State>,
}

impl<S: ResamplingStrategy> Resampler<S, Uninitialized> {
    /// Create a new uninitialized resampler
    pub fn new(strategy: S) -> Self {
        Self {
            strategy,
            _state: PhantomData,
        }
    }
    
    /// Configure the resampler, transitioning to configured state
    pub fn configure(self, _config: S::Config) -> Resampler<S, Configured> {
        // State transition enforced at compile time
        Resampler {
            strategy: self.strategy,
            _state: PhantomData,
        }
    }
}