use crate::backend::runtime::RuntimeFunctionError;
use codespan_reporting::diagnostic::Diagnostic;
use cranelift_codegen::{isa::LookupError, settings::SetError, CodegenError};
use cranelift_module::ModuleError;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum BackendError {
    #[error("Cranelift module error: {0}")]
    Cranelift(#[from] ModuleError),
    #[error("Builtin function error: {0}")]
    BuiltinError(#[from] RuntimeFunctionError),
    #[error("Internal variable lookup error")]
    VariableLookupFailure,
    #[error(transparent)]
    CodegenError(#[from] CodegenError),
    #[error(transparent)]
    SetError(#[from] SetError),
    #[error(transparent)]
    LookupError(#[from] LookupError),
    #[error(transparent)]
    Write(#[from] cranelift_object::object::write::Error),
}

impl From<BackendError> for Diagnostic<usize> {
    fn from(value: BackendError) -> Self {
        match value {
            BackendError::Cranelift(me) => {
                Diagnostic::error().with_message(format!("Internal cranelift error: {}", me))
            }
            BackendError::BuiltinError(me) => {
                Diagnostic::error().with_message(format!("Internal runtime function error: {}", me))
            }
            BackendError::VariableLookupFailure => {
                Diagnostic::error().with_message("Internal variable lookup error!")
            }
            BackendError::CodegenError(me) => {
                Diagnostic::error().with_message(format!("Internal codegen error: {}", me))
            }
            BackendError::SetError(me) => {
                Diagnostic::error().with_message(format!("Internal backend setup error: {}", me))
            }
            BackendError::LookupError(me) => {
                Diagnostic::error().with_message(format!("Internal error: {}", me))
            }
            BackendError::Write(me) => {
                Diagnostic::error().with_message(format!("Cranelift object write error: {}", me))
            }
        }
    }
}

impl PartialEq for BackendError {
    fn eq(&self, other: &Self) -> bool {
        match self {
            BackendError::BuiltinError(a) => match other {
                BackendError::BuiltinError(b) => a == b,
                _ => false,
            },

            BackendError::CodegenError(_) => matches!(other, BackendError::CodegenError(_)),

            BackendError::Cranelift(_) => matches!(other, BackendError::Cranelift(_)),

            BackendError::LookupError(a) => match other {
                BackendError::LookupError(b) => a == b,
                _ => false,
            },

            BackendError::SetError(a) => match other {
                BackendError::SetError(b) => a == b,
                _ => false,
            },

            BackendError::VariableLookupFailure => other == &BackendError::VariableLookupFailure,

            BackendError::Write(a) => match other {
                BackendError::Write(b) => a == b,
                _ => false,
            },
        }
    }
}