//! CSS properties for `margin`, `padding`, and `gap` (column-gap / row-gap).

//!

//! Shorthand parsers (`parse_layout_padding`, `parse_layout_margin`) and

//! longhand per-side parsers are gated behind `#[cfg(feature = "parser")]`.

use alloc::{

    string::{String, ToString},

    vec::Vec,

};

#[cfg(feature = "parser")]

use crate::props::basic::pixel::{parse_pixel_value_with_auto, PixelValueWithAuto};

use crate::{

    css::PrintAsCssValue,

    props::{

        basic::pixel::{CssPixelValueParseError, CssPixelValueParseErrorOwned, PixelValue},

        macros::PixelValueTaker,

    },

};

// --- TYPE DEFINITIONS ---

// Spacing properties - wrapper structs around PixelValue for type safety

macro_rules! impl_spacing_type_impls {

    ($name:ident) => {

        impl ::core::fmt::Debug for $name {

        }

        impl PixelValueTaker for $name {

        }

        impl_pixel_value!($name);

    };

}

/// Layout padding top value

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

#[repr(C)]

pub struct LayoutPaddingTop {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutPaddingTop);

/// Layout padding right value

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

#[repr(C)]

pub struct LayoutPaddingRight {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutPaddingRight);

/// Layout padding bottom value

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

#[repr(C)]

pub struct LayoutPaddingBottom {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutPaddingBottom);

/// Layout padding left value

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

#[repr(C)]

pub struct LayoutPaddingLeft {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutPaddingLeft);

/// Layout padding inline start value (for RTL/LTR support)

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

#[repr(C)]

pub struct LayoutPaddingInlineStart {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutPaddingInlineStart);

/// Layout padding inline end value (for RTL/LTR support)

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

#[repr(C)]

pub struct LayoutPaddingInlineEnd {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutPaddingInlineEnd);

/// Layout margin top value

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

#[repr(C)]

pub struct LayoutMarginTop {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutMarginTop);

/// Layout margin right value

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

#[repr(C)]

pub struct LayoutMarginRight {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutMarginRight);

/// Layout margin bottom value

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

#[repr(C)]

pub struct LayoutMarginBottom {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutMarginBottom);

/// Layout margin left value

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

#[repr(C)]

pub struct LayoutMarginLeft {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutMarginLeft);

/// Layout column gap value (for flexbox/grid)

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

#[repr(C)]

pub struct LayoutColumnGap {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutColumnGap);

/// Layout row gap value (for flexbox/grid)

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

#[repr(C)]

pub struct LayoutRowGap {

    pub inner: PixelValue,

}

impl_spacing_type_impls!(LayoutRowGap);

// --- PARSERS ---

#[cfg(feature = "parser")]

macro_rules! impl_spacing_parse_error {

    ($borrowed:ident, $owned:ident, $property_name:expr) => {

        #[cfg(feature = "parser")]

        impl_debug_as_display!($borrowed<'a>);

        #[cfg(feature = "parser")]

        impl_display! { $borrowed<'a>, {

            PixelValueParseError(e) => format!("Could not parse pixel value: {}", e),

            TooManyValues => concat!("Too many values: ", $property_name, " property accepts at most 4 values."),

            TooFewValues => concat!("Too few values: ", $property_name, " property requires at least 1 value."),

        }}

        #[cfg(feature = "parser")]

        impl_from!(

            CssPixelValueParseError<'a>,

            $borrowed::PixelValueParseError

        );

        #[cfg(feature = "parser")]

        impl<'a> $borrowed<'a> {

                    }

                }

        }

        #[cfg(feature = "parser")]

        impl $owned {

                    }

                }

        }

    };

}

// -- Padding Shorthand Parser --

/// Error from parsing a CSS `padding` shorthand value.

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq)]

pub enum LayoutPaddingParseError<'a> {

    PixelValueParseError(CssPixelValueParseError<'a>),

    TooManyValues,

    TooFewValues,

}

/// Owned variant of [`LayoutPaddingParseError`].

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum LayoutPaddingParseErrorOwned {

    PixelValueParseError(CssPixelValueParseErrorOwned),

    TooManyValues,

    TooFewValues,

}

#[cfg(feature = "parser")]

impl_spacing_parse_error!(LayoutPaddingParseError, LayoutPaddingParseErrorOwned, "padding");

/// Result of parsing the CSS `padding` shorthand property (1–4 values).

#[cfg(feature = "parser")]

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

pub struct LayoutPadding {

    pub top: PixelValueWithAuto,

    pub bottom: PixelValueWithAuto,

    pub left: PixelValueWithAuto,

    pub right: PixelValueWithAuto,

}

#[cfg(feature = "parser")]

        1 => {

            // top, right, bottom, left

        }

        2 => {

            // top/bottom, left/right

        }

        3 => {

            // top, left/right, bottom

        }

        4 => {

            // top, right, bottom, left

        }

    }

// -- Margin Shorthand Parser --

/// Error from parsing a CSS `margin` shorthand value.

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq)]

pub enum LayoutMarginParseError<'a> {

    PixelValueParseError(CssPixelValueParseError<'a>),

    TooManyValues,

    TooFewValues,

}

/// Owned variant of [`LayoutMarginParseError`].

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum LayoutMarginParseErrorOwned {

    PixelValueParseError(CssPixelValueParseErrorOwned),

    TooManyValues,

    TooFewValues,

}

#[cfg(feature = "parser")]

impl_spacing_parse_error!(LayoutMarginParseError, LayoutMarginParseErrorOwned, "margin");

/// Result of parsing the CSS `margin` shorthand property (1–4 values).

#[cfg(feature = "parser")]

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

pub struct LayoutMargin {

    pub top: PixelValueWithAuto,

    pub bottom: PixelValueWithAuto,

    pub left: PixelValueWithAuto,

    pub right: PixelValueWithAuto,

}

#[cfg(feature = "parser")]

    // Margin parsing logic is identical to padding, so we can reuse the padding parser

    // and just map the Ok and Err variants to the margin-specific types.

            }

        },

    }

// -- Longhand Property Parsers --

macro_rules! typed_pixel_value_parser {

    (

        $fn:ident, $fn_str:expr, $return:ident, $return_str:expr, $import_str:expr, $test_str:expr

    ) => {

        ///Parses a `

        #[doc = $return_str]

        ///` attribute from a `&str`

        ///

        ///# Example

        ///

        ///```rust

        #[doc = $import_str]

        #[doc = $test_str]

        ///```

        impl crate::props::formatter::FormatAsCssValue for $return {

        }

    };

    ($fn:ident, $return:ident) => {

        typed_pixel_value_parser!(

            $fn,

            stringify!($fn),

            $return,

            stringify!($return),

            concat!(

                "# extern crate azul_css;",

                "\r\n",

                "# use azul_css::props::layout::spacing::",

                stringify!($fn),

                ";",

                "\r\n",

                "# use azul_css::props::basic::pixel::PixelValue;\r\n",

                "# use azul_css::props::layout::spacing::",

                stringify!($return),

                ";\r\n"

            ),

            concat!(

                "assert_eq!(",

                stringify!($fn),

                "(\"5px\"), Ok(",

                stringify!($return),

                " { inner: PixelValue::px(5.0) }));"

            )

        );

    };

}

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_padding_top, LayoutPaddingTop);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_padding_right, LayoutPaddingRight);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_padding_bottom, LayoutPaddingBottom);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_padding_left, LayoutPaddingLeft);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_padding_inline_start, LayoutPaddingInlineStart);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_padding_inline_end, LayoutPaddingInlineEnd);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_margin_top, LayoutMarginTop);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_margin_right, LayoutMarginRight);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_margin_bottom, LayoutMarginBottom);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_margin_left, LayoutMarginLeft);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_column_gap, LayoutColumnGap);

#[cfg(feature = "parser")]

typed_pixel_value_parser!(parse_layout_row_gap, LayoutRowGap);

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

mod tests {

    use super::*;

    use crate::props::basic::pixel::{PixelValue, PixelValueWithAuto};

    #[test]

        // 1 value

            result.right,

        );

            result.bottom,

        );

        // 2 values

            result.top,

        );

            result.bottom,

        );

        // 3 values

            result.bottom,

        );

        // 4 values

            result.bottom,

        );

        // Whitespace

    #[test]

            LayoutPaddingParseError::TooFewValues

        ));

            LayoutPaddingParseError::TooManyValues

        ));

            LayoutPaddingParseError::PixelValueParseError(_)

        ));

    #[test]

        // 1 value with auto

        // 2 values

            result.bottom,

        );

    #[test]

            LayoutMarginParseError::TooFewValues

        ));

            LayoutMarginParseError::TooManyValues

        ));

            LayoutMarginParseError::PixelValueParseError(_)

        ));

    #[test]

        );

        );

}