//! CSS properties for controlling fragmentation (page/column breaks).

//!

//! Defines [`PageBreak`], [`BreakInside`], [`Widows`], [`Orphans`], and

//! [`BoxDecorationBreak`]. The `parser` sub-module (behind the `parser`

//! feature) provides CSS-value parsing for each type.

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

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

// --- break-before / break-after ---

/// Represents a `break-before` or `break-after` CSS property value.

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

#[repr(C)]

#[derive(Default)]

pub enum PageBreak {

    #[default]

    Auto,

    Avoid,

    Always,

    All,

    Page,

    AvoidPage,

    Left,

    Right,

    Recto,

    Verso,

    Column,

    AvoidColumn,

}

impl PrintAsCssValue for PageBreak {

        })

}

// --- break-inside ---

/// Represents a `break-inside` CSS property value.

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

#[repr(C)]

#[derive(Default)]

pub enum BreakInside {

    #[default]

    Auto,

    Avoid,

    AvoidPage,

    AvoidColumn,

}

impl PrintAsCssValue for BreakInside {

        })

}

// --- widows / orphans ---

/// CSS `widows` property - minimum number of lines in a block container

/// that must be shown at the top of a page, region, or column.

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

#[repr(C)]

pub struct Widows {

    pub inner: u32,

}

impl Default for Widows {

}

impl PrintAsCssValue for Widows {

}

/// CSS `orphans` property - minimum number of lines in a block container

/// that must be shown at the bottom of a page, region, or column.

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

#[repr(C)]

pub struct Orphans {

    pub inner: u32,

}

impl Default for Orphans {

}

impl PrintAsCssValue for Orphans {

}

// --- box-decoration-break ---

/// Represents a `box-decoration-break` CSS property value.

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

#[repr(C)]

#[derive(Default)]

pub enum BoxDecorationBreak {

    #[default]

    Slice,

    Clone,

}

impl PrintAsCssValue for BoxDecorationBreak {

        })

}

// Formatting to Rust code

impl crate::format_rust_code::FormatAsRustCode for PageBreak {

        }

}

impl crate::format_rust_code::FormatAsRustCode for BreakInside {

        }

}

impl crate::format_rust_code::FormatAsRustCode for Widows {

}

impl crate::format_rust_code::FormatAsRustCode for Orphans {

}

impl crate::format_rust_code::FormatAsRustCode for BoxDecorationBreak {

        }

}

// --- PARSERS ---

#[cfg(feature = "parser")]

pub mod parser {

    use super::*;

    use core::num::ParseIntError;

    use crate::corety::AzString;

    use crate::props::layout::position::ParseIntErrorWithInput;

    // -- PageBreak parser (`break-before`, `break-after`)

    /// Error returned when parsing a `break-before` or `break-after` value.

    #[derive(Clone, PartialEq)]

    pub enum PageBreakParseError<'a> {

        InvalidValue(&'a str),

    }

    impl_debug_as_display!(PageBreakParseError<'a>);

    impl_display! { PageBreakParseError<'a>, {

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

    }}

    /// Owned version of [`PageBreakParseError`] for FFI and storage.

    #[derive(Debug, Clone, PartialEq)]

    #[repr(C, u8)]

    pub enum PageBreakParseErrorOwned {

        InvalidValue(AzString),

    }

    impl<'a> PageBreakParseError<'a> {

            }

    }

    impl PageBreakParseErrorOwned {

            }

    }

        }

    // -- BreakInside parser

    /// Error returned when parsing a `break-inside` value.

    #[derive(Clone, PartialEq)]

    pub enum BreakInsideParseError<'a> {

        InvalidValue(&'a str),

    }

    impl_debug_as_display!(BreakInsideParseError<'a>);

    impl_display! { BreakInsideParseError<'a>, {

        InvalidValue(v) => format!("Invalid break-inside value: \"{}\"", v),

    }}

    /// Owned version of [`BreakInsideParseError`] for FFI and storage.

    #[derive(Debug, Clone, PartialEq)]

    #[repr(C, u8)]

    pub enum BreakInsideParseErrorOwned {

        InvalidValue(AzString),

    }

    impl<'a> BreakInsideParseError<'a> {

            }

    }

    impl BreakInsideParseErrorOwned {

            }

    }

        }

    // -- Widows / Orphans parsers

    macro_rules! define_widow_orphan_parser {

        ($fn_name:ident, $struct_name:ident, $error_name:ident, $error_owned_name:ident, $prop_name:expr) => {

            #[derive(Clone, PartialEq)]

            pub enum $error_name<'a> {

                ParseInt(ParseIntError, &'a str),

                ParseIntOwned(&'a str, &'a str),

                NegativeValue(&'a str),

            }

            impl_debug_as_display!($error_name<'a>);

            impl_display! { $error_name<'a>, {

                ParseInt(e, s) => format!("Invalid integer for {}: \"{}\". Reason: {}", $prop_name, s, e),

                ParseIntOwned(e, s) => format!("Invalid integer for {}: \"{}\". Reason: {}", $prop_name, s, e),

                NegativeValue(s) => format!("Invalid value for {}: \"{}\". Value cannot be negative.", $prop_name, s),

            }}

            #[derive(Debug, Clone, PartialEq)]

            #[repr(C, u8)]

            pub enum $error_owned_name {

                ParseInt(ParseIntErrorWithInput),

                NegativeValue(AzString),

            }

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

                    }

            }

            impl $error_owned_name {

                    }

            }

        };

    }

    define_widow_orphan_parser!(

        parse_widows,

        Widows,

        WidowsParseError,

        WidowsParseErrorOwned,

        "widows"

    );

    define_widow_orphan_parser!(

        parse_orphans,

        Orphans,

        OrphansParseError,

        OrphansParseErrorOwned,

        "orphans"

    );

    // -- BoxDecorationBreak parser

    /// Error returned when parsing a `box-decoration-break` value.

    #[derive(Clone, PartialEq)]

    pub enum BoxDecorationBreakParseError<'a> {

        InvalidValue(&'a str),

    }

    impl_debug_as_display!(BoxDecorationBreakParseError<'a>);

    impl_display! { BoxDecorationBreakParseError<'a>, {

        InvalidValue(v) => format!("Invalid box-decoration-break value: \"{}\"", v),

    }}

    /// Owned version of [`BoxDecorationBreakParseError`] for FFI and storage.

    #[derive(Debug, Clone, PartialEq)]

    #[repr(C, u8)]

    pub enum BoxDecorationBreakParseErrorOwned {

        InvalidValue(AzString),

    }

    impl<'a> BoxDecorationBreakParseError<'a> {

                }

            }

    }

    impl BoxDecorationBreakParseErrorOwned {

            }

    }

        }

}

#[cfg(feature = "parser")]

pub use parser::*;

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

mod tests {

    use super::*;

    #[test]

            PageBreak::AvoidColumn

        );

    #[test]

    #[test]

    #[test]

            BoxDecorationBreak::Slice

        );

            BoxDecorationBreak::Clone

        );

}