pub enum ControlFlow {
    Done,
    Error,
}

pub mod hint {
    use crate::protocol::{Implementer, Protocol};

    pub enum ControlFlow {
        HintGiven,
        NoHint,
        Error,
    }

    pub trait Object<'ctx> {
        fn request_hint(&mut self, hints: &mut dyn Implementer<'ctx>) -> ControlFlow;
    }

    pub enum RequestHint {}

    impl Protocol for RequestHint {
        type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
    }

    pub trait HintObject<'ctx> {
        fn hint(&mut self, visitor: &mut dyn Implementer<'ctx>) -> ControlFlow;
    }
}

pub mod recoverable {
    use crate::protocol::{Implementer, Protocol};

    use super::{hint::HintObject, ControlFlow};

    pub trait Accessor<'ctx> {
        fn new_walk(&mut self, visitor: &mut dyn Implementer<'ctx>) -> ControlFlow;
    }

    pub trait Object<'ctx> {
        fn visit(&mut self, accessor: &mut dyn Accessor<'ctx>) -> ControlFlow;
    }

    pub enum Recoverable {}

    impl Protocol for Recoverable {
        type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
    }

    pub enum Hint {}

    impl Protocol for Hint {
        type Object<'a, 'ctx: 'a> = &'a mut dyn HintObject<'ctx>;
    }
}

pub mod sequence {
    use crate::protocol::{Implementer, Protocol};

    pub enum ControlFlow {
        Done,
        Continue,
        Error,
    }

    pub trait Accessor<'ctx> {
        fn next(&mut self, visitor: &mut dyn Implementer<'ctx>) -> ControlFlow;
    }

    pub trait Object<'ctx> {
        fn visit(&mut self, accessor: &mut dyn Accessor<'ctx>) -> super::ControlFlow;
    }

    pub enum Sequence {}

    impl Protocol for Sequence {
        type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
    }

    pub trait HintObject<'ctx> {
        fn hint(&mut self, visitor: &mut dyn Implementer<'ctx>) -> super::ControlFlow;

        fn len(&mut self) -> (usize, Option<usize>) {
            (0, None)
        }
    }

    pub enum Hint {}

    impl Protocol for Hint {
        type Object<'a, 'ctx: 'a> = &'a mut dyn HintObject<'ctx>;
    }
}

pub mod bool {
    use crate::protocol::Protocol;

    use super::{hint::HintObject, ControlFlow};

    pub trait Object<'ctx> {
        fn visit(&mut self, value: bool) -> ControlFlow;
    }

    pub enum Bool {}

    impl Protocol for Bool {
        type Object<'a, 'ctx: 'a> = &'a mut dyn Object<'ctx>;
    }

    pub enum Hint {}

    impl Protocol for Hint {
        type Object<'a, 'ctx: 'a> = &'a mut dyn HintObject<'ctx>;
    }
}

/*
pub mod map {
    use crate::{protocol::Protocol, ControlFlow, Visitor};

    pub struct Hint {
        pub min_len: Option<usize>,
        pub max_len: Option<usize>,
    }

    pub struct Known {
        pub len: Option<usize>,
    }

    pub trait Accessor<'ctx> {
        fn next_key(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
        fn value(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
    }

    pub enum Map {}

    impl Protocol for Map {
        type Hint<'walking, 'ctx: 'walking> = Hint;

        type Known<'walking, 'ctx: 'walking> = Known;

        type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn Accessor<'ctx>;
    }
}

pub mod reference {
    use core::{any::Any, marker::PhantomData};

    use crate::protocol::Protocol;

    pub enum Kind {
        Walking,
        Context,
        Static,
    }

    pub struct Hint {
        pub kind: Option<Kind>,

        pub min_len: Option<usize>,
        pub max_len: Option<usize>,
    }

    pub struct Known {
        pub kind: Option<Kind>,

        /// For dynamically sized types.
        pub len: Option<usize>,
    }

    pub enum Ref<'walking, 'ctx, T: ?Sized + Any> {
        Walking(&'walking T),
        Context(&'ctx T),
        Static(&'static T),
    }

    pub enum Mut<'walking, 'ctx, T: ?Sized + Any> {
        Walking(&'walking mut T),
        Context(&'ctx mut T),
        Static(&'static mut T),
    }

    pub struct Reference<T: ?Sized + Any>(PhantomData<fn() -> T>);

    pub struct ReferenceMut<T: ?Sized + Any>(PhantomData<fn() -> T>);

    impl<T: ?Sized + Any> Protocol for Reference<T> {
        type Hint<'walking, 'ctx: 'walking> = Hint;

        type Known<'walking, 'ctx: 'walking> = Known;

        type Accessor<'walking, 'ctx: 'walking> = Ref<'walking, 'ctx, T>;
    }

    impl<T: ?Sized + Any> Protocol for ReferenceMut<T> {
        type Hint<'walking, 'ctx: 'walking> = Hint;

        type Known<'walking, 'ctx: 'walking> = Known;

        type Accessor<'walking, 'ctx: 'walking> = Mut<'walking, 'ctx, T>;
    }
}

pub mod bool {
    use crate::protocol::Protocol;

    pub enum Bool {}

    impl Protocol for Bool {
        type Hint<'walking, 'ctx: 'walking> = ();

        type Known<'walking, 'ctx: 'walking> = ();

        type Accessor<'walking, 'ctx: 'walking> = bool;
    }
}

pub mod int {
    use core::num::TryFromIntError;

    use crate::protocol::Protocol;

    pub enum Kind {
        I8,
        I16,
        I32,
        I64,
        I128,
        Isize,
        U8,
        U16,
        U32,
        U64,
        U128,
        Usize,
    }

    pub enum Value {
        I8(i8),
        I16(i16),
        I32(i32),
        I64(i64),
        I128(i128),
        Isize(isize),
        U8(u8),
        U16(u16),
        U32(u32),
        U64(u64),
        U128(u128),
        Usize(usize),
    }

    pub enum Int {}

    impl Protocol for Int {
        type Hint<'walking, 'ctx: 'walking> = Option<Kind>;

        type Known<'walking, 'ctx: 'walking> = Option<Kind>;

        type Accessor<'walking, 'ctx: 'walking> = Value;
    }

    impl From<i8> for Value {
        fn from(value: i8) -> Self {
            Self::I8(value)
        }
    }

    impl From<i16> for Value {
        fn from(value: i16) -> Self {
            Self::I16(value)
        }
    }

    impl From<i32> for Value {
        fn from(value: i32) -> Self {
            Self::I32(value)
        }
    }

    impl From<i64> for Value {
        fn from(value: i64) -> Self {
            Self::I64(value)
        }
    }

    impl From<i128> for Value {
        fn from(value: i128) -> Self {
            Self::I128(value)
        }
    }

    impl From<isize> for Value {
        fn from(value: isize) -> Self {
            Self::Isize(value)
        }
    }

    impl From<u8> for Value {
        fn from(value: u8) -> Self {
            Self::U8(value)
        }
    }

    impl From<u16> for Value {
        fn from(value: u16) -> Self {
            Self::U16(value)
        }
    }

    impl From<u32> for Value {
        fn from(value: u32) -> Self {
            Self::U32(value)
        }
    }

    impl From<u64> for Value {
        fn from(value: u64) -> Self {
            Self::U64(value)
        }
    }

    impl From<u128> for Value {
        fn from(value: u128) -> Self {
            Self::U128(value)
        }
    }

    impl From<usize> for Value {
        fn from(value: usize) -> Self {
            Self::Usize(value)
        }
    }

    impl TryFrom<Value> for i8 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::I8(value) => Ok(value),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
                Value::U8(value) => value.try_into(),
                Value::U16(value) => value.try_into(),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for i16 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::I8(value) => Ok(value.into()),
                Value::I16(value) => Ok(value),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => value.try_into(),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for i32 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::I8(value) => Ok(value.into()),
                Value::I16(value) => Ok(value.into()),
                Value::I32(value) => Ok(value),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for i64 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::I8(value) => Ok(value.into()),
                Value::I16(value) => Ok(value.into()),
                Value::I32(value) => Ok(value.into()),
                Value::I64(value) => Ok(value),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => Ok(value.into()),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for i128 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::I8(value) => Ok(value.into()),
                Value::I16(value) => Ok(value.into()),
                Value::I32(value) => Ok(value.into()),
                Value::I64(value) => Ok(value.into()),
                Value::I128(value) => Ok(value),
                Value::Isize(value) => value.try_into(),
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => Ok(value.into()),
                Value::U64(value) => Ok(value.into()),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for isize {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::I8(value) => Ok(value.into()),
                Value::I16(value) => Ok(value.into()),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => Ok(value),
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => value.try_into(),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for u8 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::U8(value) => Ok(value),
                Value::U16(value) => value.try_into(),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
                Value::I8(value) => value.try_into(),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for u16 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
                Value::I8(value) => value.try_into(),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for u32 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => Ok(value),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
                Value::I8(value) => value.try_into(),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for u64 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => Ok(value.into()),
                Value::U64(value) => Ok(value),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => value.try_into(),
                Value::I8(value) => value.try_into(),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for u128 {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => Ok(value.into()),
                Value::U64(value) => Ok(value.into()),
                Value::U128(value) => Ok(value),
                Value::Usize(value) => value.try_into(),
                Value::I8(value) => value.try_into(),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
            }
        }
    }

    impl TryFrom<Value> for usize {
        type Error = TryFromIntError;

        fn try_from(value: Value) -> Result<Self, Self::Error> {
            match value {
                Value::U8(value) => Ok(value.into()),
                Value::U16(value) => Ok(value.into()),
                Value::U32(value) => value.try_into(),
                Value::U64(value) => value.try_into(),
                Value::U128(value) => value.try_into(),
                Value::Usize(value) => Ok(value),
                Value::I8(value) => value.try_into(),
                Value::I16(value) => value.try_into(),
                Value::I32(value) => value.try_into(),
                Value::I64(value) => value.try_into(),
                Value::I128(value) => value.try_into(),
                Value::Isize(value) => value.try_into(),
            }
        }
    }
}

pub mod optional {
    use crate::{protocol::Protocol, Walker};

    pub enum Kind {
        Some,
        None,
    }

    pub enum Optional {}

    impl Protocol for Optional {
        type Hint<'walking, 'ctx: 'walking> = Option<Kind>;

        type Known<'walking, 'ctx: 'walking> = Option<Kind>;

        type Accessor<'walking, 'ctx: 'walking> = Option<&'walking mut dyn Walker<'ctx>>;
    }
}

pub mod unit {
    use crate::protocol::Protocol;

    pub enum Unit {}

    impl Protocol for Unit {
        type Hint<'walking, 'ctx: 'walking> = ();

        type Known<'walking, 'ctx: 'walking> = ();

        type Accessor<'walking, 'ctx: 'walking> = ();
    }
}

pub mod r#struct {
    use core::any::TypeId;

    use crate::protocol::Protocol;

    pub struct Hint<'walking> {
        pub name: Option<&'static str>,
        pub type_name: Option<&'static str>,
        pub id: Option<TypeId>,
        pub fields: Option<&'walking [&'walking str]>,
    }

    pub struct Known<'walking> {
        pub name: Option<&'static str>,
        pub type_name: Option<&'static str>,
        pub id: Option<TypeId>,
        pub fields: Option<&'walking [&'walking str]>,
    }

    pub enum Struct {}

    impl Protocol for Struct {
        type Hint<'walking, 'ctx: 'walking> = Hint<'walking>;

        type Known<'walking, 'ctx: 'walking> = Known<'walking>;

        type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn super::map::Accessor<'ctx>;
    }
}

pub mod r#enum {
    use core::any::TypeId;

    use crate::{protocol::Protocol, ControlFlow, Visitor};

    pub struct Hint<'walking> {
        pub name: Option<&'static str>,
        pub type_name: Option<&'static str>,
        pub id: Option<TypeId>,
        pub variants: Option<&'walking [&'walking str]>,
    }

    pub struct Known<'walking> {
        pub name: Option<&'static str>,
        pub type_name: Option<&'static str>,
        pub id: Option<TypeId>,
        pub variant: Option<&'walking str>,
    }

    pub trait Accessor<'ctx> {
        fn variant(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
        fn walk(&mut self, visitor: &mut dyn Visitor<'ctx>) -> ControlFlow;
    }

    pub enum Enum {}

    impl Protocol for Enum {
        type Hint<'walking, 'ctx: 'walking> = Hint<'walking>;

        type Known<'walking, 'ctx: 'walking> = Known<'walking>;

        type Accessor<'walking, 'ctx: 'walking> = &'walking mut dyn Accessor<'ctx>;
    }
}
*/