use super::*;

impl<'a, Ctx: Context<'a>, A: MentionableBase<'a, Ctx>> Point<'a, Ctx, A>
where
    A::Fctr: FactoryBase<'a, Ctx>,
{
    /// Make a [Point] from an [Address].
    pub fn from_address(
        address: Address,
        factory: A::Fctr,
        resolver: Arc<dyn Resolver<'a, Ctx>>,
    ) -> Self {
        Point {
            point: address.point,
            origin: Arc::new(ResolverOrigin {
                r_factory: factory,
                r_address: address,
                r_resolver: resolver,
            }),
        }
    }
}

struct ResolverOrigin<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> {
    r_factory: F,
    r_address: Address,
    r_resolver: Arc<dyn Resolver<'a, Ctx>>,
}

fn _resolve_origin<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>>(
    origin: Arc<ResolverOrigin<'a, Ctx, F>>,
) -> Resolution<'a, Ctx, F::Mtbl> {
    origin
        .r_resolver
        .clone()
        .resolve_map(origin.r_address, move |resolved| {
            let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
            let mentionable = origin
                .r_factory
                .parse_slice(&src, &resolver)
                .map_err(ResolutionError::Parse)?;
            Ok(Arc::new(mentionable))
        })
}

impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> Origin<'a, Ctx> for ResolverOrigin<'a, Ctx, F> {
    type Mtbl = F::Mtbl;

    fn factory(&self) -> OFctr<'a, Ctx, Self> {
        self.r_factory.clone()
    }

    fn resolve(self: Arc<Self>) -> Resolution<'a, Ctx, Self::Mtbl>
    where
        F: FactoryParse<'a, Ctx>,
    {
        _resolve_origin(self)
    }

    fn resolve_bytes(self: Arc<Self>) -> HashResolution<'a, Ctx> {
        self.r_resolver.clone().resolve(self.r_address)
    }
}