use std::{future::Future, marker::PhantomData, pin::Pin, thread::yield_now, time::Duration};

use treaty::{
    any::{any_trait, static_wrapper::OwnedStatic, AnyTrait, IndirectLtAny, LtTypeId},
    build_with, into_walker,
    protocol::{
        visitor::Value, AnyTraitSendObj, AsyncEffect, ControlFlowFor, Effect, SyncEffect, Visitor,
    },
    Build, Builder, Walker,
};

#[test]
fn demo() {
    let hook = Hook {
        inner: into_walker(true),
        _marker: PhantomData,
    };
    let x = build_with::<<bool as Build<_>>::Builder, _>(hook).unwrap();
    dbg!(x);
    todo!();
}

struct Hook<T, Effect> {
    inner: T,
    _marker: PhantomData<fn() -> Effect>,
}

struct VisitorHook<'a, 'ctx: 'a, E: Effect> {
    inner: E::Visitor<'a, 'ctx>,
}

impl<'ctx, T: Walker<'ctx, Effect = AsyncEffect> + Send> Walker<'ctx> for Hook<T, AsyncEffect>
where
    <T as Walker<'ctx>>::Error: Send,
    <T as Walker<'ctx>>::Output: Send,
{
    type Effect = T::Effect;

    type Error = T::Error;

    type Output = T::Output;

    fn walk<'a>(
        self,
        visitor: Visitor<'a, 'ctx, T::Effect>,
    ) -> ControlFlowFor<'a, Self::Effect, Self::Output, Self::Error>
    where
        Self: 'a,
    {
        let visitor: &'a mut (dyn AnyTrait<'ctx> + Send + 'a) = is_send(visitor);
        let inner: T = is_send(self.inner);

        let x = async move {
            let mut visitor = is_send(VisitorHook::<Self::Effect> {
                inner: is_send(visitor),
            });
            let flow: Pin<
                Box<dyn Future<Output = core::ops::ControlFlow<Self::Error, Self::Output>> + Send>,
            > = is_send(is_send(inner).walk(is_send(&mut visitor)));
            is_send(assert_send(is_send(flow)).await)
        };

        let y: Pin<
            Box<dyn Future<Output = core::ops::ControlFlow<Self::Error, Self::Output>> + Send>,
        > = Box::pin(assert_send(x));
        todo!();
    }
}

pub trait Captures<U> {}
impl<T: ?Sized, U> Captures<U> for T {}

pub fn make_async<'a, 'ctx, T: Walker<'ctx, Effect = AsyncEffect> + Send + 'a>(
    visitor: &'a mut (dyn AnyTrait<'ctx> + Send + 'a),
    inner: T,
) -> impl futures::Future<Output = ()> + Send + Captures<&'ctx ()> + 'a
where
    AsyncEffect: Send,
    T::Error: Send,
    T::Output: Send,
    T::Effect: Send,
{
    async move {
        let mut visitor = is_send(VisitorHook::<AsyncEffect> {
            inner: is_send(visitor),
        });
        // let flow: Pin<Box<dyn Future<Output = _> + Send>> =
        if false {
            let _: Pin<Box<dyn Future<Output = _> + Send>> =
                is_send(is_send(inner).walk(is_send(todo!())));
        }
        tokio::time::sleep(Duration::from_secs(1)).await;
        // is_send(assert_send(is_send(flow)).await);
        ()
    }
}

pub fn is_send<T: Send>(x: T) -> T {
    x
}

pub fn assert_send<T>(
    s: impl futures::Future<Output = T> + Send,
) -> impl futures::Future<Output = T> + Send {
    s
}

impl<'ctx, T: Walker<'ctx, Effect = SyncEffect>> Walker<'ctx> for Hook<T, SyncEffect> {
    type Effect = T::Effect;

    type Error = T::Error;

    type Output = T::Output;

    fn walk<'a>(
        self,
        visitor: Visitor<'a, 'ctx, T::Effect>,
    ) -> ControlFlowFor<'a, Self::Effect, Self::Output, Self::Error>
    where
        Self: 'a,
    {
        let mut visitor = VisitorHook::<Self::Effect> { inner: visitor };
        let flow = self.inner.walk(&mut visitor);
        flow
    }
}

impl<'b, 'ctx, E: Effect> AnyTrait<'ctx> for VisitorHook<'b, 'ctx, E> {
    fn upcast_to_id<'a>(
        &'a self,
        id: treaty::any::LtTypeId<'ctx>,
    ) -> Option<treaty::any::IndirectLtAny<'a, 'ctx, treaty::any::Ref>>
    where
        'ctx: 'a,
    {
        match id {
            id => self.inner.as_obj().upcast_to_id(id),
        }
    }

    fn upcast_to_id_mut<'a>(
        &'a mut self,
        id: treaty::any::LtTypeId<'ctx>,
    ) -> Option<treaty::any::IndirectLtAny<'a, 'ctx, treaty::any::Mut>>
    where
        'ctx: 'a,
    {
        match id {
            id if id == LtTypeId::of::<dyn Value<'a, OwnedStatic<bool>> + 'a>() => {
                if self.inner.as_obj_mut().upcast_to_id_mut(id).is_some() {
                    Some(IndirectLtAny::<'a, 'ctx, _>::new::<
                        dyn Value<'a, OwnedStatic<bool>> + 'a,
                    >(self as _))
                } else {
                    None
                }
            }
            id => self.inner.as_obj_mut().upcast_to_id_mut(id),
        }
    }
}

impl<'a, 'b, 'ctx, E: Effect> Value<'a, OwnedStatic<bool>> for VisitorHook<'b, 'ctx, E> {
    #[inline]
    fn visit(&'a mut self, OwnedStatic(value): OwnedStatic<bool>) -> ControlFlowFor<'a> {
        let visitor = self
            .inner
            .as_obj_mut()
            .upcast_mut::<dyn Value<'a, OwnedStatic<bool>> + 'a>()
            .unwrap();

        println!("Hooked bool: {}", value);
        visitor.visit(OwnedStatic(!value))
    }
}