//! CSS properties for managing content overflow.

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

use crate::corety::{AzString, OptionF32};

use crate::props::formatter::PrintAsCssValue;

// +spec:overflow:647a7b - overflow property (visible/hidden/clip/scroll/auto), overflow-clip-margin, text-overflow defined in CSS Overflow 3

/// Represents an `overflow-x` or `overflow-y` property.

///

/// Determines what to do when content overflows an element's box.

// +spec:overflow:3526f7 - overflow property with scroll/clip/hidden/visible/auto values

// +spec:overflow:36c4f6 - overflow-x/overflow-y properties with clip value

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

#[repr(C)]

pub enum LayoutOverflow {

    /// Always shows a scroll bar, overflows on scroll.

    Scroll,

    /// Shows a scroll bar only when content overflows.

    Auto,

    /// Clips overflowing content. The rest of the content will be invisible.

    Hidden,

    /// Content is not clipped and renders outside the element's box. This is the CSS default.

    // +spec:overflow:236100 - initial value of 'overflow' is 'visible'

    #[default]

    Visible,

    /// Similar to `hidden`, clips the content at the box's edge.

    Clip,

}

impl LayoutOverflow {

    /// Returns whether this overflow value requires a scrollbar to be displayed.

    ///

    /// - `overflow: scroll` always shows the scrollbar.

    /// - `overflow: auto` only shows the scrollbar if the content is currently overflowing.

    /// - `overflow: hidden`, `overflow: visible`, and `overflow: clip` do not show any scrollbars.

    // +spec:overflow:2bf182 - overflow:scroll always shows scrollbar whether or not content is clipped

    // +spec:overflow:84cd40 - scroll value always displays scrollbar for accessing clipped content

    // +spec:overflow:8fcdd8 - auto causes scrolling mechanism for overflowing boxes (table exception is UA-level)

        }

    // +spec:overflow:145749 - overflow:hidden clips content to containing element box

    // +spec:overflow:3dc18e - overflow:hidden clips content with no scrolling UI

    // +spec:overflow:81e306 - clipping region clips all aspects outside it; clipped content does not cause overflow

    // +spec:overflow:fd38ce - overflow properties specify whether a box's content is clipped / scroll container

    /// Returns `true` if this overflow value clips content (everything except `visible`).

        // All overflow values except 'visible' clip their content

            LayoutOverflow::Hidden

                | LayoutOverflow::Clip

                | LayoutOverflow::Auto

                | LayoutOverflow::Scroll

        )

    // +spec:overflow:3be57c - overflow:hidden disables user scrolling but programmatic scrolling still works

    /// Returns `true` if the overflow type is `scroll`.

    /// Returns `true` if the overflow type is `visible`, which is the only

    /// overflow type that doesn't clip its children.

    /// Returns `true` if the overflow type is `hidden`.

    // +spec:overflow:833078 - visible/clip compute to auto/hidden if other axis is scrollable

    /// Resolves the computed value per CSS Overflow 3 § 3.1:

    /// visible/clip values compute to auto/hidden (respectively)

    /// if the other axis is neither visible nor clip.

            }

        } else {

        }

}

impl PrintAsCssValue for LayoutOverflow {

        })

}

// -- Parser

/// Error returned when parsing an `overflow` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum LayoutOverflowParseError<'a> {

    /// The provided value is not a valid `overflow` keyword.

    InvalidValue(&'a str),

}

impl_debug_as_display!(LayoutOverflowParseError<'a>);

impl_display! { LayoutOverflowParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid overflow value: \"{}\". Expected 'scroll', 'auto', 'hidden', 'visible', or 'clip'.", val

    ),

}}

/// An owned version of `LayoutOverflowParseError`.

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

#[repr(C, u8)]

pub enum LayoutOverflowParseErrorOwned {

    InvalidValue(AzString),

}

impl<'a> LayoutOverflowParseError<'a> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl LayoutOverflowParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `LayoutOverflow` from a string slice.

    }

// -- StyleScrollbarGutter --

// +spec:box-model:e98b7c - scrollbar gutter: space between inner border edge and outer padding edge

/// Represents the `scrollbar-gutter` CSS property.

///

/// Controls whether space is reserved for the scrollbar, preventing

/// layout shifts when content overflows.

// +spec:overflow:da4bbc - scrollbar-gutter affects gutter presence, not scrollbar visibility

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

#[repr(C)]

pub enum StyleScrollbarGutter {

    /// No scrollbar gutter is reserved.

    #[default]

    Auto,

    /// Space is reserved for the scrollbar on one edge.

    Stable,

    /// Space is reserved for the scrollbar on both edges.

    StableBothEdges,

}

impl PrintAsCssValue for StyleScrollbarGutter {

        })

}

// -- Parser for StyleScrollbarGutter

/// Error returned when parsing a `scrollbar-gutter` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleScrollbarGutterParseError<'a> {

    /// The provided value is not a valid `scrollbar-gutter` keyword.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleScrollbarGutterParseError<'a>);

impl_display! { StyleScrollbarGutterParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid scrollbar-gutter value: \"{}\". Expected 'auto', 'stable', or 'stable both-edges'.", val

    ),

}}

/// An owned version of `StyleScrollbarGutterParseError`.

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

#[repr(C, u8)]

pub enum StyleScrollbarGutterParseErrorOwned {

    InvalidValue(AzString),

}

impl<'a> StyleScrollbarGutterParseError<'a> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleScrollbarGutterParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `StyleScrollbarGutter` from a string slice.

    }

// -- VisualBox --

// +spec:overflow:f6955f - box edge origin for overflow-clip-margin

/// Represents the `<visual-box>` value used as the overflow clip edge origin.

///

/// Specifies which box edge to use as the starting point for the clip region.

/// Defaults to `padding-box` per CSS Overflow Module Level 3.

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

#[repr(C)]

pub enum VisualBox {

    /// Clip edge starts at the content box edge.

    ContentBox,

    /// Clip edge starts at the padding box edge (default).

    #[default]

    PaddingBox,

    /// Clip edge starts at the border box edge.

    BorderBox,

}

impl PrintAsCssValue for VisualBox {

        })

}

// -- StyleOverflowClipMargin --

/// Represents the `overflow-clip-margin` CSS property.

///

/// Determines how far outside the element's box the content may paint

/// before being clipped when `overflow: clip` is used.

/// Syntax: `<visual-box> || <length [0,∞]>`

// +spec:overflow:455786 - overflow-clip-margin has no effect on hidden/scroll, only on clip

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

#[repr(C)]

pub struct StyleOverflowClipMargin {

    /// The box edge to use as the clip origin (content-box, padding-box, or border-box).

    pub clip_edge: VisualBox,

    /// The clip margin distance beyond the clip edge.

    pub inner: crate::props::basic::pixel::PixelValue,

}

impl PrintAsCssValue for StyleOverflowClipMargin {

        #[allow(clippy::float_cmp)] // exact zero check: value is default-initialized, not computed

        } else {

        }

}

/// Error returned when parsing an `overflow-clip-margin` property fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleOverflowClipMarginParseError<'a> {

    /// The provided value is not a valid `overflow-clip-margin` value.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleOverflowClipMarginParseError<'a>);

impl_display! { StyleOverflowClipMarginParseError<'a>, {

    InvalidValue(val) => format!("Invalid overflow-clip-margin value: \"{}\"", val),

}}

/// An owned version of `StyleOverflowClipMarginParseError`.

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

#[repr(C, u8)]

pub enum StyleOverflowClipMarginParseErrorOwned {

    InvalidValue(AzString),

}

impl<'a> StyleOverflowClipMarginParseError<'a> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleOverflowClipMarginParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

/// Parses a `StyleOverflowClipMargin` from a string slice.

///

/// Syntax: `<visual-box> || <length [0,∞]>`

/// The `<visual-box>` defaults to `padding-box` if omitted.

/// The `<length>` defaults to `0px` if omitted.

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

                }

            }

        }

    }

// -- StyleClipRect --

/// Represents the deprecated CSS `clip` property value `rect(top, right, bottom, left)`.

///

/// Each edge can be a length or `auto`. When `auto`, the edge matches the

/// element's generated border box edge:

/// - `auto` for top/left = 0

/// - `auto` for bottom = used height + vertical padding + vertical border

/// - `auto` for right = used width + horizontal padding + horizontal border

///

/// Negative lengths are permitted.

// +spec:overflow:297dc3 - clip rect() auto values resolve to border box edges

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

#[repr(C)]

pub struct StyleClipRect {

    /// Top edge offset in pixels. `None` means `auto` (= 0).

    pub top: OptionF32,

    /// Right edge offset in pixels. `None` means `auto` (= used width + horiz padding + horiz border).

    pub right: OptionF32,

    /// Bottom edge offset in pixels. `None` means `auto` (= used height + vert padding + vert border).

    pub bottom: OptionF32,

    /// Left edge offset in pixels. `None` means `auto` (= 0).

    pub left: OptionF32,

}

impl StyleClipRect {

    /// Resolves `auto` values to border box edges given the element's

    /// used width/height and padding/border sizes.

    ///

    /// Returns `(top, right, bottom, left)` in pixels.

}

impl PrintAsCssValue for StyleClipRect {

            }

        )

}

// -- Parser for StyleClipRect

/// Error returned when parsing a CSS `clip` property value fails.

#[derive(Clone, PartialEq, Eq)]

pub enum StyleClipRectParseError<'a> {

    /// The provided value is not a valid `clip` value.

    InvalidValue(&'a str),

}

impl_debug_as_display!(StyleClipRectParseError<'a>);

impl_display! { StyleClipRectParseError<'a>, {

    InvalidValue(val) => format!(

        "Invalid clip value: \"{}\". Expected 'auto' or 'rect(<top>, <right>, <bottom>, <left>)'.", val

    ),

}}

/// An owned version of `StyleClipRectParseError`.

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

#[repr(C, u8)]

pub enum StyleClipRectParseErrorOwned {

    InvalidValue(AzString),

}

impl<'a> StyleClipRectParseError<'a> {

    /// Converts the borrowed error into an owned error.

            }

        }

}

impl StyleClipRectParseErrorOwned {

    /// Converts the owned error back into a borrowed error.

            }

        }

}

#[cfg(feature = "parser")]

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

#[cfg(feature = "parser")]

/// Parses a `StyleClipRect` from a string slice.

///

/// Accepts:

/// - `auto` — equivalent to `rect(auto, auto, auto, auto)`.

/// - `rect(<top>, <right>, <bottom>, <left>)` — comma-separated form.

/// - `rect(<top> <right> <bottom> <left>)` — legacy space-separated form.

///

/// Each edge is either `auto` or a `<length>`. Negative lengths are permitted.

    } else {

    };

    Ok(StyleClipRect {

    })

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

mod tests {

    use super::*;

    #[test]

            LayoutOverflow::Visible

        );

            LayoutOverflow::Hidden

        );

            LayoutOverflow::Scroll

        );

    #[test]

            LayoutOverflow::Scroll

        );

    #[test]

    #[test]

    #[test]

    #[test]

    #[test]

    #[test]

    #[test]

        // Legacy CSS 2.1 syntax used spaces instead of commas.

    #[test]

        // Wrong number of edges.

        // Missing closing paren.

        // Garbage edge.

}