use core::marker::PhantomData;

use ::alloc::string::String;

use crate::{error::{BasicError, UniError}, WalkerHints, protocol::{ProtocolId, AnyHint, Hint, lookup_visit, lookup_hint, AnyVisit, Protocol}, protocols::{str::Str, self}, HintGiven, walk::{WalkOnce, WalkMut, Walk}, build::{Builder, Build}};

macro_rules! impl_walker {
    ($walker:ident) => {
        impl<'value, 'ctx: 'value, VisitorErr: 'ctx> crate::Walker<'value, 'ctx, VisitorErr>
            for $walker<'value, 'ctx>
        {
            type Error = BasicError;

            fn hints(&mut self) -> &mut dyn WalkerHints<'value, 'ctx, VisitorErr, Error = Self::Error> {
                self
            }
        }
    }
}

macro_rules! impl_hints {
    ($walker:ident, [$($protocol:ty),* $(,)?]) => {
        impl<'value, 'ctx: 'value, VisitorErr: 'ctx> WalkerHints<'value, 'ctx, VisitorErr>
            for $walker<'value, 'ctx>
        {
            type Error = BasicError;

            fn protocol(
                &mut self,
                id: ProtocolId,
            ) -> Option<AnyHint<'_, 'value, 'ctx, Self::Error, VisitorErr>> {
                match id {
                    $(id if id == ProtocolId::of::<$protocol>() => Some(AnyHint::new(self)),)?
                    _ => None,
                }
            }
        }
    }
}

pub struct WalkerOnce<'value, 'ctx: 'value>(String, PhantomData<&'value ()>);

impl_walker!(WalkerOnce);

impl<'value, 'ctx: 'value, VisitorErr: 'ctx> WalkerHints<'value, 'ctx, VisitorErr>
    for WalkerOnce<'value, 'ctx>
{
    type Error = BasicError;

    fn protocol(
        &mut self,
        id: ProtocolId,
    ) -> Option<AnyHint<'_, 'value, 'ctx, Self::Error, VisitorErr>> {
        match id {
            id if id == ProtocolId::of::<Str>() => Some(AnyHint::new(self)),
            _ => None,
        }
    }
}

impl<'value, 'ctx: 'value, VisitorErr: 'ctx> Hint<'value, 'ctx, Str, VisitorErr>
    for Walker<'value, 'ctx>
{
    type Error = BasicError;

    fn hint(
        &mut self,
        visitor: &mut dyn crate::Visitor<'value, 'ctx, Self::Error, Error = VisitorErr>,
        _hint: <Str as crate::protocol::Protocol<'value, 'ctx>>::Hint,
    ) -> Result<HintGiven, UniError<Self::Error, VisitorErr>> {
        lookup_visit::<Str, _, _>(visitor)
            .map_err(UniError::Walker)?
            .ok_or_else(|| UniError::Walker(BasicError("visitor is missing the str protocol")))?
            .visit(protocols::str::Data::Value(self.0))?;

        Ok(HintGiven)
    }

    fn known(
        &mut self,
        _hint: &<Str as crate::protocol::Protocol<'value, 'ctx>>::Hint,
    ) -> Result<<Str as crate::protocol::Protocol<'value, 'ctx>>::Known, BasicError> {
        Ok(protocols::str::Known {
            len: Some(self.0.len()),
            kind: Some(protocols::str::Kind::Value),
        })
    }
}

pub struct WalkerMut<'value, 'ctx: 'value>(&'value mut String, PhantomData<&'ctx ()>);
pub struct WalkerRef<'value, 'ctx: 'value>(&'value String, PhantomData<&'ctx ()>);

impl<'value, 'ctx: 'value, VisitorErr: 'ctx> WalkOnce<'value, 'ctx, VisitorErr> for &'ctx str {
    type Error = BasicError;
    type Walker = Walker<'value, 'ctx>;

    fn into_walker(self) -> Self::Walker {
        Walker(self, PhantomData)
    }
}

impl<'value, 'ctx: 'value, VisitorErr: 'ctx> WalkMut<'value, 'ctx, VisitorErr> for &'ctx str {
    type ErrorMut = BasicError;
    type WalkerMut = Walker<'value, 'ctx>;

    fn walker_mut(&'value mut self) -> Self::Walker {
        Walker(self, PhantomData)
    }
}

impl<'value, 'ctx: 'value, VisitorErr: 'ctx> Walk<'value, 'ctx, VisitorErr> for &'ctx str {
    type ErrorRef = BasicError;
    type WalkerRef = Walker<'value, 'ctx>;

    fn walker_ref(&'value self) -> Self::Walker {
        Walker(self, PhantomData)
    }
}

pub struct Visitor<'value>(Option<&'value str>);

impl<'value, 'ctx: 'value, WalkerErr: 'value> crate::Visitor<'value, 'ctx, WalkerErr>
    for Visitor<'value>
{
    type Error = BasicError;

    fn request_hint(
        &mut self,
        hints: &mut dyn WalkerHints<'value, 'ctx, BasicError, Error = WalkerErr>,
    ) -> Result<Option<HintGiven>, UniError<WalkerErr, BasicError>> {
        if let Some(hint) = lookup_hint::<Str, _, _>(hints).map_err(UniError::Visitor)? {
            Ok(Some(hint.hint(
                self,
                protocols::str::Hint {
                    kind: Some(protocols::str::Kind::Value),
                    min_len: None,
                    max_len: None,
                },
            )?))
        } else {
            Ok(None)
        }
    }

    fn protocol(
        &mut self,
        id: ProtocolId,
    ) -> Option<AnyVisit<'_, 'value, 'ctx, WalkerErr, BasicError>> {
        match id {
            id if id == ProtocolId::of::<Str>() => Some(AnyVisit::new(self)),
            _ => None,
        }
    }
}

impl<'value, 'ctx: 'value, WalkerErr: 'value> crate::Visit<'value, 'ctx, Str, WalkerErr>
    for Visitor<'value>
{
    type Error = BasicError;

    fn visit<'walking>(
        &'walking mut self,
        accessor: <Str as Protocol<'value, 'ctx>>::Accessor<'walking, WalkerErr, BasicError>,
    ) -> Result<(), UniError<WalkerErr, BasicError>> {
        match accessor {
            protocols::str::Data::Value(str)
            | protocols::str::Data::Context(str)
            | protocols::str::Data::Static(str) => self.0 = Some(str),
            protocols::str::Data::Walking(_) => {
                return Err(UniError::Visitor(BasicError(
                    "str doesn't live long enough",
                )))
            }
        }
        Ok(())
    }
}

impl<'value, 'ctx: 'value, WalkerErr: 'value> Builder<'value, 'ctx, WalkerErr> for Visitor<'value> {
    type Error = BasicError;

    type Value = &'value str;

    fn init() -> Self
    where
        Self: Sized,
    {
        Visitor(None)
    }

    fn as_visitor(
        &mut self,
    ) -> &mut dyn crate::Visitor<'value, 'ctx, WalkerErr, Error = Self::Error> {
        self
    }

    fn finish(self) -> Result<Self::Value, UniError<WalkerErr, Self::Error>>
    where
        Self: Sized,
    {
        if let Some(str) = self.0 {
            Ok(str)
        } else {
            Err(UniError::Visitor(BasicError("missing str")))
        }
    }
}

impl<'value, 'ctx: 'value, WalkerErr: 'value> Build<'value, 'ctx, WalkerErr> for &'value str {
    type Error = BasicError;

    type Builder = Visitor<'value>;
}