//! Core module for ADN functionality.
//! Brings [`Mentionable`]/[`Factory`]/[`Origin`] concepts from the original implementation in Python.
//! Allows for more generic behaviour via [`Context`], as opposed to original async-only.

mod addresses;
mod context;
mod dectx;
mod demoted;
mod diagnostic;
mod hashing;
mod inctx;
mod inlining;
mod modes;
mod origin;
mod point;
mod points;
mod resolution;
mod resolver_origin;
mod serialization;
mod slice_deserializer;

use std::{error::Error, rc::Rc};

use crate::func::context::*;
use crate::func::*;

use self::addresses::{Addresses, InliningAddresses};
pub use self::context::Context;
use self::dectx::{DeCtx, DeCtxT};
pub use self::demoted::Demoted;
pub use self::diagnostic::Diagnostic;
pub use self::hashing::{Hash, HASH_SIZE, HASH_ZEROS};
pub use self::inctx::InCtx;
pub use self::inlining::{Inlining, InliningExt, InliningResultExt};
pub use self::modes::{
    FactoryProxy, ParseMode, RegularFactory, RegularMode, WithMode, WithParseMode,
};
pub use self::origin::{OFctr, Origin};
pub use self::point::Point;
pub use self::points::PointsVisitor;
pub use self::resolution::{
    Address, HashResolution, HashResolutionResult, LookupError, Resolution, ResolutionError,
    ResolutionFailure, ResolutionResult, Resolver, ResolverMap,
};
pub use self::serialization::{Deserializer, DeserializerExt, Serializable, Serializer};
pub use self::slice_deserializer::SliceDeserializer;

/// Helper alias for [`WeakFunctor::F`] of [`FunctorContext::T`].
pub type Wrapped<'a, Ctx, A> = WrapC<'a, A, Ctx>;

/// Fundamental trait for ADN objects.
pub trait MentionableBase<'a, Ctx: Context<'a>>: 'a + Serializable + Sized {
    /// Type of the associated factory.
    type Fctr: FactoryBase<'a, Ctx, Mtbl = Self>;

    /// Value of the associated factory.
    fn factory(&self) -> Self::Fctr;
}

pub trait MentionableTop<'a, Ctx: Context<'a>>: 'a {
    /// See implementation for the definition.
    /// Hash of all the references' points concatenated, ordered, non-unique.
    /// Used for walking over object trees to ensure two objects with different references don't collide.
    fn topology(&self) -> Hash {
        let mut vec = Vec::new();
        self.points_typed(&mut vec);
        Ctx::hash(&vec)
    }
    /// References ([Point]s) to other objects. Typed.
    fn points_typed(&self, points: &mut impl PointsVisitor<'a, Ctx>);
}

pub trait Mentionable<'a, Ctx: Context<'a>>:
    MentionableBase<'a, Ctx, Fctr = Self::_Fctr> + MentionableTop<'a, Ctx>
{
    type _Fctr: Factory<'a, Ctx, _Mtbl = Self>;
}

impl<'a, Ctx: Context<'a>, A: MentionableBase<'a, Ctx> + MentionableTop<'a, Ctx>>
    Mentionable<'a, Ctx> for A
where
    Self::Fctr: Factory<'a, Ctx, _Mtbl = Self>,
{
    type _Fctr = Self::Fctr;
}

/// [`Factory`] associated with the [`Mentionable`]. Mostly useful for `type` definitions.
pub type Fctr<'a, Ctx, A> = <A as MentionableBase<'a, Ctx>>::Fctr;

/// Shorthand for the type of vaalues returned by [`Factory::deserialize`].
pub type ParseResult<'a, Ctx, F> = Result<Mtbl<'a, Ctx, F>, ParseError<'a, Ctx, F>>;

/// [`ParseResult`] associated with a [`Mentionable`] (instead of a [`Factory`]).
pub type ParseResultA<'a, Ctx, A> = Result<A, ParseErrorA<'a, Ctx, A>>;

/// [Factory] base.
pub trait FactoryBase<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone {
    /// Type of the associated objects.
    type Mtbl: MentionableBase<'a, Ctx, Fctr = Self>;
    /// Type of an error that [`Factory::deserialize`] can fail with.
    type ParseError: 'a + Error;
}

/// Trait representing deserialisation rules for [Mentionable]s.
/// Crucial for [`crate::rstd::typeless`].
pub trait Factory<'a, Ctx: Context<'a>>:
    FactoryBase<'a, Ctx, Mtbl = Self::_Mtbl> + ParseMode
{
    type _Mtbl: MentionableBase<'a, Ctx, Fctr = Self> + MentionableTop<'a, Ctx>;

    /// See [`Deserializer`], [`Resolver`].
    fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self>;
    /// Called by finite stream parsers if there's any data left.
    fn extend(&self, mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self>;
}

/// [`Mentionable`] associated with the [`Factory`]. Mostly useful for `type` definitions.
pub type Mtbl<'a, Ctx, F> = <F as FactoryBase<'a, Ctx>>::Mtbl;

/// [`FactoryBase::ParseError`]. Mostly useful for `type` definitions.
pub type ParseError<'a, Ctx, F> = <F as FactoryBase<'a, Ctx>>::ParseError;

/// [`FactoryBase::ParseError`] associated with the [`Mentionable`].
/// Mostly useful for `type` definitions.
pub type ParseErrorA<'a, Ctx, A> = ParseError<'a, Ctx, Fctr<'a, Ctx, A>>;

/// Extension trait for factories.
pub trait FactoryExt<'a, Ctx: Context<'a>>: Factory<'a, Ctx> {
    /// Parse the object from a slice.
    fn parse_slice(
        &self,
        slice: &[u8],
        resolver: &Rc<dyn Resolver<'a, Ctx>>,
    ) -> ParseResult<'a, Ctx, Self>;
}