//! CSS properties for flowing content into regions (`flow-into`, `flow-from`).

use alloc::string::{String, ToString};

use crate::{corety::AzString, props::formatter::PrintAsCssValue};

// --- flow-into ---

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// CSS `flow-into` property — diverts an element's content into a named flow.

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

#[derive(Default)]

pub enum FlowInto {

    /// Content is not diverted into any named flow (default).

    #[default]

    None,

    /// Content is diverted into the named flow identified by this string.

    Named(AzString),

}

impl PrintAsCssValue for FlowInto {

        }

}

// --- flow-from ---

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// CSS `flow-from` property — consumes content from a named flow into a region.

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

#[derive(Default)]

pub enum FlowFrom {

    /// No named flow is consumed (default).

    #[default]

    None,

    /// Content is consumed from the named flow identified by this string.

    Named(AzString),

}

impl PrintAsCssValue for FlowFrom {

        }

}

// Formatting to Rust code

impl crate::codegen::format::FormatAsRustCode for FlowInto {

            ),

        }

}

impl crate::codegen::format::FormatAsRustCode for FlowFrom {

            ),

        }

}

// --- PARSERS ---

#[cfg(feature = "parser")]

pub mod parser {

    #[allow(clippy::wildcard_imports)] // parser submodule reuses the parent module's value types

    use super::*;

    use crate::corety::AzString;

    macro_rules! define_flow_parser {

        (

            $fn_name:ident,

            $struct_name:ident,

            $error_name:ident,

            $error_owned_name:ident,

            $prop_name:expr

        ) => {

            #[derive(Clone, PartialEq, Eq)]

            pub enum $error_name<'a> {

                InvalidValue(&'a str),

            }

            impl_debug_as_display!($error_name<'a>);

            impl_display! { $error_name<'a>, {

                InvalidValue(v) => format!("Invalid {} value: \"{}\"", $prop_name, v),

            }}

            #[derive(Debug, Clone, PartialEq, Eq)]

            #[repr(C, u8)]

            pub enum $error_owned_name {

                InvalidValue(AzString),

            }

            impl $error_name<'_> {

                    }

            }

            impl $error_owned_name {

                    }

            }

            /// # Errors

            ///

            /// Returns an error if `input` is not a valid CSS value for this property.

                    // any other value is a custom identifier

                }

        };

    }

    define_flow_parser!(

        parse_flow_into,

        FlowInto,

        FlowIntoParseError,

        FlowIntoParseErrorOwned,

        "flow-into"

    );

    define_flow_parser!(

        parse_flow_from,

        FlowFrom,

        FlowFromParseError,

        FlowFromParseErrorOwned,

        "flow-from"

    );

}

#[cfg(feature = "parser")]

pub use parser::*;

#[cfg(all(test, feature = "parser"))]

mod tests {

    use super::*;

    #[test]

        );

    #[test]

        );

}