#[derive(Clone)]
pub struct NameBuf<'v> {
    left: &'v Name,
    right: Cow<'v, str>,
}

enum ErrorKind {}

#[derive(Debug, Clone, Copy)]
struct ObjectId;

#[derive(Debug, Clone, Copy)]
pub struct UserId(ObjectId);

impl From<ObjectId> for UserId {
    fn from(oid: ObjectId) -> Self {
        UserId(oid)
    }
}

impl Into<ObjectId> for UserId {
    fn into(self) -> ObjectId {
        self.0
    }
}

pub trait FromFormField<'v>: Send + Sized {
    fn from_value(field: ValueField<'v>) -> Result<'v, Self> {
        Err(field.unexpected())?
    }

    async fn from_data(field: DataField<'v, '_>) -> Result<'v, Self> {
        Err(field.unexpected())?
    }

    fn default() -> Option<Self> {
        None
    }
}

impl<'v> FromFormField<'v> for UserId {
    fn from_value(field: ValueField<'v>) -> form::Result<'v, Self> {
        match ObjectId::parse_str(field.value) {
            Ok(oid) => Ok(UserId(oid)),
            Err(_) => Err(Errors::from(form::Error::validation(
                "Invalid ObjectId format",
            ))),
        }
    }
}

#[allow(non_snake_case)]
const _: () = {
    pub struct FromFormGeneratedContext<'r> {
        __opts: Options,
        __errors: Errors<'r>,
        __parent: ::std::option::Option<&'r Name>,
        email: ::std::option::Option<<&'r str as FromForm<'r>>::Context>,
        password: ::std::option::Option<<&'r str as FromForm<'r>>::Context>,
        description: ::std::option::Option<<&'r str as FromForm<'r>>::Context>,
        role: ::std::option::Option<<u8 as FromForm<'r>>::Context>,
        _id: ::std::option::Option<<Option<UserId> as FromForm<'r>>::Context>,
    }
    #[allow(unused_imports)]
    #[allow(renamed_and_removed_lints)]
    #[allow(private_in_public)]

    impl<'r> FromForm<'r> for User<'r> {
        type Context = FromFormGeneratedContext<'r>;
        fn init(__opts: Options) -> Self::Context {
            Self::Context {
                __opts,
                __errors: Errors::new(),
                __parent: ::std::option::Option::None,
                email: ::std::option::Option::None,
                password: ::std::option::Option::None,
                description: ::std::option::Option::None,
                role: ::std::option::Option::None,
                _id: ::std::option::Option::None,
            }
        }
        fn push_value(__c: &mut Self::Context, __f: ValueField<'r>) {
            __c.__parent = __f.name.parent();
            match __f.name.key_lossy().as_str() {
                "email" => {
                    <&'_ str as FromForm<'r>>::push_value(
                        {
                            let __o = __c.__opts;
                            __c.email
                                .get_or_insert_with(|| <&'_ str as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                }
                "password" => {
                    <&'_ str as FromForm<'r>>::push_value(
                        {
                            let __o = __c.__opts;
                            __c.password
                                .get_or_insert_with(|| <&'_ str as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                }
                "description" => {
                    <&'_ str as FromForm<'r>>::push_value(
                        {
                            let __o = __c.__opts;
                            __c.description
                                .get_or_insert_with(|| <&'_ str as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                }
                "role" => {
                    <u8 as FromForm<'r>>::push_value(
                        {
                            let __o = __c.__opts;
                            __c.role
                                .get_or_insert_with(|| <u8 as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                }
                "_id" => {
                    <Option<UserId> as FromForm<'r>>::push_value(
                        {
                            let __o = __c.__opts;
                            __c._id
                                .get_or_insert_with(|| <Option<UserId> as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                }
                __k if __k == "_method" || !__c.__opts.strict => {}
                _ => __c.__errors.push(__f.unexpected()),
            }
        }
        async fn push_data(__c: &mut FromFormGeneratedContext<'r>, __f: DataField<'r, '_>) {
            __c.__parent = __f.name.parent();
            match __f.name.key_lossy().as_str() {
                "email" => {
                    let _fut = <&'_ str as FromForm<'r>>::push_data(
                        {
                            let __o = __c.__opts;
                            __c.email
                                .get_or_insert_with(|| <&'_ str as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                    _fut.await;
                }
                "password" => {
                    let _fut = <&'_ str as FromForm<'r>>::push_data(
                        {
                            let __o = __c.__opts;
                            __c.password
                                .get_or_insert_with(|| <&'_ str as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                    _fut.await;
                }
                "description" => {
                    let _fut = <&'_ str as FromForm<'r>>::push_data(
                        {
                            let __o = __c.__opts;
                            __c.description
                                .get_or_insert_with(|| <&'_ str as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                    _fut.await;
                }
                "role" => {
                    let _fut = <u8 as FromForm<'r>>::push_data(
                        {
                            let __o = __c.__opts;
                            __c.role
                                .get_or_insert_with(|| <u8 as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                    _fut.await;
                }
                "_id" => {
                    let _fut = <Option<UserId> as FromForm<'r>>::push_data(
                        {
                            let __o = __c.__opts;
                            __c._id
                                .get_or_insert_with(|| <Option<UserId> as FromForm<'r>>::init(__o))
                        },
                        __f.shift(),
                    );
                    _fut.await;
                }
                __k if __k == "_method" || !__c.__opts.strict => {}
                _ => __c.__errors.push(__f.unexpected()),
            }
        }
        fn finalize(mut __c: Self::Context) -> ::std::result::Result<Self, Errors<'r>> {
            #[allow(unused_imports)]
            use validate::*;
            let email = match {
                let __opts = __c.__opts;
                let __name = Some(NameBuf::from((__c.__parent, "email")));
                __c.email
                    .map_or_else(
                        || {
                            { <&'_ str as FromForm<'r>>::default(__opts) }
                                .ok_or_else(|| ErrorKind::Missing.into())
                        },
                        <&'_ str as FromForm<'r>>::finalize,
                    )
                    .map_err(|__e| match __name {
                        Some(__name) => __e.with_name(__name),
                        None => __e,
                    })
                    .map_err(|__e| {
                        __e.is_empty()
                            .then(|| ErrorKind::Unknown.into())
                            .unwrap_or(__e)
                    })
            } {
                ::std::result::Result::Ok(email) => ::std::option::Option::Some(email),
                ::std::result::Result::Err(__e) => {
                    __c.__errors.extend(__e);
                    ::std::option::Option::None
                }
            };
            let password = match {
                let __opts = __c.__opts;
                let __name = Some(NameBuf::from((__c.__parent, "password")));
                __c.password
                    .map_or_else(
                        || {
                            { <&'_ str as FromForm<'r>>::default(__opts) }
                                .ok_or_else(|| ErrorKind::Missing.into())
                        },
                        <&'_ str as FromForm<'r>>::finalize,
                    )
                    .map_err(|__e| match __name {
                        Some(__name) => __e.with_name(__name),
                        None => __e,
                    })
                    .map_err(|__e| {
                        __e.is_empty()
                            .then(|| ErrorKind::Unknown.into())
                            .unwrap_or(__e)
                    })
            } {
                ::std::result::Result::Ok(password) => ::std::option::Option::Some(password),
                ::std::result::Result::Err(__e) => {
                    __c.__errors.extend(__e);
                    ::std::option::Option::None
                }
            };
            let description = match {
                let __opts = __c.__opts;
                let __name = Some(NameBuf::from((__c.__parent, "description")));
                __c.description
                    .map_or_else(
                        || {
                            { <&'_ str as FromForm<'r>>::default(__opts) }
                                .ok_or_else(|| ErrorKind::Missing.into())
                        },
                        <&'_ str as FromForm<'r>>::finalize,
                    )
                    .map_err(|__e| match __name {
                        Some(__name) => __e.with_name(__name),
                        None => __e,
                    })
                    .map_err(|__e| {
                        __e.is_empty()
                            .then(|| ErrorKind::Unknown.into())
                            .unwrap_or(__e)
                    })
            } {
                ::std::result::Result::Ok(description) => ::std::option::Option::Some(description),
                ::std::result::Result::Err(__e) => {
                    __c.__errors.extend(__e);
                    ::std::option::Option::None
                }
            };
            let role = match {
                let __opts = __c.__opts;
                let __name = Some(NameBuf::from((__c.__parent, "role")));
                __c.role
                    .map_or_else(
                        || {
                            { <u8 as FromForm<'r>>::default(__opts) }
                                .ok_or_else(|| ErrorKind::Missing.into())
                        },
                        <u8 as FromForm<'r>>::finalize,
                    )
                    .map_err(|__e| match __name {
                        Some(__name) => __e.with_name(__name),
                        None => __e,
                    })
                    .map_err(|__e| {
                        __e.is_empty()
                            .then(|| ErrorKind::Unknown.into())
                            .unwrap_or(__e)
                    })
            } {
                ::std::result::Result::Ok(role) => ::std::option::Option::Some(role),
                ::std::result::Result::Err(__e) => {
                    __c.__errors.extend(__e);
                    ::std::option::Option::None
                }
            };
            let _id = match {
                let __opts = __c.__opts;
                let __name = Some(NameBuf::from((__c.__parent, "_id")));
                __c._id
                    .map_or_else(
                        || {
                            { <Option<UserId> as FromForm<'r>>::default(__opts) }
                                .ok_or_else(|| ErrorKind::Missing.into())
                        },
                        <Option<UserId> as FromForm<'r>>::finalize,
                    )
                    .map_err(|__e| match __name {
                        Some(__name) => __e.with_name(__name),
                        None => __e,
                    })
                    .map_err(|__e| {
                        __e.is_empty()
                            .then(|| ErrorKind::Unknown.into())
                            .unwrap_or(__e)
                    })
            } {
                ::std::result::Result::Ok(_id) => ::std::option::Option::Some(_id),
                ::std::result::Result::Err(__e) => {
                    __c.__errors.extend(__e);
                    ::std::option::Option::None
                }
            };
            if !__c.__errors.is_empty() {
                return ::std::result::Result::Err(__c.__errors);
            }
            Ok(User {
                email: email.unwrap(),
                password: password.unwrap(),
                description: description.unwrap(),
                role: role.unwrap(),
                _id: _id.unwrap(),
            })
        }
    }
};

#[derive(Debug, Clone)]
pub struct User<'r> {
    pub email: &'r str,
    pub password: &'r str,
    pub description: &'r str,
    pub role: u8,
    pub _id: Option<UserId>,
}

#[crate::async_trait]
pub trait FromForm<'r>: Send + Sized {
    type Context: Send;

    fn init(opts: Options) -> Self::Context;

    fn push_value(ctxt: &mut Self::Context, field: ValueField<'r>);

    async fn push_data(ctxt: &mut Self::Context, field: DataField<'r, '_>);

    fn push_error(_ctxt: &mut Self::Context, _error: Error<'r>) {}

    fn finalize(ctxt: Self::Context) -> Result<'r, Self>;

    fn default(opts: Options) -> Option<Self> {
        Self::finalize(Self::init(opts)).ok()
    }
}