use core::{any::TypeId, marker::PhantomData, ops::ControlFlow};

use crate::{
    any::{static_wrapper::OwnedStatic, LtTypeId},
    any_trait,
    effect::{Effect, Future},
    never::Never,
    protocol::{
        self,
        visitor::{
            request_hint::{DynRequestHint, RequestHint},
            sequence::{DynSequence, Sequence},
            tag::{Dyn, DynTag, Tag, DynFlow},
            value::{DynValue, Value},
        },
    },
    DynWalker, Flow,
};

pub struct Visitor<E>(usize, PhantomData<fn() -> E>);

any_trait! {
    impl['a, 'ctx, E] Visitor<E> = [
        DynRequestHint<'a, 'ctx, E>,
        DynTag<'a, 'ctx, Dyn, E>,
        DynValue<'a, 'ctx, OwnedStatic<&'static str>, E>,
        DynValue<'a, 'ctx, OwnedStatic<TypeId>, E>,
        DynValue<'a, 'ctx, OwnedStatic<usize>, E>,
        DynValue<'a, 'ctx, OwnedStatic<bool>, E>,
        // DynValue<'a, 'ctx, OwnedStatic<&'static [&'static str]>, E>,
        DynSequence<'a, 'ctx, E>,
    ] else fallback where E: Effect<'ctx>
}

fn fallback(id: LtTypeId<'_>) {
    // println!("Unknown trait: {}", id);
}

impl<'ctx, E: Effect<'ctx>> Visitor<E> {
    pub fn new() -> Self {
        Self(0, PhantomData)
    }

    fn tab(&self) {
        for _ in 0..self.0 {
            print!("  ");
        }
    }
}

impl<'ctx, E: Effect<'ctx>> RequestHint<'ctx, E> for Visitor<E> {
    fn request_hint<'a>(
        &'a mut self,
        _walker: crate::protocol::Walker<'a, 'ctx>,
    ) -> Future<'a, 'ctx, Flow, E> {
        self.tab();
        println!("Visit request hint (no hint given)");
        E::ready(Flow::Continue)
    }
}

impl<'ctx, E: Effect<'ctx>> Tag<'ctx, Dyn, E> for Visitor<E> {
    fn visit<'a>(
        &'a mut self,
        kind: Dyn,
        walker: DynWalker<'a, 'ctx, E>,
    ) -> Future<'a, 'ctx, DynFlow, E> {
        self.tab();
        println!("Visit tag: {}", kind.0);

        E::wrap(async {
            self.0 += 1;
            let result = walker.walk(self).await;
            self.0 -= 1;
            // DynFlow::Flow(result)
            DynFlow::Skipped
        })
    }
}

impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<&'static str>, E> for Visitor<E> {
    fn visit(
        &'a mut self,
        OwnedStatic(value): OwnedStatic<&'static str>,
    ) -> Future<'a, 'ctx, Flow, E>
    where
        Self: 'a,
    {
        self.tab();
        println!("Visit static str: {:?}", value);
        E::ready(Flow::Continue)
    }
}

impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<usize>, E> for Visitor<E> {
    fn visit(&'a mut self, OwnedStatic(value): OwnedStatic<usize>) -> Future<'a, 'ctx, Flow, E>
    where
        Self: 'a,
    {
        self.tab();
        println!("Visit usize: {}", value);
        E::ready(Flow::Continue)
    }
}

impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<bool>, E> for Visitor<E> {
    fn visit(&'a mut self, OwnedStatic(value): OwnedStatic<bool>) -> Future<'a, 'ctx, Flow, E>
    where
        Self: 'a,
    {
        self.tab();
        println!("Visit bool: {}", value);
        E::ready(Flow::Continue)
    }
}

impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<&'static [&'static str]>, E>
    for Visitor<E>
{
    fn visit(
        &'a mut self,
        OwnedStatic(value): OwnedStatic<&'static [&'static str]>,
    ) -> Future<'a, 'ctx, Flow, E>
    where
        Self: 'a,
    {
        self.tab();
        println!("Visit static slice of static str: {:?}", value);
        E::ready(Flow::Continue)
    }
}

impl<'a, 'ctx: 'a, E: Effect<'ctx>> Value<'a, 'ctx, OwnedStatic<TypeId>, E> for Visitor<E> {
    fn visit(&'a mut self, OwnedStatic(value): OwnedStatic<TypeId>) -> Future<'a, 'ctx, Flow, E>
    where
        Self: 'a,
    {
        self.tab();
        println!("Visit type ID: {:?}", value);
        E::ready(Flow::Continue)
    }
}

impl<'ctx, E: Effect<'ctx>> Sequence<'ctx, E> for Visitor<E> {
    fn visit<'a>(
        &'a mut self,
        scope: protocol::visitor::sequence::DynSequenceScope<'a, 'ctx, E>,
    ) -> Future<'a, 'ctx, Flow, E> {
        self.tab();
        E::wrap(async {
            println!("Visit sequence, size hint: {:?}", scope.size_hint().await);
            self.0 += 1;

            let mut index = 0;
            let flow = loop {
                self.tab();
                println!("Calling next: {}", index);
                self.0 += 1;
                match scope.next(self).await {
                    Flow::Done => {
                        self.tab();
                        println!("Sequence done");
                        break Flow::Continue;
                    }
                    Flow::Continue => {}
                    Flow::Break => break Flow::Break,
                }
                index += 1;
                self.0 -= 1;
            };
            self.0 -= 2;
            flow
        })
    }
}