//! This module contains code for various types of errors that may occur when assembling a
//! set of source DSA files.

use std::fmt::{Debug, Display};

use crate::source::{source_info::SourceInfo, tokeniser::error::TokeniserError};

/// An error that may occur during the assembly of a set of source files.
#[derive(Debug)]
pub struct AssembleError {
    /// Display implementation can handle when the source code information is shown or
    /// not.
    source_info: Option<SourceInfo>,
    /// The type of assembly error that occurred.
    kind: AssembleErrorKind,
}

impl AssembleError {
    #[must_use]
    pub const fn new_source_error(
        source_info: SourceInfo,
        kind: AssembleErrorKind,
    ) -> Self {
        Self {
            source_info: Some(source_info),
            kind,
        }
    }

    #[must_use]
    pub const fn new_other_error(kind: AssembleErrorKind) -> Self {
        Self {
            source_info: None,
            kind,
        }
    }
}

impl Display for AssembleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(info) = &self.source_info {
            write!(f, "at {info}")?;
        }

        write!(f, "{}", self.kind)?;

        Ok(())
    }
}

/// Marker trait.
impl std::error::Error for AssembleError {}

/// Different types of errors that may occur when assembling a set of input source files.
#[non_exhaustive]
#[derive(Debug)]
pub enum AssembleErrorKind {
    /// Usually unexpected I/O errors. Not normally recoverable.
    IO(std::io::Error),
    /// Errors emitted from the [`Tokeniser`].
    Tokenise(TokeniserError),
    /// Returned for code where the functionality has not yet been implemented but we
    /// don't want the program to panic.
    Unimplemented(String),
}

impl Display for AssembleErrorKind {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Tokenise(why) => write!(f, "tokeniser error: {why}"),
            Self::Unimplemented(why) => write!(f, "used unimplemented feature: {why}"),
            Self::IO(why) => write!(f, "problem occurred with I/O: {why}"),
            #[expect(unreachable_patterns)]
            _ => write!(
                f,
                "unhandled error type in Display implementation! See error.rs!"
            ),
        }
    }
}

impl From<std::io::Error> for AssembleErrorKind {
    fn from(err: std::io::Error) -> Self {
        Self::IO(err)
    }
}

pub mod conversions;