// TDD: RED phase - Write tests first for error types
use rtx_cfd::error::{CfdError, CfdResult};

#[test]
fn test_gpu_memory_error_creation() {
    let error = CfdError::GpuMemoryError("Out of GPU memory".to_string());
    match error {
        CfdError::GpuMemoryError(msg) => assert_eq!(msg, "Out of GPU memory"),
        _ => panic!("Expected GpuMemoryError"),
    }
}

#[test]
fn test_convergence_error_creation() {
    let error = CfdError::ConvergenceError {
        iteration: 100,
        residual: 1e-3,
        target: 1e-6,
    };
    match error {
        CfdError::ConvergenceError {
            iteration,
            residual,
            target,
        } => {
            assert_eq!(iteration, 100);
            assert_eq!(residual, 1e-3);
            assert_eq!(target, 1e-6);
        }
        _ => panic!("Expected ConvergenceError"),
    }
}

#[test]
fn test_mesh_error_creation() {
    let error = CfdError::MeshError("Invalid mesh topology".to_string());
    match error {
        CfdError::MeshError(msg) => assert_eq!(msg, "Invalid mesh topology"),
        _ => panic!("Expected MeshError"),
    }
}

#[test]
fn test_solver_error_creation() {
    let error = CfdError::SolverError("Matrix is singular".to_string());
    match error {
        CfdError::SolverError(msg) => assert_eq!(msg, "Matrix is singular"),
        _ => panic!("Expected SolverError"),
    }
}

#[test]
fn test_boundary_condition_error_creation() {
    let error = CfdError::BoundaryConditionError("Incompatible BC types".to_string());
    match error {
        CfdError::BoundaryConditionError(msg) => assert_eq!(msg, "Incompatible BC types"),
        _ => panic!("Expected BoundaryConditionError"),
    }
}

#[test]
fn test_cuda_error_conversion() {
    // Test that CUDA errors can be converted to CfdError
    let cfd_error = CfdError::CudaError("Test CUDA error".to_string());
    match cfd_error {
        CfdError::CudaError(_) => (),
        _ => panic!("Expected CudaError conversion"),
    }
}

#[test]
fn test_error_display() {
    let error = CfdError::ConvergenceError {
        iteration: 50,
        residual: 1e-4,
        target: 1e-6,
    };
    let display_str = format!("{}", error);
    println!("Display string: {}", display_str);
    assert!(display_str.contains("Convergence failed"));
    assert!(display_str.contains("50"));
    assert!(
        display_str.contains("1.00e-4")
            || display_str.contains("1e-4")
            || display_str.contains("0.0001")
    );
    assert!(
        display_str.contains("1.00e-6")
            || display_str.contains("1e-6")
            || display_str.contains("0.000001")
    );
}

#[test]
fn test_cfd_result_ok() {
    let result: CfdResult<i32> = Ok(42);
    assert!(result.is_ok());
    assert_eq!(result.unwrap(), 42);
}

#[test]
fn test_cfd_result_err() {
    let result: CfdResult<i32> = Err(CfdError::MeshError("Test error".to_string()));
    assert!(result.is_err());
}