//! CSS properties for positioning elements: `position`, `top`, `right`,

//! `bottom`, `left`, and `z-index`. Types defined here are consumed by the

//! layout solver to resolve positioned elements.

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

use crate::corety::AzString;

#[cfg(feature = "parser")]

use crate::props::basic::pixel::parse_pixel_value;

use crate::props::{

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

    formatter::PrintAsCssValue,

    macros::PixelValueTaker,

};

// --- LayoutPosition ---

/// Represents a `position` attribute - default: `Static`

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

#[repr(C)]

#[derive(Default)]

pub enum LayoutPosition {

    #[default]

    Static,

    Relative,

    Absolute,

    Fixed,

    Sticky,

}

impl LayoutPosition {

}

impl PrintAsCssValue for LayoutPosition {

        })

}

impl_enum_fmt!(LayoutPosition, Static, Fixed, Absolute, Relative, Sticky);

// -- Parser for LayoutPosition

#[derive(Clone, PartialEq)]

pub enum LayoutPositionParseError<'a> {

    InvalidValue(&'a str),

}

impl_debug_as_display!(LayoutPositionParseError<'a>);

impl_display! { LayoutPositionParseError<'a>, {

    InvalidValue(val) => format!("Invalid position value: \"{}\"", val),

}}

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum LayoutPositionParseErrorOwned {

    InvalidValue(AzString),

}

impl<'a> LayoutPositionParseError<'a> {

            }

        }

}

impl LayoutPositionParseErrorOwned {

            }

        }

}

#[cfg(feature = "parser")]

    }

// --- Offset Properties (top, right, bottom, left) ---

macro_rules! define_position_property {

    ($struct_name:ident) => {

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

        #[repr(C)]

        pub struct $struct_name {

            pub inner: PixelValue,

        }

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

        }

        impl PixelValueTaker for $struct_name {

        }

        impl_pixel_value!($struct_name);

        impl PrintAsCssValue for $struct_name {

        }

    };

}

/// Represents the CSS `top` offset property for positioned elements.

define_position_property!(LayoutTop);

/// Represents the CSS `right` offset property for positioned elements.

define_position_property!(LayoutRight);

/// Represents the CSS `bottom` offset property for positioned elements.

define_position_property!(LayoutInsetBottom);

/// Represents the CSS `left` offset property for positioned elements.

define_position_property!(LayoutLeft);

// -- Parse error types and parsers for offset properties (top, right, bottom, left)

macro_rules! define_offset_parse_error {

    ($struct_name:ident, $error_name:ident, $error_owned_name:ident, $parse_fn:ident) => {

        #[derive(Clone, PartialEq)]

        pub enum $error_name<'a> {

            PixelValue(CssPixelValueParseError<'a>),

        }

        impl_debug_as_display!($error_name<'a>);

        impl_display! { $error_name<'a>, { PixelValue(e) => format!("{}", e), }}

        impl_from!(CssPixelValueParseError<'a>, $error_name::PixelValue);

        #[derive(Debug, Clone, PartialEq)]

        #[repr(C, u8)]

        pub enum $error_owned_name {

            PixelValue(CssPixelValueParseErrorOwned),

        }

        impl<'a> $error_name<'a> {

                    }

                }

        }

        impl $error_owned_name {

                    }

                }

        }

        #[cfg(feature = "parser")]

    };

}

define_offset_parse_error!(LayoutTop, LayoutTopParseError, LayoutTopParseErrorOwned, parse_layout_top);

define_offset_parse_error!(LayoutRight, LayoutRightParseError, LayoutRightParseErrorOwned, parse_layout_right);

define_offset_parse_error!(LayoutInsetBottom, LayoutInsetBottomParseError, LayoutInsetBottomParseErrorOwned, parse_layout_bottom);

define_offset_parse_error!(LayoutLeft, LayoutLeftParseError, LayoutLeftParseErrorOwned, parse_layout_left);

// --- LayoutZIndex ---

/// Represents a `z-index` attribute - controls stacking order of positioned elements

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

#[repr(C, u8)]

#[derive(Default)]

pub enum LayoutZIndex {

    #[default]

    Auto,

    Integer(i32),

}

// Formatting to Rust code

impl crate::format_rust_code::FormatAsRustCode for LayoutZIndex {

            }

        }

}

impl PrintAsCssValue for LayoutZIndex {

        }

}

// -- Parser for LayoutZIndex

#[derive(Clone, PartialEq)]

pub enum LayoutZIndexParseError<'a> {

    InvalidValue(&'a str),

    ParseInt(::core::num::ParseIntError, &'a str),

}

impl_debug_as_display!(LayoutZIndexParseError<'a>);

impl_display! { LayoutZIndexParseError<'a>, {

    InvalidValue(val) => format!("Invalid z-index value: \"{}\"", val),

    ParseInt(e, s) => format!("Invalid z-index integer \"{}\": {}", s, e),

}}

/// Wrapper for `ParseIntError` that stores the error message and original

/// input as owned strings for FFI compatibility.

#[derive(Debug, Clone, PartialEq)]

#[repr(C)]

pub struct ParseIntErrorWithInput {

    /// The stringified parse error (e.g. "invalid digit found in string").

    pub error: AzString,

    /// The original input string that failed to parse.

    pub input: AzString,

}

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum LayoutZIndexParseErrorOwned {

    InvalidValue(AzString),

    ParseInt(ParseIntErrorWithInput),

}

impl<'a> LayoutZIndexParseError<'a> {

            }

            }

        }

}

impl LayoutZIndexParseErrorOwned {

    /// Converts back to the borrowed error type.

    ///

    /// **Note:** This conversion is lossy for `ParseInt` — the original

    /// `core::num::ParseIntError` cannot be reconstructed from its string

    /// representation, so `ParseInt` is mapped to `InvalidValue` instead.

            }

                // We can't reconstruct ParseIntError, so use InvalidValue

            }

        }

}

#[cfg(feature = "parser")]

    }

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

mod tests {

    use super::*;

    #[test]

            LayoutPosition::Static

        );

            LayoutPosition::Relative

        );

            LayoutPosition::Absolute

        );

            LayoutPosition::Fixed

        );

            LayoutPosition::Sticky

        );

    #[test]

            LayoutPosition::Absolute

        );

    #[test]

    #[test]

            LayoutZIndex::Integer(10)

        );

            LayoutZIndex::Integer(-5)

        );

            LayoutZIndex::Integer(999)

        );

    #[test]

    #[test]

        );

        );

        );

        );

    #[test]

        // The simple `parse_pixel_value` does not handle `auto`.

        // Liberal parsing accepts whitespace between number and unit

}