use effectful::{
    bound::{Dynamic, No},
    effective::Effective,
    effective::NativeEffective,
    environment::{DynBind, EnvConfig, Environment, NativeForm},
    SendSync,
};
use serde::{de::MapAccess, Deserializer};

use crate::{
    any::{BorrowedStaticHrt, OwnedStatic, TempBorrowedStatic, TempBorrowedStaticHrt, TypeName},
    any_trait,
    hkt::Marker,
    protocol::{
        visitor::{
            request_hint, tags, visit_sequence, visit_value, EffectiveVisitExt as _, SequenceScope,
            TagConst, TagKnown, TagProto, ValueKnown, ValueProto, VisitResult,
        },
        walker::hint::{DynVisitorWith, Hint, HintMeta, HintProto, MetaHint, MetaKnown},
        DynVisitor, DynWalker,
    },
    walkers::core::int::IntegerWalkerError,
    Flow, Walker,
};

#[derive(SendSync)]
pub struct DeserializerWalker<'ctx, T, E>
where
    T: Deserializer<'ctx>,
{
    inner: Inner<'ctx, T>,
    _marker: Marker<E>,
}

#[derive(SendSync)]
enum Inner<'ctx, T>
where
    T: Deserializer<'ctx>,
{
    Temp,
    Init(Dynamic<T>),
    Error(DeserializerWalkerError<'ctx, T>),
    Done,
}

impl<'ctx, T, E: Environment> DeserializerWalker<'ctx, T, E>
where
    T: Deserializer<'ctx>,
{
    pub fn new(deserializer: T) -> Self {
        Self {
            inner: Inner::Init(Dynamic(deserializer)),
            _marker: Default::default(),
        }
    }
}

#[derive(SendSync)]
pub struct DeserializerWalkerError<'ctx, T>
where
    T: Deserializer<'ctx>,
{
    inner: VisitorError<'ctx, T>,
}

impl<'ctx, T> core::fmt::Debug for DeserializerWalkerError<'ctx, T>
where
    T: Deserializer<'ctx>,
{
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match &self.inner {
            VisitorError::u8(err) => write!(f, "{}", err),
            VisitorError::u16(err) => write!(f, "{}", err),
            VisitorError::u32(err) => write!(f, "{}", err),
            VisitorError::u64(err) => write!(f, "{}", err),
            VisitorError::u128(err) => write!(f, "{}", err),
            VisitorError::usize(err) => write!(f, "{}", err),
            VisitorError::i8(err) => write!(f, "{}", err),
            VisitorError::i16(err) => write!(f, "{}", err),
            VisitorError::i32(err) => write!(f, "{}", err),
            VisitorError::i64(err) => write!(f, "{}", err),
            VisitorError::i128(err) => write!(f, "{}", err),
            VisitorError::isize(err) => write!(f, "{}", err),
            VisitorError::Serde(err) => write!(f, "{}", err.0),
        }
    }
}

impl<'ctx, T> core::fmt::Display for DeserializerWalkerError<'ctx, T>
where
    T: Deserializer<'ctx>,
{
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{:?}", self)
    }
}

impl<'ctx, T, E: Environment> Walker<'ctx, E> for DeserializerWalker<'ctx, T, E>
where
    T: Deserializer<'ctx> + 'ctx,
    E: EnvConfig<NeedSend = No, NeedSync = No>,
{
    type Error = DeserializerWalkerError<'ctx, T>;

    type Output = ();

    fn walk<'visitor: 'effect, 'effect>(
        self,
        visitor: DynVisitor<'visitor, 'ctx, E>,
    ) -> NativeForm<'effect, Result<Self::Output, Self::Error>, E>
    where
        Self: 'effect,
    {
        E::value((self, visitor))
            .update((), |_, (this, visitor)| {
                // Serde deserializers usually prefer that a hint method is called rather than _any.
                // As such we need to ask the visitor for a hint first.
                request_hint::<E>(visitor.cast(), DynWalker(this))
                    .map((), |_, x| VisitResult::unit_skipped(x))
                    .cast()
            })
            .if_not_finished((), |_, (this, visitor)| {
                this.call_deserialize(|deserializer| {
                    deserializer.deserialize_any(Visitor::<T, E>::new(visitor.cast(), "any"))
                })
                .cast()
            })
            .map((), |_, ((this, _), _)| match this.inner {
                Inner::Temp => todo!(),
                Inner::Init(_) => todo!(),
                Inner::Error(err) => Err(err),
                Inner::Done => Ok(()),
            })
            .cast()
    }
}

any_trait! {
    impl['ctx, T][E] DeserializerWalker<'ctx, T, E> = [
        HintProto<ValueProto<OwnedStatic<bool>, E>>,
        HintProto<ValueProto<OwnedStatic<i8>, E>>,
        HintProto<ValueProto<OwnedStatic<i16>, E>>,
        HintProto<ValueProto<OwnedStatic<i32>, E>>,
        HintProto<ValueProto<OwnedStatic<i64>, E>>,
        HintProto<ValueProto<OwnedStatic<i128>, E>>,
        HintProto<ValueProto<OwnedStatic<u8>, E>>,
        HintProto<ValueProto<OwnedStatic<u16>, E>>,
        HintProto<ValueProto<OwnedStatic<u32>, E>>,
        HintProto<ValueProto<OwnedStatic<u64>, E>>,
        HintProto<ValueProto<OwnedStatic<u128>, E>>,
        HintProto<ValueProto<OwnedStatic<char>, E>>,
        HintProto<TagProto<tags::Map, E>>,
    ] where
        T: Deserializer<'ctx> + 'ctx,
        E: Environment<NeedSend = No, NeedSync = No>
}

impl<'ctx, T, E: Environment> DeserializerWalker<'ctx, T, E>
where
    T: Deserializer<'ctx> + 'ctx,
    E: EnvConfig<NeedSend = No, NeedSync = No>,
{
    fn call_deserialize<'visitor: 'e, 'e, F>(&'e mut self, f: F) -> NativeForm<'e, VisitResult, E>
    where
        'ctx: 'visitor,
        F: FnOnce(
            T,
        ) -> Result<
            NativeForm<'visitor, (Option<VisitorError<'ctx, T>>, VisitResult), E>,
            T::Error,
        >,
    {
        match core::mem::replace(&mut self.inner, Inner::Temp) {
            Inner::Init(deserializer) => {
                match f(deserializer.0) {
                    Ok(eff) => eff
                        .map(self, |this, result| match result {
                            (None, result) => {
                                // Return the flow the visitor decided on.
                                this.inner = Inner::Done;
                                result
                            }
                            (Some(err), _) => {
                                this.inner = Inner::Error(DeserializerWalkerError { inner: err });
                                Flow::Err.into()
                            }
                        })
                        .cast::<()>(),
                    Err(err) => {
                        self.inner = Inner::Error(DeserializerWalkerError {
                            inner: VisitorError::Serde(Dynamic(err)),
                        });
                        E::value(Flow::Err.into()).cast()
                    }
                }
            }
            inner => {
                // We really shouldn't be in this situation...
                self.inner = inner;
                E::value(VisitResult::Skipped(())).cast()
            }
        }
    }
}

macro_rules! impl_hints {
    (<$ctx:lifetime, $T:ident, $E:ident> $($proto:ty => $method:ident: $type:ty),* $(,)?) => {
        $(impl<$ctx, $T, $E: Environment> Hint<$ctx, $proto> for DeserializerWalker<$ctx, $T, $E>
        where
            $T: Deserializer<$ctx> + $ctx,
            $E: EnvConfig<NeedSend = No, NeedSync = No>
        {
            fn hint<'this: 'e, 'visitor: 'e, 'hint: 'e, 'e>(
                &'this mut self,
                visitor: DynVisitorWith<'visitor, $ctx, $proto>,
                _hint: MetaHint<'hint, $ctx, $proto>,
            ) -> NativeForm<'e, VisitResult, $E>
            where
                $ctx: 'this + 'visitor + 'hint + 'e,
            {
                self.call_deserialize(|deserializer| deserializer.$method(Visitor::<$T, $E>::new(visitor.into_inner(), stringify!($type))))
            }

            fn known<'a>(
                &'a mut self,
                _hint: &'a MetaHint<'a, 'ctx, $proto>,
            ) -> NativeForm<'a, Result<MetaKnown<'a, 'ctx, $proto>, ()>, $E> {
                E::value(Ok(ValueKnown { preview: None })).cast()
            }
        })*
    };
}

impl_hints! {
    <'ctx, T, E>
    ValueProto<OwnedStatic<bool>, E> => deserialize_bool: bool,
    ValueProto<OwnedStatic<i8>, E> => deserialize_i8: i8,
    ValueProto<OwnedStatic<i16>, E> => deserialize_i16: i16,
    ValueProto<OwnedStatic<i32>, E> => deserialize_i32: i32,
    ValueProto<OwnedStatic<i64>, E> => deserialize_i64: i64,
    ValueProto<OwnedStatic<i128>, E> => deserialize_i128: i128,
    ValueProto<OwnedStatic<u8>, E> => deserialize_u8: u8,
    ValueProto<OwnedStatic<u16>, E> => deserialize_u16: u16,
    ValueProto<OwnedStatic<u32>, E> => deserialize_u32: u32,
    ValueProto<OwnedStatic<u64>, E> => deserialize_u64: u64,
    ValueProto<OwnedStatic<u128>, E> => deserialize_u128: u128,
    ValueProto<OwnedStatic<f32>, E> => deserialize_f32: f32,
    ValueProto<OwnedStatic<f64>, E> => deserialize_f64: f64,
    ValueProto<OwnedStatic<char>, E> => deserialize_char: char,
    ValueProto<TempBorrowedStaticHrt<str>, E> => deserialize_str: &str,
    ValueProto<BorrowedStaticHrt<str>, E> => deserialize_str: &str,
    ValueProto<OwnedStatic<String>, E> => deserialize_string: String,
    ValueProto<TempBorrowedStaticHrt<[u8]>, E> => deserialize_bytes: &[u8],
    ValueProto<BorrowedStaticHrt<[u8]>, E> => deserialize_bytes: &[u8],
    ValueProto<OwnedStatic<Vec<u8>>, E> => deserialize_byte_buf: Vec<u8>,
    // ...
}

impl<'ctx, T, E: Environment> Hint<'ctx, TagProto<tags::Map, E>> for DeserializerWalker<'ctx, T, E>
where
    T: Deserializer<'ctx> + 'ctx,
    E: EnvConfig<NeedSend = No, NeedSync = No>,
{
    fn hint<'this: 'e, 'visitor: 'e, 'hint: 'e, 'e>(
        &'this mut self,
        visitor: DynVisitorWith<'visitor, 'ctx, TagProto<tags::Map, E>>,
        hint: MetaHint<'hint, 'ctx, TagProto<tags::Map, E>>,
    ) -> NativeForm<'e, VisitResult, <TagProto<tags::Map, E> as HintMeta>::Effect>
    where
        'ctx: 'this + 'visitor + 'hint + 'e,
    {
        // self.call_deserialize(|deserializer| {
        //     todo!()
        // })
        E::value(VisitResult::Skipped(())).cast()
    }

    fn known<'a>(
        &'a mut self,
        _hint: &'a MetaHint<'a, 'ctx, TagProto<tags::Map, E>>,
    ) -> NativeForm<
        'a,
        Result<MetaKnown<'a, 'ctx, TagProto<tags::Map, E>>, ()>,
        <TagProto<tags::Map, E> as HintMeta>::Effect,
    > {
        E::value(Ok(TagKnown {
            kind_available: Some(true),
        }))
        .cast()
    }
}

#[allow(non_camel_case_types, unused)]
#[derive(SendSync)]
enum VisitorError<'ctx, T>
where
    T: Deserializer<'ctx>,
{
    u8(IntegerWalkerError<u8>),
    u16(IntegerWalkerError<u16>),
    u32(IntegerWalkerError<u32>),
    u64(IntegerWalkerError<u64>),
    u128(IntegerWalkerError<u128>),
    usize(IntegerWalkerError<usize>),
    i8(IntegerWalkerError<i8>),
    i16(IntegerWalkerError<i16>),
    i32(IntegerWalkerError<i32>),
    i64(IntegerWalkerError<i64>),
    i128(IntegerWalkerError<i128>),
    isize(IntegerWalkerError<isize>),
    Serde(Dynamic<T::Error>),
}

#[derive(SendSync)]
struct Visitor<'temp, 'ctx, T, E: Environment>
where
    T: Deserializer<'ctx>,
{
    wanted: &'static str,
    visitor: DynVisitor<'temp, 'ctx, E>,
    _marker: Marker<(T, E)>,
}

impl<'temp, 'ctx, T, E: Environment> Visitor<'temp, 'ctx, T, E>
where
    T: Deserializer<'ctx>,
{
    pub fn new(visitor: DynVisitor<'temp, 'ctx, E>, wanted: &'static str) -> Self {
        Self {
            wanted,
            visitor,
            _marker: Default::default(),
        }
    }
}

macro_rules! impl_visits {
    (@owned $($method:ident: $type:ty),* $(,)?) => {
        $(fn $method<Err>(self, v: $type) -> Result<Self::Value, Err>
        where
            Err: serde::de::Error,
        {
            // Visit the treaty visitor with the value serde gave.
            Ok(visit_value::<_, E>(self.visitor, OwnedStatic(v)).map((), |_, result| (None, result.unit_skipped())).cast())
        })*
    };
    // Many serde deserializers (like serde_json) don't follow the hint given when visiting.
    // So we need to use the full integer walker that can visit all the types.
    (@int $($method:ident: $type:ident),* $(,)?) => {
        $(fn $method<Err>(self, v: $type) -> Result<Self::Value, Err>
        where
            Err: serde::de::Error,
        {
            // This will attempt every native integer type until the visitor accepts one of them.
            Ok($crate::walkers::core::int::IntegerWalker::<_, E>::new(v).walk(self.visitor).map((), |_, result| match result {
                Ok(_) => (None, Flow::Done.into()),
                Err(err) => (Some(VisitorError::$type(err)), Flow::Err.into())
            }).cast())
        })*
    };
}

impl<'temp, 'ctx, T: Deserializer<'ctx> + 'temp, E: Environment> serde::de::Visitor<'ctx>
    for Visitor<'temp, 'ctx, T, E>
where
    E: EnvConfig<NeedSend = No, NeedSync = No>,
{
    type Value = NativeForm<'temp, (Option<VisitorError<'ctx, T>>, VisitResult), E>;

    fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        formatter.write_str(&self.wanted)
    }

    impl_visits! {
        @owned
        visit_bool: bool,
        visit_char: char,
        visit_string: String,
        visit_byte_buf: Vec<u8>,
        // ...
    }

    impl_visits! {
        @int
        visit_i8: i8,
        visit_i16: i16,
        visit_i32: i32,
        visit_i64: i64,
        visit_i128: i128,
        visit_u8: u8,
        visit_u16: u16,
        visit_u32: u32,
        visit_u64: u64,
        visit_u128: u128,
    }

    fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
    where
        A: MapAccess<'ctx>,
    {
        E::value((self, MapScope { map: Dynamic(map) })).update((), |_, (this, scope)| {
            visit_sequence(this.visitor.cast(), scope).cast()
        });

        todo!()
    }
}

#[derive(SendSync)]
struct MapScope<A> {
    map: Dynamic<A>,
}

impl<'ctx, A, E: Environment> SequenceScope<'ctx, E> for MapScope<A>
where
    E: EnvConfig<NeedSend = No, NeedSync = No>,
    A: MapAccess<'ctx>,
{
    fn size_hint(&mut self) -> NativeForm<'_, (usize, Option<usize>), E> {
        E::value((0, self.map.0.size_hint())).cast()
    }

    fn next<'a: 'c, 'b: 'c, 'c>(
        &'a mut self,
        visitor: DynVisitor<'b, 'ctx, E>,
    ) -> NativeForm<'c, Flow, E>
    where
        'ctx: 'c + 'a + 'b,
    {
        todo!()
    }
}