//! CSS properties for fonts, such as font-family, font-size, font-weight, and font-style.

//!

//! Also contains `FontRef` (reference-counted handle to parsed font data),

//! `FontMetrics` (OpenType font metrics from head/hhea/os2 tables), and

//! `Panose` (font classification).

use alloc::{

    boxed::Box,

    string::{String, ToString},

    vec::Vec,

};

use core::{

    cmp::Ordering,

    ffi::c_void,

    fmt,

    hash::{Hash, Hasher},

    num::ParseIntError,

    sync::atomic::{AtomicUsize, Ordering as AtomicOrdering},

};

#[cfg(feature = "parser")]

use crate::props::basic::parse::{strip_quotes, UnclosedQuotesError};

use crate::system::SystemFontType;

use crate::{

    corety::{AzString, U8Vec},

    format_rust_code::{FormatAsRustCode, GetHash},

    props::{

        basic::{

            error::{InvalidValueErr, InvalidValueErrOwned},

            pixel::{

                parse_pixel_value, CssPixelValueParseError, CssPixelValueParseErrorOwned,

                PixelValue,

            },

        },

        formatter::PrintAsCssValue,

    },

};

// --- Font Weight ---

/// Represents the `font-weight` property.

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

#[repr(C)]

#[derive(Default)]

pub enum StyleFontWeight {

    Lighter,

    W100,

    W200,

    W300,

    #[default]

    Normal,

    W500,

    W600,

    Bold,

    W800,

    W900,

    Bolder,

}

impl PrintAsCssValue for StyleFontWeight {

        }

}

impl crate::format_rust_code::FormatAsRustCode for StyleFontWeight {

        use StyleFontWeight::*;

            }

        )

}

// --- Font Style ---

/// Represents the `font-style` property.

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

#[repr(C)]

#[derive(Default)]

pub enum StyleFontStyle {

    #[default]

    Normal,

    Italic,

    Oblique,

}

impl PrintAsCssValue for StyleFontStyle {

        }

}

impl crate::format_rust_code::FormatAsRustCode for StyleFontStyle {

        use StyleFontStyle::*;

            }

        )

}

// --- Font Size ---

/// Represents a `font-size` attribute

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

#[repr(C)]

pub struct StyleFontSize {

    pub inner: PixelValue,

}

impl Default for StyleFontSize {

}

impl_pixel_value!(StyleFontSize);

impl PrintAsCssValue for StyleFontSize {

}

// --- Font Resource Management ---

/// Callback type for FontRef destructor - must be extern "C" for FFI safety

pub type FontRefDestructorCallbackType = extern "C" fn(*mut c_void);

/// FontRef is a reference-counted pointer to a parsed font.

/// It holds a *const c_void that points to the actual parsed font data

/// (typically a ParsedFont from the layout crate).

///

/// The parsed data is managed via atomic reference counting, allowing

/// safe sharing across threads without duplicating the font data.

#[repr(C)]

pub struct FontRef {

    /// Pointer to the parsed font data (e.g., ParsedFont)

    pub parsed: *const c_void,

    /// Reference counter for memory management

    pub copies: *const AtomicUsize,

    /// Whether to run the destructor on drop

    pub run_destructor: bool,

    /// Destructor function for the parsed data

    pub parsed_destructor: FontRefDestructorCallbackType,

}

impl fmt::Debug for FontRef {

        } else {

        }

}

impl FontRef {

    /// Create a new FontRef from parsed font data

    ///

    /// # Arguments

    /// * `parsed` - Pointer to parsed font data (e.g., Arc::into_raw(Arc::new(ParsedFont)))

    /// * `destructor` - Function to clean up the parsed data

    /// Get a raw pointer to the parsed font data

    #[inline]

}

impl_option!(

    FontRef,

    OptionFontRef,

    copy = false,

    [Debug, Clone, PartialEq, Eq, Hash]

);

unsafe impl Send for FontRef {}

unsafe impl Sync for FontRef {}

impl PartialEq for FontRef {

}

impl PartialOrd for FontRef {

}

impl Ord for FontRef {

}

impl Eq for FontRef {}

impl Hash for FontRef {

}

impl Clone for FontRef {

}

impl Drop for FontRef {

}

// --- Font Family ---

/// Represents a `font-family` attribute.

/// 

/// Can be:

/// - `System(AzString)`: A named font family (e.g., "Arial", "Times New Roman")

/// - `SystemType(SystemFontType)`: A semantic system font type (e.g., `system:ui`, `system:monospace`)

/// - `File(AzString)`: A font loaded from a file URL

/// - `Ref(FontRef)`: A reference to a pre-loaded font

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

#[repr(C, u8)]

pub enum StyleFontFamily {

    /// Named font family (e.g., "Arial", "Times New Roman", "monospace")

    System(AzString),

    /// Semantic system font type (e.g., `system:ui`, `system:monospace:bold`)

    /// Resolved at runtime based on platform and accessibility settings

    SystemType(SystemFontType),

    /// Font loaded from a file URL

    File(AzString),

    /// Reference to a pre-loaded font

    Ref(FontRef),

}

impl_option!(

    StyleFontFamily,

    OptionStyleFontFamily,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl StyleFontFamily {

                } else {

                }

            }

        }

}

impl_vec!(StyleFontFamily, StyleFontFamilyVec, StyleFontFamilyVecDestructor, StyleFontFamilyVecDestructorType, StyleFontFamilyVecSlice, OptionStyleFontFamily);

impl_vec_clone!(

    StyleFontFamily,

    StyleFontFamilyVec,

    StyleFontFamilyVecDestructor

);

impl_vec_debug!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_eq!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_ord!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_hash!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_partialeq!(StyleFontFamily, StyleFontFamilyVec);

impl_vec_partialord!(StyleFontFamily, StyleFontFamilyVec);

impl PrintAsCssValue for StyleFontFamilyVec {

}

// Formatting to Rust code for StyleFontFamilyVec

impl crate::format_rust_code::FormatAsRustCode for StyleFontFamilyVec {

        )

}

// --- PARSERS ---

// -- Font Weight Parser --

#[derive(Clone, PartialEq)]

pub enum CssFontWeightParseError<'a> {

    InvalidValue(InvalidValueErr<'a>),

    InvalidNumber(ParseIntError),

}

// Formatting to Rust code for StyleFontFamily

impl crate::format_rust_code::FormatAsRustCode for StyleFontFamily {

            }

            }

            }

            }

        }

}

impl_debug_as_display!(CssFontWeightParseError<'a>);

impl_display! { CssFontWeightParseError<'a>, {

    InvalidValue(e) => format!("Invalid font-weight keyword: \"{}\"", e.0),

    InvalidNumber(e) => format!("Invalid font-weight number: {}", e),

}}

impl<'a> From<InvalidValueErr<'a>> for CssFontWeightParseError<'a> {

}

impl<'a> From<ParseIntError> for CssFontWeightParseError<'a> {

}

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssFontWeightParseErrorOwned {

    InvalidValue(InvalidValueErrOwned),

    InvalidNumber(crate::props::basic::error::ParseIntError),

}

impl<'a> CssFontWeightParseError<'a> {

        }

}

impl CssFontWeightParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

    }

// -- Font Style Parser --

#[derive(Clone, PartialEq)]

pub enum CssFontStyleParseError<'a> {

    InvalidValue(InvalidValueErr<'a>),

}

impl_debug_as_display!(CssFontStyleParseError<'a>);

impl_display! { CssFontStyleParseError<'a>, {

    InvalidValue(e) => format!("Invalid font-style: \"{}\"", e.0),

}}

impl_from! { InvalidValueErr<'a>, CssFontStyleParseError::InvalidValue }

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssFontStyleParseErrorOwned {

    InvalidValue(InvalidValueErrOwned),

}

impl<'a> CssFontStyleParseError<'a> {

        }

}

impl CssFontStyleParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

    }

// -- Font Size Parser --

#[derive(Clone, PartialEq)]

pub enum CssStyleFontSizeParseError<'a> {

    PixelValue(CssPixelValueParseError<'a>),

}

impl_debug_as_display!(CssStyleFontSizeParseError<'a>);

impl_display! { CssStyleFontSizeParseError<'a>, {

    PixelValue(e) => format!("Invalid font-size: {}", e),

}}

impl_from! { CssPixelValueParseError<'a>, CssStyleFontSizeParseError::PixelValue }

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssStyleFontSizeParseErrorOwned {

    PixelValue(CssPixelValueParseErrorOwned),

}

impl<'a> CssStyleFontSizeParseError<'a> {

        }

}

impl CssStyleFontSizeParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

    Ok(StyleFontSize {

    })

// -- Font Family Parser --

#[derive(PartialEq, Clone)]

pub enum CssStyleFontFamilyParseError<'a> {

    InvalidStyleFontFamily(&'a str),

    UnclosedQuotes(UnclosedQuotesError<'a>),

}

impl_debug_as_display!(CssStyleFontFamilyParseError<'a>);

impl_display! { CssStyleFontFamilyParseError<'a>, {

    InvalidStyleFontFamily(val) => format!("Invalid font-family: \"{}\"", val),

    UnclosedQuotes(val) => format!("Unclosed quotes in font-family: \"{}\"", val.0),

}}

impl<'a> From<UnclosedQuotesError<'a>> for CssStyleFontFamilyParseError<'a> {

}

#[derive(Debug, Clone, PartialEq)]

#[repr(C, u8)]

pub enum CssStyleFontFamilyParseErrorOwned {

    InvalidStyleFontFamily(AzString),

    UnclosedQuotes(AzString),

}

impl<'a> CssStyleFontFamilyParseError<'a> {

            }

            }

        }

}

impl CssStyleFontFamilyParseErrorOwned {

            }

            }

        }

}

#[cfg(feature = "parser")]

        // Check for system font type syntax: system:ui, system:monospace:bold, etc.

            // Invalid system font type, fall through to treat as regular font name

    }

// --- Font Metrics ---

use crate::corety::{OptionI16, OptionU16, OptionU32};

/// PANOSE classification values for font identification (10 bytes).

/// See https://learn.microsoft.com/en-us/typography/opentype/spec/os2#panose

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

#[repr(C)]

#[derive(Default)]

pub struct Panose {

    pub family_type: u8,

    pub serif_style: u8,

    pub weight: u8,

    pub proportion: u8,

    pub contrast: u8,

    pub stroke_variation: u8,

    pub arm_style: u8,

    pub letterform: u8,

    pub midline: u8,

    pub x_height: u8,

}

impl Panose {

}

/// Font metrics structure containing all font-related measurements from

/// the font file tables (head, hhea, and os/2 tables).

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

#[repr(C)]

pub struct FontMetrics {

    // os/2 version 1 table (u32 fields - align 4, placed first)

    pub ul_code_page_range1: OptionU32,

    pub ul_code_page_range2: OptionU32,

    // os/2 table (u32 fields)

    pub ul_unicode_range1: u32,

    pub ul_unicode_range2: u32,

    pub ul_unicode_range3: u32,

    pub ul_unicode_range4: u32,

    pub ach_vend_id: u32,

    // os/2 version 0 table (Option<i16>/Option<u16> - align 2)

    pub s_typo_ascender: OptionI16,

    pub s_typo_descender: OptionI16,

    pub s_typo_line_gap: OptionI16,

    pub us_win_ascent: OptionU16,

    pub us_win_descent: OptionU16,

    // +spec:font-metrics:d3b654 - cap-height and x-height metrics for visual text centering (leading-trim)

    // os/2 version 2 table

    pub sx_height: OptionI16,

    pub s_cap_height: OptionI16,

    pub us_default_char: OptionU16,

    pub us_break_char: OptionU16,

    pub us_max_context: OptionU16,

    // os/2 version 3 table

    pub us_lower_optical_point_size: OptionU16,

    pub us_upper_optical_point_size: OptionU16,

    // head table (u16/i16 - align 2)

    pub units_per_em: u16,

    pub font_flags: u16,

    pub x_min: i16,

    pub y_min: i16,

    pub x_max: i16,

    pub y_max: i16,

    // hhea table

    pub ascender: i16,

    pub descender: i16,

    pub line_gap: i16,

    pub advance_width_max: u16,

    pub min_left_side_bearing: i16,

    pub min_right_side_bearing: i16,

    pub x_max_extent: i16,

    pub caret_slope_rise: i16,

    pub caret_slope_run: i16,

    pub caret_offset: i16,

    pub num_h_metrics: u16,

    // os/2 table (u16/i16 fields)

    pub x_avg_char_width: i16,

    pub us_weight_class: u16,

    pub us_width_class: u16,

    pub fs_type: u16,

    pub y_subscript_x_size: i16,

    pub y_subscript_y_size: i16,

    pub y_subscript_x_offset: i16,

    pub y_subscript_y_offset: i16,

    pub y_superscript_x_size: i16,

    pub y_superscript_y_size: i16,

    pub y_superscript_x_offset: i16,

    pub y_superscript_y_offset: i16,

    pub y_strikeout_size: i16,

    pub y_strikeout_position: i16,

    pub s_family_class: i16,

    pub fs_selection: u16,

    pub us_first_char_index: u16,

    pub us_last_char_index: u16,

    // panose (align 1 - last)

    pub panose: Panose,

}

impl Default for FontMetrics {

}

impl FontMetrics {

    /// Only for testing, zero-sized font, will always return 0 for every metric

    /// (`units_per_em = 1000`)

    /// Returns the ascender value from the hhea table

    /// Returns the descender value from the hhea table

    /// Returns the line gap value from the hhea table

    /// Returns the maximum advance width from the hhea table

    /// Returns the minimum left side bearing from the hhea table

    /// Returns the minimum right side bearing from the hhea table

    /// Returns the x_min value from the head table

    /// Returns the y_min value from the head table

    /// Returns the x_max value from the head table

    /// Returns the y_max value from the head table

    /// Returns the maximum extent in the x direction from the hhea table

    /// Returns the average character width from the os/2 table

    /// Returns the subscript x size from the os/2 table

    /// Returns the subscript y size from the os/2 table

    /// Returns the subscript x offset from the os/2 table

    /// Returns the subscript y offset from the os/2 table

    /// Returns the superscript x size from the os/2 table

    /// Returns the superscript y size from the os/2 table

    /// Returns the superscript x offset from the os/2 table

    /// Returns the superscript y offset from the os/2 table

    /// Returns the strikeout size from the os/2 table

    /// Returns the strikeout position from the os/2 table

    /// Returns whether typographic metrics should be used (from fs_selection flag)

        // Bit 7 of fs_selection indicates USE_TYPO_METRICS

}

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

mod tests {

    use super::*;

    #[test]

            StyleFontWeight::Normal

        );

            StyleFontWeight::Lighter

        );

            StyleFontWeight::Bolder

        );

    #[test]

    #[test]

    #[test]

            StyleFontStyle::Oblique

        );

            StyleFontStyle::Italic

        );

    #[test]

        );

        );

        );

        );

    #[test]

        // Single unquoted

        );

        // Single quoted

        );

        // Multiple

        );

        );

        // Multiple with quotes and extra whitespace

        );

        );

    #[test]

        use crate::system::SystemFontType;

        // Single system font type

        // System font type with bold variant

        // System font type with italic variant

        // System font type with fallback

        // All system font types

        // Invalid system font type should be parsed as regular font name

    #[test]

        use crate::system::SystemFontType;

        // Test that as_css_str() and from_css_str() are inverses

        }

}