//! This module allows to describe a primitive subset of [Mentionable] types, [Atomic]s,
//! simple static types, which are completely [Context]-independent.

pub mod array;
pub mod atomic_object;
pub mod au64;
pub mod boolean;
mod modes;
pub mod plain;

use std::marker::PhantomData;

use crate::rcore::*;

use super::*;

pub use self::modes::{
    AExtensionResultM, AExtensionSourceM, AModeResultM, AtomicModeParse, AtomicModeProxy,
    CRegularAtomic, RegularAtomic,
};

/// [`Atomic`] equivalent of [`ParseError`].
pub type AParseError<A> = <A as AtomicBase>::AParseError;

pub type AParseResult<A> = Result<A, AParseError<A>>;

/// Base for [`Atomic`].
pub trait AtomicBase: 'static + Send + Sync + Send + Clone + Serializable {
    /// Equivalent of [`FactoryBase::ParseError`].
    type AParseError: Error;
}

/// This trait combines functionality of [`Mentionable`] and [`Factory`],
/// while limiting [`MentionableTop::points_typed`] (and corresponding [`MentionableTop::topology`])
/// to an empty sequence.
pub trait Atomic: AtomicBase + ParseMode {
    /// Static equivalent of [`FactoryParse::deserialize`].
    fn a_deserialize(inlining: impl Inlining) -> AParseResult<Self>;
    /// Static equivalent of [`FactoryParse::extend`].
    fn a_extend(self, tail: &[u8]) -> AParseResult<Self>;
}

fn _parse_slice<A: Atomic>(slice: &[u8]) -> AParseResult<A> {
    let mut deserializer = SliceDeserializer::from(slice);
    let atomic = A::a_deserialize(&mut deserializer)?;
    let tail = deserializer.read_all();
    if tail.is_empty() {
        Ok(atomic)
    } else {
        A::a_extend(atomic, tail)
    }
}

/// Extension trait to provide method-like utilities associated with [Atomic]s.
pub trait AtomicExt: Atomic {
    /// Static equivalent of [`FactoryExt::parse_slice`].
    fn parse_slice(slice: &[u8]) -> AParseResult<Self> {
        _parse_slice(slice)
    }
}

impl<A: Atomic> AtomicExt for A {}