pubsat 0.1.0

//! Error types for dependency resolution
//!
//! This module defines comprehensive error types for all resolution scenarios,
//! from SAT solver failures to dependency conflicts and version
//! incompatibilities.

use std::time::Duration;

use thiserror::Error;

/// Main error type for dependency resolution operations
#[derive(Debug, Error)]
pub enum ResolutionError {
    /// SAT solver encountered an error
    #[error("SAT solver error: {0}")]
    Solver(#[from] SatError),

    /// No solution exists for the given constraints
    #[error("Dependency conflict: {message}")]
    Conflict {
        message: String,
        conflicts: Vec<ConflictDetail>,
    },

    /// Resolution timed out
    #[error("Resolution timed out after {timeout:?}")]
    Timeout { timeout: Duration },

    /// Invalid package specification
    #[error("Invalid package specification: {package} {version}")]
    InvalidPackage { package: String, version: String },

    /// Version constraint is malformed
    #[error("Invalid version constraint: '{constraint}' for package {package}")]
    InvalidConstraint { package: String, constraint: String },

    /// Circular dependency detected
    #[error("Circular dependency detected: {cycle}")]
    CircularDependency { cycle: String },

    /// Registry communication failed
    #[error("Registry error: {0}")]
    Registry(#[from] anyhow::Error),

    /// Registry specific error
    #[error("Registry error: {message}")]
    RegistryError { message: String },

    /// Invalid version constraint (alias for InvalidConstraint)
    #[error("Invalid version constraint: '{constraint}' for package {package}")]
    InvalidVersionConstraint { package: String, constraint: String },

    /// Package not found in registry
    #[error("Package not found: {package}@{version}")]
    PackageNotFound { package: String, version: String },

    /// Peer dependency cannot be satisfied
    #[error("Peer dependency conflict: {package} requires {peer} {constraint}")]
    PeerConflict {
        package: String,
        peer: String,
        constraint: String,
        reason: String,
    },

    /// Optional dependency resolution failed (warning, not fatal)
    #[error("Optional dependency unavailable: {package}@{version}")]
    OptionalUnavailable { package: String, version: String },

    /// Internal resolver error (shouldn't happen in normal operation)
    #[error("Internal resolver error: {message}")]
    Internal { message: String },
}

/// SAT solver specific errors
#[derive(Debug, Error)]
pub enum SatError {
    /// SAT solver initialization failed
    #[error("Failed to initialize SAT solver: {reason}")]
    InitializationFailed { reason: String },

    /// Problem encoding failed
    #[error("Failed to encode problem: {reason}")]
    EncodingFailed { reason: String },

    /// Solver crashed or returned invalid result
    #[error("SAT solver failure: {reason}")]
    SolverFailure { reason: String },

    /// Problem is unsatisfiable (no solution)
    #[error("Problem is unsatisfiable")]
    Unsatisfiable,

    /// Solver timed out
    #[error("SAT solver timed out after {duration:?}")]
    Timeout { duration: Duration },

    /// Out of memory during solving
    #[error("SAT solver ran out of memory")]
    OutOfMemory,

    /// Invalid model returned by solver
    #[error("Invalid solution model from solver")]
    InvalidModel,

    /// Clause generation error
    #[error("Failed to generate clauses: {reason}")]
    ClauseGeneration { reason: String },
}

/// Details about a specific dependency conflict
#[derive(Debug, Clone)]
pub struct ConflictDetail {
    /// Package that has the conflict
    pub package: String,
    /// Version or constraint causing the conflict
    pub constraint: String,
    /// Conflicting package
    pub conflicts_with: String,
    /// Reason for the conflict
    pub reason: ConflictReason,
}

/// Types of dependency conflicts
#[derive(Debug, Clone)]
pub enum ConflictReason {
    /// Version ranges don't overlap
    VersionIncompatible,
    /// Peer dependency cannot be satisfied
    PeerDependency,
    /// Circular dependency
    CircularDependency,
    /// Package not found
    PackageNotFound,
    /// Engine incompatibility (node version, etc.)
    EngineIncompatible,
    /// Platform incompatibility (OS, architecture)
    PlatformIncompatible,
}

impl ConflictDetail {
    /// Create a new conflict detail
    pub fn new(
        package: String,
        constraint: String,
        conflicts_with: String,
        reason: ConflictReason,
    ) -> Self {
        Self {
            package,
            constraint,
            conflicts_with,
            reason,
        }
    }

    /// Create a version incompatibility conflict
    pub fn version_conflict(package: String, constraint: String, conflicts_with: String) -> Self {
        Self::new(
            package,
            constraint,
            conflicts_with,
            ConflictReason::VersionIncompatible,
        )
    }

    /// Create a peer dependency conflict
    pub fn peer_conflict(package: String, constraint: String, conflicts_with: String) -> Self {
        Self::new(
            package,
            constraint,
            conflicts_with,
            ConflictReason::PeerDependency,
        )
    }
}

impl ResolutionError {
    /// Create a conflict error with details
    pub fn conflict(message: String, conflicts: Vec<ConflictDetail>) -> Self {
        Self::Conflict { message, conflicts }
    }

    /// Create a simple conflict error
    pub fn simple_conflict(message: String) -> Self {
        Self::Conflict {
            message,
            conflicts: Vec::new(),
        }
    }

    /// Create a timeout error
    pub fn timeout(timeout: Duration) -> Self {
        Self::Timeout { timeout }
    }

    /// Create an invalid package error
    pub fn invalid_package(package: String, version: String) -> Self {
        Self::InvalidPackage { package, version }
    }

    /// Create a no matching versions error  
    pub fn no_matching_versions(package: String, version_set: crate::version::VersionSet) -> Self {
        Self::InvalidPackage {
            package: format!("{} with constraint {}", package, version_set),
            version: "no matching versions".to_string(),
        }
    }

    /// Create an invalid constraint error
    pub fn invalid_constraint(package: String, constraint: String) -> Self {
        Self::InvalidConstraint {
            package,
            constraint,
        }
    }

    /// Create a circular dependency error
    pub fn circular_dependency(cycle: String) -> Self {
        Self::CircularDependency { cycle }
    }

    /// Create a package not found error
    pub fn package_not_found(package: String, version: String) -> Self {
        Self::PackageNotFound { package, version }
    }

    /// Create a peer dependency conflict error
    pub fn peer_conflict(
        package: String,
        peer: String,
        constraint: String,
        reason: String,
    ) -> Self {
        Self::PeerConflict {
            package,
            peer,
            constraint,
            reason,
        }
    }

    /// Create an internal error
    pub fn internal(message: String) -> Self {
        Self::Internal { message }
    }

    /// Check if this error represents a conflict that might be resolvable
    pub fn is_resolvable_conflict(&self) -> bool {
        matches!(
            self,
            Self::Conflict { .. } | Self::PeerConflict { .. } | Self::InvalidConstraint { .. }
        )
    }

    /// Check if this error is fatal (no point in retrying)
    pub fn is_fatal(&self) -> bool {
        matches!(
            self,
            Self::CircularDependency { .. }
                | Self::PackageNotFound { .. }
                | Self::InvalidPackage { .. }
                | Self::Internal { .. }
        )
    }

    /// Get a user-friendly error message with suggestions
    pub fn user_message(&self) -> String {
        match self {
            Self::Conflict { message, conflicts } => {
                let mut msg = format!("Dependency conflict: {}", message);
                if !conflicts.is_empty() {
                    msg.push_str("\n\nConflicts:");
                    for conflict in conflicts {
                        msg.push_str(&format!(
                            "\n  • {} {} conflicts with {}",
                            conflict.package, conflict.constraint, conflict.conflicts_with
                        ));
                    }
                    msg.push_str(
                        "\n\nTry:\n  • Update conflicting packages\n  • Use --force to override \
                         (not recommended)",
                    );
                }
                msg
            }
            Self::PackageNotFound { package, version } => {
                format!(
                    "Package not found: {}@{}\n\nTry:\n  • Check package name spelling\n  • \
                     Verify version exists\n  • Check registry configuration",
                    package, version
                )
            }
            Self::CircularDependency { cycle } => {
                format!(
                    "Circular dependency detected: {}\n\nThis indicates a problem with the \
                     packages themselves.",
                    cycle
                )
            }
            _ => self.to_string(),
        }
    }
}

impl SatError {
    /// Create an initialization failed error
    pub fn initialization_failed(reason: String) -> Self {
        Self::InitializationFailed { reason }
    }

    /// Create an encoding failed error
    pub fn encoding_failed(reason: String) -> Self {
        Self::EncodingFailed { reason }
    }

    /// Create a solver failure error
    pub fn solver_failure(reason: String) -> Self {
        Self::SolverFailure { reason }
    }

    /// Create a timeout error
    pub fn timeout(duration: Duration) -> Self {
        Self::Timeout { duration }
    }

    /// Create a clause generation error
    pub fn clause_generation(reason: String) -> Self {
        Self::ClauseGeneration { reason }
    }

    /// Check if the error indicates the problem is unsatisfiable
    pub fn is_unsatisfiable(&self) -> bool {
        matches!(self, Self::Unsatisfiable)
    }

    /// Check if the error indicates a solver failure
    pub fn is_solver_failure(&self) -> bool {
        matches!(
            self,
            Self::SolverFailure { .. } | Self::OutOfMemory | Self::InvalidModel
        )
    }
}

/// Result type for resolution operations
pub type ResolutionResult<T> = std::result::Result<T, ResolutionError>;

/// Result type for SAT operations  
pub type SatResult<T> = std::result::Result<T, SatError>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_conflict_detail_creation() {
        let conflict = ConflictDetail::version_conflict(
            "lodash".to_string(),
            "^4.0.0".to_string(),
            "lodash@3.10.1".to_string(),
        );

        assert_eq!(conflict.package, "lodash");
        assert_eq!(conflict.constraint, "^4.0.0");
        assert_eq!(conflict.conflicts_with, "lodash@3.10.1");
        assert!(matches!(
            conflict.reason,
            ConflictReason::VersionIncompatible
        ));
    }

    #[test]
    fn test_resolution_error_classification() {
        let conflict = ResolutionError::simple_conflict("test conflict".to_string());
        assert!(conflict.is_resolvable_conflict());
        assert!(!conflict.is_fatal());

        let circular = ResolutionError::circular_dependency("A -> B -> A".to_string());
        assert!(!circular.is_resolvable_conflict());
        assert!(circular.is_fatal());

        let not_found =
            ResolutionError::package_not_found("missing".to_string(), "1.0.0".to_string());
        assert!(!not_found.is_resolvable_conflict());
        assert!(not_found.is_fatal());
    }

    #[test]
    fn test_sat_error_classification() {
        let unsatisfiable = SatError::Unsatisfiable;
        assert!(unsatisfiable.is_unsatisfiable());
        assert!(!unsatisfiable.is_solver_failure());

        let failure = SatError::solver_failure("crashed".to_string());
        assert!(!failure.is_unsatisfiable());
        assert!(failure.is_solver_failure());

        let timeout = SatError::timeout(Duration::from_secs(30));
        assert!(!timeout.is_unsatisfiable());
        assert!(!timeout.is_solver_failure());
    }

    #[test]
    fn test_user_friendly_messages() {
        let conflict =
            ResolutionError::package_not_found("lodash".to_string(), "999.0.0".to_string());
        let message = conflict.user_message();
        assert!(message.contains("Package not found"));
        assert!(message.contains("Check package name spelling"));
    }
}