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::{DynTag, Tag, TagDyn},
            value::{DynValue, Value},
            Status,
        },
    },
    DynWalker, Flow,
};

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

any_trait! {
    impl['a, 'ctx, E] Visitor<E> = [
        DynRequestHint<'a, 'ctx, E>,
        // DynRecoverable<'a, 'ctx, E>,
        DynTag<'a, 'ctx, TagDyn, 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) {
        if self.0 > 0 {
            for _ in 0..self.0 - 1 {
                print!(" | ");
            }
            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)");
        // println!("Visit request hint (hint for recoverable)");
        E::ready(Flow::Continue)
    }
}

impl<'ctx, E: Effect<'ctx>> Tag<'ctx, TagDyn, E> for Visitor<E> {
    fn visit<'a>(
        &'a mut self,
        kind: TagDyn,
        walker: DynWalker<'a, 'ctx, E>,
    ) -> Future<'a, 'ctx, Status, E> {
        E::wrap(async move {
            match kind.0 {
                crate::TAG_TYPE_NAME => {
                    self.tab();
                    println!("type name:");

                    self.0 += 1;
                    walker.walk(self).await;
                    self.0 -= 1;

                    Status::r#continue()
                }
                crate::TAG_KEY => {
                    self.tab();
                    println!("key:");

                    self.0 += 1;
                    walker.walk(self).await;
                    self.0 -= 1;

                    Status::r#continue()
                }
                crate::TAG_VALUE => {
                    self.tab();
                    println!("value:");

                    self.0 += 1;
                    walker.walk(self).await;
                    self.0 -= 1;

                    Status::r#continue()
                }
                _ => Status::skipped(),
            }
        })
    }
}

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

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

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

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

impl<'ctx, E: Effect<'ctx>> Value<'ctx, OwnedStatic<TypeId>, E> for Visitor<E> {
    fn visit<'a>(&'a mut self, OwnedStatic(value): OwnedStatic<TypeId>) -> Future<'a, 'ctx, Flow, E>
    {
        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> {
        E::wrap(async {
            self.tab();
            println!("sequence{:?}", scope.size_hint().await);

            self.0 += 1;

            let mut index = 0;
            let flow = loop {
                self.tab();
                println!("{}:", index);

                self.0 += 1;
                match scope.next(self).await {
                    Flow::Done => {
                        self.tab();
                        println!("<end>");
                        break Flow::Continue;
                    }
                    Flow::Continue => {}
                    Flow::Break => break Flow::Break,
                }
                index += 1;
                self.0 -= 1;
            };
            self.0 -= 2;
            flow
        })
    }
}