use std::rc::Rc;

use crate::rcore::*;
use crate::rstd::{singular::*, *};

trait Inject<'a, Ctx: Context<'a>>: 'a + Sized {
    fn inject<A: 'a>(&self, fa: Wrapped<'a, Ctx, A>) -> Wrapped<'a, Ctx, A>;

    fn inject_mentionable<A: Mentionable<'a, Ctx>>(
        self: Rc<Self>,
        a: &A,
    ) -> ParseResultA<'a, Ctx, A> {
        let factory = a.factory();
        let inject = self;
        let resolver = SingularResolver::from_mentionable(a).into_rc();
        let resolver = InjectedResolver { resolver, inject }.into_rc();
        let bytes = a.bytes();
        factory.parse_slice(&bytes, &resolver)
    }
}

struct InjectedResolver<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> {
    resolver: Rc<dyn Resolver<'a, Ctx>>,
    inject: Rc<F>,
}

impl<'a, Ctx: Context<'a>, F: Inject<'a, Ctx>> Resolver<'a, Ctx> for InjectedResolver<'a, Ctx, F> {
    fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
        let inject = self.inject.clone();
        self.inject.inject(
            self.resolver
                .clone()
                .resolve_map(address, |resolved| match resolved {
                    Ok((source, resolver)) => {
                        Ok((source, InjectedResolver { resolver, inject }.into_rc()))
                    }
                    Err(e) => Err(e),
                }),
        )
    }
}