bun_css 0.1.0

use crate::css_parser as css;
use crate::css_parser::CssResult;
use crate::values::length::LengthPercentage;
use crate::values::percentage::{DimensionPercentage, Percentage};
use crate::values::protocol;

/// A CSS `<position>` value,
/// as used in the `background-position` property, gradients, masks, etc.
#[derive(Clone, PartialEq)]
pub struct Position {
    /// The x-position.
    pub x: HorizontalPosition,
    /// The y-position.
    pub y: VerticalPosition,
}

impl Position {
    pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Position> {
        // Try parsing a horizontal position first
        if let Ok(horizontal_pos) = input.try_parse(HorizontalPosition::parse) {
            match horizontal_pos {
                PositionComponent::Center => {
                    // Try parsing a vertical position next
                    if let Ok(y) = input.try_parse(VerticalPosition::parse) {
                        return Ok(Position {
                            x: PositionComponent::Center,
                            y,
                        });
                    }

                    // If it didn't work, assume the first actually represents a y position,
                    // and the next is an x position. e.g. `center left` rather than `left center`.
                    let x = input
                        .try_parse(HorizontalPosition::parse)
                        .unwrap_or(HorizontalPosition::Center);
                    let y = VerticalPosition::Center;
                    return Ok(Position { x, y });
                }
                PositionComponent::Length(x) => {
                    // If we got a length as the first component, then the second must
                    // be a keyword or length (not a side offset).
                    if let Ok(y_keyword) = input.try_parse(VerticalPositionKeyword::parse) {
                        let y = VerticalPosition::Side(PositionComponentSide {
                            side: y_keyword,
                            offset: None,
                        });
                        return Ok(Position {
                            x: PositionComponent::Length(x),
                            y,
                        });
                    }
                    if let Ok(y_lp) = input.try_parse(LengthPercentage::parse) {
                        let y = VerticalPosition::Length(y_lp);
                        return Ok(Position {
                            x: PositionComponent::Length(x),
                            y,
                        });
                    }
                    let y = VerticalPosition::Center;
                    let _ = input.try_parse(|i| i.expect_ident_matching(b"center"));
                    return Ok(Position {
                        x: PositionComponent::Length(x),
                        y,
                    });
                }
                PositionComponent::Side(side) => {
                    let x_keyword = side.side;
                    let lp = side.offset;

                    // If we got a horizontal side keyword (and optional offset), expect another for the vertical side.
                    // e.g. `left center` or `left 20px center`
                    if input
                        .try_parse(|i| i.expect_ident_matching(b"center"))
                        .is_ok()
                    {
                        let x = HorizontalPosition::Side(PositionComponentSide {
                            side: x_keyword,
                            offset: lp,
                        });
                        let y = VerticalPosition::Center;
                        return Ok(Position { x, y });
                    }

                    // e.g. `left top`, `left top 20px`, `left 20px top`, or `left 20px top 20px`
                    if let Ok(y_keyword) = input.try_parse(VerticalPositionKeyword::parse) {
                        let y_lp = input.try_parse(LengthPercentage::parse).ok();
                        let x = HorizontalPosition::Side(PositionComponentSide {
                            side: x_keyword,
                            offset: lp,
                        });
                        let y = VerticalPosition::Side(PositionComponentSide {
                            side: y_keyword,
                            offset: y_lp,
                        });
                        return Ok(Position { x, y });
                    }

                    // If we didn't get a vertical side keyword (e.g. `left 20px`), then apply the offset to the vertical side.
                    let x = HorizontalPosition::Side(PositionComponentSide {
                        side: x_keyword,
                        offset: None,
                    });
                    let y = if let Some(lp_val) = lp {
                        VerticalPosition::Length(lp_val)
                    } else {
                        VerticalPosition::Center
                    };
                    return Ok(Position { x, y });
                }
            }
        }

        // If the horizontal position didn't parse, then it must be out of order. Try vertical position keyword.
        let y_keyword = VerticalPositionKeyword::parse(input)?;
        let lp_and_x_pos = input.try_parse(
            |i: &mut css::Parser| -> CssResult<(Option<LengthPercentage>, HorizontalPosition)> {
                let y_lp = i.try_parse(LengthPercentage::parse).ok();
                if let Ok(x_keyword) = i.try_parse(HorizontalPositionKeyword::parse) {
                    let x_lp = i.try_parse(LengthPercentage::parse).ok();
                    let x_pos = HorizontalPosition::Side(PositionComponentSide {
                        side: x_keyword,
                        offset: x_lp,
                    });
                    return Ok((y_lp, x_pos));
                }
                i.expect_ident_matching(b"center")?;
                let x_pos = HorizontalPosition::Center;
                Ok((y_lp, x_pos))
            },
        );

        if let Ok(tuple) = lp_and_x_pos {
            let y_lp = tuple.0;
            let x = tuple.1;
            let y = VerticalPosition::Side(PositionComponentSide {
                side: y_keyword,
                offset: y_lp,
            });
            return Ok(Position { x, y });
        }

        let x = HorizontalPosition::Center;
        let y = VerticalPosition::Side(PositionComponentSide {
            side: y_keyword,
            offset: None,
        });
        Ok(Position { x, y })
    }

    pub(crate) fn to_css(&self, dest: &mut css::Printer) -> Result<(), css::PrintErr> {
        // PORT NOTE: reshaped for borrowck — Zig used tag-then-payload-access (`this.x == .side and this.x.side.side != .left`);
        // Rust uses if-let pattern matching to bind payloads.
        if let (PositionComponent::Side(xs), PositionComponent::Length(yl)) = (&self.x, &self.y) {
            if xs.side != HorizontalPositionKeyword::Left {
                self.x.to_css(dest)?;
                dest.write_str(" top ")?;
                return yl.to_css(dest);
            }
        }
        if let PositionComponent::Side(xs) = &self.x {
            if xs.side != HorizontalPositionKeyword::Left && self.y.is_center() {
                // If there is a side keyword with an offset, "center" must be a keyword not a percentage.
                self.x.to_css(dest)?;
                return dest.write_str(" center");
            }
        }
        if let (PositionComponent::Length(xl), PositionComponent::Side(ys)) = (&self.x, &self.y) {
            if ys.side != VerticalPositionKeyword::Top {
                dest.write_str("left ")?;
                xl.to_css(dest)?;
                dest.write_str(" ")?;
                return self.y.to_css(dest);
            }
        }
        if self.x.is_center() && self.y.is_center() {
            // `center center` => 50%
            return self.x.to_css(dest);
        }
        if let PositionComponent::Length(xl) = &self.x {
            if self.y.is_center() {
                // `center` is assumed if omitted.
                return xl.to_css(dest);
            }
        }
        if let PositionComponent::Side(xs) = &self.x {
            if xs.offset.is_none() && self.y.is_center() {
                let p: LengthPercentage = xs.side.into_length_percentage();
                return p.to_css(dest);
            }
        }
        if let PositionComponent::Side(ys) = &self.y {
            if ys.offset.is_none() && self.x.is_center() {
                return self.y.to_css(dest);
            }
        }
        if let (PositionComponent::Side(xs), PositionComponent::Side(ys)) = (&self.x, &self.y) {
            if xs.offset.is_none() && ys.offset.is_none() {
                let x: LengthPercentage = xs.side.into_length_percentage();
                let y: LengthPercentage = ys.side.into_length_percentage();
                x.to_css(dest)?;
                dest.write_str(" ")?;
                return y.to_css(dest);
            }
        }

        let zero = LengthPercentage::zero();
        let fifty = DimensionPercentage::Percentage(Percentage { v: 0.5 });
        let x_len: Option<&LengthPercentage> = 'x_len: {
            match &self.x {
                PositionComponent::Side(side) => {
                    if side.side == HorizontalPositionKeyword::Left {
                        if let Some(offset) = &side.offset {
                            if offset.is_zero() {
                                break 'x_len Some(&zero);
                            } else {
                                break 'x_len Some(offset);
                            }
                        } else {
                            break 'x_len Some(&zero);
                        }
                    }
                }
                PositionComponent::Length(len) => {
                    if len.is_zero() {
                        break 'x_len Some(&zero);
                    }
                }
                PositionComponent::Center => break 'x_len Some(&fifty),
            }
            None
        };

        let y_len: Option<&LengthPercentage> = 'y_len: {
            match &self.y {
                PositionComponent::Side(side) => {
                    if side.side == VerticalPositionKeyword::Top {
                        if let Some(offset) = &side.offset {
                            if offset.is_zero() {
                                break 'y_len Some(&zero);
                            } else {
                                break 'y_len Some(offset);
                            }
                        } else {
                            break 'y_len Some(&zero);
                        }
                    }
                }
                PositionComponent::Length(len) => {
                    if len.is_zero() {
                        break 'y_len Some(&zero);
                    }
                }
                PositionComponent::Center => break 'y_len Some(&fifty),
            }
            None
        };

        if let (Some(xl), Some(yl)) = (x_len, y_len) {
            xl.to_css(dest)?;
            dest.write_str(" ")?;
            yl.to_css(dest)
        } else {
            self.x.to_css(dest)?;
            dest.write_str(" ")?;
            self.y.to_css(dest)
        }
    }

    /// Returns whether both the x and y positions are centered.
    pub(crate) fn is_center(&self) -> bool {
        self.x.is_center() && self.y.is_center()
    }

    pub(crate) fn center() -> Position {
        Position {
            x: PositionComponent::Center,
            y: PositionComponent::Center,
        }
    }

    pub(crate) fn is_zero(&self) -> bool {
        self.x.is_zero() && self.y.is_zero()
    }
}

impl Default for Position {
    fn default() -> Self {
        Position {
            x: HorizontalPosition::Length(DimensionPercentage::Percentage(Percentage { v: 0.0 })),
            y: VerticalPosition::Length(DimensionPercentage::Percentage(Percentage { v: 0.0 })),
        }
    }
}

/// A side keyword with an optional offset.
#[derive(Clone, PartialEq)]
pub struct PositionComponentSide<S> {
    /// A side keyword.
    pub side: S,
    /// Offset from the side.
    pub offset: Option<LengthPercentage>,
}

/// A component of a CSS `<position>` value (horizontal or vertical).
#[derive(Clone, PartialEq)]
pub enum PositionComponent<S> {
    /// The `center` keyword.
    Center,
    /// A length or percentage from the top-left corner of the box.
    Length(LengthPercentage),
    /// A side keyword with an optional offset.
    Side(PositionComponentSide<S>),
}

// PORT NOTE: Zig used duck-typed `S.parse`/`S.toCss`; Rust bounds on the
// values-local `protocol::{Parse,ToCss}` shapes until `generics::Parse`
// un-gates.
impl<S: protocol::Parse + protocol::ToCss + Clone + PartialEq> PositionComponent<S> {
    pub(crate) fn is_zero(&self) -> bool {
        if let PositionComponent::Length(l) = self {
            if l.is_zero() {
                return true;
            }
        }
        false
    }

    pub(crate) fn parse(input: &mut css::Parser) -> CssResult<Self> {
        if input
            .try_parse(|i: &mut css::Parser| i.expect_ident_matching(b"center"))
            .is_ok()
        {
            return Ok(PositionComponent::Center);
        }

        if let Ok(lp) = input.try_parse(LengthPercentage::parse) {
            return Ok(PositionComponent::Length(lp));
        }

        let side = S::parse(input)?;
        let offset = input.try_parse(LengthPercentage::parse).ok();
        Ok(PositionComponent::Side(PositionComponentSide {
            side,
            offset,
        }))
    }

    pub(crate) fn to_css(&self, dest: &mut css::Printer) -> Result<(), css::PrintErr> {
        match self {
            PositionComponent::Center => {
                if dest.minify {
                    dest.write_str("50%")
                } else {
                    dest.write_str("center")
                }
            }
            PositionComponent::Length(lp) => lp.to_css(dest),
            PositionComponent::Side(s) => {
                s.side.to_css(dest)?;
                if let Some(lp) = &s.offset {
                    dest.write_str(" ")?;
                    lp.to_css(dest)?;
                }
                Ok(())
            }
        }
    }

    pub(crate) fn is_center(&self) -> bool {
        match self {
            PositionComponent::Center => return true,
            PositionComponent::Length(l) => {
                if let DimensionPercentage::Percentage(p) = l {
                    return p.v == 0.5;
                }
            }
            _ => {}
        }
        false
    }
}

#[derive(Clone, Copy, PartialEq, Eq, css::DefineEnumProperty)]
pub enum HorizontalPositionKeyword {
    /// The `left` keyword.
    Left,
    /// The `right` keyword.
    Right,
}

impl HorizontalPositionKeyword {
    pub(crate) fn into_length_percentage(self) -> LengthPercentage {
        match self {
            HorizontalPositionKeyword::Left => LengthPercentage::zero(),
            HorizontalPositionKeyword::Right => {
                DimensionPercentage::Percentage(Percentage { v: 1.0 })
            }
        }
    }
}

#[derive(Clone, Copy, PartialEq, Eq, css::DefineEnumProperty)]
pub enum VerticalPositionKeyword {
    /// The `top` keyword.
    Top,
    /// The `bottom` keyword.
    Bottom,
}

impl VerticalPositionKeyword {
    pub(crate) fn into_length_percentage(self) -> LengthPercentage {
        match self {
            VerticalPositionKeyword::Top => LengthPercentage::zero(),
            VerticalPositionKeyword::Bottom => {
                DimensionPercentage::Percentage(Percentage { v: 1.0 })
            }
        }
    }
}

pub(crate) type HorizontalPosition = PositionComponent<HorizontalPositionKeyword>;
pub(crate) type VerticalPosition = PositionComponent<VerticalPositionKeyword>;

// ported from: src/css/values/position.zig