//! Error traits and error kinds

#[cfg(doc)]
use super::*;

use std::borrow::Cow;
use std::error::Error;
use std::fmt;
use std::ops::{Deref, DerefMut};

/// Kinds of [`MachineError`]s
#[derive(Copy, Clone, PartialEq, Eq, Hash, Default, Debug)]
pub enum MachineErrorKind {
    /// Out-of-memory error
    Memory,
    /// Syntax error during compilation (see [`Compile::compile`])
    Syntax,
    /// Execution limit error
    ExecLimit,
    /// Generic runtime error (see [`Function::call`])
    Runtime,
    /// Unexpected value(s) (e.g. wrong type or wrong count of return values)
    Data,
    /// Error kind unknown
    #[default]
    Unknown,
}

/// Unboxed version of [`MachineError`]
///
/// All fields of this struct may be accessed through `MachineError` as well
/// (due to [`Deref`] and [`DerefMut`] implementation by `MachineError).
#[derive(Clone, Default)]
#[non_exhaustive]
pub struct MachineErrorUnboxed {
    /// Kind of runtime error
    pub kind: MachineErrorKind,
    /// Error message
    pub message: Option<String>,
    /// Backtrace (multiple lines, without trailing newline)
    pub machine_backtrace: Option<String>,
    /// Chunk name already included in message?
    pub message_incl_chunk_name: bool,
    /// Chunk name
    pub chunk_name: Option<String>,
    /// Position already included in message?
    pub message_incl_pos: bool,
    /// Line number
    pub line: Option<usize>,
    /// Column number (in UTF-8 codepoints)
    pub column: Option<usize>,
    /// Byte position
    pub position: Option<usize>,
}

/// Runtime or compiler errors that may refer to a specific position in code
#[derive(Clone, Default)]
pub struct MachineError {
    /// Boxed struct containing all fields
    /// (accessible through [`Deref`] and [`DerefMut`])
    pub boxed: Box<MachineErrorUnboxed>,
}

impl Deref for MachineError {
    type Target = MachineErrorUnboxed;
    fn deref(&self) -> &Self::Target {
        &self.boxed
    }
}

impl DerefMut for MachineError {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.boxed
    }
}

impl MachineError {
    /// Creates a new `MachineError` that may also be used as a builder
    pub fn new() -> Self {
        Default::default()
    }
    /// Builder-style method to set the [`MachineErrorKind`]
    pub fn set_kind(mut self, kind: MachineErrorKind) -> Self {
        self.kind = kind;
        self
    }
    /// Builder-style method to set an error [`message`]
    ///
    /// [`message`]: MachineErrorUnboxed::message
    pub fn set_message(mut self, message: String) -> Self {
        self.message = Some(message);
        self
    }
    /// Builder-style method to set an error [`message`] using a `str` slice
    ///
    /// [`message`]: MachineErrorUnboxed::message
    pub fn set_message_str(mut self, message: &str) -> Self {
        self.message = Some(message.to_owned());
        self
    }
    /// Builder-style method to set an error [`message`] [option]
    ///
    /// [`message`]: MachineErrorUnboxed::message
    /// [option]: Option
    pub fn set_message_opt(mut self, message: Option<String>) -> Self {
        self.message = message;
        self
    }
    /// Builder-style method to set [`machine_backtrace`]
    ///
    /// [`machine_backtrace`]: MachineErrorUnboxed::machine_backtrace
    pub fn set_machine_backtrace(mut self, machine_backtrace: String) -> Self {
        self.machine_backtrace = Some(machine_backtrace);
        self
    }
    /// Builder-style method to set a [`machine_backtrace`] [option]
    ///
    /// [`machine_backtrace`]: MachineErrorUnboxed::machine_backtrace
    /// [option]: Option
    pub fn set_machine_backtrace_opt(mut self, machine_backtrace: Option<String>) -> Self {
        self.machine_backtrace = machine_backtrace;
        self
    }
    /// Builder-style method to set [`message_incl_chunk_name`] to `true`
    ///
    /// [`message_incl_chunk_name`]: MachineErrorUnboxed::message_incl_chunk_name
    pub fn set_message_incl_chunk_name(mut self) -> Self {
        self.message_incl_chunk_name = true;
        self
    }
    /// Builder-style method to set [`message_incl_chunk_name`] to `bool`
    ///
    /// [`message_incl_chunk_name`]: MachineErrorUnboxed::message_incl_chunk_name
    pub fn set_message_incl_chunk_name_bool(mut self, message_incl_chunk_name: bool) -> Self {
        self.message_incl_chunk_name = message_incl_chunk_name;
        self
    }
    /// Builder-style method to set [`chunk_name`]
    ///
    /// [`chunk_name`]: MachineErrorUnboxed::chunk_name
    pub fn set_chunk_name(mut self, chunk_name: String) -> Self {
        self.chunk_name = Some(chunk_name);
        self
    }
    /// Builder-style method to set [`chunk_name`] [option]
    ///
    /// [`chunk_name`]: MachineErrorUnboxed::chunk_name
    /// [option]: Option
    pub fn set_chunk_name_opt(mut self, chunk_name: Option<String>) -> Self {
        self.chunk_name = chunk_name;
        self
    }
    /// Builder-style method to set [`message_incl_pos`] to `true`
    ///
    /// [`message_incl_pos`]: MachineErrorUnboxed::message_incl_pos
    pub fn set_message_incl_pos(mut self) -> Self {
        self.message_incl_pos = true;
        self
    }
    /// Builder-style method to set [`message_incl_pos`] to a `bool`
    ///
    /// [`message_incl_pos`]: MachineErrorUnboxed::message_incl_pos
    pub fn set_message_incl_pos_bool(mut self, message_incl_pos: bool) -> Self {
        self.message_incl_pos = message_incl_pos;
        self
    }
    /// Builder-style method to set [`line`]
    ///
    /// [`line`]: MachineErrorUnboxed::line
    pub fn set_line(mut self, line: usize) -> Self {
        self.line = Some(line);
        self
    }
    /// Builder-style method to set [`line`] [option]
    ///
    /// [`line`]: MachineErrorUnboxed::line
    /// [option]: Option
    pub fn set_line_opt(mut self, line: Option<usize>) -> Self {
        self.line = line;
        self
    }
    /// Builder-style method to set [`column`]
    ///
    /// [`column`]: MachineErrorUnboxed::column
    pub fn set_column(mut self, column: usize) -> Self {
        self.column = Some(column);
        self
    }
    /// Builder-style method to set [`column`] [option]
    ///
    /// [`column`]: MachineErrorUnboxed::column
    /// [option]: Option
    pub fn set_column_opt(mut self, column: Option<usize>) -> Self {
        self.column = column;
        self
    }
    /// Builder-style method to set [`position`]
    ///
    /// [`position`]: MachineErrorUnboxed::position
    pub fn set_position(mut self, position: usize) -> Self {
        self.position = Some(position);
        self
    }
    /// Builder-style method to set [`position`] [option]
    ///
    /// [`position`]: MachineErrorUnboxed::position
    /// [option]: Option
    pub fn set_position_opt(mut self, position: Option<usize>) -> Self {
        self.position = position;
        self
    }
}

impl Error for MachineError {}

impl fmt::Display for MachineError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.kind {
            MachineErrorKind::Memory => write!(f, "VM memory exhausted")?,
            MachineErrorKind::Syntax => write!(f, "syntax error in code for VM")?,
            MachineErrorKind::ExecLimit => write!(f, "VM execution limit exhausted")?,
            MachineErrorKind::Runtime => write!(f, "runtime error in VM")?,
            MachineErrorKind::Data => write!(f, "unexpected data from VM")?,
            _ => write!(f, "VM error")?,
        }
        let mut chunk_name_written = false;
        if !self.message_incl_chunk_name {
            if let Some(ref chunk_name) = self.chunk_name {
                write!(f, " in chunk \"{}\"", chunk_name)?;
                chunk_name_written = true;
            }
        }
        if !self.message_incl_pos {
            if let Some(line) = self.line {
                write!(
                    f,
                    "{} line {}",
                    if chunk_name_written { ", " } else { " in" },
                    line
                )?;
                if let Some(column) = self.column {
                    write!(f, ", column {}", column)?;
                }
            } else if let Some(position) = self.position {
                write!(f, ", at byte position {}", position)?;
            }
        }
        if let Some(msg) = &self.message {
            write!(f, ": {}", msg)?;
        }
        Ok(())
    }
}

impl fmt::Debug for MachineError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("MachineError")
            .field("kind", &self.kind)
            .field("message", &self.message)
            .field("message_incl_pos", &self.message_incl_pos)
            .field("chunk_name", &self.chunk_name)
            .field("line", &self.line)
            .field("column", &self.column)
            .field("position", &self.position)
            .finish_non_exhaustive()
    }
}

/// Error indicating that [`Machine::Datum`] had an unexpected (dynamic) type
///
/// See also [`types`] module.
///
/// For convenience, this error type can be converted into a [`MachineError`].
#[derive(Debug)]
pub struct TypeMismatch {
    /// Error description
    message: Cow<'static, str>,
}

impl TypeMismatch {
    /// Create new `TypeMismatch` without specific message
    pub const fn new() -> Self {
        TypeMismatch {
            message: Cow::Borrowed("dynamic type mismatch (no details available)"),
        }
    }
    /// Create new `TypeMismatch` from owned [`String`]
    pub fn with_msg(message: String) -> Self {
        TypeMismatch {
            message: Cow::Owned(message),
        }
    }
    /// Create new `TypeMismatch` with static error message
    pub const fn with_static_msg(message: &'static str) -> Self {
        TypeMismatch {
            message: Cow::Borrowed(message),
        }
    }
}

impl fmt::Display for TypeMismatch {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(&self.message)
    }
}

impl Error for TypeMismatch {}

impl From<TypeMismatch> for MachineError {
    fn from(datum_err: TypeMismatch) -> Self {
        MachineError::new()
            .set_kind(MachineErrorKind::Data)
            .set_message(datum_err.to_string())
    }
}

/// Error type when using [`TryFrom`]/[`TryInto`] to convert a
/// [`Machine::Datum`] into a particular type
///
/// See also [`types`] module.
///
/// Since this type contains the original `Datum`, it might not be
/// `Send + Sync + 'static`. `DatumConversionFailure` also does not implement
/// [`std::error::Error`]. You can convert this error into [`TypeMismatch`]
/// (or extract the [`error`] field), which implements `std::error::Error` and
/// is `Send + Sync + 'static`.
///
/// For convenience, values of this type can also be directly converted into a
/// [`MachineError`].
///
/// [`error`]: DatumConversionFailure::error
pub struct DatumConversionFailure<D> {
    /// Original datum that could not be converted
    pub original: D,
    /// Error description
    pub error: TypeMismatch,
}

impl<D> DatumConversionFailure<D> {
    /// Create new `DatumConversionFailure` with given [`TypeMismatch`] error
    pub fn new(original: D, error: TypeMismatch) -> Self {
        DatumConversionFailure { original, error }
    }
    /// Create new `DatumConversionFailure` with owned [`String`] error message
    pub fn with_msg(original: D, message: String) -> Self {
        DatumConversionFailure::new(original, TypeMismatch::with_msg(message))
    }
    /// Create new `DatumConversionFailure` with static error message
    pub fn with_static_msg(original: D, message: &'static str) -> Self {
        DatumConversionFailure::new(original, TypeMismatch::with_static_msg(message))
    }
}

impl<D> fmt::Debug for DatumConversionFailure<D> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("DatumConversionFailure")
            .field("error", &self.error)
            .finish_non_exhaustive()
    }
}

impl<D> From<DatumConversionFailure<D>> for TypeMismatch {
    fn from(failure: DatumConversionFailure<D>) -> Self {
        failure.error
    }
}
impl<D> From<DatumConversionFailure<D>> for MachineError {
    fn from(failure: DatumConversionFailure<D>) -> Self {
        MachineError::new()
            .set_kind(MachineErrorKind::Data)
            .set_message(TypeMismatch::from(failure).to_string())
    }
}