pub(crate) mod get;
pub(crate) mod insert;

// Types
pub(crate) mod barcode;
pub(crate) mod product;
pub(crate) mod product_amount;
pub(crate) mod product_parent;
pub(crate) mod recipe;
pub(crate) mod recipe_parent;
pub(crate) mod unit;
pub(crate) mod unit_property;
pub(crate) mod user;

macro_rules! mk_id {
    ($name:ident and $stub_name:ident) => {
        mk_id!(
            $name and $stub_name,
            with uuid::Uuid, "uuid::Uuid",
            to_string {|val: &uuid::Uuid| val.to_string()},
            copy Copy
        );
    };
    (
        $name:ident and $stub_name:ident,
        with $inner:path $(=> $($args:meta)* )?, $inner_string:literal,
        to_string $to_string:expr,
        $(copy $copy:path)?
    ) => {
        #[derive(
            serde::Deserialize,
            serde::Serialize,
            Debug,
            Default,
            utoipa::ToSchema,
            Clone,
            PartialEq,
            Eq,
            PartialOrd,
            Ord,
            $($copy,)?
        )]
        pub(crate) struct $name {
            $(
                $(
                    #[$args]
                )*
            )?
            value: $inner,
        }

        #[derive(
            Deserialize,
            Serialize,
            Debug,
            Clone,
            $($copy,)?
        )]
        #[serde(from = $inner_string)]
        pub(crate) struct $stub_name {
            value: $inner,
        }

        impl $name {
            pub(crate) fn from_db(id: &str) -> Self {
                use std::str::FromStr;

                Self {
                    value: <$inner as FromStr>::from_str(id)
                        .expect(
                            concat!(
                                "We put an ",
                                $inner_string,
                                " into the db, it should also go out again"
                            )
                        ),
                }
            }
        }

        impl std::fmt::Display for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write!(f, "{}", $to_string(&self.value))
            }
        }

        impl From<$inner> for $name {
            fn from(value: $inner) -> Self {
                Self { value }
            }
        }
        impl From<$inner> for $stub_name {
            fn from(value: $inner) -> Self {
                Self { value }
            }
        }
        impl From<$stub_name> for $name {
            fn from(value: $stub_name) -> Self {
                Self { value: value.value }
            }
        }

        impl<'q, DB: sqlx::Database> sqlx::Encode<'q, DB> for $name
        where
            String: sqlx::Encode<'q, DB>,
        {
            fn encode_by_ref(
                &self,
                buf: &mut <DB as sqlx::Database>::ArgumentBuffer<'q>,
            ) -> Result<sqlx::encode::IsNull, sqlx::error::BoxDynError> {
                let inner = $to_string(&self.value);
                sqlx::Encode::<DB>::encode_by_ref(&inner, buf)
            }
        }
        impl<DB: sqlx::Database> sqlx::Type<DB> for $name
        where
            String: sqlx::Type<DB>,
        {
            fn type_info() -> DB::TypeInfo {
                <String as sqlx::Type<DB>>::type_info()
            }
        }
    };
}

pub(crate) use mk_id;