//! [`Protocol`] for giving a visitor an owned value.
//!
//! In some sense, this is the most basic protocol.

use core::ops::ControlFlow;

use crate::{
    any::{TypeName, TypeNameable},
    hkt::hkt,
    nameable,
    protocol::{any_t, walker::HintMeta, Effect, SyncEffect, Yield},
};

/// Trait object for the [`Value`] protocol.
///
/// Types implementing the [`Value`] protocol will implement this trait.
pub trait Value<'ctx, T, E: Effect<'ctx, ControlFlow<(), ()>>> {
    /// Visit a value of type `T`.
    ///
    /// Use this to give a value to a visitor. Its expected that a walker
    /// only calls this once per usage of the trait object, but that is not
    /// forced.
    ///
    /// If a [`ControlFlow::Break`] is returned then the walker
    /// should stop walking as soon as possible as there has likely been
    /// and error.
    fn visit<'a>(&'a mut self, value: T) -> Yield<'a, 'ctx, ControlFlow<(), ()>, E>
    where
        'ctx: 'a;
}

nameable! {
    pub struct Name['a, 'ctx, T, E];

    impl [T::Name, E] for dyn Value<'ctx, T, E> + 'a where {
        T: TypeNameable<'a, 'ctx> + ?Sized,
        E: Effect<'ctx, ControlFlow<(), ()>>,
        'ctx: 'a,
    }

    impl [T, E] where dyn Value<'ctx, T::Nameable, E> + 'a {
        T: TypeName<'a, 'ctx> + ?Sized,
        E: Effect<'ctx, ControlFlow<(), ()>>,
        'ctx: 'a,
    }
}

hkt!((any_t): for<'a, 'ctx> pub KnownHkt => ());

// This enrolls the Value protocol into the walker hint system.
impl<'a, 'ctx: 'a, T, E: Effect<'ctx, ControlFlow<(), ()>>> HintMeta<'ctx>
    for dyn Value<'ctx, T, E> + 'a
{
    type Known = KnownHkt<'ctx>;

    type Hint = ();
}

#[cfg(test)]
mod test {
    use core::ops::ControlFlow;

    use crate::{
        any::{
            static_wrapper::{BorrowedMutStatic, BorrowedStatic, OwnedStatic},
            AnyTrait,
        },
        any_trait,
    };

    use super::*;

    #[test]
    fn visit() {
        struct Visitor(Option<i32>);

        impl<'ctx> Value<'ctx, OwnedStatic<i32>> for Visitor {
            fn visit<'a>(
                &'a mut self,
                OwnedStatic(value): OwnedStatic<i32>,
            ) -> core::ops::ControlFlow<()>
            where
                'ctx: 'a,
            {
                self.0 = Some(value);
                ControlFlow::Continue(())
            }
        }

        impl<'ctx> Value<'ctx, BorrowedStatic<'ctx, i32>> for Visitor {
            fn visit<'a>(
                &'a mut self,
                BorrowedStatic(value): BorrowedStatic<'ctx, i32>,
            ) -> core::ops::ControlFlow<()>
            where
                'ctx: 'a,
            {
                self.0 = Some(*value);
                ControlFlow::Continue(())
            }
        }

        any_trait! {
            impl['a, 'ctx] Visitor = [
                dyn Value<'ctx, OwnedStatic<i32>> + 'a,
                dyn Value<'ctx, BorrowedStatic<'ctx, i32>> + 'a,
            ]
        }

        let mut v = Visitor(None);
        let object: &mut dyn AnyTrait<'_> = &mut v;
        object
            .upcast_mut::<dyn Value<'_, OwnedStatic<i32>>>()
            .unwrap()
            .visit(OwnedStatic(42));

        assert_eq!(v.0, Some(42));

        let object: &mut dyn AnyTrait<'_> = &mut v;
        object
            .upcast_mut::<dyn Value<'_, BorrowedStatic<'_, i32>>>()
            .unwrap()
            .visit(BorrowedStatic(&101));

        assert_eq!(v.0, Some(101));
    }

    #[test]
    fn visit_borrowed() {
        struct Visitor<'ctx>(Option<&'ctx mut String>);

        impl<'ctx> Value<'ctx, BorrowedMutStatic<'ctx, String>> for Visitor<'ctx> {
            fn visit<'a>(
                &'a mut self,
                BorrowedMutStatic(value): BorrowedMutStatic<'ctx, String>,
            ) -> ControlFlow<()>
            where
                'ctx: 'a,
            {
                self.0 = Some(value);
                ControlFlow::Continue(())
            }
        }

        any_trait! {
            impl['a, 'ctx] Visitor<'ctx> = [
                dyn Value<'ctx, BorrowedMutStatic<'ctx, String>> + 'a,
            ]
        }

        let mut v = Visitor(None);

        let mut y = String::from("abc");
        let object: &mut dyn AnyTrait<'_> = &mut v;
        object
            .upcast_mut::<dyn Value<'_, _>>()
            .unwrap()
            .visit(BorrowedMutStatic(&mut y));

        v.0.unwrap().push_str("def");
        assert_eq!(y, "abcdef");
    }

    #[test]
    fn visit_borrowed_unsized() {
        struct Visitor<'ctx>(Option<&'ctx str>);

        impl<'ctx> Value<'ctx, BorrowedStatic<'ctx, str>> for Visitor<'ctx> {
            fn visit<'a>(
                &'a mut self,
                BorrowedStatic(value): BorrowedStatic<'ctx, str>,
            ) -> ControlFlow<()>
            where
                'ctx: 'a,
            {
                self.0 = Some(value);
                ControlFlow::Continue(())
            }
        }

        any_trait! {
            impl['a, 'ctx] Visitor<'ctx> = [
                dyn Value<'ctx, BorrowedStatic<'ctx, str>> + 'a,
            ]
        }

        let mut v = Visitor(None);

        let y = String::from("abc");
        let object: &mut dyn AnyTrait<'_> = &mut v;
        object
            .upcast_mut::<dyn Value<'_, BorrowedStatic<'_, str>> + '_>()
            .unwrap()
            .visit(BorrowedStatic(&y));

        assert_eq!(v.0, Some("abc"));
    }
}