use core::fmt::{Debug, Display};

use effectful::bound::{Bool, Dynamic, IsSend, IsSync};
use effectful::effective::Effective;
use effectful::environment::{DynBind, Environment, NativeForm};
use effectful::higher_ranked::Mut;
use effectful::SendSync;

use crate::any::{OwnedStatic, TempBorrowedStatic, TempBorrowedStaticHrt};
use crate::protocol::visitor::{DynRecoverableScope, Recoverable, RecoverableProto};
use crate::protocol::AsVisitor;
use crate::{
    any::{AnyTraitObject, TypeName, TypeNameId},
    any_trait,
    hkt::Invariant,
    protocol::{
        visitor::{tags, Tag, TagProto, Value, ValueProto, VisitResult},
        DynVisitor,
    },
    Builder, BuilderTypes, DynWalkerObjSafe, Flow,
};

#[derive(SendSync)]
pub struct EnumBuilder<'ctx, Info, Mode, E: Environment>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
{
    inner: Inner<'ctx, Info, Mode, E>,
}

#[derive(SendSync)]
enum Inner<'ctx, Info, Mode, E: Environment>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
{
    Temp,
    Seed(Info::Seed),
    Builder { builder: Info::Builders },
    Value(Result<Dynamic<Info::T>, Info::Error>),
}

pub trait EnumBuildInfo<'ctx, Mode, E: Environment> {
    type Builders: DynBind<E>;

    type Seed: DynBind<E>;

    type Error: DynBind<E> + Debug + Display;

    type ValueT: TypeName::MemberType<E>;

    type T;

    type VariantMarker: DynBind<E> + Copy + Display;

    fn new_builder<'a>(
        seed: Self::Seed,
        variant: Self::VariantMarker,
    ) -> NativeForm<'a, Self::Builders, E>;

    fn finish_builder<'a>(
        builder: Self::Builders,
    ) -> NativeForm<'a, Result<Dynamic<Self::T>, Self::Error>, E>
    where
        Dynamic<Self::T>: DynBind<E>;

    fn from_value<'a>(value: TypeName::T<'a, 'ctx, Self::ValueT, E>) -> Self::T;

    fn as_visitor<'a>(builder: &'a mut Self::Builders) -> DynVisitor<'a, 'ctx, E>;

    fn marker_from_name(name: &str) -> Option<Self::VariantMarker>;

    fn marker_from_discriminant(discriminant: u32) -> Option<Self::VariantMarker>;

    fn guess_variant<'a>(
        seed: Self::Seed,
        scope: DynRecoverableScope<'a, 'ctx, E>,
    ) -> NativeForm<'a, Result<Dynamic<Self::T>, Self::Error>, E>
    where
        Dynamic<Self::T>: DynBind<E>;
}

impl<'ctx, Info, Mode, E: Environment> BuilderTypes<E> for EnumBuilder<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    Dynamic<Info::T>: DynBind<E>,
{
    type Seed = Info::Seed;

    type Error = Info::Error;

    type Value = Info::T;

    type Output = Dynamic<Info::T>;

    fn unwrap_output(output: Self::Output) -> Self::Value {
        output.0
    }
}

impl<'ctx, Info, Mode, E: Environment> Builder<'ctx, E> for EnumBuilder<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    Dynamic<Info::T>: DynBind<E>,
    for<'a> Dynamic<TypeName::T<'a, 'ctx, Info::ValueT, E>>: DynBind<E>,
    for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,
    Dynamic<OwnedStatic<u32>>: DynBind<E>,
{
    fn from_seed<'a>(seed: Self::Seed) -> NativeForm<'a, Self, E>
    where
        Self: 'a,
    {
        E::value(Self {
            inner: Inner::Seed(seed),
        })
        .cast()
    }

    fn build<'a>(self) -> NativeForm<'a, Result<Self::Output, Self::Error>, E>
    where
        Self: 'a,
    {
        match self.inner {
            Inner::Temp => unreachable!(),
            Inner::Seed(seed) => {
                // what to do...
                todo!()
            }
            Inner::Builder { builder } => Info::finish_builder(builder),
            Inner::Value(value) => E::value(value).cast(),
        }
    }
}

impl<'ctx, Info, Mode, E: Environment> AsVisitor<'ctx, E> for EnumBuilder<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    Dynamic<Info::T>: DynBind<E>,
    for<'a> Dynamic<TypeName::T<'a, 'ctx, Info::ValueT, E>>: DynBind<E>,
    for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,
    Dynamic<OwnedStatic<u32>>: DynBind<E>,
{
    fn as_visitor<'a>(&'a mut self) -> DynVisitor<'a, 'ctx, E>
    where
        'ctx: 'a,
    {
        DynVisitor(self)
    }
}

any_trait! {
    impl['ctx, Info, Mode][E] EnumBuilder<'ctx, Info, Mode, E> = [
        ValueProto<Info::ValueT, E>,
        TagProto<tags::Variant, E>,
        RecoverableProto<E>
    ] ref {
        let (_this, _id);
    } else ref {
        None
    } mut {
        let (this, id);

        // If a variant has been chosen, then forward everything to it's builder.
        if matches!(this.inner, Inner::Builder { .. }) {
            match &mut this.inner {
                Inner::Builder { builder } => {
                    return Info::as_visitor(builder).0.upcast_to_id_mut(id)
                }
                _ => unreachable!(),
            }
        }
    } else mut {
        None
    } where
        E: Environment,
        Info: EnumBuildInfo<'ctx, Mode, E>,
        Dynamic<Info::T>: DynBind<E>,
        for<'a> Dynamic<TypeName::T<'a, 'ctx, Info::ValueT, E>>: DynBind<E>,
        for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,
        Dynamic<OwnedStatic<u32>>: DynBind<E>,
}

impl<'ctx, Info, Mode, E: Environment> Recoverable<'ctx, E> for EnumBuilder<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    Dynamic<Info::T>: DynBind<E>,
{
    fn visit<'a>(
        &'a mut self,
        scope: DynRecoverableScope<'a, 'ctx, E>,
    ) -> NativeForm<'a, VisitResult, E> {
        match core::mem::replace(&mut self.inner, Inner::Temp) {
            Inner::Seed(seed) => Info::guess_variant(seed, scope)
                .map(self, |this, result| {
                    this.inner = Inner::Value(result);
                    Flow::Done.into()
                })
                .cast(),
            inner => {
                self.inner = inner;
                E::value(Flow::Continue.into()).cast()
            }
        }
    }
}

impl<'ctx, Info, Mode, E: Environment> Value<'ctx, Info::ValueT, E>
    for EnumBuilder<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    Dynamic<Info::T>: DynBind<E>,
    for<'a> Dynamic<TypeName::T<'a, 'ctx, Info::ValueT, E>>: DynBind<E>,
{
    fn visit<'a>(
        &'a mut self,
        value: TypeName::T<'a, 'ctx, Info::ValueT, E>,
    ) -> NativeForm<'a, VisitResult<Dynamic<TypeName::T<'a, 'ctx, Info::ValueT, E>>>, E>
    where
        TypeName::T<'a, 'ctx, Info::ValueT, E>: Sized,
        'ctx: 'a,
    {
        self.inner = Inner::Value(Ok(Dynamic(Info::from_value(value))));
        E::value(Flow::Done.into()).cast()
    }
}

impl<'ctx, Info, Mode, E: Environment> Tag<'ctx, tags::Variant, E>
    for EnumBuilder<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    Dynamic<Info::T>: DynBind<E>,
    for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,
    Dynamic<OwnedStatic<u32>>: DynBind<E>,
{
    fn visit<'a: 'c, 'b: 'c, 'c>(
        &'a mut self,
        _kind: tags::Variant,
        walker: DynWalkerObjSafe<'b, 'ctx, E>,
    ) -> NativeForm<'c, VisitResult, E> {
        let visitor = VariantVisitor::<Info, Mode, E> { marker: None };

        E::value((visitor, walker))
            .update((), |_, (visitor, walker)| {
                walker.walk(DynVisitor(visitor)).cast()
            })
            .then(self, |this, ((visitor, _), result)| {
                if let Some(variant) = visitor.marker {
                    match core::mem::replace(&mut this.inner, Inner::Temp) {
                        // A variant was given so we need to make the builder for
                        // it.
                        Inner::Seed(seed) => Info::new_builder(seed, variant)
                            .map((this, result), |(this, result), builder| {
                                this.inner = Inner::Builder { builder };
                                result.to_done().into()
                            })
                            .cast::<()>(),
                        inner => {
                            this.inner = inner;
                            E::value(result.to_done().into()).cast()
                        }
                    }
                } else {
                    E::value(result.to_done().into()).cast()
                }
            })
            .cast()
    }
}

#[derive(SendSync)]
struct VariantVisitor<'ctx, Info, Mode, E: Environment>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
{
    marker: Option<Info::VariantMarker>,
}

any_trait! {
    impl['ctx, Info, Mode][E] VariantVisitor<'ctx, Info, Mode, E> = [
        ValueProto<TempBorrowedStaticHrt<str>, E>,
        ValueProto<OwnedStatic<u32>, E>,
    ]
    where
        E: Environment,
        Info: EnumBuildInfo<'ctx, Mode, E>,
        Dynamic<OwnedStatic<u32>>: DynBind<E>,
        for<'a> Dynamic<TempBorrowedStatic<'a, str>>: DynBind<E>,
}

impl<'ctx, Info, Mode, E: Environment> Value<'ctx, TempBorrowedStaticHrt<str>, E>
    for VariantVisitor<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    for<'a> Dynamic<TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>>: DynBind<E>,
{
    fn visit<'a>(
        &'a mut self,
        TempBorrowedStatic(value): TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>,
    ) -> NativeForm<'a, VisitResult<Dynamic<TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>>>, E>
    where
        TypeName::T<'a, 'ctx, TempBorrowedStaticHrt<str>, E>: Sized,
        'ctx: 'a,
    {
        if let Some(variant) = Info::marker_from_name(value) {
            self.marker = Some(variant);

            E::value(Flow::Done.into()).cast()
        } else {
            E::value(Flow::Continue.into()).cast()
        }
    }
}

impl<'ctx, Info, Mode, E: Environment> Value<'ctx, OwnedStatic<u32>, E>
    for VariantVisitor<'ctx, Info, Mode, E>
where
    Info: EnumBuildInfo<'ctx, Mode, E>,
    for<'a> Dynamic<TypeName::T<'a, 'ctx, OwnedStatic<u32>, E>>: DynBind<E>,
    Dynamic<OwnedStatic<u32>>: DynBind<E>,
{
    fn visit<'a>(
        &'a mut self,
        OwnedStatic(value): TypeName::T<'a, 'ctx, OwnedStatic<u32>, E>,
    ) -> NativeForm<'a, VisitResult<Dynamic<TypeName::T<'a, 'ctx, OwnedStatic<u32>, E>>>, E>
    where
        TypeName::T<'a, 'ctx, OwnedStatic<u32>, E>: Sized,
        'ctx: 'a,
    {
        if let Some(variant) = Info::marker_from_discriminant(value) {
            self.marker = Some(variant);

            E::value(Flow::Done.into()).cast()
        } else {
            E::value(Flow::Continue.into()).cast()
        }
    }
}